fitpage.py @ 83db1cc

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 83db1cc was 48154abb, checked in by krzywon, 7 years ago
Smear and draw fit pages at the end of loading save states to update plots.
Property mode set to `100644`
File size: 126.6 KB

Line
1	"""
2	FitPanel class contains fields allowing to display results when
3	fitting a model and one data
4	"""
5	import sys
6	import wx
7	import wx.lib.newevent
8	import numpy as np
9	import copy
10	import math
11	import time
12	import traceback
13
14	from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
15
16	from sas.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	try:
1159	self._on_select_model_helper()
1160	except Exception as e:
1161	evt = StatusEvent(status=e.message, info="error")
1162	wx.PostEvent(self._manager.parent, evt)
1163	# Set S(Q) to None
1164	self.structurebox.SetSelection(0)
1165	self._on_select_model()
1166	return
1167	self.set_model_param_sizer(self.model)
1168	if self.model is None:
1169	self._set_bookmark_flag(False)
1170	self._keep.Enable(False)
1171	self._set_save_flag(False)
1172	self.enable_disp.SetValue(False)
1173	self.disable_disp.SetValue(True)
1174	# TODO: should not have an untrapped exception when displaying disperser
1175	# TODO: do we need to create the disperser panel on every model change?
1176	# Note: if we fix this, then remove ID_DISPERSER_HELP from basepage
1177	try:
1178	self.set_dispers_sizer()
1179	except:
1180	pass
1181	self.state.enable_disp = self.enable_disp.GetValue()
1182	self.state.disable_disp = self.disable_disp.GetValue()
1183	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
1184	self.state.slit_smearer = self.slit_smearer.GetValue()
1185
1186	self.state.structurecombobox = self.structurebox.GetValue()
1187	self.state.formfactorcombobox = self.formfactorbox.GetValue()
1188	self.state.categorycombobox = self.categorybox.GetValue()
1189	self.enable_fit_button()
1190	if self.model is not None:
1191	self.m_name = self.model.name
1192	self.state.m_name = self.m_name
1193	self.rename_model()
1194	self._set_copy_flag(True)
1195	self._set_paste_flag(True)
1196	if self.data is not None:
1197	is_data = check_data_validity(self.data)
1198	if is_data:
1199	self._set_bookmark_flag(not self.batch_on)
1200	self._keep.Enable(not self.batch_on)
1201	self._set_save_flag(True)
1202	#Setting smearing for cases with and without data.
1203	self._set_smear(self.data)
1204
1205	# more disables for 2D
1206	self._set_smear_buttons()
1207
1208	try:
1209	# update smearer sizer
1210	#This call for smearing set up caused double evaluation of
1211	#I(q) and double compilation as results
1212	#self.onSmear(None)
1213	temp_smear = None
1214	if not self.disable_smearer.GetValue():
1215	# Set the smearer environments
1216	temp_smear = self.current_smearer
1217	except:
1218	raise
1219	# error occured on chisqr computation
1220	# pass
1221	# event to post model to fit to fitting plugins
1222	(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
1223
1224	# set smearing value whether or not data contain the smearing info
1225	evt = ModelEventbox(model=self.model,
1226	smearer=temp_smear,
1227	enable_smearer=not self.disable_smearer.GetValue(),
1228	qmin=float(self.qmin_x),
1229	uid=self.uid,
1230	caption=self.window_caption,
1231	qmax=float(self.qmax_x))
1232
1233	self._manager._on_model_panel(evt=evt)
1234	self.mbox_description.SetLabel("Model [ %s ]" %
1235	str(self.model.name))
1236	self.mbox_description.SetForegroundColour(wx.BLUE)
1237	self.state.model = self.model.clone()
1238	self.state.model.name = self.model.name
1239
1240	if event is not None:
1241	# post state to fit panel
1242	new_event = PageInfoEvent(page=self)
1243	wx.PostEvent(self.parent, new_event)
1244	# update list of plugins if new plugin is available
1245	mod_cat = self.categorybox.GetStringSelection()
1246	if mod_cat == CUSTOM_MODEL:
1247	temp_id = self.model.id
1248	temp = self.parent.update_model_list()
1249	for v in self.parent.model_dictionary.values():
1250	if v.id == temp_id:
1251	self.model = v()
1252	break
1253	if temp:
1254	self.model_list_box = temp
1255	current_val = self.formfactorbox.GetLabel()
1256	pos = self.formfactorbox.GetSelection()
1257	self._show_combox_helper()
1258	self.formfactorbox.SetSelection(pos)
1259	self.formfactorbox.SetValue(current_val)
1260	# when select a model only from guictr/button
1261	if is_poly_enabled is not None:
1262	self.enable_disp.SetValue(is_poly_enabled)
1263	self.disable_disp.SetValue(not is_poly_enabled)
1264	self._set_dipers_Param(event=None)
1265	self.state.enable_disp = self.enable_disp.GetValue()
1266	self.state.disable_disp = self.disable_disp.GetValue()
1267
1268	# Keep the previous param values
1269	if copy_flag:
1270	self.get_paste_params(copy_flag)
1271	wx.CallAfter(self._onDraw, None)
1272
1273	else:
1274	self._draw_model()
1275
1276	if self.batch_on:
1277	self.slit_smearer.Enable(False)
1278	self.pinhole_smearer.Enable(False)
1279	self.btEditMask.Disable()
1280	self.EditMask_title.Disable()
1281
1282	self.Show(True)
1283	self.SetupScrolling()
1284
1285	def _onparamEnter(self, event):
1286	"""
1287	when enter value on panel redraw model according to changed
1288	"""
1289	if self.model is None:
1290	msg = "Please select a Model first..."
1291	wx.MessageBox(msg, 'Info')
1292	return
1293
1294	# default flag
1295	flag = False
1296	self.fitrange = True
1297	# get event object
1298	tcrtl = event.GetEventObject()
1299	# Clear msg if previously shown.
1300	msg = ""
1301	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1302
1303	if check_float(tcrtl):
1304	flag = self._onparamEnter_helper()
1305	self.show_npts2fit()
1306	if self.fitrange:
1307	temp_smearer = None
1308	if not self.disable_smearer.GetValue():
1309	temp_smearer = self.current_smearer
1310	# set smearing value whether or not data contain the
1311	# smearing info
1312	if self.slit_smearer.GetValue():
1313	flag1 = self.update_slit_smear()
1314	flag = flag or flag1
1315	elif self.pinhole_smearer.GetValue():
1316	flag1 = self.update_pinhole_smear()
1317	flag = flag or flag1
1318	elif self.data.__class__.__name__ != "Data2D" and \
1319	not self.enable2D:
1320	enable_smearer = not self.disable_smearer.GetValue()
1321	self._manager.set_smearer(smearer=temp_smearer,
1322	fid=self.data.id,
1323	uid=self.uid,
1324	qmin=float(self.qmin_x),
1325	qmax=float(self.qmax_x),
1326	enable_smearer=enable_smearer)
1327	if flag:
1328	# self.compute_chisqr(smearer= temp_smearer)
1329
1330	# new state posted
1331	if self.state_change:
1332	# self._undo.Enable(True)
1333	event = PageInfoEvent(page=self)
1334	wx.PostEvent(self.parent, event)
1335	self.state_change = False
1336	else:
1337	# invalid fit range: do nothing here:
1338	# msg already displayed in validate
1339	return
1340	else:
1341	self.save_current_state()
1342	msg = "Cannot Plot: Must enter a number!!! "
1343	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1344
1345	self.save_current_state()
1346	return
1347
1348	def _onparamRangeEnter(self, event):
1349	"""
1350	Check validity of value enter in the parameters range field
1351	"""
1352	tcrtl = event.GetEventObject()
1353	# Clear msg if previously shown.
1354	msg = ""
1355	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1356	# Flag to register when a parameter has changed.
1357	is_modified = False
1358	if tcrtl.GetValue().lstrip().rstrip() != "":
1359	try:
1360	tcrtl.SetBackgroundColour(wx.WHITE)
1361	self._check_value_enter(self.fittable_param)
1362	self._check_value_enter(self.parameters)
1363	except:
1364	tcrtl.SetBackgroundColour("pink")
1365	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1366	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1367	return
1368	else:
1369	tcrtl.SetBackgroundColour(wx.WHITE)
1370
1371	# self._undo.Enable(True)
1372	self.save_current_state()
1373	event = PageInfoEvent(page=self)
1374	wx.PostEvent(self.parent, event)
1375	self.state_change = False
1376
1377	def qrang_set_focus(self, event=None):
1378	"""
1379	ON Qrange focus
1380	"""
1381	if event is not None:
1382	event.Skip()
1383	# tcrtl = event.GetEventObject()
1384	self._validate_qrange(self.qmin, self.qmax)
1385
1386	def qrange_click(self, event):
1387	"""
1388	On Qrange textctrl click, make the qrange lines in the plot
1389	"""
1390	if event is not None:
1391	event.Skip()
1392	if self.data.__class__.__name__ == "Data2D":
1393	return
1394	is_click = event.LeftDown()
1395	if is_click:
1396	d_id = self.data.id
1397	d_group_id = self.data.group_id
1398	act_ctrl = event.GetEventObject()
1399	wx.PostEvent(self._manager.parent,
1400	PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
1401	group_id=d_group_id, leftdown=is_click,
1402	active=act_ctrl))
1403
1404	def on_qrange_text(self, event):
1405	"""
1406	#On q range value updated. DO not combine with qrange_click().
1407	"""
1408	if event is not None:
1409	event.Skip()
1410	if self.data.__class__.__name__ == "Data2D":
1411	return
1412	act_ctrl = event.GetEventObject()
1413	d_id = self.data.id
1414	d_group_id = self.data.group_id
1415	wx.PostEvent(self._manager.parent,
1416	PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
1417	group_id=d_group_id, leftdown=False,
1418	active=act_ctrl))
1419	self._validate_qrange(self.qmin, self.qmax)
1420
1421	def on_key(self, event):
1422	"""
1423	On Key down
1424	"""
1425	event.Skip()
1426	if self.data.__class__.__name__ == "Data2D":
1427	return
1428	ctrl = event.GetEventObject()
1429	try:
1430	x_data = float(ctrl.GetValue())
1431	except:
1432	return
1433	key = event.GetKeyCode()
1434	length = len(self.data.x)
1435	indx = (np.abs(self.data.x - x_data)).argmin()
1436	# return array.flat[idx]
1437	if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP:
1438	indx += 1
1439	if indx >= length:
1440	indx = length - 1
1441	elif key == wx.WXK_PAGEDOWN or key == wx.WXK_NUMPAD_PAGEDOWN:
1442	indx -= 1
1443	if indx < 0:
1444	indx = 0
1445	else:
1446	return
1447	ctrl.SetValue(str(self.data.x[indx]))
1448	self._validate_qrange(self.qmin, self.qmax)
1449
1450	def _onQrangeEnter(self, event):
1451	"""
1452	Check validity of value enter in the Q range field
1453	"""
1454	tcrtl = event.GetEventObject()
1455	# Clear msg if previously shown.
1456	msg = ""
1457	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1458	# For theory mode
1459	if not self.data.is_data:
1460	self.npts_x = self.Npts_total.GetValue()
1461	self.Npts_fit.SetValue(self.npts_x)
1462	self.create_default_data()
1463	# Flag to register when a parameter has changed.
1464	if tcrtl.GetValue().lstrip().rstrip() != "":
1465	try:
1466	tcrtl.SetBackgroundColour(wx.WHITE)
1467	# If qmin and qmax have been modified, update qmin and qmax
1468	if self._validate_qrange(self.qmin, self.qmax):
1469	tempmin = float(self.qmin.GetValue())
1470	if tempmin != self.qmin_x:
1471	self.qmin_x = tempmin
1472	tempmax = float(self.qmax.GetValue())
1473	if tempmax != self.qmax_x:
1474	self.qmax_x = tempmax
1475	else:
1476	tcrtl.SetBackgroundColour("pink")
1477	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1478	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1479	return
1480	except:
1481	tcrtl.SetBackgroundColour("pink")
1482	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1483	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1484	return
1485	# Check if # of points for theory model are valid(>0).
1486	# check for 2d
1487	if self.data.__class__.__name__ == "Data2D" or \
1488	self.enable2D:
1489	# set mask
1490	radius = np.sqrt(self.data.qx_data * self.data.qx_data +
1491	self.data.qy_data * self.data.qy_data)
1492	index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x))
1493	index_data = (index_data) & (self.data.mask)
1494	index_data = (index_data) & (np.isfinite(self.data.data))
1495	if len(index_data[index_data]) < 10:
1496	msg = "Cannot Plot :No or too little npts in"
1497	msg += " that data range!!! "
1498	wx.PostEvent(self._manager.parent,
1499	StatusEvent(status=msg))
1500	return
1501	else:
1502	# self.data.mask = index_data
1503	# self.Npts_fit.SetValue(str(len(self.data.mask)))
1504	self.show_npts2fit()
1505	else:
1506	index_data = ((self.qmin_x <= self.data.x) &
1507	(self.data.x <= self.qmax_x))
1508	self.Npts_fit.SetValue(str(len(self.data.x[index_data])))
1509
1510	self.npts_x = self.Npts_total.GetValue()
1511	self.create_default_data()
1512	self._save_plotting_range()
1513	else:
1514	tcrtl.SetBackgroundColour("pink")
1515	msg = "Model Error:wrong value entered!!!"
1516	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1517
1518	self._draw_model()
1519	self.save_current_state()
1520	event = PageInfoEvent(page=self)
1521	wx.PostEvent(self.parent, event)
1522	self.state_change = False
1523	return
1524
1525	def _clear_Err_on_Fit(self):
1526	"""
1527	hide the error text control shown
1528	after fitting
1529	"""
1530
1531	if self.is_mac:
1532	return
1533	if hasattr(self, "text2_3"):
1534	self.text2_3.Hide()
1535
1536	if len(self.parameters) > 0:
1537	for item in self.parameters:
1538	if item[0].IsShown():
1539	# Skip the angle parameters if 1D data
1540	if self.data.__class__.__name__ != "Data2D" and \
1541	not self.enable2D:
1542	if item in self.orientation_params:
1543	continue
1544	if item in self.param_toFit:
1545	continue
1546	# hide statictext +/-
1547	if len(item) < 4:
1548	continue
1549	if item[3] is not None and item[3].IsShown():
1550	item[3].Hide()
1551	# hide textcrtl for error after fit
1552	if item[4] is not None and item[4].IsShown():
1553	item[4].Hide()
1554
1555	if len(self.fittable_param) > 0:
1556	for item in self.fittable_param:
1557	if item[0].IsShown():
1558	# Skip the angle parameters if 1D data
1559	if self.data.__class__.__name__ != "Data2D" and \
1560	not self.enable2D:
1561	if item in self.orientation_params:
1562	continue
1563	if item in self.param_toFit:
1564	continue
1565	if len(item) < 4:
1566	continue
1567	# hide statictext +/-
1568	if item[3] is not None and item[3].IsShown():
1569	item[3].Hide()
1570	# hide textcrtl for error after fit
1571	if item[4] is not None and item[4].IsShown():
1572	item[4].Hide()
1573	return
1574
1575	def _get_defult_custom_smear(self):
1576	"""
1577	Get the defult values for custum smearing.
1578	"""
1579	# get the default values
1580	if self.dxl is None:
1581	self.dxl = 0.0
1582	if self.dxw is None:
1583	self.dxw = ""
1584	if self.dx_percent is None:
1585	self.dx_percent = SMEAR_SIZE_H
1586
1587	def _get_smear_info(self):
1588	"""
1589	Get the smear info from data.
1590
1591	:return: self.smear_type, self.dq_l and self.dq_r,
1592	respectively the type of the smear, dq_min and
1593	dq_max for pinhole smear data
1594	while dxl and dxw for slit smear
1595	"""
1596	# default
1597	self.smear_type = None
1598	self.dq_l = None
1599	self.dq_r = None
1600	data = self.data
1601	if self.data is None:
1602	return
1603	elif self.data.__class__.__name__ == "Data2D" or \
1604	self.enable2D:
1605	if data.dqx_data is None or data.dqy_data is None:
1606	return
1607	elif self.current_smearer is not None \
1608	and data.dqx_data.any() != 0 \
1609	and data.dqx_data.any() != 0:
1610	self.smear_type = "Pinhole2d"
1611	self.dq_l = format_number(np.average(data.dqx_data))
1612	self.dq_r = format_number(np.average(data.dqy_data))
1613	return
1614	else:
1615	return
1616	# check if it is pinhole smear and get min max if it is.
1617	if data.dx is not None and np.any(data.dx):
1618	self.smear_type = "Pinhole"
1619	self.dq_l = data.dx[0]
1620	self.dq_r = data.dx[-1]
1621
1622	# check if it is slit smear and get min max if it is.
1623	elif data.dxl is not None or data.dxw is not None:
1624	self.smear_type = "Slit"
1625	if data.dxl is not None and np.all(data.dxl, 0):
1626	self.dq_l = data.dxl[0]
1627	if data.dxw is not None and np.all(data.dxw, 0):
1628	self.dq_r = data.dxw[0]
1629	# return self.smear_type,self.dq_l,self.dq_r
1630
1631	def _show_smear_sizer(self):
1632	"""
1633	Show only the sizers depending on smear selection
1634	"""
1635	# smear disabled
1636	if self.disable_smearer.GetValue():
1637	self.smear_description_none.Show(True)
1638	# 2Dsmear
1639	elif self._is_2D():
1640	self.smear_description_accuracy_type.Show(True)
1641	self.smear_accuracy.Show(True)
1642	self.smear_description_accuracy_type.Show(True)
1643	self.smear_description_2d.Show(True)
1644	self.smear_description_2d_x.Show(True)
1645	self.smear_description_2d_y.Show(True)
1646	if self.pinhole_smearer.GetValue():
1647	self.smear_pinhole_percent.Show(True)
1648	# smear from data
1649	elif self.enable_smearer.GetValue():
1650
1651	self.smear_description_dqdata.Show(True)
1652	if self.smear_type is not None:
1653	self.smear_description_smear_type.Show(True)
1654	if self.smear_type == 'Slit':
1655	self.smear_description_slit_height.Show(True)
1656	self.smear_description_slit_width.Show(True)
1657	elif self.smear_type == 'Pinhole':
1658	self.smear_description_pin_percent.Show(True)
1659	self.smear_description_smear_type.Show(True)
1660	self.smear_description_type.Show(True)
1661	self.smear_data_left.Show(True)
1662	self.smear_data_right.Show(True)
1663	# custom pinhole smear
1664	elif self.pinhole_smearer.GetValue():
1665	if self.smear_type == 'Pinhole':
1666	self.smear_message_new_p.Show(True)
1667	self.smear_description_pin_percent.Show(True)
1668
1669	self.smear_pinhole_percent.Show(True)
1670	# custom slit smear
1671	elif self.slit_smearer.GetValue():
1672	self.smear_message_new_s.Show(True)
1673	self.smear_description_slit_height.Show(True)
1674	self.smear_slit_height.Show(True)
1675	self.smear_description_slit_width.Show(True)
1676	self.smear_slit_width.Show(True)
1677
1678	def _hide_all_smear_info(self):
1679	"""
1680	Hide all smearing messages in the set_smearer sizer
1681	"""
1682	self.smear_description_none.Hide()
1683	self.smear_description_dqdata.Hide()
1684	self.smear_description_type.Hide()
1685	self.smear_description_smear_type.Hide()
1686	self.smear_description_accuracy_type.Hide()
1687	self.smear_description_2d_x.Hide()
1688	self.smear_description_2d_y.Hide()
1689	self.smear_description_2d.Hide()
1690
1691	self.smear_accuracy.Hide()
1692	self.smear_data_left.Hide()
1693	self.smear_data_right.Hide()
1694	self.smear_description_pin_percent.Hide()
1695	self.smear_pinhole_percent.Hide()
1696	self.smear_description_slit_height.Hide()
1697	self.smear_slit_height.Hide()
1698	self.smear_description_slit_width.Hide()
1699	self.smear_slit_width.Hide()
1700	self.smear_message_new_p.Hide()
1701	self.smear_message_new_s.Hide()
1702
1703	def _set_accuracy_list(self):
1704	"""
1705	Set the list of an accuracy in 2D custum smear:
1706	Xhigh, High, Med, or Low
1707	"""
1708	# list of accuracy choices
1709	list = ['Low', 'Med', 'High', 'Xhigh']
1710	for idx in range(len(list)):
1711	self.smear_accuracy.Append(list[idx], idx)
1712
1713	def _set_fun_box_list(self, fun_box):
1714	"""
1715	Set the list of func for multifunctional models
1716	"""
1717	# Check if it is multi_functional model
1718	if self.model.__class__ not in self.model_list_box["Multi-Functions"] \
1719	and not self.temp_multi_functional:
1720	return None
1721	# Get the func name list
1722	list = self.model.fun_list
1723	if len(list) == 0:
1724	return None
1725	# build function (combo)box
1726	ind = 0
1727	while(ind < len(list)):
1728	for key, val in list.iteritems():
1729	if (val == ind):
1730	fun_box.Append(key, val)
1731	break
1732	ind += 1
1733
1734	def _on_select_accuracy(self, event):
1735	"""
1736	Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
1737	"""
1738	# event.Skip()
1739	# Check if the accuracy is same as before
1740	# self.smear2d_accuracy = event.GetEventObject().GetValue()
1741	self.smear2d_accuracy = self.smear_accuracy.GetValue()
1742	if self.pinhole_smearer.GetValue():
1743	self.onPinholeSmear(event=None)
1744	else:
1745	self.onSmear(event=None)
1746	if self.current_smearer is not None:
1747	self.current_smearer.set_accuracy(accuracy=\
1748	self.smear2d_accuracy)
1749	event.Skip()
1750
1751	def _on_fun_box(self, event):
1752	"""
1753	Select an func: Erf,Rparabola,LParabola
1754	"""
1755	fun_val = None
1756	fun_box = event.GetEventObject()
1757	name = fun_box.Name
1758	value = fun_box.GetValue()
1759	if value in self.model.fun_list:
1760	fun_val = self.model.fun_list[value]
1761
1762	self.model.setParam(name, fun_val)
1763	# save state
1764	self._copy_parameters_state(self.str_parameters,
1765	self.state.str_parameters)
1766	# update params
1767	self._update_paramv_on_fit()
1768	# draw
1769	self._draw_model()
1770	self.Refresh()
1771	# get ready for new event
1772	event.Skip()
1773
1774	def _onMask(self, event):
1775	"""
1776	Build a panel to allow to edit Mask
1777	"""
1778	from sas.sasgui.guiframe.local_perspectives.plotting.masking import \
1779	MaskPanel as MaskDialog
1780
1781	self.panel = MaskDialog(base=self, data=self.data, id=wx.NewId())
1782	self.panel.ShowModal()
1783
1784	def _draw_masked_model(self, event):
1785	"""
1786	Draw model image w/mask
1787	"""
1788	is_valid_qrange = self._update_paramv_on_fit()
1789
1790	if is_valid_qrange and self.model is not None:
1791	self.panel.MakeModal(False)
1792	event.Skip()
1793	# try re draw the model plot if it exists
1794	self._draw_model()
1795	self.show_npts2fit()
1796	elif self.model is None:
1797	self.panel.MakeModal(False)
1798	event.Skip()
1799	self.show_npts2fit()
1800	msg = "No model is found on updating MASK in the model plot... "
1801	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1802	else:
1803	event.Skip()
1804	msg = ' Please consider your Q range, too.'
1805	self.panel.ShowMessage(msg)
1806
1807	def _set_smear(self, data):
1808	"""
1809	Set_smear
1810	"""
1811	if data is None:
1812	return
1813	self.current_smearer = smear_selection(data, self.model)
1814	flag = self.disable_smearer.GetValue()
1815	if self.current_smearer is None:
1816	self.enable_smearer.Disable()
1817	else:
1818	self.enable_smearer.Enable()
1819	if not flag:
1820	self.onSmear(None)
1821
1822	def get_view_mode(self):
1823	"""
1824	return True if the panel allow 2D or False if 1D
1825	"""
1826	return self.enable2D
1827
1828	def compute_data_set_range(self, data_list):
1829	"""
1830	find the range that include all data in the set
1831	return the minimum and the maximum values
1832	"""
1833	if data_list is not None and data_list != []:
1834	for data in data_list:
1835	qmin, qmax, npts = self.compute_data_range(data)
1836	self.qmin_data_set = min(self.qmin_data_set, qmin)
1837	self.qmax_data_set = max(self.qmax_data_set, qmax)
1838	self.npts_data_set += npts
1839	return self.qmin_data_set, self.qmax_data_set, self.npts_data_set
1840
1841	def compute_data_range(self, data):
1842	"""
1843	compute the minimum and the maximum range of the data
1844	return the npts contains in data
1845	:param data:
1846	"""
1847	qmin, qmax, npts = None, None, None
1848	if data is not None:
1849	if not hasattr(data, "data"):
1850	try:
1851	qmin = min(data.x)
1852	# Maximum value of data
1853	qmax = max(data.x)
1854	npts = len(data.x)
1855	except:
1856	msg = "Unable to find min/max/length of \n data named %s" %\
1857	data.filename
1858	wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
1859	info="error"))
1860	raise ValueError, msg
1861
1862	else:
1863	qmin = 0
1864	try:
1865	x = max(math.fabs(data.xmin), math.fabs(data.xmax))
1866	y = max(math.fabs(data.ymin), math.fabs(data.ymax))
1867	except:
1868	msg = "Unable to find min/max of \n data named %s" % \
1869	data.filename
1870	wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
1871	info="error"))
1872	raise ValueError, msg
1873	# Maximum value of data
1874	qmax = math.sqrt(x * x + y * y)
1875	npts = len(data.data)
1876	return qmin, qmax, npts
1877
1878	def set_data(self, data):
1879	"""
1880	reset the current data
1881	"""
1882	id = None
1883	flag = False
1884	is_data = False
1885	npts = 0
1886	try:
1887	old_id = self.data.id
1888	old_group_id = self.data.group_id
1889	except:
1890	old_id = id
1891	old_group_id = id
1892	if self.data is not None:
1893	is_data = check_data_validity(self.data)
1894	if not is_data and data is not None:
1895	flag = True
1896	if data is not None:
1897	if is_data:
1898	self.graph_id = self.data.group_id
1899	flag = (data.id != self.data.id)
1900	self.data = data
1901	if check_data_validity(data):
1902	self.graph_id = data.group_id
1903	self.data.group_id = self.graph_id
1904
1905	if self.data is None:
1906	data_name = ""
1907	self._set_bookmark_flag(False)
1908	self._keep.Enable(False)
1909	self._set_save_flag(False)
1910	else:
1911	if self.model is not None:
1912	self._set_bookmark_flag(not self.batch_on)
1913	self._keep.Enable(not self.batch_on)
1914	if self.data.is_data:
1915	self._set_save_flag(True)
1916	self._set_preview_flag(True)
1917
1918	# more disables for 2D
1919	di_flag = False
1920	dq_flag = False
1921	if self.data.__class__.__name__ == "Data2D" or \
1922	self.enable2D:
1923	self.slit_smearer.Disable()
1924	self.pinhole_smearer.Enable(True)
1925	self.default_mask = copy.deepcopy(self.data.mask)
1926	if self.data.err_data is not None \
1927	and np.any(self.data.err_data):
1928	di_flag = True
1929	if self.data.dqx_data is not None \
1930	and np.any(self.data.dqx_data):
1931	dq_flag = True
1932	else:
1933	self.slit_smearer.Enable(True)
1934	self.pinhole_smearer.Enable(True)
1935	if self.data.dy is not None and np.any(self.data.dy):
1936	di_flag = True
1937	if self.data.dx is not None and np.any(self.data.dx):
1938	dq_flag = True
1939	elif self.data.dxl is not None and np.any(self.data.dxl):
1940	dq_flag = True
1941
1942	if dq_flag:
1943	self.enable_smearer.Enable(True)
1944	self.enable_smearer.SetValue(True)
1945	self.disable_smearer.SetValue(False)
1946	else:
1947	self.enable_smearer.Disable()
1948	self.disable_smearer.Enable(True)
1949	self.disable_smearer.SetValue(True)
1950
1951	if di_flag:
1952	self.dI_didata.Enable(True)
1953	self.dI_didata.SetValue(True)
1954	self.weightbt_string = self.dI_didata.GetLabelText()
1955	else:
1956	self.dI_didata.Enable(False)
1957	self.dI_noweight.SetValue(True)
1958	self.weightbt_string = self.dI_noweight.GetLabelText()
1959
1960	# Enable weighting radio buttons
1961	self.dI_noweight.Enable(True)
1962	self.dI_sqrdata.Enable(True)
1963	self.dI_idata.Enable(True)
1964
1965	self.formfactorbox.Enable()
1966	self.structurebox.Enable()
1967	data_name = self.data.name
1968	_, _, npts = self.compute_data_range(self.data)
1969	# set maximum range for x in linear scale
1970	if not hasattr(self.data, "data"): # Display only for 1D data fit
1971	self.btEditMask.Disable()
1972	self.EditMask_title.Disable()
1973	else:
1974	self.btEditMask.Enable()
1975	self.EditMask_title.Enable()
1976
1977	self.Npts_total.SetValue(str(npts))
1978	# default:number of data points selected to fit
1979	self.Npts_fit.SetValue(str(npts))
1980	self.Npts_total.SetEditable(False)
1981	self.Npts_total.SetBackgroundColour(
1982	self.GetParent().GetBackgroundColour())
1983
1984	self.Npts_total.Bind(wx.EVT_MOUSE_EVENTS, self._npts_click)
1985	self.pointsbox.Disable()
1986	self.dataSource.SetValue(data_name)
1987	self.state.data = data
1988	self.enable_fit_button()
1989	# send graph_id to page_finder
1990	self._manager.set_graph_id(uid=self.uid, graph_id=self.graph_id)
1991	# focus the page
1992	if check_data_validity(data):
1993	self.data_box_description.SetForegroundColour(wx.BLUE)
1994
1995	if self.batch_on:
1996	self.slit_smearer.Enable(False)
1997	self.pinhole_smearer.Enable(False)
1998	self.btEditMask.Disable()
1999	self.EditMask_title.Disable()
2000
2001	self.on_smear_helper()
2002	self.on_set_focus(None)
2003	self.Refresh()
2004	# update model plot with new data information
2005	if flag:
2006	if self.data.__class__.__name__ == "Data2D":
2007	self.enable2D = True
2008	self.model_view.SetLabel("2D Mode")
2009	else:
2010	self.enable2D = False
2011	self.model_view.SetLabel("1D Mode")
2012	self.model_view.Disable()
2013	# replace data plot on combo box selection
2014	# by removing the previous selected data
2015	try:
2016	wx.PostEvent(self._manager.parent,
2017	NewPlotEvent(action="delete",
2018	group_id=old_group_id, id=old_id))
2019	except:
2020	pass
2021	# plot the current selected data
2022	wx.PostEvent(self._manager.parent,
2023	NewPlotEvent(action="check", plot=self.data,
2024	title=str(self.data.title)))
2025	self._draw_model()
2026
2027	def _npts_click(self, event):
2028	"""
2029	Prevent further handling of the mouse event on Npts_total
2030	by not calling Skip().
2031	"""
2032	pass
2033
2034	def reset_page(self, state, first=False):
2035	"""
2036	reset the state
2037	"""
2038	try:
2039	self.reset_page_helper(state)
2040
2041	self.select_param()
2042	# Save state_fit
2043	self.save_current_state_fit()
2044	self.onSmear(None)
2045	self._onDraw(None)
2046	except:
2047	self._show_combox_helper()
2048	msg = "Error: This model state has missing or outdated "
2049	msg += "information.\n"
2050	msg += traceback.format_exc()
2051	wx.PostEvent(self._manager.parent,
2052	StatusEvent(status=msg, info="error"))
2053	self._lay_out()
2054	self.Refresh()
2055
2056	def get_range(self):
2057	"""
2058	return the fitting range
2059	"""
2060	return float(self.qmin_x), float(self.qmax_x)
2061
2062	def get_npts2fit(self):
2063	"""
2064	return numbers of data points within qrange
2065
2066	:Note: This is to normalize chisq by Npts of fit
2067
2068	"""
2069	if self.data is None:
2070	return
2071	npts2fit = 0
2072	qmin, qmax = self.get_range()
2073	if self.data.__class__.__name__ == "Data2D" or \
2074	self.enable2D:
2075	radius = np.sqrt(self.data.qx_data * self.data.qx_data +
2076	self.data.qy_data * self.data.qy_data)
2077	index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x)
2078	index_data = (index_data) & (self.data.mask)
2079	index_data = (index_data) & (np.isfinite(self.data.data))
2080	npts2fit = len(self.data.data[index_data])
2081	else:
2082	for qx in self.data.x:
2083	if qmax >= qx >= qmin:
2084	npts2fit += 1
2085	return npts2fit
2086
2087	def show_npts2fit(self):
2088	"""
2089	setValue Npts for fitting
2090	"""
2091	self.Npts_fit.SetValue(str(self.get_npts2fit()))
2092
2093	def get_chi2(self):
2094	"""
2095	return the current chi2
2096	"""
2097	return self.tcChi.GetValue()
2098
2099	def onsetValues(self, chisqr, p_name, out, cov):
2100	"""
2101	Build the panel from the fit result
2102
2103	:param chisqr: Value of the goodness of fit metric
2104	:param p_name: the name of parameters
2105	:param out: list of parameter with the best value found during fitting
2106	:param cov: Covariance matrix
2107
2108	"""
2109
2110	# make sure stop button to fit button all the time
2111	self._on_fit_complete()
2112	if out is None or not np.isfinite(chisqr):
2113	raise ValueError, "Fit error occured..."
2114
2115	is_modified = False
2116	has_error = False
2117	dispersity = ''
2118
2119	# Hide textctrl boxes of errors.
2120	self._clear_Err_on_Fit()
2121
2122	# Check if chi2 is finite
2123	if chisqr is not None and np.isfinite(chisqr):
2124	# format chi2
2125	chi2 = format_number(chisqr, True)
2126	self.tcChi.SetValue(chi2)
2127	self.tcChi.Refresh()
2128	else:
2129	self.tcChi.SetValue("-")
2130
2131	# Hide error title
2132	if self.text2_3.IsShown() and not self.is_mac:
2133	self.text2_3.Hide()
2134
2135	try:
2136	if self.enable_disp.GetValue():
2137	if hasattr(self, "text_disp_1"):
2138	if self.text_disp_1 is not None and not self.is_mac:
2139	self.text_disp_1.Hide()
2140	except:
2141	dispersity = None
2142	pass
2143
2144	i = 0
2145	# Set the panel when fit result are list
2146
2147	for item in self.param_toFit:
2148	if len(item) > 5 and item is not None:
2149
2150	if item[0].IsShown():
2151	# reset error value to initial state
2152	if not self.is_mac:
2153	item[3].Hide()
2154	item[4].Hide()
2155	for ind in range(len(out)):
2156	if item[1] == p_name[ind]:
2157	break
2158	if len(out) > 0 and out[ind] is not None:
2159	val_out = format_number(out[ind], True)
2160	item[2].SetValue(val_out)
2161
2162	if(cov is not None and len(cov) == len(out)):
2163	try:
2164	if dispersity is not None:
2165	if self.enable_disp.GetValue():
2166	if hasattr(self, "text_disp_1"):
2167	if self.text_disp_1 is not None:
2168	if not self.text_disp_1.IsShown()\
2169	and not self.is_mac:
2170	self.text_disp_1.Show(True)
2171	except:
2172	pass
2173
2174	if cov[ind] is not None:
2175	if np.isfinite(float(cov[ind])):
2176	val_err = format_number(cov[ind], True)
2177	item[4].SetForegroundColour(wx.BLACK)
2178	else:
2179	val_err = 'NaN'
2180	item[4].SetForegroundColour(wx.RED)
2181	if not self.is_mac:
2182	item[3].Show(True)
2183	item[4].Show(True)
2184	item[4].SetValue(val_err)
2185	has_error = True
2186	i += 1
2187	else:
2188	raise ValueError, "onsetValues: Invalid parameters..."
2189	# Show error title when any errors displayed
2190	if has_error:
2191	if not self.text2_3.IsShown():
2192	self.text2_3.Show(True)
2193	# save current state
2194	self.save_current_state()
2195
2196	if not self.is_mac:
2197	self.Layout()
2198	self.Refresh()
2199	# plot model ( when drawing, do not update chisqr value again)
2200	self._draw_model(update_chisqr=False, source='fit')
2201
2202	def onWeighting(self, event):
2203	"""
2204	On Weighting radio button event, sets the weightbt_string
2205	"""
2206	self.weightbt_string = event.GetEventObject().GetLabelText()
2207	self._set_weight()
2208
2209	def _set_weight(self, is_2D=None):
2210	"""
2211	Set weight in fit problem
2212	"""
2213	# compute weight for the current data
2214	flag_weight = self.get_weight_flag()
2215	if is_2D is None:
2216	is_2D = self._is_2D()
2217	self._manager.set_fit_weight(uid=self.uid,
2218	flag=flag_weight,
2219	is2d=is_2D,
2220	fid=None)
2221
2222	def onPinholeSmear(self, event):
2223	"""
2224	Create a custom pinhole smear object that will change the way residuals
2225	are compute when fitting
2226
2227	:Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
2228	None for 1D
2229
2230	"""
2231	# Need update param values
2232	self._update_paramv_on_fit()
2233
2234	if event is not None:
2235	tcrtl = event.GetEventObject()
2236	# event case of radio button
2237	if tcrtl.GetValue():
2238	self.dx_percent = 0.0
2239	is_new_pinhole = True
2240	else:
2241	is_new_pinhole = self._is_changed_pinhole()
2242	else:
2243	is_new_pinhole = True
2244	# if any value is changed
2245	if is_new_pinhole:
2246	self._set_pinhole_smear()
2247	# hide all silt sizer
2248	self._hide_all_smear_info()
2249
2250	# show relevant slit sizers
2251	self._show_smear_sizer()
2252
2253	self.sizer_set_smearer.Layout()
2254	# we need FitInside here not just self.Layout to ensure all the sizers
2255	# end up with the necessasary space to in the scroll panel. In
2256	# particular the compute and fit buttons end up on top of each other
2257	# PDB Nov 28 2015.
2258	self.FitInside()
2259
2260	if event is not None:
2261	event.Skip()
2262	# self._undo.Enable(True)
2263	self.save_current_state()
2264	event = PageInfoEvent(page=self)
2265	wx.PostEvent(self.parent, event)
2266
2267	def _is_changed_pinhole(self):
2268	"""
2269	check if any of pinhole smear is changed
2270
2271	:return: True or False
2272
2273	"""
2274	# get the values
2275	pin_percent = self.smear_pinhole_percent.GetValue()
2276
2277	# Check changes in slit heigth
2278	try:
2279	dx_percent = float(pin_percent)
2280	except:
2281	return True
2282	if self.dx_percent != dx_percent:
2283	return True
2284	return False
2285
2286	def _set_pinhole_smear(self):
2287	"""
2288	Set custom pinhole smear
2289
2290	:return: msg
2291
2292	"""
2293	# copy data
2294	data = copy.deepcopy(self.data)
2295	if self._is_2D():
2296	self.smear_type = 'Pinhole2d'
2297	len_data = len(data.data)
2298	data.dqx_data = np.zeros(len_data)
2299	data.dqy_data = np.zeros(len_data)
2300	else:
2301	self.smear_type = 'Pinhole'
2302	len_data = len(data.x)
2303	data.dx = np.zeros(len_data)
2304	data.dxl = None
2305	data.dxw = None
2306	msg = None
2307
2308	get_pin_percent = self.smear_pinhole_percent
2309
2310	if not check_float(get_pin_percent):
2311	get_pin_percent.SetBackgroundColour("pink")
2312	msg = "Model Error:wrong value entered!!!"
2313	else:
2314	if len_data < 2:
2315	len_data = 2
2316	self.dx_percent = float(get_pin_percent.GetValue())
2317	if self.dx_percent < 0:
2318	get_pin_percent.SetBackgroundColour("pink")
2319	msg = "Model Error:This value can not be negative!!!"
2320	elif self.dx_percent is not None:
2321	percent = self.dx_percent/100
2322	if self._is_2D():
2323	data.dqx_data[data.dqx_data == 0] = percent * data.qx_data
2324	data.dqy_data[data.dqy_data == 0] = percent * data.qy_data
2325	else:
2326	data.dx = percent * data.x
2327	self.current_smearer = smear_selection(data, self.model)
2328	# 2D need to set accuracy
2329	if self._is_2D():
2330	self.current_smearer.set_accuracy(
2331	accuracy=self.smear2d_accuracy)
2332
2333	if msg is not None:
2334	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2335	else:
2336	get_pin_percent.SetBackgroundColour("white")
2337	# set smearing value whether or not the data contain the smearing info
2338
2339	enable_smearer = not self.disable_smearer.GetValue()
2340	self._manager.set_smearer(smearer=self.current_smearer,
2341	fid=self.data.id,
2342	qmin=float(self.qmin_x),
2343	qmax=float(self.qmax_x),
2344	enable_smearer=enable_smearer,
2345	uid=self.uid)
2346	return msg
2347
2348	def update_pinhole_smear(self):
2349	"""
2350	called by kill_focus on pinhole TextCntrl
2351	to update the changes
2352
2353	:return: False when wrong value was entered
2354
2355	"""
2356	# msg default
2357	msg = None
2358	# check if any value is changed
2359	if self._is_changed_pinhole():
2360	msg = self._set_pinhole_smear()
2361	wx.CallAfter(self.save_current_state)
2362
2363	if msg is not None:
2364	return False
2365	else:
2366	return True
2367
2368	def onSlitSmear(self, event):
2369	"""
2370	Create a custom slit smear object that will change the way residuals
2371	are compute when fitting
2372	"""
2373	# Need update param values
2374	self._update_paramv_on_fit()
2375
2376	# msg default
2377	msg = None
2378	# for event given
2379	if event is not None:
2380	tcrtl = event.GetEventObject()
2381	# event case of radio button
2382	if tcrtl.GetValue():
2383	self.dxl = 0.0
2384	self.dxw = 0.0
2385	is_new_slit = True
2386	else:
2387	is_new_slit = self._is_changed_slit()
2388	else:
2389	is_new_slit = True
2390
2391	# if any value is changed
2392	if is_new_slit:
2393	msg = self._set_slit_smear()
2394
2395	# hide all silt sizer
2396	self._hide_all_smear_info()
2397	# show relevant slit sizers
2398	self._show_smear_sizer()
2399	self.sizer_set_smearer.Layout()
2400	# we need FitInside here not just self.Layout to ensure all the sizers
2401	# end up with the necessasary space to in the scroll panel. In
2402	# particular the compute and fit buttons end up on top of each other
2403	# PDB Nov 28 2015.
2404	self.FitInside()
2405
2406	if event is not None:
2407	event.Skip()
2408	self.save_current_state()
2409	event = PageInfoEvent(page=self)
2410	wx.PostEvent(self.parent, event)
2411	if msg is not None:
2412	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2413
2414	def _is_changed_slit(self):
2415	"""
2416	check if any of slit lengths is changed
2417
2418	:return: True or False
2419
2420	"""
2421	# get the values
2422	width = self.smear_slit_width.GetValue()
2423	height = self.smear_slit_height.GetValue()
2424
2425	# check and change the box bg color if it was pink
2426	# but it should be white now
2427	# because this is the case that _set_slit_smear() will not handle
2428	if height.lstrip().rstrip() == "":
2429	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2430	if width.lstrip().rstrip() == "":
2431	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2432
2433	# Check changes in slit width
2434	if width == "":
2435	dxw = 0.0
2436	else:
2437	try:
2438	dxw = float(width)
2439	except:
2440	return True
2441	if self.dxw != dxw:
2442	return True
2443
2444	# Check changes in slit heigth
2445	if height == "":
2446	dxl = 0.0
2447	else:
2448	try:
2449	dxl = float(height)
2450	except:
2451	return True
2452	if self.dxl != dxl:
2453	return True
2454
2455	return False
2456
2457	def _set_slit_smear(self):
2458	"""
2459	Set custom slit smear
2460
2461	:return: message to inform the user about the validity
2462	of the values entered for slit smear
2463	"""
2464	if self.data.__class__.__name__ == "Data2D" or self.enable2D:
2465	return
2466	# make sure once more if it is smearer
2467	data = copy.deepcopy(self.data)
2468	data_len = len(data.x)
2469	data.dx = None
2470	data.dxl = None
2471	data.dxw = None
2472	msg = None
2473
2474	try:
2475	self.dxl = float(self.smear_slit_height.GetValue())
2476	data.dxl = self.dxl * np.ones(data_len)
2477	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2478	except:
2479	self.dxl = None
2480	data.dxl = np.zeros(data_len)
2481	if self.smear_slit_height.GetValue().lstrip().rstrip() != "":
2482	self.smear_slit_height.SetBackgroundColour("pink")
2483	msg = "Wrong value entered... "
2484	else:
2485	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2486	try:
2487	self.dxw = float(self.smear_slit_width.GetValue())
2488	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2489	data.dxw = self.dxw * np.ones(data_len)
2490	except:
2491	self.dxw = None
2492	data.dxw = np.zeros(data_len)
2493	if self.smear_slit_width.GetValue().lstrip().rstrip() != "":
2494	self.smear_slit_width.SetBackgroundColour("pink")
2495	msg = "Wrong Fit value entered... "
2496	else:
2497	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2498
2499	self.current_smearer = smear_selection(data, self.model)
2500	# set smearing value whether or not the data contain the smearing info
2501	enable_smearer = not self.disable_smearer.GetValue()
2502	self._manager.set_smearer(smearer=self.current_smearer,
2503	fid=self.data.id,
2504	qmin=float(self.qmin_x),
2505	qmax=float(self.qmax_x),
2506	enable_smearer=enable_smearer,
2507	uid=self.uid)
2508	return msg
2509
2510	def update_slit_smear(self):
2511	"""
2512	called by kill_focus on pinhole TextCntrl
2513	to update the changes
2514
2515	:return: False when wrong value was entered
2516
2517	"""
2518	# msg default
2519	msg = None
2520	# check if any value is changed
2521	if self._is_changed_slit():
2522	msg = self._set_slit_smear()
2523	# self._undo.Enable(True)
2524	self.save_current_state()
2525
2526	if msg is not None:
2527	return False
2528	else:
2529	return True
2530
2531	def onSmear(self, event):
2532	"""
2533	Create a smear object that will change the way residuals
2534	are computed when fitting
2535	"""
2536	if event is not None:
2537	event.Skip()
2538	if self.data is None:
2539	return
2540
2541	# Need update param values
2542	self._update_paramv_on_fit()
2543	if self.model is not None:
2544	if self.data.is_data:
2545	self._manager.page_finder[self.uid].add_data(data=self.data)
2546	temp_smearer = self.on_smear_helper()
2547
2548	self.sizer_set_smearer.Layout()
2549	# we need FitInside here not just self.Layout to ensure all the sizers
2550	# end up with the necessasary space to in the scroll panel. In
2551	# particular the compute and fit buttons end up on top of each other
2552	# PDB Nov 28 2015.
2553	self.FitInside()
2554	self._set_weight()
2555
2556	# set smearing value whether or not the data contain the smearing info
2557	enable_smearer = not self.disable_smearer.GetValue()
2558	wx.CallAfter(self._manager.set_smearer, uid=self.uid,
2559	smearer=temp_smearer,
2560	fid=self.data.id,
2561	qmin=float(self.qmin_x),
2562	qmax=float(self.qmax_x),
2563	enable_smearer=enable_smearer)
2564
2565	self.state.enable_smearer = self.enable_smearer.GetValue()
2566	self.state.disable_smearer = self.disable_smearer.GetValue()
2567	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
2568	self.state.slit_smearer = self.slit_smearer.GetValue()
2569
2570	def on_smear_helper(self, update=False):
2571	"""
2572	Help for onSmear
2573
2574	:param update: force or not to update
2575	"""
2576	self._get_smear_info()
2577	# renew smear sizer
2578	if self.smear_type is not None:
2579	self.smear_description_smear_type.SetValue(str(self.smear_type))
2580	self.smear_data_left.SetValue(str(self.dq_l))
2581	self.smear_data_right.SetValue(str(self.dq_r))
2582
2583	self._hide_all_smear_info()
2584	data = copy.deepcopy(self.data)
2585
2586	# make sure once more if it is smearer
2587	temp_smearer = smear_selection(data, self.model)
2588	if self.current_smearer != temp_smearer or update:
2589	self.current_smearer = temp_smearer
2590	if self.enable_smearer.GetValue():
2591	if self.current_smearer is None:
2592	wx.PostEvent(self._manager.parent,
2593	StatusEvent(status="Data contains no smearing information"))
2594	else:
2595	wx.PostEvent(self._manager.parent,
2596	StatusEvent(status="Data contains smearing information"))
2597
2598	self.smear_data_left.Show(True)
2599	self.smear_data_right.Show(True)
2600	temp_smearer = self.current_smearer
2601	elif self.disable_smearer.GetValue():
2602	self.smear_description_none.Show(True)
2603	elif self.pinhole_smearer.GetValue():
2604	self.onPinholeSmear(None)
2605	elif self.slit_smearer.GetValue():
2606	self.onSlitSmear(None)
2607	self._show_smear_sizer()
2608
2609	return temp_smearer
2610
2611	def on_complete_chisqr(self, event):
2612	"""
2613	Display result chisqr on the panel
2614	:event: activated by fitting/ complete after draw
2615	"""
2616	try:
2617	if event is None:
2618	output = "-"
2619	elif not np.isfinite(event.output):
2620	output = "-"
2621	else:
2622	output = event.output
2623	self.tcChi.SetValue(str(format_number(output, True)))
2624	self.state.tcChi = self.tcChi.GetValue()
2625	except:
2626	pass
2627
2628	def get_all_checked_params(self):
2629	"""
2630	Found all parameters current check and add them to list of parameters
2631	to fit
2632	"""
2633	self.param_toFit = []
2634	for item in self.parameters:
2635	if item[0].GetValue() and item not in self.param_toFit:
2636	if item[0].IsShown():
2637	self.param_toFit.append(item)
2638	for item in self.fittable_param:
2639	if item[0].GetValue() and item not in self.param_toFit:
2640	if item[0].IsShown():
2641	self.param_toFit.append(item)
2642	self.save_current_state_fit()
2643
2644	event = PageInfoEvent(page=self)
2645	wx.PostEvent(self.parent, event)
2646	param2fit = []
2647	for item in self.param_toFit:
2648	if item[0] and item[0].IsShown():
2649	param2fit.append(item[1])
2650	self._manager.set_param2fit(self.uid, param2fit)
2651
2652	def select_param(self, event=None):
2653	"""
2654	Select TextCtrl checked for fitting purpose and stores them
2655	in self.param_toFit=[] list
2656	"""
2657	self.param_toFit = []
2658	for item in self.parameters:
2659	# Skip t ifhe angle parameters if 1D data
2660	if self.data.__class__.__name__ != "Data2D" and\
2661	not self.enable2D:
2662	if item in self.orientation_params:
2663	continue
2664	# Select parameters to fit for list of primary parameters
2665	if item[0].GetValue() and item[0].IsShown():
2666	if not (item in self.param_toFit):
2667	self.param_toFit.append(item)
2668	else:
2669	#remove parameters from the fitting list
2670	if item in self.param_toFit:
2671	self.param_toFit.remove(item)
2672
2673	# Select parameters to fit for list of fittable parameters
2674	# with dispersion
2675	for item in self.fittable_param:
2676	# Skip t ifhe angle parameters if 1D data
2677	if self.data.__class__.__name__ != "Data2D" and\
2678	not self.enable2D:
2679	if item in self.orientation_params:
2680	continue
2681	if item[0].GetValue() and item[0].IsShown():
2682	if not (item in self.param_toFit):
2683	self.param_toFit.append(item)
2684	else:
2685	# remove parameters from the fitting list
2686	if item in self.param_toFit:
2687	self.param_toFit.remove(item)
2688
2689	# Calculate num. of angle parameters
2690	if self.data.__class__.__name__ == "Data2D" or \
2691	self.enable2D:
2692	len_orient_para = 0
2693	else:
2694	len_orient_para = len(self.orientation_params) # assume even len
2695	# Total num. of angle parameters
2696	if len(self.fittable_param) > 0:
2697	len_orient_para *= 2
2698
2699	self.save_current_state_fit()
2700	if event is not None:
2701	# post state to fit panel
2702	event = PageInfoEvent(page=self)
2703	wx.PostEvent(self.parent, event)
2704
2705	param2fit = []
2706	for item in self.param_toFit:
2707	if item[0] and item[0].IsShown():
2708	param2fit.append(item[1])
2709	self._manager.set_param2fit(self.uid, param2fit)
2710
2711	def set_model_param_sizer(self, model):
2712	"""
2713	Build the panel from the model content
2714
2715	:param model: the model selected in combo box for fitting purpose
2716
2717	"""
2718	self.sizer3.Clear(True)
2719	self.parameters = []
2720	self.str_parameters = []
2721	self.param_toFit = []
2722	self.fittable_param = []
2723	self.fixed_param = []
2724	self.orientation_params = []
2725	self.orientation_params_disp = []
2726
2727	if model is None:
2728	self.sizer3.Layout()
2729	self.SetupScrolling()
2730	return
2731
2732	box_description = wx.StaticBox(self, wx.ID_ANY, str("Model Parameters"))
2733	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
2734	sizer = wx.GridBagSizer(5, 5)
2735	# save the current model
2736	self.model = model
2737
2738	keys = self.model.getParamList()
2739
2740	# list of dispersion parameters
2741	self.disp_list = self.model.getDispParamList()
2742
2743	def custom_compare(a, b):
2744	"""
2745	Custom compare to order, first by alphabets then second by number.
2746	"""
2747	# number at the last digit
2748	a_last = a[len(a) - 1]
2749	b_last = b[len(b) - 1]
2750	# default
2751	num_a = None
2752	num_b = None
2753	# split the names
2754	a2 = a.lower().split('_')
2755	b2 = b.lower().split('_')
2756	# check length of a2, b2
2757	len_a2 = len(a2)
2758	len_b2 = len(b2)
2759	# check if it contains a int number(<10)
2760	try:
2761	num_a = int(a_last)
2762	except:
2763	pass
2764	try:
2765	num_b = int(b_last)
2766	except:
2767	pass
2768	# Put 'scale' near the top; happens
2769	# when numbered param name exists
2770	if a == 'scale':
2771	return -1
2772	# both have a number
2773	if num_a is not None and num_b is not None:
2774	if num_a > num_b:
2775	return -1
2776	# same number
2777	elif num_a == num_b:
2778	# different last names
2779	if a2[len_a2 - 1] != b2[len_b2 - 1] and num_a != 0:
2780	return -cmp(a2[len_a2 - 1], b2[len_b2 - 1])
2781	else:
2782	return cmp(a, b)
2783	else:
2784	return 1
2785	# one of them has a number
2786	elif num_a is not None:
2787	return 1
2788	elif num_b is not None:
2789	return -1
2790	# no numbers
2791	else:
2792	return cmp(a.lower(), b.lower())
2793
2794	# keys obtained now from ordered dict, so commenting alphabetical
2795	# ordering keys.sort(custom_compare)
2796
2797	iy = 0
2798	ix = 0
2799	sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Parameter'),
2800	(iy, ix), (1, 1), wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2801	ix += 1
2802	self.text2_2 = wx.StaticText(self, wx.ID_ANY, 'Value')
2803	sizer.Add(self.text2_2, (iy, ix), (1, 1),
2804	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2805	ix += 2
2806	self.text2_3 = wx.StaticText(self, wx.ID_ANY, 'Error')
2807	sizer.Add(self.text2_3, (iy, ix), (1, 1),
2808	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2809	if not self.is_mac:
2810	self.text2_3.Hide()
2811	ix += 1
2812	self.text2_min = wx.StaticText(self, wx.ID_ANY, 'Min')
2813	sizer.Add(self.text2_min, (iy, ix), (1, 1),
2814	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2815	# self.text2_min.Hide()
2816	ix += 1
2817	self.text2_max = wx.StaticText(self, wx.ID_ANY, 'Max')
2818	sizer.Add(self.text2_max, (iy, ix), (1, 1),
2819	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2820	# self.text2_max.Hide()
2821	ix += 1
2822	self.text2_4 = wx.StaticText(self, wx.ID_ANY, '[Units]')
2823	sizer.Add(self.text2_4, (iy, ix), (1, 1),
2824	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2825	self.text2_4.Hide()
2826
2827	CHECK_STATE = False
2828	for item in keys:
2829
2830	if item not in self.disp_list and not item in \
2831	self.model.orientation_params:
2832
2833	# prepare a spot to store errors
2834	if item not in self.model.details:
2835	self.model.details[item] = ["", None, None]
2836
2837	iy += 1
2838	ix = 0
2839	if (self.model.__class__ in
2840	self.model_list_box["Multi-Functions"] or
2841	self.temp_multi_functional)\
2842	and (item in self.model.non_fittable):
2843	non_fittable_name = wx.StaticText(self, wx.ID_ANY, item)
2844	sizer.Add(non_fittable_name, (iy, ix), (1, 1),
2845	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 21)
2846	# add parameter value
2847	ix += 1
2848	value = self.model.getParam(item)
2849	if len(self.model.fun_list) > 0:
2850	# num = item.split('_')[1][5:7]
2851	fun_box = wx.ComboBox(self, wx.ID_ANY, size=(100, -1),
2852	style=wx.CB_READONLY, name='%s' % item)
2853	self._set_fun_box_list(fun_box)
2854	fun_box.SetSelection(0)
2855	# self.fun_box.SetToolTipString("A function
2856	# describing the interface")
2857	wx.EVT_COMBOBOX(fun_box, wx.ID_ANY, self._on_fun_box)
2858	else:
2859	fun_box = ModelTextCtrl(self, wx.ID_ANY,
2860	size=(_BOX_WIDTH, 20),
2861	style=wx.TE_PROCESS_ENTER, name='%s' % item)
2862	fun_box.SetToolTipString(
2863	"Hit 'Enter' after typing to update the plot.")
2864	fun_box.SetValue(format_number(value, True))
2865	sizer.Add(fun_box, (iy, ix), (1, 1), wx.EXPAND)
2866	self.str_parameters.append([None, item, fun_box,
2867	None, None, None,
2868	None, None])
2869	else:
2870	# add parameters name with checkbox for selecting to fit
2871	cb = wx.CheckBox(self, wx.ID_ANY, item)
2872	cb.SetValue(CHECK_STATE)
2873	cb.SetToolTipString(" Check mark to fit.")
2874	# cb.SetValue(True)
2875	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2876
2877	sizer.Add(cb, (iy, ix), (1, 1),
2878	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
2879
2880	# add parameter value
2881	ix += 1
2882	value = self.model.getParam(item)
2883	ctl1 = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
2884	style=wx.TE_PROCESS_ENTER)
2885	ctl1.SetToolTipString(
2886	"Hit 'Enter' after typing to update the plot.")
2887	ctl1.SetValue(format_number(value, True))
2888	sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
2889	# text to show error sign
2890	ix += 1
2891	text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
2892	sizer.Add(text2, (iy, ix), (1, 1),
2893	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2894	if not self.is_mac:
2895	text2.Hide()
2896	ix += 1
2897	ctl2 = wx.TextCtrl(self, wx.ID_ANY,
2898	size=(_BOX_WIDTH / 1.2, 20), style=0)
2899	sizer.Add(ctl2, (iy, ix), (1, 1),
2900	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2901	if not self.is_mac:
2902	ctl2.Hide()
2903
2904	ix += 1
2905	ctl3 = ModelTextCtrl(self, wx.ID_ANY,
2906	size=(_BOX_WIDTH / 1.9, 20),
2907	style=wx.TE_PROCESS_ENTER,
2908	text_enter_callback=self._onparamRangeEnter)
2909	min_bound = self.model.details[item][1]
2910	if min_bound is not None:
2911	ctl3.SetValue(format_number(min_bound, True))
2912
2913	sizer.Add(ctl3, (iy, ix), (1, 1),
2914	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2915
2916	ix += 1
2917	ctl4 = ModelTextCtrl(self, wx.ID_ANY,
2918	size=(_BOX_WIDTH / 1.9, 20),
2919	style=wx.TE_PROCESS_ENTER,
2920	text_enter_callback=self._onparamRangeEnter)
2921	max_bound = self.model.details[item][2]
2922	if max_bound is not None:
2923	ctl4.SetValue(format_number(max_bound, True))
2924	sizer.Add(ctl4, (iy, ix), (1, 1),
2925	wx.EXPAND \| wx.FIXED_MINSIZE, 0)
2926
2927	ix += 1
2928	# Units
2929	if item in self.model.details:
2930	units = wx.StaticText(self, wx.ID_ANY,
2931	self.model.details[item][0], style=wx.ALIGN_LEFT)
2932	else:
2933	units = wx.StaticText(self, wx.ID_ANY, "",
2934	style=wx.ALIGN_LEFT)
2935	sizer.Add(units, (iy, ix), (1, 1),
2936	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
2937
2938	self.parameters.append([cb, item, ctl1,
2939	text2, ctl2, ctl3, ctl4, units])
2940
2941	iy += 1
2942	sizer.Add((10, 10), (iy, ix), (1, 1),
2943	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
2944
2945	# type can be either Guassian or Array
2946	if len(self.model.dispersion.values()) > 0:
2947	type = self.model.dispersion.values()[0]["type"]
2948	else:
2949	type = "Gaussian"
2950
2951	iy += 1
2952	ix = 0
2953	# Add tile for orientational angle
2954	for item in keys:
2955	if item in self.model.orientation_params:
2956	orient_angle = wx.StaticText(self, wx.ID_ANY, '[For 2D only]:')
2957	mag_on_button = wx.Button(self, wx.ID_ANY, "Magnetic ON")
2958	mag_on_button.SetToolTipString("Turn Pol Beam/Mag scatt on/off")
2959	mag_on_button.Bind(wx.EVT_BUTTON, self._on_mag_on)
2960	mag_angle_help_button = wx.Button(self, wx.ID_ANY,
2961	"Magnetic angles?")
2962	mag_angle_help_button.SetToolTipString("see angle definitions")
2963	mag_help_button = wx.Button(self, wx.ID_ANY, "Mag HELP")
2964	mag_help_button.SetToolTipString("Help on pol beam/mag fitting")
2965	mag_help_button.Bind(wx.EVT_BUTTON, self._on_mag_help)
2966	mag_angle_help_button.Bind(wx.EVT_BUTTON,
2967	self._on_mag_angle_help)
2968	sizer.Add(orient_angle, (iy, ix), (1, 1),
2969	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
2970	iy += 1
2971	sizer.Add(mag_on_button, (iy, ix), (1, 1),
2972	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
2973	ix += 1
2974	sizer.Add(mag_angle_help_button, (iy, ix), (1, 1),
2975	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
2976	sizer.Add(mag_help_button, (iy, ix + 1), (1, 1),
2977	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
2978
2979	# handle the magnetic buttons
2980	# clean this up so that assume mag is off then turn
2981	# all buttons on IF mag has mag and has 2D
2982	if not self._has_magnetic:
2983	mag_on_button.Show(False)
2984	elif not self.data.__class__.__name__ == "Data2D":
2985	mag_on_button.Show(False)
2986	else:
2987	mag_on_button.Show(True)
2988	mag_help_button.Show(False)
2989	mag_angle_help_button.Show(False)
2990	if mag_on_button.IsShown():
2991	if self.magnetic_on:
2992	mag_on_button.SetLabel("Magnetic OFF")
2993	mag_help_button.Show(True)
2994	mag_angle_help_button.Show(True)
2995	else:
2996	mag_on_button.SetLabel("Magnetic ON")
2997	mag_help_button.Show(False)
2998	mag_angle_help_button.Show(False)
2999
3000	if not self.data.__class__.__name__ == "Data2D" and \
3001	not self.enable2D:
3002	orient_angle.Hide()
3003	else:
3004	orient_angle.Show(True)
3005	break
3006
3007	# For Gaussian only
3008	if type.lower() != "array":
3009	for item in self.model.orientation_params:
3010	if not self.magnetic_on:
3011	if item in self.model.magnetic_params:
3012	continue
3013	if item not in self.disp_list:
3014	# prepare a spot to store min max
3015	if item not in self.model.details:
3016	self.model.details[item] = ["", None, None]
3017
3018	iy += 1
3019	ix = 0
3020	# add parameters name with checkbox for selecting to fit
3021	cb = wx.CheckBox(self, wx.ID_ANY, item)
3022	cb.SetValue(CHECK_STATE)
3023	cb.SetToolTipString("Check mark to fit")
3024	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
3025	if self.data.__class__.__name__ == "Data2D" or \
3026	self.enable2D:
3027	cb.Show(True)
3028	else:
3029	cb.Hide()
3030	sizer.Add(cb, (iy, ix), (1, 1),
3031	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
3032
3033	# add parameter value
3034	ix += 1
3035	value = self.model.getParam(item)
3036	ctl1 = ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
3037	style=wx.TE_PROCESS_ENTER)
3038	ctl1.SetToolTipString(
3039	"Hit 'Enter' after typing to update the plot.")
3040	ctl1.SetValue(format_number(value, True))
3041	if self.data.__class__.__name__ == "Data2D" or \
3042	self.enable2D:
3043	ctl1.Show(True)
3044	else:
3045	ctl1.Hide()
3046	sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
3047	# text to show error sign
3048	ix += 1
3049	text2 = wx.StaticText(self, -1, '+/-')
3050	sizer.Add(text2, (iy, ix), (1, 1),
3051	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
3052
3053	text2.Hide()
3054	ix += 1
3055	ctl2 = wx.TextCtrl(self, -1,
3056	size=(_BOX_WIDTH / 1.2, 20), style=0)
3057	sizer.Add(ctl2, (iy, ix), (1, 1),
3058	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
3059
3060	ctl2.Hide()
3061
3062	ix += 1
3063	ctl3 = ModelTextCtrl(self, -1,
3064	size=(_BOX_WIDTH / 1.8, 20),
3065	style=wx.TE_PROCESS_ENTER,
3066	text_enter_callback=self._onparamRangeEnter)
3067
3068	sizer.Add(ctl3, (iy, ix), (1, 1),
3069	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
3070	ctl3.Hide()
3071
3072	ix += 1
3073	ctl4 = ModelTextCtrl(self, -1,
3074	size=(_BOX_WIDTH / 1.8, 20),
3075	style=wx.TE_PROCESS_ENTER,
3076	text_enter_callback=self._onparamRangeEnter)
3077	sizer.Add(ctl4, (iy, ix), (1, 1),
3078	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
3079
3080	ctl4.Hide()
3081
3082	if self.data.__class__.__name__ == "Data2D" or \
3083	self.enable2D:
3084	if self.is_mac:
3085	text2.Show(True)
3086	ctl2.Show(True)
3087	ctl3.Show(True)
3088	ctl4.Show(True)
3089
3090	ix += 1
3091	# Units
3092	if item in self.model.details:
3093	units = wx.StaticText(self, -1,
3094	self.model.details[item][0],
3095	style=wx.ALIGN_LEFT)
3096	else:
3097	units = wx.StaticText(self, -1, "",
3098	style=wx.ALIGN_LEFT)
3099	if self.data.__class__.__name__ == "Data2D" or \
3100	self.enable2D:
3101	units.Show(True)
3102	else:
3103	units.Hide()
3104
3105	sizer.Add(units, (iy, ix), (1, 1),
3106	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
3107
3108	self.parameters.append([cb, item, ctl1,
3109	text2, ctl2, ctl3, ctl4, units])
3110	self.orientation_params.append([cb, item, ctl1,
3111	text2, ctl2, ctl3, ctl4, units])
3112
3113	iy += 1
3114	box_description.SetForegroundColour(wx.BLUE)
3115	# Display units text on panel
3116	for item in keys:
3117	if item in self.model.details:
3118	self.text2_4.Show()
3119	# Fill the list of fittable parameters
3120	self.get_all_checked_params()
3121	self.save_current_state_fit()
3122	boxsizer1.Add(sizer)
3123	self.sizer3.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
3124	self.sizer3.Layout()
3125	self.Layout()
3126
3127	def on_right_down(self, event):
3128	"""
3129	Get key stroke event
3130	"""
3131	if self.data is None:
3132	return
3133	# Figuring out key combo: Cmd for copy, Alt for paste
3134	if event.AltDown() and event.ShiftDown():
3135	flag = True
3136	elif event.AltDown() or event.ShiftDown():
3137	flag = False
3138	else:
3139	return
3140	# make event free
3141	event.Skip()
3142	# messages depending on the flag
3143	if not flag:
3144	infor = 'warning'
3145	# inform msg to wx
3146	wx.PostEvent(self._manager.parent,
3147	StatusEvent(status=msg, info=infor))
3148
3149	def _onModel2D(self, event):
3150	"""
3151	toggle view of model from 1D to 2D or 2D from 1D
3152	"""
3153	if self.model_view.GetLabelText() == "Show 2D":
3154	self.model_view.SetLabel("Show 1D")
3155	self.enable2D = True
3156
3157	else:
3158	self.model_view.SetLabel("Show 2D")
3159	self.enable2D = False
3160	self.Show(False)
3161	self.create_default_data()
3162	self._manager.store_data(self.uid, data_list=[self.data])
3163
3164	self.set_model_param_sizer(self.model)
3165	self._set_sizer_dispersion()
3166	self._set_weight(is_2D=self.enable2D)
3167	self._set_smear_buttons()
3168	self.Show(True)
3169	self.SetupScrolling()
3170	self._draw_model()
3171
3172	self.state.enable2D = copy.deepcopy(self.enable2D)
3173
3174	def _set_smear_buttons(self):
3175	"""
3176	Set semarer radio buttons
3177	"""
3178	# more disables for 2D
3179	if self.data.__class__.__name__ == "Data2D" or \
3180	self.enable2D:
3181	self.slit_smearer.Disable()
3182	self.pinhole_smearer.Enable(True)
3183	self.default_mask = copy.deepcopy(self.data.mask)
3184	else:
3185	self.slit_smearer.Enable(True)
3186	self.pinhole_smearer.Enable(True)
3187
3188
3189	class BGTextCtrl(wx.TextCtrl):
3190	"""
3191	Text control used to display outputs.
3192	No editing allowed. The background is
3193	grayed out. User can't select text.
3194	"""
3195	def __init__(self, args, *kwds):
3196	wx.TextCtrl.__init__(self, args, *kwds)
3197	self.SetEditable(False)
3198	self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
3199
3200	# Bind to mouse event to avoid text highlighting
3201	# The event will be skipped once the call-back
3202	# is called.
3203	self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
3204
3205	def _click(self, event):
3206	"""
3207	Prevent further handling of the mouse event
3208	by not calling Skip().
3209	"""
3210	pass

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

SasView

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

Download in other formats: