resolution_calculator_panel.py @ b9d74f3

Last change on this file since b9d74f3 was b9d74f3, checked in by andyfaff, 8 years ago
MAINT: use raise Exception() not raise Exception
Property mode set to `100644`
File size: 57.2 KB

Line
1	# pylint: disable=attribute-defined-outside-init
2	"""
3	This software was developed by the University of Tennessee as part of the
4	Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
5	project funded by the US National Science Foundation.
6
7	See the license text in license.txt
8
9	copyright 2008, 2009, 2010 University of Tennessee
10	"""
11	import wx
12	import sys
13	import os
14	import matplotlib
15	import math
16	import logging
17	#Use the WxAgg back end. The Wx one takes too long to render
18	matplotlib.use('WXAgg')
19	from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
20	from matplotlib.backends.backend_wxagg import NavigationToolbar2Wx as Toolbar
21	from matplotlib.backend_bases import FigureManagerBase
22	# Wx-Pylab magic for displaying plots within an application's window.
23	from matplotlib import _pylab_helpers
24	# The Figure object is used to create backend-independent plot representations.
25	from matplotlib.figure import Figure
26
27	#from sas.guicomm.events import StatusEvent
28	from sas.sascalc.calculator.resolution_calculator import ResolutionCalculator
29	from sas.sasgui.guiframe.events import StatusEvent
30	from sas.sasgui.perspectives.calculator.calculator_widgets import OutputTextCtrl
31	from sas.sasgui.perspectives.calculator.calculator_widgets import InputTextCtrl
32	from wx.lib.scrolledpanel import ScrolledPanel
33	from math import fabs
34	from sas.sasgui.perspectives.calculator import calculator_widgets as widget
35	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
36
37	logger = logging.getLogger(__name__)
38
39	_BOX_WIDTH = 100
40	_Q_DEFAULT = 0.0
41	#Slit length panel size
42	if sys.platform.count("win32") > 0:
43	PANEL_TOP = 0
44	PANEL_WIDTH = 525
45	PANEL_HEIGHT = 653
46	FONT_VARIANT = 0
47	IS_WIN = True
48	else:
49	PANEL_TOP = 60
50	PANEL_WIDTH = 540
51	PANEL_HEIGHT = 662
52	FONT_VARIANT = 1
53	IS_WIN = False
54
55	_SOURCE_MASS = {'Alpha':6.64465620E-24,
56	'Deuteron':3.34358320E-24,
57	'Neutron':1.67492729E-24,
58	'Photon': 0.0,
59	'Proton':1.67262137E-24,
60	'Triton':5.00826667E-24}
61
62	class ResolutionCalculatorPanel(ScrolledPanel):
63	"""
64	Provides the Resolution calculator GUI.
65	"""
66	## Internal nickname for the window, used by the AUI manager
67	window_name = "Q Resolution Estimator"
68	## Name to appear on the window title bar
69	window_caption = ""
70	## Flag to tell the AUI manager to put this panel in the center pane
71	CENTER_PANE = True
72
73	def __init__(self, parent, args, *kwds):
74	kwds["size"] = (PANEL_WIDTH * 2, PANEL_HEIGHT)
75	kwds["style"] = wx.FULL_REPAINT_ON_RESIZE
76	ScrolledPanel.__init__(self, parent, args, *kwds)
77	self.SetupScrolling()
78	self.parent = parent
79
80	# input defaults
81	self.qx = []
82	self.qy = []
83	# dQ defaults
84	self.sigma_r = None
85	self.sigma_phi = None
86	self.sigma_1d = None
87	# monchromatic or polychromatic
88	self.wave_color = 'mono'
89	self.num_wave = 10
90	self.spectrum_dic = {}
91	# dQ 2d image
92	self.image = None
93	# results of sigmas
94	self.sigma_strings = ' '
95	#Font size
96	self.SetWindowVariant(variant=FONT_VARIANT)
97	# Object that receive status event
98	self.resolution = ResolutionCalculator()
99	# Source selection dic
100	self.source_mass = _SOURCE_MASS
101	#layout attribute
102	self.hint_sizer = None
103	# detector coordinate of estimation of sigmas
104	self.det_coordinate = 'cartesian'
105	self.source_cb = None
106	self._do_layout()
107
108	def _define_structure(self):
109	"""
110	Define the main sizers building to build this application.
111	"""
112	self.main_sizer = wx.BoxSizer(wx.HORIZONTAL)
113	self.vertical_l_sizer = wx.BoxSizer(wx.VERTICAL)
114	self.vertical_r_spacer = wx.BoxSizer(wx.VERTICAL)
115	self.vertical_r_frame = wx.StaticBox(self, -1, '')
116	self.vertical_r_sizer = wx.StaticBoxSizer(self.vertical_r_frame,
117	wx.VERTICAL)
118	self.box_source = wx.StaticBox(self, -1, str(self.window_caption))
119	self.boxsizer_source = wx.StaticBoxSizer(self.box_source, wx.VERTICAL)
120	self.mass_sizer = wx.BoxSizer(wx.HORIZONTAL)
121	self.intensity_sizer = wx.BoxSizer(wx.HORIZONTAL)
122	self.wavelength_sizer = wx.BoxSizer(wx.HORIZONTAL)
123	self.wavelength_spread_sizer = wx.BoxSizer(wx.HORIZONTAL)
124	self.source_aperture_sizer = wx.BoxSizer(wx.HORIZONTAL)
125	self.sample_aperture_sizer = wx.BoxSizer(wx.HORIZONTAL)
126	self.source2sample_distance_sizer = wx.BoxSizer(wx.HORIZONTAL)
127	self.sample2sample_distance_sizer = wx.BoxSizer(wx.HORIZONTAL)
128	self.sample2detector_distance_sizer = wx.BoxSizer(wx.HORIZONTAL)
129	self.detector_size_sizer = wx.BoxSizer(wx.HORIZONTAL)
130	self.detector_pix_size_sizer = wx.BoxSizer(wx.HORIZONTAL)
131	self.input_sizer = wx.BoxSizer(wx.VERTICAL)
132	self.output_sizer = wx.BoxSizer(wx.VERTICAL)
133	self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)
134	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
135
136	def _layout_mass(self):
137	"""
138	Fill the sizer containing mass
139	"""
140	# get the mass
141	mass_value = str(self.resolution.mass)
142	self.mass_txt = wx.StaticText(self, -1, 'Source: ')
143	self.mass_hint = "Mass of Neutrons m = %s [g]" % str(self.resolution.mass)
144	self.source_cb = wx.ComboBox(self, -1,
145	style=wx.CB_READONLY,
146	name='%s' % mass_value)
147	# Sort source name because wx2.9 on Mac does not support CB_SORT
148	# Custom sorting
149	source_list = []
150	for key, _ in self.source_mass.iteritems():
151	name_source = str(key)
152	source_list.append(name_source)
153	source_list.sort()
154	for idx in range(len(source_list)):
155	self.source_cb.Append(source_list[idx], idx)
156	self.source_cb.SetStringSelection("Neutron")
157	wx.EVT_COMBOBOX(self.source_cb, -1, self._on_source_selection)
158
159	# combo box for color
160	self.wave_color_cb = wx.ComboBox(self, -1,
161	style=wx.CB_READONLY,
162	name='color')
163	# two choices
164	self.wave_color_cb.Append('Monochromatic')
165	self.wave_color_cb.Append('TOF')
166	self.wave_color_cb.SetStringSelection("Monochromatic")
167	wx.EVT_COMBOBOX(self.wave_color_cb, -1, self._on_source_color)
168
169	source_hint = "Source Selection: Affect on"
170	source_hint += " the gravitational contribution.\n"
171	source_hint += "Mass of %s: m = %s [g]" % \
172	('Neutron', str(self.resolution.mass))
173	self.mass_txt.SetToolTipString(source_hint)
174	self.mass_sizer.AddMany([(self.mass_txt, 0, wx.LEFT, 15),
175	(self.source_cb, 0, wx.LEFT, 15),
176	(self.wave_color_cb, 0, wx.LEFT, 15)])
177
178	def _layout_intensity(self):
179	"""
180	Fill the sizer containing intensity
181	"""
182	# get the intensity
183	intensity_value = str(self.resolution.intensity)
184	intensity_unit_txt = wx.StaticText(self, -1, '[counts/s]')
185	intensity_txt = wx.StaticText(self, -1, 'Intensity: ')
186	self.intensity_tcl = InputTextCtrl(self, -1,
187	size=(_BOX_WIDTH, -1))
188	intensity_hint = "Intensity of Neutrons"
189	self.intensity_tcl.SetValue(intensity_value)
190	self.intensity_tcl.SetToolTipString(intensity_hint)
191	self.intensity_sizer.AddMany([(intensity_txt, 0, wx.LEFT, 15),
192	(self.intensity_tcl, 0, wx.LEFT, 15),
193	(intensity_unit_txt, 0, wx.LEFT, 10)])
194
195
196	def _layout_wavelength(self):
197	"""
198	Fill the sizer containing wavelength
199	"""
200	# get the wavelength
201	wavelength_value = str(self.resolution.get_wavelength())
202	wavelength_unit_txt = wx.StaticText(self, -1, '[A]')
203	wavelength_txt = wx.StaticText(self, -1, 'Wavelength: ')
204	self.wavelength_tcl = InputTextCtrl(self, -1,
205	size=(_BOX_WIDTH, -1))
206	wavelength_hint = "Wavelength of Neutrons"
207	self.wavelength_tcl.SetValue(wavelength_value)
208	self.wavelength_tcl.SetToolTipString(wavelength_hint)
209
210	# get the spectrum
211	spectrum_value = self.resolution.get_default_spectrum()
212	self.spectrum_dic['Add new'] = ''
213	self.spectrum_dic['Flat'] = spectrum_value
214
215	self.spectrum_txt = wx.StaticText(self, -1, 'Spectrum: ')
216	self.spectrum_cb = wx.ComboBox(self, -1,
217	style=wx.CB_READONLY,
218	size=(_BOX_WIDTH, -1),
219	name='spectrum')
220	self.spectrum_cb.Append('Add new')
221	self.spectrum_cb.Append('Flat')
222	wx.EVT_COMBOBOX(self.spectrum_cb, -1, self._on_spectrum_cb)
223	spectrum_hint = "Wavelength Spectrum: Intensity vs. wavelength"
224	self.spectrum_cb.SetStringSelection('Flat')
225	self.spectrum_cb.SetToolTipString(spectrum_hint)
226	self.wavelength_sizer.AddMany([(wavelength_txt, 0, wx.LEFT, 15),
227	(self.wavelength_tcl, 0, wx.LEFT, 5),
228	(wavelength_unit_txt, 0, wx.LEFT, 5),
229	(self.spectrum_txt, 0, wx.LEFT, 20),
230	(self.spectrum_cb, 0, wx.LEFT, 5)])
231	self.spectrum_txt.Show(False)
232	self.spectrum_cb.Show(False)
233
234	def _layout_wavelength_spread(self):
235	"""
236	Fill the sizer containing wavelength
237	"""
238	# get the wavelength
239	wavelength_spread_value = str(self.resolution.get_wavelength_spread())
240	wavelength_spread_unit_txt = wx.StaticText(self, -1, '')
241	wavelength_spread_txt = wx.StaticText(self, -1, 'Wavelength Spread: ')
242	self.wavelength_spread_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
243	wavelength_spread_hint = "Wavelength Spread of Neutrons"
244	self.wavelength_spread_tcl.SetValue(wavelength_spread_value)
245	self.wavelength_spread_tcl.SetToolTipString(wavelength_spread_hint)
246	self.wavelength_spread_sizer.AddMany([(wavelength_spread_txt, 0,
247	wx.LEFT, 15),
248	(self.wavelength_spread_tcl, 0, wx.LEFT, 15),
249	(wavelength_spread_unit_txt, 0, wx.LEFT, 10)])
250
251
252	def _layout_source_aperture(self):
253	"""
254	Fill the sizer containing source aperture size
255	"""
256	# get the wavelength
257	source_aperture_value = str(self.resolution.source_aperture_size[0])
258	if len(self.resolution.source_aperture_size) > 1:
259	source_aperture_value += ", "
260	source_aperture_value += str(self.resolution.source_aperture_size[1])
261	source_aperture_unit_txt = wx.StaticText(self, -1, '[cm]')
262	source_aperture_txt = wx.StaticText(self, -1, 'Source Aperture Size: ')
263	self.source_aperture_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
264	source_aperture_hint = "Source Aperture Size"
265	self.source_aperture_tcl.SetValue(source_aperture_value)
266	self.source_aperture_tcl.SetToolTipString(source_aperture_hint)
267	self.source_aperture_sizer.AddMany([(source_aperture_txt, 0, wx.LEFT, 15),
268	(self.source_aperture_tcl, 0, wx.LEFT, 15),
269	(source_aperture_unit_txt, 0, wx.LEFT, 10)])
270
271	def _layout_sample_aperture(self):
272	"""
273	Fill the sizer containing sample aperture size
274	"""
275	# get the wavelength
276	sample_aperture_value = str(self.resolution.sample_aperture_size[0])
277	if len(self.resolution.sample_aperture_size) > 1:
278	sample_aperture_value += ", "
279	sample_aperture_value += str(self.resolution.sample_aperture_size[1])
280	sample_aperture_unit_txt = wx.StaticText(self, -1, '[cm]')
281	sample_aperture_txt = wx.StaticText(self, -1, 'Sample Aperture Size: ')
282	self.sample_aperture_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
283	sample_aperture_hint = "Sample Aperture Size"
284	self.sample_aperture_tcl.SetValue(sample_aperture_value)
285	self.sample_aperture_tcl.SetToolTipString(sample_aperture_hint)
286	self.sample_aperture_sizer.AddMany([(sample_aperture_txt, 0, wx.LEFT, 15),
287	(self.sample_aperture_tcl, 0, wx.LEFT, 15),
288	(sample_aperture_unit_txt, 0, wx.LEFT, 10)])
289
290	def _layout_source2sample_distance(self):
291	"""
292	Fill the sizer containing souce2sample_distance
293	"""
294	# get the wavelength
295	source2sample_distance_value = str(self.resolution.source2sample_distance[0])
296
297	source2sample_distance_unit_txt = wx.StaticText(self, -1, '[cm]')
298	source2sample_distance_txt = wx.StaticText(self, -1,
299	'Source to Sample Aperture Distance: ')
300	self.source2sample_distance_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
301	source2sample_distance_hint = "Source to Sample Aperture Distance"
302	self.source2sample_distance_tcl.SetValue(source2sample_distance_value)
303	self.source2sample_distance_tcl.SetToolTipString(source2sample_distance_hint)
304	self.source2sample_distance_sizer.AddMany([(source2sample_distance_txt, 0, wx.LEFT, 15),
305	(self.source2sample_distance_tcl, 0, wx.LEFT, 15),
306	(source2sample_distance_unit_txt, 0, wx.LEFT, 10)])
307
308	def _layout_sample2sample_distance(self):
309	"""
310	Fill the sizer containing sampleslit2sample_distance
311	"""
312	# get the distance
313	sample2sample_distance_value = str(self.resolution.sample2sample_distance[0])
314
315	sample2sample_distance_unit_txt = wx.StaticText(self, -1, '[cm]')
316	sample2sample_distance_txt = wx.StaticText(self, -1, 'Sample Offset: ')
317	self.sample2sample_distance_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
318	sample2sample_distance_hint = "Sample Aperture to Sample Distance"
319	self.sample2sample_distance_tcl.SetValue(sample2sample_distance_value)
320	self.sample2sample_distance_tcl.SetToolTipString(sample2sample_distance_hint)
321	self.sample2sample_distance_sizer.AddMany([(sample2sample_distance_txt, 0, wx.LEFT, 15),
322	(self.sample2sample_distance_tcl, 0, wx.LEFT, 15),
323	(sample2sample_distance_unit_txt, 0, wx.LEFT, 10)])
324
325	def _layout_sample2detector_distance(self):
326	"""
327	Fill the sizer containing sample2detector_distance
328	"""
329	# get the wavelength
330	sample2detector_distance_value = str(self.resolution.sample2detector_distance[0])
331
332	sample2detector_distance_unit_txt = wx.StaticText(self, -1, '[cm]')
333	sample2detector_distance_txt = wx.StaticText(self, -1,
334	'Sample Aperture to Detector Distance: ')
335	self.sample2detector_distance_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
336	sample2detector_distance_hint = "Sample Aperture to Detector Distance"
337	self.sample2detector_distance_tcl.SetValue(sample2detector_distance_value)
338	self.sample2detector_distance_tcl.SetToolTipString(sample2detector_distance_hint)
339	self.sample2detector_distance_sizer.AddMany([\
340	(sample2detector_distance_txt, 0, wx.LEFT, 15),
341	(self.sample2detector_distance_tcl, 0, wx.LEFT, 15),
342	(sample2detector_distance_unit_txt, 0, wx.LEFT, 10)])
343
344	def _layout_detector_size(self):
345	"""
346	Fill the sizer containing detector size
347	"""
348	# get the wavelength
349	detector_size_value = str(self.resolution.detector_size[0])
350	if len(self.resolution.detector_size) > 1:
351	detector_size_value += ", "
352	detector_size_value += str(self.resolution.detector_size[1])
353	detector_size_unit_txt = wx.StaticText(self, -1, '')
354	detector_size_txt = wx.StaticText(self, -1, 'Number of Pixels on Detector: ')
355	self.detector_size_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
356	detector_size_hint = "Number of Pixels on Detector"
357	self.detector_size_tcl.SetValue(detector_size_value)
358	self.detector_size_tcl.SetToolTipString(detector_size_hint)
359	self.detector_size_sizer.AddMany([(detector_size_txt, 0, wx.LEFT, 15),
360	(self.detector_size_tcl, 0, wx.LEFT, 15),
361	(detector_size_unit_txt, 0, wx.LEFT, 10)])
362
363	def _layout_detector_pix_size(self):
364	"""
365	Fill the sizer containing detector pixel size
366	"""
367	# get the detector_pix_size
368	detector_pix_size_value = str(self.resolution.detector_pix_size[0])
369	if len(self.resolution.detector_pix_size) > 1:
370	detector_pix_size_value += ", "
371	detector_pix_size_value += str(self.resolution.detector_pix_size[1])
372	detector_pix_size_unit_txt = wx.StaticText(self, -1, '[cm]')
373	detector_pix_size_txt = wx.StaticText(self, -1, 'Detector Pixel Size: ')
374	self.detector_pix_size_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, -1))
375	detector_pix_size_hint = "Detector Pixel Size"
376	self.detector_pix_size_tcl.SetValue(detector_pix_size_value)
377	self.detector_pix_size_tcl.SetToolTipString(detector_pix_size_hint)
378	self.detector_pix_size_sizer.AddMany([(detector_pix_size_txt, 0, wx.LEFT, 15),
379	(self.detector_pix_size_tcl, 0, wx.LEFT, 15),
380	(detector_pix_size_unit_txt, 0, wx.LEFT, 10)])
381
382	def _layout_input(self):
383	"""
384	Fill the sizer containing inputs; qx, qy
385	"""
386
387	q_title = wx.StaticText(self, -1, "[Q Location of the Estimation]:")
388	# sizers for inputs
389	inputQx_sizer = wx.BoxSizer(wx.HORIZONTAL)
390	inputQy_sizer = wx.BoxSizer(wx.HORIZONTAL)
391	# get the default dq
392	qx_value = str(_Q_DEFAULT)
393	qy_value = str(_Q_DEFAULT)
394	qx_unit_txt = wx.StaticText(self, -1, '[1/A] ')
395	qy_unit_txt = wx.StaticText(self, -1, '[1/A] ')
396	qx_name_txt = wx.StaticText(self, -1, 'Qx: ')
397	qy_name_txt = wx.StaticText(self, -1, 'Qy: ')
398	self.qx_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 3, -1))
399	self.qy_tcl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 3, -1))
400	qx_hint = "Type the Qx value."
401	qy_hint = "Type the Qy value."
402	self.qx_tcl.SetValue(qx_value)
403	self.qy_tcl.SetValue(qy_value)
404	self.qx_tcl.SetToolTipString(qx_hint)
405	self.qy_tcl.SetToolTipString(qy_hint)
406	inputQx_sizer.AddMany([(qx_name_txt, 0, wx.LEFT, 15),
407	(self.qx_tcl, 0, wx.LEFT, 15),
408	(qx_unit_txt, 0, wx.LEFT, 15)])
409	inputQy_sizer.AddMany([(qy_name_txt, 0, wx.LEFT, 15),
410	(self.qy_tcl, 0, wx.LEFT, 15),
411	(qy_unit_txt, 0, wx.LEFT, 15)])
412	self.input_sizer.AddMany([(q_title, 0, wx.LEFT, 15),
413	(inputQx_sizer, 0,
414	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
415	(inputQy_sizer, 0,
416	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5)])
417
418	def _layout_output(self):
419	"""
420	Fill the sizer containing dQ\|\| and dQ+
421	"""
422	sigma_title = wx.StaticText(self, -1,
423	"[Standard Deviation of the Resolution Distribution]:")
424	# sizers for inputs
425	outputQxy_sizer = wx.BoxSizer(wx.HORIZONTAL)
426	outputQ_sizer = wx.BoxSizer(wx.HORIZONTAL)
427	sigma_unit = '[' + '1/A' + ']'
428	self.sigma_r_txt = wx.StaticText(self, -1, 'Sigma_x: ')
429	self.sigma_r_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH * 0.8, -1))
430	self.sigma_phi_txt = wx.StaticText(self, -1, 'Sigma_y:')
431	self.sigma_phi_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH * 0.8, -1))
432	self.sigma_lamd_txt = wx.StaticText(self, -1, 'Sigma_lamd:')
433	self.sigma_lamd_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH * 0.7, -1))
434	sigma_1d_txt = wx.StaticText(self, -1, '( 1D: Sigma:')
435	self.sigma_1d_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH * 0.7, -1))
436	sigmax_hint = " The x component of the geometric resolution,"
437	sigmax_hint += " excluding sigma_lamda."
438	sigmay_hint = " The y component of the geometric resolution,"
439	sigmay_hint += " excluding sigma_lamda."
440	sigma_hint_lamd = " The wavelength contribution in the radial direction"
441	sigma_hint_lamd += ".\n Note: The phi component is always zero."
442	sigma_hint_1d = " Resolution in 1-dimension (for 1D data)."
443	self.sigma_r_tcl.SetToolTipString(sigmax_hint)
444	self.sigma_phi_tcl.SetToolTipString(sigmay_hint)
445	self.sigma_lamd_tcl.SetToolTipString(sigma_hint_lamd)
446	self.sigma_1d_tcl.SetToolTipString(sigma_hint_1d)
447	sigma_r_unit_txt = wx.StaticText(self, -1, sigma_unit)
448	sigma_phi_unit_txt = wx.StaticText(self, -1, sigma_unit)
449	sigma_lamd_unit_txt = wx.StaticText(self, -1, sigma_unit)
450	sigma_1d_unit_txt = wx.StaticText(self, -1, sigma_unit + ' )')
451	outputQxy_sizer.AddMany([(self.sigma_r_txt, 0, wx.LEFT, 15),
452	(self.sigma_r_tcl, 0, wx.LEFT, 15),
453	(sigma_r_unit_txt, 0, wx.LEFT, 15),
454	(self.sigma_phi_txt, 0, wx.LEFT, 15),
455	(self.sigma_phi_tcl, 0, wx.LEFT, 15),
456	(sigma_phi_unit_txt, 0, wx.LEFT, 15)])
457	outputQ_sizer.AddMany([(self.sigma_lamd_txt, 0, wx.LEFT, 15),
458	(self.sigma_lamd_tcl, 0, wx.LEFT, 15),
459	(sigma_lamd_unit_txt, 0, wx.LEFT, 15),
460	(sigma_1d_txt, 0, wx.LEFT, 15),
461	(self.sigma_1d_tcl, 0, wx.LEFT, 15),
462	(sigma_1d_unit_txt, 0, wx.LEFT, 15)])
463	self.output_sizer.AddMany([(sigma_title, 0, wx.LEFT, 15),
464	(outputQxy_sizer, 0,
465	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
466	(outputQ_sizer, 0,
467	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5)])
468
469	def _layout_hint(self):
470	"""
471	Fill the sizer containing hint
472	"""
473	hint_msg = ""
474	#hint_msg += "This tool is to approximately compute "
475	#hint_msg += "the instrumental resolution (dQ)."
476
477	self.hint_txt = wx.StaticText(self, -1, hint_msg)
478	self.hint_sizer.AddMany([(self.hint_txt, 0, wx.LEFT, 15)])
479
480	def _layout_button(self):
481	"""
482	Do the layout for the button widgets
483	"""
484
485	wx_id = wx.NewId()
486	self.reset_button = wx.Button(self, wx_id, "Reset")
487	hint_on_reset = "..."
488	self.reset_button.SetToolTipString(hint_on_reset)
489	self.Bind(wx.EVT_BUTTON, self.on_reset, id=wx_id)
490	#compute button
491	wx_id = wx.NewId()
492	self.compute_button = wx.Button(self, wx_id, "Compute")
493	hint_on_compute = "Compute... Please wait until finished."
494	self.compute_button.SetToolTipString(hint_on_compute)
495	self.Bind(wx.EVT_BUTTON, self.on_compute, id=wx_id)
496	#help button
497	wx_id = wx.NewId()
498	self.help_button = wx.Button(self, wx_id, "HELP")
499	hint_on_help = "Help on using the Resolution Calculator"
500	self.help_button.SetToolTipString(hint_on_help)
501	self.Bind(wx.EVT_BUTTON, self.on_help, id=wx_id)
502	# close button
503	self.bt_close = wx.Button(self, wx.ID_CANCEL, 'Close')
504	self.bt_close.Bind(wx.EVT_BUTTON, self.on_close)
505	self.bt_close.SetToolTipString("Close this window.")
506
507	self.button_sizer.Add((110, -1))
508	self.button_sizer.AddMany([(self.reset_button, 0, wx.LEFT, 50),
509	(self.compute_button, 0, wx.LEFT, 15),
510	(self.help_button, 0, wx.LEFT, 15),
511	(self.bt_close, 0, wx.LEFT, 15)])
512	self.compute_button.SetFocus()
513
514	def _layout_image(self):
515	"""
516	Layout for image plot
517	"""
518	# Contribution by James C.
519	# Instantiate a figure object that will contain our plots.
520	# Make the fig a little smaller than the default
521	self.figure = Figure(figsize=(6.5, 6), facecolor='white')
522
523	# Initialize the figure canvas, mapping the figure object to the plot
524	# engine backend.
525	self.canvas = FigureCanvas(self, wx.ID_ANY, self.figure)
526
527	# Wx-Pylab magic ...
528	# Make our canvas the active figure manager for pylab so that when
529	# pylab plotting statements are executed they will operate on our
530	# canvas and not create a new frame and canvas for display purposes.
531	# This technique allows this application to execute code that uses
532	# pylab stataments to generate plots and embed these plots in our
533	# application window(s).
534	self.fm = FigureManagerBase(self.canvas, 1)
535	_pylab_helpers.Gcf.set_active(self.fm)
536
537	# Instantiate the matplotlib navigation toolbar and explicitly show it.
538	mpl_toolbar = Toolbar(self.canvas)
539	# Diable pan
540	mpl_toolbar.DeleteToolByPos(3)
541
542	# Add a toolbar into the frame
543	mpl_toolbar.Realize()
544
545	# Compute before adding the canvas to the sizer
546	self.on_compute()
547
548	# Fill up the sizer
549	if IS_WIN:
550	gap = 27
551	else:
552	gap = 13
553	self.vertical_r_sizer.Add(self.canvas, 0, wx.ALL \| wx.EXPAND, 2)
554	self.vertical_r_spacer.Add((0, gap))
555	self.vertical_r_spacer.Add(self.vertical_r_sizer, 0, wx.ALL \| wx.EXPAND, 2)
556	self.vertical_r_spacer.Add((0, gap))
557	self.vertical_r_spacer.Add(wx.StaticLine(self), 0, wx.ALL \| wx.EXPAND, 2)
558	self.vertical_r_spacer.Add(mpl_toolbar, 0, wx.ALL \| wx.EXPAND, 2)
559
560	def _do_layout(self):
561	"""
562	Draw window layout
563	"""
564	# Title of parameters
565	instrument_txt = wx.StaticText(self, -1, '[Instrumental Parameters]:')
566	# Build individual layouts
567	self._define_structure()
568	self._layout_mass()
569	self._layout_wavelength()
570	self._layout_wavelength_spread()
571	self._layout_source_aperture()
572	self._layout_sample_aperture()
573	self._layout_source2sample_distance()
574	self._layout_sample2detector_distance()
575	self._layout_sample2sample_distance()
576	self._layout_detector_size()
577	self._layout_detector_pix_size()
578	self._layout_input()
579	self._layout_output()
580	self._layout_hint()
581	self._layout_button()
582	# Fill the sizers
583	self.boxsizer_source.AddMany([(instrument_txt, 0,
584	wx.EXPAND \| wx.LEFT, 15),
585	(self.mass_sizer, 0,
586	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
587	(self.wavelength_sizer, 0,
588	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
589	(self.wavelength_spread_sizer, 0,
590	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
591	(self.source_aperture_sizer, 0,
592	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
593	(self.sample_aperture_sizer, 0,
594	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
595	(self.source2sample_distance_sizer, 0,
596	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
597	(self.sample2detector_distance_sizer, 0,
598	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
599	(self.sample2sample_distance_sizer, 0,
600	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
601	(self.detector_size_sizer, 0,
602	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
603	(self.detector_pix_size_sizer, 0,
604	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
605	(wx.StaticLine(self), 0,
606	wx.ALL \| wx.EXPAND, 5),
607	(self.input_sizer, 0,
608	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5),
609	(wx.StaticLine(self), 0,
610	wx.ALL \| wx.EXPAND, 5),
611	(self.output_sizer, 0,
612	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5)])
613	self.vertical_l_sizer.AddMany([(self.boxsizer_source, 0, wx.ALL, 10),
614	(wx.StaticLine(self), 0,
615	wx.ALL \| wx.EXPAND, 5),
616	(self.button_sizer, 0,
617	wx.EXPAND \| wx.TOP \| wx.BOTTOM, 5)])
618	self.main_sizer.Add(self.vertical_l_sizer, 0, wx.ALL, 10)
619
620	# Build image plot layout
621	self._layout_image()
622	# Add a vertical static line
623	self.main_sizer.Add(wx.StaticLine(self, -1, (2, 2),
624	(2, PANEL_HEIGHT * 0.94), style=wx.LI_VERTICAL))
625	# Add the plot to main sizer
626	self.main_sizer.Add(self.vertical_r_spacer, 0, wx.ALL, 10)
627	self.SetSizer(self.main_sizer)
628	self.SetAutoLayout(True)
629
630	def on_help(self, event):
631	"""
632	Bring up the Resolution calculator Documentation whenever
633	the HELP button is clicked.
634
635	Calls DocumentationWindow with the path of the location within the
636	documentation tree (after /doc/ ....". Note that when using old
637	versions of Wx (before 2.9) and thus not the release version of
638	installers, the help comes up at the top level of the file as
639	webbrowser does not pass anything past the # to the browser when it is
640	running "file:///...."
641
642	:param evt: Triggers on clicking the help button
643	"""
644
645	_TreeLocation = "user/sasgui/perspectives/calculator/"
646	_TreeLocation += "resolution_calculator_help.html"
647	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, "",
648	"Resolution Calculator Help")
649
650	def on_close(self, event):
651	"""
652	close the window containing this panel
653	"""
654	# get ready for other events
655	if event is not None:
656	event.Skip()
657	# Clear the plot
658	if self.image is not None:
659	self.image.clf()
660	# reset image
661	self.image = None
662	# Close panel
663	self.parent.OnClose(None)
664
665	def on_compute(self, event=None):
666	"""
667	Execute the computation of resolution
668	"""
669	wx.CallAfter(self.on_compute_call, event)
670
671	def on_compute_call(self, event=None):
672	"""
673	Execute the computation of resolution
674	"""
675	# Skip event for next event
676	if event is not None:
677	event.Skip()
678	msg = "Please Check your input values "
679	msg += "before starting the computation..."
680
681	# message
682	status_type = 'progress'
683	msg = 'Calculating...'
684	self._status_info(msg, status_type)
685
686	status_type = 'stop'
687	# Q min max list default
688	qx_min = []
689	qx_max = []
690	qy_min = []
691	qy_max = []
692	# possible max qrange
693	self.resolution.qxmin_limit = 0
694	self.resolution.qxmax_limit = 0
695	self.resolution.qymin_limit = 0
696	self.resolution.qymax_limit = 0
697	# q min and max of the detector
698	try:
699	# Get all the values at set to compute
700	# default num bin of wave list
701	self.num_wave = 10
702	wavelength = self._str2longlist(self.wavelength_tcl.GetValue())
703	source = self.source_cb.GetValue()
704	mass = self.source_mass[str(source)]
705	self.resolution.set_neutron_mass(float(mass))
706	wavelength_spread = self._str2longlist(\
707	self.wavelength_spread_tcl.GetValue().split(';')[0])
708	# Validate the wave inputs
709	wave_input = self._validate_q_input(wavelength, wavelength_spread)
710	if wave_input is not None:
711	wavelength, wavelength_spread = wave_input
712
713	self.resolution.set_wave(wavelength)
714	self.resolution.set_wave_spread(wavelength_spread)
715	source_aperture_size = self.source_aperture_tcl.GetValue()
716	source_aperture_size = self._string2list(source_aperture_size)
717	self.resolution.set_source_aperture_size(source_aperture_size)
718	sample_aperture_size = self.sample_aperture_tcl.GetValue()
719	sample_aperture_size = self._string2list(sample_aperture_size)
720	self.resolution.set_sample_aperture_size(sample_aperture_size)
721	source2sample_distance = self.source2sample_distance_tcl.GetValue()
722	source2sample_distance = self._string2list(source2sample_distance)
723	self.resolution.set_source2sample_distance(source2sample_distance)
724	sample2sample_distance = self.sample2sample_distance_tcl.GetValue()
725	sample2sample_distance = self._string2list(sample2sample_distance)
726	self.resolution.set_sample2sample_distance(sample2sample_distance)
727	sample2detector_distance = \
728	self.sample2detector_distance_tcl.GetValue()
729	sample2detector_distance = \
730	self._string2list(sample2detector_distance)
731	self.resolution.set_sample2detector_distance(\
732	sample2detector_distance)
733	detector_size = self.detector_size_tcl.GetValue()
734	detector_size = self._string2list(detector_size)
735	self.resolution.set_detector_size(detector_size)
736	detector_pix_size = self.detector_pix_size_tcl.GetValue()
737	detector_pix_size = self._string2list(detector_pix_size)
738	self.resolution.set_detector_pix_size(detector_pix_size)
739	self.qx = self._string2inputlist(self.qx_tcl.GetValue())
740	self.qy = self._string2inputlist(self.qy_tcl.GetValue())
741
742	# Find min max of qs
743	xmin = min(self.qx)
744	xmax = max(self.qx)
745	ymin = min(self.qy)
746	ymax = max(self.qy)
747	if not self._validate_q_input(self.qx, self.qy):
748	raise
749	except:
750	msg = "An error occured during the resolution computation."
751	msg += "Please check your inputs..."
752	self._status_info(msg, status_type)
753	wx.MessageBox(msg, 'Warning')
754	return
755	#raise ValueError, "Invalid Q Input..."
756
757	# Validate the q inputs
758	q_input = self._validate_q_input(self.qx, self.qy)
759	if q_input is not None:
760	self.qx, self.qy = q_input
761
762	# Make list of q min max for mapping
763	for i in range(len(self.qx)):
764	qx_min.append(xmin)
765	qx_max.append(xmax)
766	for i in range(len(self.qy)):
767	qy_min.append(ymin)
768	qy_max.append(ymax)
769
770	# Compute the resolution
771	if self.image is not None:
772	#_pylab_helpers.Gcf.set_active(self.fm)
773	_pylab_helpers.Gcf.figs = {}
774	# Clear the image before redraw
775	self.image.clf()
776	# reset the image
777	self.resolution.reset_image()
778
779	# Compute and get the image plot
780	try:
781	from sas.sasgui.perspectives.calculator.resolcal_thread import CalcRes as thread
782	self.sigma_strings = '\nResolution: Computation is finished. \n'
783	cal_res = thread(func=self._map_func,
784	qx=self.qx,
785	qy=self.qy,
786	qx_min=qx_min,
787	qx_max=qx_max,
788	qy_min=qy_min,
789	qy_max=qy_max,
790	image=self.image,
791	completefn=self.complete)
792	cal_res.queue()
793	msg = "Computation is in progress..."
794	status_type = 'progress'
795	self._status_info(msg, status_type)
796	except:
797	raise
798
799	def complete(self, image, elapsed=None):
800	"""
801	Callafter complete: wx call after needed for stable output
802	"""
803	wx.CallAfter(self.complete_cal, image, elapsed)
804
805	def complete_cal(self, image, elapsed=None):
806	"""
807	Complete computation
808	"""
809	self.image = image
810	# Draw lines in image before drawing
811	wave_list, _ = self.resolution.get_wave_list()
812	if len(wave_list) > 1 and wave_list[-1] == max(wave_list):
813	# draw a green rectangle(limit for the longest wavelength
814	# to be involved) for tof inputs
815	self._draw_lines(self.image, color='g')
816	self._draw_lines(self.image, color='r')
817	# Draw image
818	self.image.draw()
819
820	# Get and format the sigmas
821	sigma_r = self.format_number(self.resolution.sigma_1)
822	sigma_phi = self.format_number(self.resolution.sigma_2)
823	sigma_lamd = self.format_number(self.resolution.sigma_lamd)
824	sigma_1d = self.format_number(self.resolution.sigma_1d)
825
826	# Set output values
827	self.sigma_r_tcl.SetValue(str(sigma_r))
828	self.sigma_phi_tcl.SetValue(str(sigma_phi))
829	self.sigma_lamd_tcl.SetValue(str(sigma_lamd))
830	self.sigma_1d_tcl.SetValue(str(sigma_1d))
831	msg = self.sigma_strings
832	msg += "\n"
833	status_type = 'stop'
834	self._status_info(msg, status_type)
835
836	def _draw_lines(self, image=None, color='r'):
837	"""
838	Draw lines in image if applicable
839	: Param image: pylab object
840	"""
841	if image is None:
842	return
843	if color == 'g':
844	# Get the params from resolution
845	# ploting range for largest wavelength
846	qx_min = self.resolution.qx_min
847	qx_max = self.resolution.qx_max
848	qy_min = self.resolution.qy_min
849	qy_max = self.resolution.qy_max
850	# detector range
851	detector_qx_min = self.resolution.detector_qx_min
852	detector_qx_max = self.resolution.detector_qx_max
853	detector_qy_min = self.resolution.detector_qy_min
854	detector_qy_max = self.resolution.detector_qy_max
855	else:
856	qx_min, qx_max, qy_min, qy_max = \
857	self.resolution.get_detector_qrange()
858	# detector range
859	detector_qx_min = self.resolution.qxmin_limit
860	detector_qx_max = self.resolution.qxmax_limit
861	detector_qy_min = self.resolution.qymin_limit
862	detector_qy_max = self.resolution.qymax_limit
863
864	# Draw zero axis lines
865	if qy_min < 0 and qy_max >= 0:
866	image.axhline(linewidth=1)
867	if qx_min < 0 and qx_max >= 0:
868	image.axvline(linewidth=1)
869
870	# Find x and y ratio values to draw the detector outline
871	x_min = fabs(detector_qx_min - qx_min) / (qx_max - qx_min)
872	x_max = fabs(detector_qx_max - qx_min) / (qx_max - qx_min)
873	y_min = fabs(detector_qy_min - qy_min) / (qy_max - qy_min)
874	y_max = fabs(detector_qy_max - qy_min) / (qy_max - qy_min)
875
876	# Draw Detector outline
877	if detector_qy_min >= qy_min:
878	image.axhline(y=detector_qy_min + 0.0002,
879	xmin=x_min, xmax=x_max,
880	linewidth=2, color=color)
881	if detector_qy_max <= qy_max:
882	image.axhline(y=detector_qy_max - 0.0002,
883	xmin=x_min, xmax=x_max,
884	linewidth=2, color=color)
885	if detector_qx_min >= qx_min:
886	image.axvline(x=detector_qx_min + 0.0002,
887	ymin=y_min, ymax=y_max,
888	linewidth=2, color=color)
889	if detector_qx_max <= qx_max:
890	image.axvline(x=detector_qx_max - 0.0002,
891	ymin=y_min, ymax=y_max,
892	linewidth=2, color=color)
893	xmin = min(self.qx)
894	xmax = max(self.qx)
895	ymin = min(self.qy)
896	ymax = max(self.qy)
897	if color != 'g':
898	if xmin < detector_qx_min or xmax > detector_qx_max or \
899	ymin < detector_qy_min or ymax > detector_qy_max:
900	# message
901	status_type = 'stop'
902	msg = 'At least one q value located out side of\n'
903	msg += " the detector range (%s < qx < %s, %s < qy < %s),\n" % \
904	(self.format_number(detector_qx_min),
905	self.format_number(detector_qx_max),
906	self.format_number(detector_qy_min),
907	self.format_number(detector_qy_max))
908	msg += " is ignored in computation.\n"
909
910	self._status_info(msg, status_type)
911	wx.MessageBox(msg, 'Warning')
912
913	def _map_func(self, qx, qy, qx_min, qx_max, qy_min, qy_max):
914	"""
915	Prepare the Mapping for the computation
916	: params qx, qy, qx_min, qx_max, qy_min, qy_max:
917
918	: return: image (pylab)
919	"""
920	try:
921	qx_value = float(qx)
922	qy_value = float(qy)
923	except:
924	raise
925	# calculate 2D resolution distribution image
926	image = self.resolution.compute_and_plot(qx_value, qy_value,
927	qx_min, qx_max, qy_min, qy_max,
928	self.det_coordinate)
929	# record sigmas
930	self.sigma_strings += " At Qx = %s, Qy = %s; \n" % (qx_value, qy_value)
931	self._sigma_strings()
932	return image
933
934	def _sigma_strings(self):
935	"""
936	Recode sigmas as strins
937	"""
938	sigma_r = self.format_number(self.resolution.sigma_1)
939	sigma_phi = self.format_number(self.resolution.sigma_2)
940	sigma_lamd = self.format_number(self.resolution.sigma_lamd)
941	sigma_1d = self.format_number(self.resolution.sigma_1d)
942	# Set output values
943	self.sigma_strings += " sigma_x = %s\n" % sigma_r
944	self.sigma_strings += " sigma_y = %s\n" % sigma_phi
945	self.sigma_strings += " sigma_lamd = %s\n" % sigma_lamd
946	self.sigma_strings += " sigma_1D = %s\n" % sigma_1d
947
948	def _validate_q_input(self, qx, qy):
949	"""
950	Check if q inputs are valid
951	: params qx: qx as a list
952	: params qy: qy as a list
953
954	: return: True/False
955	"""
956	# check qualifications
957	if qx.__class__.__name__ != 'list':
958	return None
959	if qy.__class__.__name__ != 'list':
960	return None
961	if len(qx) < 1:
962	return None
963	if len(qy) < 1:
964	return None
965	# allow one input
966	if len(qx) == 1 and len(qy) > 1:
967	qx = [qx[0] for ind in range(len(qy))]
968	#self.qx = qx
969	if len(qy) == 1 and len(qx) > 1:
970	qy = [qy[0] for ind in range(len(qx))]
971	#self.qy = qy
972	# check length
973	if len(qx) != len(qy):
974	return None
975	if qx is None or qy is None:
976	return None
977	return qx, qy
978
979	def on_reset(self, event):
980	"""
981	Execute the reset
982	"""
983	# skip for another event
984	if event is not None:
985	event.Skip()
986	# init resolution_calculator
987	self.resolution = ResolutionCalculator()
988	self.resolution.get_all_instrument_params()
989	# reset all param values
990	self.source_cb.SetValue('Neutron')
991	self._on_source_selection(None)
992	self.wave_color_cb.SetValue('Monochromatic')
993	self._on_source_color(None)
994	#self.intensity_tcl.SetValue(str(self.resolution.intensity))
995	self.wavelength_tcl.SetValue(str(6.0))
996	self.wavelength_spread_tcl.SetValue(str(0.125))
997	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
998	self.spectrum_txt.Show(False)
999	self.spectrum_cb.Show(False)
1000	source_aperture_value = str(self.resolution.source_aperture_size[0])
1001	if len(self.resolution.source_aperture_size) > 1:
1002	source_aperture_value += ", "
1003	source_aperture_value += \
1004	str(self.resolution.source_aperture_size[1])
1005	self.source_aperture_tcl.SetValue(str(source_aperture_value))
1006	sample_aperture_value = str(self.resolution.sample_aperture_size[0])
1007	if len(self.resolution.sample_aperture_size) > 1:
1008	sample_aperture_value += ", "
1009	sample_aperture_value += \
1010	str(self.resolution.sample_aperture_size[1])
1011	self.sample_aperture_tcl.SetValue(sample_aperture_value)
1012	source2sample_distance_value = \
1013	str(self.resolution.source2sample_distance[0])
1014	self.source2sample_distance_tcl.SetValue(source2sample_distance_value)
1015	sample2sample_distance_value = \
1016	str(self.resolution.sample2sample_distance[0])
1017	self.sample2sample_distance_tcl.SetValue(sample2sample_distance_value)
1018	sample2detector_distance_value = \
1019	str(self.resolution.sample2detector_distance[0])
1020	self.sample2detector_distance_tcl.SetValue(\
1021	sample2detector_distance_value)
1022	detector_size_value = str(self.resolution.detector_size[0])
1023	if len(self.resolution.detector_size) > 1:
1024	detector_size_value += ", "
1025	detector_size_value += str(self.resolution.detector_size[1])
1026	self.detector_size_tcl.SetValue(detector_size_value)
1027	detector_pix_size_value = str(self.resolution.detector_pix_size[0])
1028	if len(self.resolution.detector_pix_size) > 1:
1029	detector_pix_size_value += ", "
1030	detector_pix_size_value += str(self.resolution.detector_pix_size[1])
1031	self.detector_pix_size_tcl.SetValue(detector_pix_size_value)
1032	#layout attribute
1033	self.hint_sizer = None
1034	# reset q inputs
1035	self.qx_tcl.SetValue(str(_Q_DEFAULT))
1036	self.qy_tcl.SetValue(str(_Q_DEFAULT))
1037	# reset sigma outputs
1038	self.sigma_r_tcl.SetValue('')
1039	self.sigma_phi_tcl.SetValue('')
1040	self.sigma_1d_tcl.SetValue('')
1041	# reset radio button
1042	#self.r_phi_rb.SetValue(True)
1043	# Finally re-compute
1044	self.on_compute()
1045	# msg on info
1046	msg = " Finished the resetting..."
1047	self._status_info(msg, 'stop')
1048
1049	def format_number(self, value=None):
1050	"""
1051	Return a float in a standardized, human-readable formatted string
1052	"""
1053	try:
1054	value = float(value)
1055	except:
1056	output = None
1057	return output
1058
1059	output = "%-7.4g" % value
1060	return output.lstrip().rstrip()
1061
1062	def _string2list(self, string):
1063	"""
1064	Change NNN, NNN to list,ie. [NNN, NNN] where NNN is a number
1065	"""
1066	new_string = []
1067	# check the number of floats
1068	try:
1069	strg = float(string)
1070	new_string.append(strg)
1071	except:
1072	string_split = string.split(',')
1073	if len(string_split) == 2:
1074	str_1 = string_split[0]
1075	str_2 = string_split[1]
1076	new_string.append(float(str_1))
1077	new_string.append(float(str_2))
1078	elif len(string_split) == 1:
1079	str_1 = string_split[0]
1080	new_string.append(float(str_1))
1081	else:
1082	msg = "The numbers must be one or two (separated by ',')..."
1083	self._status_info(msg, 'stop')
1084	raise RuntimeError(msg)
1085
1086	return new_string
1087
1088	def _string2inputlist(self, string):
1089	"""
1090	Change NNN, NNN,... to list,ie. [NNN, NNN,...] where NNN is a number
1091
1092	: return new_string: string like list
1093	"""
1094	new_string = []
1095	string_split = string.split(',')
1096	length = len(string_split)
1097	for ind in range(length):
1098	try:
1099	value = float(string_split[ind])
1100	new_string.append(value)
1101	except:
1102	logger.error(sys.exc_value)
1103
1104	return new_string
1105
1106	def _str2longlist(self, string):
1107	"""
1108	Change NNN, NNN,... to list, NNN - NNN ; NNN to list, or float to list
1109
1110	: return new_string: string like list
1111	"""
1112	msg = "Wrong format of intputs."
1113	try:
1114	# is float
1115	out = [float(string)]
1116	return out
1117	except:
1118	if self.wave_color.lower().count('mono') > 0:
1119	wx.MessageBox(msg, 'Warning')
1120	else:
1121	try:
1122	# has a '-'
1123	if string.count('-') > 0:
1124	value = string.split('-')
1125	if value[1].count(';') > 0:
1126	# has a ';'
1127	last_list = value[1].split(';')
1128	num = math.ceil(float(last_list[1]))
1129	max_value = float(last_list[0])
1130	self.num_wave = num
1131	else:
1132	# default num
1133	num = self.num_wave
1134	max_value = float(value[1])
1135	min_value = float(value[0])
1136	# make a list
1137	bin_size = math.fabs(max_value - min_value) / (num - 1)
1138	out = [min_value + bin_size * bnum for bnum in range(num)]
1139	return out
1140	if string.count(',') > 0:
1141	out = self._string2inputlist(string)
1142	return out
1143	except:
1144	logger.error(sys.exc_value)
1145
1146	def _on_xy_coordinate(self, event=None):
1147	"""
1148	Set the detector coordinate for sigmas to x-y coordinate
1149	"""
1150	if event is not None:
1151	event.Skip()
1152	# Set the coordinate in Cartesian
1153	self.det_coordinate = 'cartesian'
1154	self.sigma_r_txt.SetLabel('Sigma_x:')
1155	self.sigma_phi_txt.SetLabel('Sigma_y:')
1156	self._onparamEnter()
1157
1158	def _on_rp_coordinate(self, event=None):
1159	"""
1160	Set the detector coordinate for sigmas to polar coordinate
1161	"""
1162	if event is not None:
1163	event.Skip()
1164	# Set the coordinate in polar
1165	self.det_coordinate = 'polar'
1166	self.sigma_r_txt.SetLabel('Sigma_r: ')
1167	self.sigma_phi_txt.SetLabel('Sigma_phi:')
1168	self._onparamEnter()
1169
1170	def _status_info(self, msg='', type="update"):
1171	"""
1172	Status msg
1173	"""
1174	if type == "stop":
1175	label = "Compute"
1176	able = True
1177	else:
1178	label = "Wait..."
1179	able = False
1180	self.compute_button.Enable(able)
1181	self.compute_button.SetLabel(label)
1182	self.compute_button.SetToolTipString(label)
1183	if self.parent.parent is not None:
1184	wx.PostEvent(self.parent.parent,
1185	StatusEvent(status=msg, type=type))
1186
1187
1188	def _onparamEnter(self, event=None):
1189	"""
1190	On Text_enter_callback, perform compute
1191	"""
1192	self.on_compute()
1193
1194	def _on_source_selection(self, event=None):
1195	"""
1196	On source combobox selection
1197	"""
1198	if event is not None:
1199	combo = event.GetEventObject()
1200	event.Skip()
1201	else:
1202	combo = self.source_cb
1203	selection = combo.GetValue()
1204	mass = self.source_mass[selection]
1205	self.resolution.set_neutron_mass(mass)
1206	source_hint = "Source Selection: Affect on"
1207	source_hint += " the gravitational contribution.\n"
1208	source_hint += "Mass of %s: m = %s [g]" % \
1209	(selection, str(self.resolution.get_neutron_mass()))
1210	#source_tip.SetTip(source_hint)
1211	self.mass_txt.ToolTip.SetTip(source_hint)
1212
1213	def _on_source_color(self, event=None):
1214	"""
1215	On source color combobox selection
1216	"""
1217	if event is not None:
1218	#combo = event.GetEventObject()
1219	event.Skip()
1220	#else:
1221	combo = self.wave_color_cb
1222	selection = combo.GetValue()
1223	self.wave_color = selection
1224	if self.wave_color.lower() == 'tof':
1225	list = self.resolution.get_wave_list()
1226	minw = min(list[0])
1227	if len(list[0]) < 2:
1228	maxw = 2 * minw
1229	else:
1230	maxw = max(list[0])
1231	self.wavelength_tcl.SetValue('%s - %s' % (minw, maxw))
1232	minw = min(list[1])
1233	maxw = max(list[1])
1234	self.wavelength_spread_tcl.SetValue('%s - %s' % (minw, maxw))
1235	spectrum_val = self.spectrum_cb.GetValue()
1236	self.resolution.set_spectrum(self.spectrum_dic[spectrum_val])
1237	self.spectrum_txt.Show(True)
1238	self.spectrum_cb.Show(True)
1239
1240	else:
1241	wavelength = self.resolution.get_wavelength()
1242	wavelength_spread = self.resolution.get_wavelength_spread()
1243	self.wavelength_tcl.SetValue(str(wavelength))
1244	self.wavelength_spread_tcl.SetValue(str(wavelength_spread))
1245	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
1246	self.spectrum_txt.Show(False)
1247	self.spectrum_cb.Show(False)
1248	self.wavelength_sizer.Layout()
1249	self.Layout()
1250
1251	def _on_spectrum_cb(self, event=None):
1252	"""
1253	On spectrum ComboBox event
1254	"""
1255	if event is not None:
1256	#combo = event.GetEventObject()
1257	event.Skip()
1258	else:
1259	raise
1260	selection = self.spectrum_cb.GetValue()
1261	if selection == 'Add new':
1262	path = self._selectDlg()
1263	if path is None:
1264	self.spectrum_cb.SetValue('Flat')
1265	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
1266	msg = "No file has been chosen."
1267	wx.MessageBox(msg, 'Info')
1268	return
1269	try:
1270	basename = os.path.basename(path)
1271	if basename not in self.spectrum_dic.keys():
1272	self.spectrum_cb.Append(basename)
1273	self.spectrum_dic[basename] = self._read_file(path)
1274	self.spectrum_cb.SetValue(basename)
1275	self.resolution.set_spectrum(self.spectrum_dic[basename])
1276	return
1277	except:
1278	raise
1279
1280	self.resolution.set_spectrum(self.spectrum_dic[selection])
1281
1282	def _selectDlg(self):
1283	"""
1284	open a dialog file to select a customized spectrum
1285	"""
1286	dlg = wx.FileDialog(self,
1287	"Choose a wavelength spectrum file: Intensity vs. wavelength",
1288	self.parent.parent.get_save_location() , "", ".", wx.OPEN)
1289	path = None
1290	if dlg.ShowModal() == wx.ID_OK:
1291	path = dlg.GetPath()
1292	dlg.Destroy()
1293	return path
1294
1295	def _read_file(self, path):
1296	"""
1297	Read two columns file as tuples of numpy array
1298
1299	:param path: the path to the file to read
1300
1301	"""
1302	try:
1303	if path is None:
1304	wx.PostEvent(self.parent.parent, StatusEvent(status=\
1305	" Selected Distribution was not loaded: %s" % path))
1306	return None, None
1307	input_f = open(path, 'r')
1308	buff = input_f.read()
1309	lines = buff.split('\n')
1310
1311	wavelength = []
1312	intensity = []
1313	for line in lines:
1314	toks = line.split()
1315	try:
1316	wave = float(toks[0])
1317	intens = float(toks[1])
1318	wavelength.append(wave)
1319	intensity.append(intens)
1320	except:
1321	# Skip non-data lines
1322	logger.error(sys.exc_value)
1323
1324	return [wavelength, intensity]
1325	except:
1326	raise
1327
1328	class ResolutionWindow(widget.CHILD_FRAME):
1329	"""
1330	Resolution Window
1331	"""
1332	def __init__(self, parent=None, manager=None,
1333	title="Q Resolution Estimator",
1334	size=(PANEL_WIDTH * 2, PANEL_HEIGHT), args, *kwds):
1335	kwds['title'] = title
1336	kwds['size'] = size
1337	widget.CHILD_FRAME.__init__(self, parent=parent, args, *kwds)
1338	self.parent = parent
1339	self.manager = manager
1340	self.panel = ResolutionCalculatorPanel(parent=self)
1341	self.Bind(wx.EVT_CLOSE, self.OnClose)
1342	self.SetPosition((wx.LEFT, PANEL_TOP))
1343	self.Show(True)
1344
1345	def OnClose(self, event):
1346	"""
1347	On close event
1348	"""
1349	_pylab_helpers.Gcf.figs = {}
1350	if self.manager is not None:
1351	self.manager.cal_res_frame = None
1352	self.Destroy()
1353
1354
1355	if __name__ == "__main__":
1356	app = wx.PySimpleApp()
1357	widget.CHILD_FRAME = wx.Frame
1358	frame = ResolutionWindow()
1359	frame.Show(True)
1360	app.MainLoop()

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

SasView

source: sasview/src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py @ b9d74f3

Download in other formats: