fitpage.py @ 587ce8c

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

Last change on this file since 587ce8c was ef2cdb3, checked in by butler, 8 years ago
Merge remote-tracking branch 'origin/master' into ticket-756
Property mode set to `100644`
File size: 128.7 KB

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

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

SasView

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

Download in other formats: