gen_scatter_panel.py @ 418e59f

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.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 418e59f was 3f5d75b, checked in by butler, 10 years ago

Fixed General Scattering Panel

Removed abandoned menu bar code
Removed toolbar code - It is not consistent with rest of tools.

Furthermore, it had nothing useful except help.

Added a Help button to bottom of panel
Cleaned up help code (i.e. removed all the old code and replaced with

simple call to Sphinx documentation)

Fixed sizing of panel (1 + ½.5 = 1.4 not 1.3 for total width)

—- still seems to be an odd vertical line to left of right hand pane
when trying to resize said pane.

Property mode set to 100644

File size: 74.6 KB

Line
1	"""
2	Generic Scattering panel.
3	This module relies on guiframe manager.
4	"""
5
6	import wx
7	import sys
8	import os
9	import numpy
10	#import math
11	import wx.aui as aui
12	#import wx.lib.agw.aui as aui
13	import logging
14	import time
15
16	import matplotlib
17	matplotlib.interactive(False)
18	#Use the WxAgg back end. The Wx one takes too long to render
19	matplotlib.use('WXAgg')
20
21	#from sas.guiframe.gui_manager import MDIFrame
22	from sas.data_util.calcthread import CalcThread
23	from sas.guiframe.local_perspectives.plotting.SimplePlot import PlotFrame
24	from sas.guiframe.dataFitting import Data2D
25	from sas.guiframe.dataFitting import Data1D
26	from sas.dataloader.data_info import Detector
27	from sas.dataloader.data_info import Source
28	from sas.guiframe.panel_base import PanelBase
29	from sas.guiframe.utils import format_number
30	from sas.guiframe.events import StatusEvent
31	from sas.calculator import sas_gen
32	from sas.perspectives.calculator.calculator_widgets import OutputTextCtrl
33	from sas.perspectives.calculator.calculator_widgets import InputTextCtrl
34	from wx.lib.scrolledpanel import ScrolledPanel
35	from sas.perspectives.calculator.load_thread import GenReader
36	from sas.plottools.arrow3d import Arrow3D
37	from sas.perspectives.calculator import calculator_widgets as widget
38	from sas.guiframe.events import NewPlotEvent
39	from sas.guiframe.documentation_window import DocumentationWindow
40
41	_BOX_WIDTH = 76
42	#Slit length panel size
43	if sys.platform.count("win32") > 0:
44	PANEL_WIDTH = 570
45	PANEL_HEIGHT = 370
46	FONT_VARIANT = 0
47	else:
48	PANEL_WIDTH = 620
49	PANEL_HEIGHT = 370
50	FONT_VARIANT = 1
51	_QMAX_DEFAULT = 0.3
52	_NPTS_DEFAULT = 50
53	_Q1D_MIN = 0.001
54
55	def add_icon(parent, frame):
56	"""
57	Add icon in the frame
58	"""
59	if parent != None:
60	if hasattr(frame, "IsIconized"):
61	if not frame.IsIconized():
62	try:
63	icon = parent.GetIcon()
64	frame.SetIcon(icon)
65	except:
66	pass
67
68	def _set_error(panel, item, show_msg=False):
69	"""
70	Set_error dialog
71	"""
72	if item != None:
73	item.SetBackgroundColour("pink")
74	item.Refresh()
75	if show_msg:
76	msg = "Error: wrong (or out of range) value entered."
77	if panel.parent.parent != None:
78	wx.PostEvent(panel.parent.parent,
79	StatusEvent(status=msg, info='Error' ))
80	panel.SetFocus()
81	return False
82
83
84
85	class CalcGen(CalcThread):
86	"""
87	Computation
88	"""
89	def __init__(self,
90	id=-1,
91	input = None,
92	completefn = None,
93	updatefn = None,
94	#elapsed = 0,
95	yieldtime = 0.01,
96	worktime = 0.01):
97	"""
98	"""
99	CalcThread.__init__(self, completefn,
100	updatefn,
101	yieldtime,
102	worktime)
103	self.starttime = 0
104	self.id = id
105	self.input = input
106	self.update_fn = updatefn
107
108	def compute(self):
109	"""
110	excuting computation
111	"""
112	#elapsed = time.time() - self.starttime
113	self.starttime = time.time()
114	self.complete(input=self.input, update=self.update_fn)
115
116	class SasGenPanel(ScrolledPanel, PanelBase):
117	"""
118	Provides the sas gen calculator GUI.
119	"""
120	## Internal nickname for the window, used by the AUI manager
121	window_name = "Generic SAS Calculator"
122	## Name to appear on the window title bar
123	window_caption = "Generic SAS "
124
125	def __init__(self, parent, args, *kwds):
126	ScrolledPanel.__init__(self, parent, style=wx.RAISED_BORDER,
127	args, *kwds)
128	#kwds['style'] = wx.SUNKEN_BORDER
129	PanelBase.__init__(self)
130	#Font size
131	self.SetWindowVariant(variant=FONT_VARIANT)
132	self.SetupScrolling()
133	#thread to read data
134	self.reader = None
135	self.ext = None
136	self.id = 'GenSAS'
137	self.file_name = ''
138	self.time_text = None
139	self.orient_combo = None
140	self.omfreader = sas_gen.OMFReader()
141	self.sldreader = sas_gen.SLDReader()
142	self.pdbreader = sas_gen.PDBReader()
143	self.model = sas_gen.GenSAS()
144	self.param_dic = self.model.params
145	self.parameters = []
146	self.data = None
147	self.scale2d = None
148	self.is_avg = False
149	self.plot_frame = None
150	self.qmax_x = _QMAX_DEFAULT
151	self.npts_x = _NPTS_DEFAULT
152	self.sld_data = None
153	self.graph_num = 1
154	self.default_shape = 'rectangular'
155	# Object that receive status event
156	self.parent = parent
157	self._do_layout()
158	self._create_default_sld_data()
159	self._create_default_2d_data()
160	wx.CallAfter(self._set_sld_data_helper)
161
162	def _define_structure(self):
163	"""
164	Define the main sizers building to build this application.
165	"""
166	self.main_sizer = wx.BoxSizer(wx.VERTICAL)
167	self.box_source = wx.StaticBox(self, -1, str("SLD Data File"))
168	self.box_parameters = wx.StaticBox(self, -1, str("Input Parameters"))
169	self.box_qrange = wx.StaticBox(self, -1, str("Q Range"))
170	self.boxsizer_source = wx.StaticBoxSizer(self.box_source,
171	wx.VERTICAL)
172	self.boxsizer_parameters = wx.StaticBoxSizer(self.box_parameters,
173	wx.VERTICAL)
174	self.boxsizer_qrange = wx.StaticBoxSizer(self.box_qrange,
175	wx.VERTICAL)
176	self.data_name_sizer = wx.BoxSizer(wx.HORIZONTAL)
177	self.param_sizer = wx.BoxSizer(wx.HORIZONTAL)
178	self.shape_sizer = wx.BoxSizer(wx.HORIZONTAL)
179	self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)
180	self.qrange_sizer = wx.BoxSizer(wx.HORIZONTAL)
181	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
182
183	def _layout_data_name(self):
184	"""
185	Fill the sizer containing data's name
186	"""
187	data_name_txt = wx.StaticText(self, -1, 'Data: ')
188	self.data_name_tcl = OutputTextCtrl(self, -1,
189	size=(_BOX_WIDTH * 4, -1))
190	data_hint = "Loaded data"
191	self.data_name_tcl.SetToolTipString(data_hint)
192	#control that triggers importing data
193	id = wx.NewId()
194	self.browse_button = wx.Button(self, id, "Load")
195	hint_on_browse = "Click to load data into this panel."
196	self.browse_button.SetToolTipString(hint_on_browse)
197	self.Bind(wx.EVT_BUTTON, self.on_load_data, id=id)
198	self.data_name_sizer.AddMany([(data_name_txt, 0, wx.LEFT, 15),
199	(self.data_name_tcl, 0, wx.LEFT, 10),
200	(self.browse_button, 0, wx.LEFT, 10)])
201	def _layout_param_size(self):
202	"""
203	Fill the sizer containing slit size information
204	"""
205	self.parameters = []
206	sizer = wx.GridBagSizer(3, 6)
207	model = self.model
208	details = self.model.details
209	params = self.model.params
210	ix = 0
211	iy = 0
212	param_title = wx.StaticText(self, -1, 'Parameter')
213	sizer.Add(param_title, (iy, ix), (1, 1), \
214	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
215	ix += 1
216	value_title = wx.StaticText(self, -1, 'Value')
217	sizer.Add(value_title, (iy, ix), (1, 1), \
218	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
219	ix += 1
220	unit_title = wx.StaticText(self, -1, 'Unit')
221	sizer.Add(unit_title, (iy, ix), (1, 1), \
222	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
223	key_list = params.keys()
224	key_list.sort()
225	for param in key_list:
226	iy += 1
227	ix = 0
228	p_name = wx.StaticText(self, -1, param)
229	sizer.Add(p_name, (iy, ix), (1, 1), \
230	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
231	## add parameter value
232	ix += 1
233	value = model.getParam(param)
234	ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 2, 20),
235	style=wx.TE_PROCESS_ENTER)
236	#ctl.SetToolTipString(\
237	# "Hit 'Enter' after typing to update the plot.")
238	ctl.SetValue(format_number(value, True))
239	sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
240	## add unit
241	ix += 1
242	unit = wx.StaticText(self, -1, details[param][0])
243	sizer.Add(unit, (iy, ix), (1, 1), \
244	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
245	self.parameters.append([p_name, ctl, unit])
246
247	self.param_sizer.Add(sizer, 0, wx.LEFT, 10)
248
249	def _layout_hint(self):
250	"""
251	Fill the sizer containing hint
252	"""
253	hint_msg = "We support omf, sld or pdb data files only."
254	hint_msg += " "
255	if FONT_VARIANT < 1:
256	hint_msg += "Very "
257	hint_msg += "SLOW drawing -->"
258	hint_txt = wx.StaticText(self, -1, hint_msg)
259
260	id = wx.NewId()
261	self.draw_button = wx.Button(self, id, "Arrow Draw")
262	hint_on_draw = "Draw with arrows. Caution: it is a very slow drawing."
263	self.draw_button.SetToolTipString(hint_on_draw)
264	self.draw_button.Bind(wx.EVT_BUTTON, self.sld_draw, id=id)
265
266	self.draw_button.Enable(False)
267	self.hint_sizer.AddMany([(hint_txt, 0, wx.LEFT, 15),
268	(self.draw_button, 0, wx.LEFT, 7)])
269
270	def _layout_shape(self):
271	"""
272	Fill the shape sizer
273	"""
274	label_txt = wx.StaticText(self, -1, "Shape:")
275	self.shape_combo = self._fill_shape_combo()
276	self.shape_sizer.AddMany([(label_txt, 0, wx.LEFT, 15),
277	(self.shape_combo, 0, wx.LEFT, 5)])
278
279	def _fill_shape_combo(self):
280	"""
281	Fill up the shape combo box
282	"""
283	shape_combo = wx.ComboBox(self, -1, size=(150, -1),
284	style=wx.CB_READONLY)
285	shape_combo.Append('Rectangular')
286	shape_combo.Append('Ellipsoid')
287	shape_combo.Bind(wx.EVT_COMBOBOX, self._on_shape_select)
288	shape_combo.SetSelection(0)
289	return shape_combo
290
291	def _on_shape_select(self, event):
292	"""
293	On selecting a shape
294	"""
295	event.Skip()
296	label = event.GetEventObject().GetValue().lower()
297	self.default_shape = label
298	self.parent.set_omfpanel_default_shap(self.default_shape)
299	self.parent.set_omfpanel_npts()
300
301	def _fill_orient_combo(self):
302	"""
303	Fill up the orientation combo box: used only for atomic structure
304	"""
305	orient_combo = wx.ComboBox(self, -1, size=(150, -1),
306	style=wx.CB_READONLY)
307	orient_combo.Append('Fixed orientation')
308	orient_combo.Append('Debye full avg.')
309	#orient_combo.Append('Debye sph. sym.')
310
311	orient_combo.Bind(wx.EVT_COMBOBOX, self._on_orient_select)
312	orient_combo.SetSelection(0)
313	return orient_combo
314
315	def _on_orient_select(self, event):
316	"""
317	On selecting a orientation
318	"""
319	event.Skip()
320	cb = event.GetEventObject()
321	if cb.GetCurrentSelection() == 2:
322	self.is_avg = None
323	else:
324	is_avg = cb.GetCurrentSelection() == 1
325	self.is_avg = is_avg
326	self.model.set_is_avg(self.is_avg)
327	self.set_est_time()
328
329	def _layout_qrange(self):
330	"""
331	Fill the sizer containing qrange
332	"""
333	sizer = wx.GridBagSizer(2, 3)
334	ix = 0
335	iy = 0
336	#key_list.sort()
337	name = wx.StaticText(self, -1, 'No. of Qx (Qy) bins: ')
338	sizer.Add(name, (iy, ix), (1, 1), \
339	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
340	## add parameter value
341	ix += 1
342	self.npt_ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 1.5, 20),
343	style=wx.TE_PROCESS_ENTER)
344	self.npt_ctl.Bind(wx.EVT_TEXT, self._onparamEnter)
345	self.npt_ctl.SetValue(format_number(self.npts_x, True))
346	sizer.Add(self.npt_ctl, (iy, ix), (1, 1), wx.EXPAND)
347	## add unit
348	ix += 1
349	unit = wx.StaticText(self, -1, '')
350	sizer.Add(unit, (iy, ix), (1, 1), \
351	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
352	iy += 1
353	ix = 0
354	name = wx.StaticText(self, -1, 'Qx (Qy) Max: ')
355	sizer.Add(name, (iy, ix), (1, 1), \
356	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
357	## add parameter value
358	ix += 1
359	self.qmax_ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 1.5, 20),
360	style=wx.TE_PROCESS_ENTER)
361	self.qmax_ctl.Bind(wx.EVT_TEXT, self._onparamEnter )
362	self.qmax_ctl.SetValue(format_number(self.qmax_x, True))
363	sizer.Add(self.qmax_ctl, (iy, ix), (1, 1), wx.EXPAND)
364	## add unit
365	ix += 1
366	unit = wx.StaticText(self, -1, '[1/A]')
367	sizer.Add(unit, (iy, ix), (1, 1), \
368	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
369	self.qrange_sizer.Add(sizer, 0, wx.LEFT, 10)
370
371	def _layout_button(self):
372	"""
373	Do the layout for the button widgets
374	"""
375	self.est_time = '*Estimated Computation time :\n %s'
376	self.time_text = wx.StaticText(self, -1, self.est_time% str('2 sec') )
377	self.orient_combo = self._fill_orient_combo()
378	self.orient_combo.Show(False)
379	self.bt_compute = wx.Button(self, wx.NewId(),'Compute')
380	self.bt_compute.Bind(wx.EVT_BUTTON, self.on_compute)
381	self.bt_compute.SetToolTipString("Compute 2D Scattering Pattern.")
382	self.bt_help = wx.Button(self, wx.NewId(),'HELP')
383	self.bt_help.Bind(wx.EVT_BUTTON, self.on_help)
384	self.bt_help.SetToolTipString("Help on Scatter Calculator")
385	self.button_sizer.AddMany([(self.time_text , 0, wx.LEFT, 20),
386	(self.orient_combo , 0, wx.LEFT, 20),
387	(self.bt_compute, 0, wx.LEFT, 20),
388	(self.bt_help, 0, wx.LEFT, 5)])
389
390	def estimate_ctime(self):
391	"""
392	Calculation time estimation
393	"""
394	# magic equation: not very accurate
395	factor = 1
396	n_qbins = float(self.npt_ctl.GetValue())
397	n_qbins *= n_qbins
398	n_pixs = float(self.parent.get_npix())
399	if self.is_avg:
400	factor = 6
401	n_pixs *= (n_pixs / 200)
402	x_in = n_qbins * n_pixs / 100000
403	etime = factor + 0.085973 * x_in
404	return int(etime)
405
406	def set_est_time(self):
407	"""
408	Set text for est. computation time
409	"""
410	unit = 'sec'
411	if self.time_text != None:
412	self.time_text.SetForegroundColour('black')
413	etime = self.estimate_ctime()
414	if etime > 60:
415	etime /= 60
416	unit = 'min'
417	self.time_text.SetForegroundColour('red')
418	time_str = str(etime) + ' ' + unit
419	self.time_text.SetLabel(self.est_time% time_str)
420
421	def _do_layout(self):
422	"""
423	Draw window content
424	"""
425	self._define_structure()
426	self._layout_data_name()
427	self._layout_param_size()
428	self._layout_qrange()
429	self._layout_hint()
430	self._layout_shape()
431	self._layout_button()
432	self.boxsizer_source.AddMany([(self.data_name_sizer, 0,
433	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5),
434	(self.hint_sizer, 0,
435	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5),
436	(self.shape_sizer, 0,
437	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5)])
438	self.boxsizer_parameters.AddMany([(self.param_sizer, 0,
439	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5),])
440	self.boxsizer_qrange.AddMany([(self.qrange_sizer, 0,
441	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5),])
442	self.main_sizer.AddMany([(self.boxsizer_source, 0,
443	wx.EXPAND\|wx.ALL, 10),
444	(self.boxsizer_parameters, 0,
445	wx.EXPAND\|wx.ALL, 10),
446	(self.boxsizer_qrange, 0,
447	wx.EXPAND\|wx.ALL, 10),
448	(self.button_sizer, 0,
449	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5)])
450	self.SetSizer(self.main_sizer)
451	self.SetAutoLayout(True)
452
453	def _create_default_sld_data(self):
454	"""
455	Making default sld-data
456	"""
457	sld_n_default = 6.97e-06
458	omfdata = sas_gen.OMFData()
459	omf2sld = sas_gen.OMF2SLD()
460	omf2sld.set_data(omfdata, self.default_shape)
461	self.sld_data = omf2sld.output
462	self.sld_data.is_data = False
463	self.sld_data.filename = "Default SLD Profile"
464	self.sld_data.set_sldn(sld_n_default)
465	self.data_name_tcl.SetValue(self.sld_data.filename)
466
467	def choose_data_file(self, location=None):
468	"""
469	Choosing a dtata file
470	"""
471	path = None
472	filename = ''
473	if location == None:
474	location = os.getcwd()
475
476	exts = "*" + self.omfreader.ext[0]
477	exts += ", *" + self.sldreader.ext[0]
478	exts += ", *" + self.pdbreader.ext[0]
479	all_type = "All GEN files (%s, %s) \| %s"% (exts.upper(), exts.lower(),
480	exts.lower().replace(',', ';'))
481	wildcard = [all_type]
482	omf_type = self.omfreader.type
483	sld_type = self.sldreader.type
484	pdb_type = self.pdbreader.type
485
486	for type in sld_type:
487	wildcard.append(type)
488	for type in omf_type:
489	wildcard.append(type)
490	for type in pdb_type:
491	wildcard.append(type)
492	wildcard = '\|'.join(wildcard)
493	dlg = wx.FileDialog(self, "Choose a file", location,
494	"", wildcard, wx.OPEN)
495	if dlg.ShowModal() == wx.ID_OK:
496	path = dlg.GetPath()
497	filename = os.path.basename(path)
498	dlg.Destroy()
499	return path
500
501	def on_load_data(self, event):
502	"""
503	Open a file dialog to allow the user to select a given file.
504	The user is only allow to load file with extension .omf, .txt, .sld.
505	Display the slit size corresponding to the loaded data.
506	"""
507	location = self.parent.get_path()
508	path = self.choose_data_file(location=location)
509	if path is None:
510	return
511
512	self.shape_sizer.ShowItems(False)
513	self.default_shape = 'rectangular'
514	self.parent.set_omfpanel_default_shap(self.default_shape)
515
516	self.parent.set_file_location(os.path.dirname(path))
517	try:
518	#Load data
519	self.ext = os.path.splitext(path)[-1]
520	if self.ext in self.omfreader.ext:
521	loader = self.omfreader
522	elif self.ext in self.sldreader.ext:
523	loader = self.sldreader
524	elif self.ext in self.pdbreader.ext:
525	loader = self.pdbreader
526	else:
527	loader = None
528	if self.reader is not None and self.reader.isrunning():
529	self.reader.stop()
530	self.browse_button.Enable(False)
531	self.browse_button.SetLabel("Loading...")
532	if self.parent.parent is not None:
533	wx.PostEvent(self.parent.parent,
534	StatusEvent(status="Loading...",
535	type="progress"))
536	self.reader = GenReader(path=path, loader=loader,
537	completefn=self.complete_loading,
538	updatefn=self.load_update)
539	self.reader.queue()
540	#self.load_update()
541	except:
542	self.ext = None
543	if self.parent.parent is None:
544	return
545	msg = "Generic SAS Calculator: %s" % (sys.exc_value)
546	wx.PostEvent(self.parent.parent,
547	StatusEvent(status=msg, type='stop'))
548	self.SetFocus()
549	return
550
551	def load_update(self):
552	"""
553	print update on the status bar
554	"""
555	if self.parent.parent is None:
556	return
557	if self.reader.isrunning():
558	type = "progress"
559	else:
560	type = "stop"
561	wx.PostEvent(self.parent.parent, StatusEvent(status="",
562	type=type))
563
564	def complete_loading(self, data=None, filename=''):
565	"""
566	Complete the loading
567	"""
568	#compute the slit size
569	self.browse_button.Enable(True)
570	self.browse_button.SetLabel('Load')
571	try:
572	is_pdbdata = False
573	filename = data.filename
574	self.data_name_tcl.SetValue(str(filename))
575	self.file_name = filename.split('.')[0]
576	self.orient_combo.SetSelection(0)
577	self.is_avg = False
578	if self.ext in self.omfreader.ext:
579	gen = sas_gen.OMF2SLD()
580	gen.set_data(data)
581	#omf_data = data
582	self.sld_data = gen.get_magsld()
583	elif self.ext in self.sldreader.ext:
584	self.sld_data = data
585	elif self.ext in self.pdbreader.ext:
586	self.sld_data = data
587	is_pdbdata = True
588	#omf_data = None
589	else:
590	raise
591	self.orient_combo.Show(is_pdbdata)
592	self.button_sizer.Layout()
593	self._set_sld_data_helper(True)
594	except:
595	if self.parent.parent is None:
596	raise
597	msg = "Loading Error: This file format is not supported "
598	msg += "for GenSAS."
599	wx.PostEvent(self.parent.parent,
600	StatusEvent(status=msg, type='stop', info='Error'))
601	self.SetFocus()
602	return
603	if self.parent.parent is None:
604	return
605
606	msg = "Load Complete"
607	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, type='stop'))
608	self.SetFocus()
609
610	def _set_sld_data_helper(self, is_draw=False):
611	"""
612	Set sld data helper
613	"""
614	#is_avg = self.orient_combo.GetCurrentSelection() == 1
615	self.model.set_is_avg(self.is_avg)
616	self.model.set_sld_data(self.sld_data)
617
618	self.draw_button.Enable(self.sld_data!=None)
619	wx.CallAfter(self.parent.set_sld_data, self.sld_data)
620	self._update_model_params()
621	if is_draw:
622	wx.CallAfter(self.sld_draw, None, False)
623
624	def _update_model_params(self):
625	"""
626	Update the model parameter values
627	"""
628	for list in self.parameters:
629	param_name = list[0].GetLabelText()
630	val = str(self.model.params[param_name])
631	list[1].SetValue(val)
632
633	def set_volume_ctl_val(self, val):
634	"""
635	Set volume txtctrl value
636	"""
637	for list in self.parameters:
638	param_name = list[0].GetLabelText()
639	if param_name.lower() == 'total_volume':
640	list[1].SetValue(val)
641	list[1].Refresh()
642	break
643
644	def _onparamEnter(self, event):
645	"""
646	On param enter
647	"""
648	try:
649	item = event.GetEventObject()
650	self._check_value()
651	item.Refresh()
652	except:
653	pass
654
655	def sld_draw(self, event=None, has_arrow=True):
656	"""
657	Draw 3D sld profile
658	"""
659	flag = self.parent.check_omfpanel_inputs()
660	if not flag:
661	infor = 'Error'
662	msg = 'Error: Wrong inputs in the SLD info panel.'
663	# inform msg to wx
664	wx.PostEvent(self.parent.parent,
665	StatusEvent(status=msg, info=infor))
666	self.SetFocus()
667	return
668
669	self.sld_data = self.parent.get_sld_from_omf()
670	output = self.sld_data
671	#frame_size = wx.Size(470, 470)
672	self.plot_frame = PlotFrame(self, -1, 'testView')
673	frame = self.plot_frame
674	frame.Show(False)
675	add_icon(self.parent, frame)
676	panel = frame.plotpanel
677	try:
678	# mpl >= 1.0.0
679	ax = panel.figure.gca(projection='3d')
680	except:
681	# mpl < 1.0.0
682	try:
683	from mpl_toolkits.mplot3d import Axes3D
684	ax = Axes3D(panel.figure)
685	except:
686	logging.error("PlotPanel could not import Axes3D")
687	raise
688	panel.dimension = 3
689	graph_title = self._sld_plot_helper(ax, output, has_arrow)
690	# Use y, z axes (in mpl 3d) as z, y axes
691	# that consistent with our SAS detector coords.
692	ax.set_xlabel('x ($\A%s$)'% output.pos_unit)
693	ax.set_ylabel('z ($\A%s$)'% output.pos_unit)
694	ax.set_zlabel('y ($\A%s$)'% output.pos_unit)
695	panel.subplot.figure.subplots_adjust(left=0.05, right=0.95,
696	bottom=0.05, top=0.96)
697	if output.pix_type == 'atom':
698	ax.legend(loc='upper left', prop={'size':10})
699	num_graph = str(self.graph_num)
700	frame.SetTitle('Graph %s: %s'% (num_graph, graph_title))
701	wx.CallAfter(frame.Show, True)
702	self.graph_num += 1
703
704	def _sld_plot_helper(self, ax, output, has_arrow=False):
705	"""
706	Actual plot definition happens here
707	:Param ax: axis3d
708	:Param output: sld_data [MagSLD]
709	:Param has_arrow: whether or not draws M vector [bool]
710	"""
711	# Set the locals
712	color_dic = {'H':'blue', 'D':'purple', 'N': 'orange',
713	'O':'red', 'C':'green', 'P':'cyan', 'Other':'k'}
714	marker = ','
715	m_size = 2
716	graph_title = self.file_name
717	graph_title += " 3D SLD Profile "
718	pos_x = output.pos_x
719	pos_y = output.pos_y
720	pos_z = output.pos_z
721	sld_mx = output.sld_mx
722	sld_my = output.sld_my
723	sld_mz = output.sld_mz
724	pix_symbol = output.pix_symbol
725	if output.pix_type == 'atom':
726	marker = 'o'
727	m_size = 3.5
728	sld_tot = (numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \
729	numpy.fabs(sld_mz) + numpy.fabs(output.sld_n))
730	is_nonzero = sld_tot > 0.0
731	is_zero = sld_tot == 0.0
732	# I. Plot null points
733	if is_zero.any():
734	ax.plot(pos_x[is_zero], pos_z[is_zero], pos_y[is_zero], marker,
735	c="y", alpha=0.5, markeredgecolor='y', markersize=m_size)
736	pos_x = pos_x[is_nonzero]
737	pos_y = pos_y[is_nonzero]
738	pos_z = pos_z[is_nonzero]
739	sld_mx = sld_mx[is_nonzero]
740	sld_my = sld_my[is_nonzero]
741	sld_mz = sld_mz[is_nonzero]
742	pix_symbol = output.pix_symbol[is_nonzero]
743	# II. Plot selective points in color
744	other_color = numpy.ones(len(pix_symbol), dtype='bool')
745	for key in color_dic.keys():
746	chosen_color = pix_symbol == key
747	if numpy.any(chosen_color):
748	other_color = other_color & (chosen_color != True)
749	color = color_dic[key]
750	ax.plot(pos_x[chosen_color], pos_z[chosen_color],
751	pos_y[chosen_color], marker, c=color, alpha=0.5,
752	markeredgecolor=color, markersize=m_size, label=key)
753	# III. Plot All others
754	if numpy.any(other_color):
755	a_name = ''
756	if output.pix_type == 'atom':
757	# Get atom names not in the list
758	a_names = [symb for symb in pix_symbol \
759	if symb not in color_dic.keys()]
760	a_name = a_names[0]
761	for name in a_names:
762	new_name = ", " + name
763	if a_name.count(name) == 0:
764	a_name += new_name
765	# plot in black
766	ax.plot(pos_x[other_color], pos_z[other_color], pos_y[other_color],
767	marker, c="k", alpha=0.5, markeredgecolor="k",
768	markersize=m_size, label=a_name)
769	# IV. Draws atomic bond with grey lines if any
770	if output.has_conect:
771	for ind in range(len(output.line_x)):
772	ax.plot(output.line_x[ind], output.line_z[ind],
773	output.line_y[ind], '-', lw=0.6, c="grey", alpha=0.3)
774	# V. Draws magnetic vectors
775	if has_arrow and len(pos_x) > 0:
776	graph_title += " - Magnetic Vector as Arrow -"
777	panel = self.plot_frame.plotpanel
778	def _draw_arrow(input=None, update=None):
779	"""
780	draw magnetic vectors w/arrow
781	"""
782	max_mx = max(numpy.fabs(sld_mx))
783	max_my = max(numpy.fabs(sld_my))
784	max_mz = max(numpy.fabs(sld_mz))
785	max_m = max(max_mx, max_my, max_mz)
786	try:
787	max_step = max(output.xstepsize, output.ystepsize,
788	output.zstepsize)
789	except:
790	max_step = 0
791	if max_step <= 0:
792	max_step = 5
793	try:
794	if max_m != 0:
795	unit_x2 = sld_mx / max_m
796	unit_y2 = sld_my / max_m
797	unit_z2 = sld_mz / max_m
798	# 0.8 is for avoiding the color becomes white=(1,1,1))
799	color_x = numpy.fabs(unit_x2 * 0.8)
800	color_y = numpy.fabs(unit_y2 * 0.8)
801	color_z = numpy.fabs(unit_z2 * 0.8)
802	x2 = pos_x + unit_x2 * max_step
803	y2 = pos_y + unit_y2 * max_step
804	z2 = pos_z + unit_z2 * max_step
805	x_arrow = numpy.column_stack((pos_x, x2))
806	y_arrow = numpy.column_stack((pos_y, y2))
807	z_arrow = numpy.column_stack((pos_z, z2))
808	colors = numpy.column_stack((color_x, color_y, color_z))
809	arrows = Arrow3D(panel, x_arrow, z_arrow, y_arrow,
810	colors, mutation_scale=10, lw=1,
811	arrowstyle="->", alpha = 0.5)
812	ax.add_artist(arrows)
813	except:
814	pass
815	msg = "Arrow Drawing completed.\n"
816	status_type = 'stop'
817	self._status_info(msg, status_type)
818	msg = "Arrow Drawing is in progress..."
819	status_type = 'progress'
820	self._status_info(msg, status_type)
821	draw_out = CalcGen(input=ax,
822	completefn=_draw_arrow, updatefn=self._update)
823	draw_out.queue()
824	return graph_title
825
826	def set_input_params(self):
827	"""
828	Set model parameters
829	"""
830	for list in self.parameters:
831	param_name = list[0].GetLabelText()
832	param_value = float(list[1].GetValue())
833	self.model.setParam(param_name, param_value)
834
835	def on_compute(self, event):
836	"""
837	Compute I(qx, qy)
838	"""
839	flag = self.parent.check_omfpanel_inputs()
840	if not flag and self.parent.parent != None:
841	infor = 'Error'
842	msg = 'Error: Wrong inputs in the SLD info panel.'
843	# inform msg to wx
844	wx.PostEvent(self.parent.parent,
845	StatusEvent(status=msg, info=infor))
846	self.SetFocus()
847	return
848	self.sld_data = self.parent.get_sld_from_omf()
849	if self.sld_data == None:
850	if self.parent.parent != None:
851	infor = 'Error'
852	msg = 'Error: No data has been selected.'
853	# inform msg to wx
854	wx.PostEvent(self.parent.parent,
855	StatusEvent(status=msg, info=infor))
856	self.SetFocus()
857	return
858	flag = self._check_value()
859	if not flag:
860	_set_error(self, None, True)
861	return
862	try:
863	self.model.set_sld_data(self.sld_data)
864	self.set_input_params()
865	if self.is_avg or self.is_avg == None:
866	self._create_default_1d_data()
867	i_out = numpy.zeros(len(self.data.y))
868	inputs = [self.data.x, [], i_out]
869	else:
870	self._create_default_2d_data()
871	i_out = numpy.zeros(len(self.data.data))
872	inputs=[self.data.qx_data, self.data.qy_data, i_out]
873
874	msg = "Computation is in progress..."
875	status_type = 'progress'
876	self._status_info(msg, status_type)
877	cal_out = CalcGen(input=inputs,
878	completefn=self.complete,
879	updatefn=self._update)
880	cal_out.queue()
881
882	except:
883	msg = "%s."% sys.exc_value
884	status_type = 'stop'
885	self._status_info(msg, status_type)
886	wx.PostEvent(self.parent.parent,
887	StatusEvent(status=msg, info='Error'))
888	self.SetFocus()
889
890	def on_help(self, event):
891	"""
892	Bring up the General scattering Calculator Documentation whenever
893	the HELP button is clicked.
894
895	Calls DocumentationWindow with the path of the location within the
896	documentation tree (after /doc/ ....". Note that when using old
897	versions of Wx (before 2.9) and thus not the release version of
898	installers, the help comes up at the top level of the file as
899	webbrowser does not pass anything past the # to the browser when it is
900	running "file:///...."
901
902	:param evt: Triggers on clicking the help button
903	"""
904
905	_TreeLocation = "user/perspectives/calculator/sas_calculator_help.html"
906	_doc_viewer = DocumentationWindow(self, -1, \
907	_TreeLocation,"General Scattering Calculator Help")
908
909	def _check_value(self):
910	"""
911	Check input values if float
912	"""
913	flag = True
914	self.npt_ctl.SetBackgroundColour("white")
915	self.qmax_ctl.SetBackgroundColour("white")
916	try:
917	npt_val = float(self.npt_ctl.GetValue())
918	if npt_val < 2 or npt_val > 1000:
919	raise
920	self.npt_ctl.SetValue(str(int(npt_val)))
921	self.set_est_time()
922	except:
923	flag = _set_error(self, self.npt_ctl)
924	try:
925	qmax_val = float(self.qmax_ctl.GetValue())
926	if qmax_val <= 0 or qmax_val > 1000:
927	raise
928	except:
929	flag = _set_error(self, self.qmax_ctl)
930	for list in self.parameters:
931	list[1].SetBackgroundColour("white")
932	param_name = list[0].GetLabelText()
933	try:
934	param_val = float(list[1].GetValue())
935	if param_name.count('frac') > 0:
936	if param_val < 0 or param_val > 1:
937	raise
938	except:
939	flag = _set_error(self, list[1])
940	return flag
941
942	def _status_info(self, msg = '', type = "update"):
943	"""
944	Status msg
945	"""
946	if type == "stop":
947	label = "Compute"
948	able = True
949	else:
950	label = "Wait..."
951	able = False
952	self.bt_compute.Enable(able)
953	self.bt_compute.SetLabel(label)
954	self.bt_compute.SetToolTipString(label)
955	if self.parent.parent != None:
956	wx.PostEvent(self.parent.parent,
957	StatusEvent(status = msg, type = type ))
958
959	def _update(self, time=None):
960	"""
961	Update the progress bar
962	"""
963	if self.parent.parent == None:
964	return
965	type = "progress"
966	msg = "Please wait. Computing... (Note: Window may look frozen.)"
967	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
968	type=type))
969
970	def complete(self, input, update=None):
971	"""
972	Gen compute complete function
973	:Param input: input list [qx_data, qy_data, i_out]
974	"""
975	out = numpy.empty(0)
976	#s = time.time()
977	for ind in range(len(input[0])):
978	if self.is_avg:
979	if ind % 1 == 0 and update != None:
980	update()
981	time.sleep(0.1)
982	inputi = [input[0][ind:ind+1], [], input[2][ind:ind+1]]
983	outi = self.model.run(inputi)
984	out = numpy.append(out, outi)
985	else:
986	if ind % 50 == 0 and update != None:
987	update()
988	time.sleep(0.001)
989	inputi = [input[0][ind:ind+1], input[1][ind:ind+1],
990	input[2][ind:ind+1]]
991	outi = self.model.runXY(inputi)
992	out = numpy.append(out, outi)
993	#print time.time() - s
994	if self.is_avg or self.is_avg == None:
995	self._draw1D(out)
996	else:
997	#out = self.model.runXY(input)
998	self._draw2D(out)
999
1000	msg = "Gen computation completed.\n"
1001	status_type = 'stop'
1002	self._status_info(msg, status_type)
1003
1004	def _create_default_2d_data(self):
1005	"""
1006	Create 2D data by default
1007	Only when the page is on theory mode.
1008	:warning: This data is never plotted.
1009	"""
1010	self.qmax_x = float(self.qmax_ctl.GetValue())
1011	self.npts_x = int(float(self.npt_ctl.GetValue()))
1012	self.data = Data2D()
1013	qmax = self.qmax_x #/ numpy.sqrt(2)
1014	self.data.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
1015	self.data.yaxis('\\rm{Q_{y}}', '\AA^{-1}')
1016	self.data.is_data = False
1017	self.data.id = str(self.uid) + " GenData"
1018	self.data.group_id = str(self.uid) + " Model2D"
1019	## Default values
1020	self.data.detector.append(Detector())
1021	index = len(self.data.detector) - 1
1022	self.data.detector[index].distance = 8000 # mm
1023	self.data.source.wavelength = 6 # A
1024	self.data.detector[index].pixel_size.x = 5 # mm
1025	self.data.detector[index].pixel_size.y = 5 # mm
1026	self.data.detector[index].beam_center.x = qmax
1027	self.data.detector[index].beam_center.y = qmax
1028	xmax = qmax
1029	xmin = -qmax
1030	ymax = qmax
1031	ymin = -qmax
1032	qstep = self.npts_x
1033
1034	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
1035	y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
1036	## use data info instead
1037	new_x = numpy.tile(x, (len(y), 1))
1038	new_y = numpy.tile(y, (len(x), 1))
1039	new_y = new_y.swapaxes(0, 1)
1040	# all data reuire now in 1d array
1041	qx_data = new_x.flatten()
1042	qy_data = new_y.flatten()
1043	q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
1044	# set all True (standing for unmasked) as default
1045	mask = numpy.ones(len(qx_data), dtype=bool)
1046	# store x and y bin centers in q space
1047	x_bins = x
1048	y_bins = y
1049	self.data.source = Source()
1050	self.data.data = numpy.ones(len(mask))
1051	self.data.err_data = numpy.ones(len(mask))
1052	self.data.qx_data = qx_data
1053	self.data.qy_data = qy_data
1054	self.data.q_data = q_data
1055	self.data.mask = mask
1056	self.data.x_bins = x_bins
1057	self.data.y_bins = y_bins
1058	# max and min taking account of the bin sizes
1059	self.data.xmin = xmin
1060	self.data.xmax = xmax
1061	self.data.ymin = ymin
1062	self.data.ymax = ymax
1063
1064	def _create_default_1d_data(self):
1065	"""
1066	Create 2D data by default
1067	Only when the page is on theory mode.
1068	:warning: This data is never plotted.
1069	residuals.x = data_copy.x[index]
1070	residuals.dy = numpy.ones(len(residuals.y))
1071	residuals.dx = None
1072	residuals.dxl = None
1073	residuals.dxw = None
1074	"""
1075	self.qmax_x = float(self.qmax_ctl.GetValue())
1076	self.npts_x = int(float(self.npt_ctl.GetValue()))
1077	qmax = self.qmax_x #/ numpy.sqrt(2)
1078	## Default values
1079	xmax = qmax
1080	xmin = qmax * _Q1D_MIN
1081	qstep = self.npts_x
1082	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
1083	# store x and y bin centers in q space
1084	#self.data.source = Source()
1085	y = numpy.ones(len(x))
1086	dy = numpy.zeros(len(x))
1087	dx = numpy.zeros(len(x))
1088	self.data = Data1D(x=x, y=y)
1089	self.data.dx = dx
1090	self.data.dy = dy
1091
1092	def _draw1D(self, y_out):
1093	"""
1094	Complete get the result of modelthread and create model 2D
1095	that can be plot.
1096	"""
1097	page_id = self.id
1098	data = self.data
1099
1100	model = self.model
1101	state = None
1102
1103	new_plot = Data1D(x=data.x, y=y_out)
1104	new_plot.dx = data.dx
1105	new_plot.dy = data.dy
1106	new_plot.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
1107	new_plot.yaxis('\\rm{Intensity}', 'cm^{-1}')
1108	new_plot.is_data = False
1109	new_plot.id = str(self.uid) + " GenData1D"
1110	new_plot.group_id = str(self.uid) + " Model1D"
1111	new_plot.name = model.name + '1d'
1112	new_plot.title = "Generic model1D "
1113	new_plot.id = str(page_id) + ': ' + self.file_name \
1114	+ ' #%s'% str(self.graph_num) + "_1D"
1115	new_plot.group_id = str(page_id) + " Model1D" +\
1116	' #%s'% str(self.graph_num) + "_1D"
1117	new_plot.is_data = False
1118
1119	title = new_plot.title
1120	_yaxis, _yunit = new_plot.get_yaxis()
1121	_xaxis, _xunit = new_plot.get_xaxis()
1122	new_plot.xaxis(str(_xaxis), str(_xunit))
1123	new_plot.yaxis(str(_yaxis), str(_yunit))
1124
1125	if new_plot.is_data:
1126	data_name = str(new_plot.name)
1127	else:
1128	data_name = str(model.__class__.__name__) + '1d'
1129
1130	if len(title) > 1:
1131	new_plot.title = "Gen Theory for %s "% model.name + data_name
1132	new_plot.name = new_plot.id
1133	new_plot.label = new_plot.id
1134	#theory_data = deepcopy(new_plot)
1135	if self.parent.parent != None:
1136	self.parent.parent.update_theory(data_id=new_plot.id,
1137	theory=new_plot,
1138	state=state)
1139	title = new_plot.title
1140	num_graph = str(self.graph_num)
1141	wx.CallAfter(self.parent.draw_graph, new_plot,
1142	title="GEN Graph %s: "% num_graph + new_plot.id )
1143	self.graph_num += 1
1144
1145	def _draw2D(self, image):
1146	"""
1147	Complete get the result of modelthread and create model 2D
1148	that can be plot.
1149	"""
1150	page_id = self.id
1151	data = self.data
1152
1153	model = self.model
1154	qmin = 0.0
1155	state = None
1156
1157	numpy.nan_to_num(image)
1158	new_plot = Data2D(image=image, err_image=data.err_data)
1159	new_plot.name = model.name + '2d'
1160	new_plot.title = "Generic model 2D "
1161	new_plot.id = str(page_id) + ': ' + self.file_name \
1162	+ ' #%s'% str(self.graph_num) + "_2D"
1163	new_plot.group_id = str(page_id) + " Model2D" \
1164	+ ' #%s'% str(self.graph_num) + "_2D"
1165	new_plot.detector = data.detector
1166	new_plot.source = data.source
1167	new_plot.is_data = False
1168	new_plot.qx_data = data.qx_data
1169	new_plot.qy_data = data.qy_data
1170	new_plot.q_data = data.q_data
1171	new_plot.mask = data.mask
1172	## plot boundaries
1173	new_plot.ymin = data.ymin
1174	new_plot.ymax = data.ymax
1175	new_plot.xmin = data.xmin
1176	new_plot.xmax = data.xmax
1177	title = data.title
1178	_yaxis, _yunit = data.get_yaxis()
1179	_xaxis, _xunit = data.get_xaxis()
1180	new_plot.xaxis(str(_xaxis), str(_xunit))
1181	new_plot.yaxis(str(_yaxis), str(_yunit))
1182
1183	new_plot.is_data = False
1184	if data.is_data:
1185	data_name = str(data.name)
1186	else:
1187	data_name = str(model.__class__.__name__) + '2d'
1188
1189	if len(title) > 1:
1190	new_plot.title = "Gen Theory for %s "% model.name + data_name
1191	new_plot.name = new_plot.id
1192	new_plot.label = new_plot.id
1193	#theory_data = deepcopy(new_plot)
1194	if self.parent.parent != None:
1195	self.parent.parent.update_theory(data_id=data.id,
1196	theory=new_plot,
1197	state=state)
1198	title = new_plot.title
1199	num_graph = str(self.graph_num)
1200	wx.CallAfter(self.parent.draw_graph, new_plot,
1201	title="GEN Graph %s: "% num_graph + new_plot.id )
1202	self.graph_num += 1
1203
1204	def set_scale2d(self, scale):
1205	"""
1206	Set SLD plot scale
1207	"""
1208	self.scale2d = None
1209
1210	def on_panel_close(self, event):
1211	"""
1212	On Close SLD panel
1213	"""
1214	#Not implemented
1215
1216	class OmfPanel(ScrolledPanel, PanelBase):
1217	"""
1218	Provides the sas gen calculator GUI.
1219	"""
1220	## Internal nickname for the window, used by the AUI manager
1221	window_name = "SLD Pixel Info"
1222	## Name to appear on the window title bar
1223	window_caption = "SLD Pixel Info "
1224
1225	def __init__(self, parent, args, *kwds):
1226	ScrolledPanel.__init__(self, parent, style=wx.RAISED_BORDER,
1227	args, *kwds)
1228	PanelBase.__init__(self)
1229	#Font size
1230	self.SetWindowVariant(variant=FONT_VARIANT)
1231	self.SetupScrolling()
1232	# Object that receive status event
1233	self.parent = parent
1234	self.sld_data = sas_gen.MagSLD([0], [0], [0])
1235	self.sld_ctl = None
1236	self.default_shape = 'rectangular'
1237	self._do_layout()
1238
1239	def set_slddata(self, slddata):
1240	"""
1241	Set sld data related items
1242	"""
1243	self.sld_data = slddata
1244	self._set_slddata_ctr_val(slddata)
1245	# Make sure that self._set_slddata_ctr_val() is finished
1246	wx.CallAfter(self._set_omfdata_ctr, slddata)
1247
1248	def get_sld_val(self):
1249	"""
1250	Set sld_n of slddata on sld input
1251	"""
1252	sld_sets = {}
1253	if not self.sld_data.is_data:
1254	self._get_other_val()
1255	for list in self.slds:
1256	if list[1].IsEnabled():
1257	list[1].SetBackgroundColour("white")
1258	list[1].Refresh()
1259	try:
1260	val = float(list[1].GetValue())
1261	sld_sets[list[0]] = val
1262	except:
1263	flag = _set_error(self, list[1])
1264	if not flag:
1265	return self.sld_data
1266	else:
1267	sld_sets[list[0]] = None
1268	for key in sld_sets.keys():
1269	key_low = key.lower()
1270	if key_low.count('mx') > 0:
1271	if sld_sets[key] == None:
1272	sld_sets[key] = self.sld_data.sld_mx
1273	mx = sld_sets[key]
1274	elif key_low.count('my') > 0:
1275	if sld_sets[key] == None:
1276	sld_sets[key] = self.sld_data.sld_my
1277	my = sld_sets[key]
1278	elif key_low.count('mz') > 0:
1279	if sld_sets[key] == None:
1280	sld_sets[key] = self.sld_data.sld_mz
1281	mz = sld_sets[key]
1282	else:
1283	if sld_sets[key] != None:
1284	self.sld_data.set_sldn(sld_sets[key])
1285	self.sld_data.set_sldms(mx, my, mz)
1286	self._set_slddata_ctr_val(self.sld_data)
1287
1288	return self.sld_data
1289
1290	def get_pix_volumes(self):
1291	"""
1292	Get the pixel volume
1293	"""
1294	vol = self.sld_data.vol_pix
1295
1296	return vol
1297
1298	def _get_other_val(self):
1299	"""
1300	"""
1301	omfdata = sas_gen.OMFData()
1302	sets = {}
1303	try:
1304	for lst in self.stepsize:
1305	if lst[1].IsEnabled():
1306	val = float(lst[1].GetValue())
1307	sets[lst[0]] = val
1308	else:
1309	sets[lst[0]] = None
1310	return
1311	for lst in self.nodes:
1312	if lst[1].IsEnabled():
1313	val = float(lst[1].GetValue())
1314	sets[lst[0]] = val
1315	else:
1316	sets[lst[0]] = None
1317	return
1318
1319	for key in sets.keys():
1320	exec "omfdata.%s = sets['%s']"% (key, key)
1321
1322	omf2sld = sas_gen.OMF2SLD()
1323	omf2sld.set_data(omfdata, self.default_shape)
1324	self.sld_data = omf2sld.output
1325	self.sld_data.is_data = False
1326	self.sld_data.filename = "Default SLD Profile"
1327	except:
1328	msg = "OMF Panel: %s"% sys.exc_value
1329	infor = 'Error'
1330	#logging.error(msg)
1331	if self.parent.parent != None:
1332	# inform msg to wx
1333	wx.PostEvent(self.parent.parent,
1334	StatusEvent(status=msg, info=infor))
1335	self.SetFocus()
1336
1337	def _set_slddata_ctr_val(self, slddata):
1338	"""
1339	Set slddata crl
1340	"""
1341	try:
1342	val = str(len(slddata.sld_n))
1343	except:
1344	val = 'Unknown'
1345	self.npix_ctl.SetValue(val)
1346
1347	def _set_omfdata_ctr(self, omfdata):
1348	"""
1349	Set the textctr box values
1350	"""
1351
1352	if omfdata == None:
1353	self._set_none_text()
1354	return
1355	nodes_list = self._get_nodes_key_list(omfdata)
1356	step_list = self._get_step_key_list(omfdata)
1357	for ctr_list in self.nodes:
1358	for key in nodes_list.keys():
1359	if ctr_list[0] == key:
1360	ctr_list[1].SetValue(format_number(nodes_list[key], True))
1361	ctr_list[1].Enable(not omfdata.is_data)
1362	break
1363	for ctr_list in self.stepsize:
1364	for key in step_list.keys():
1365	if ctr_list[0] == key:
1366	ctr_list[1].SetValue(format_number(step_list[key], True))
1367	ctr_list[1].Enable(not omfdata.is_data)
1368	break
1369
1370	def _set_none_text(self):
1371	"""
1372	Set Unknown in textctrls
1373	"""
1374	val = 'Unknown'
1375	for ctr_list in self.nodes:
1376	ctr_list[1].SetValue(val)
1377	for ctr_list in self.stepsize:
1378	ctr_list[1].SetValue(val)
1379
1380	def _define_structure(self):
1381	"""
1382	Define the main sizers building to build this application.
1383	"""
1384	self.main_sizer = wx.BoxSizer(wx.VERTICAL)
1385
1386	self.npixels_sizer = wx.BoxSizer(wx.HORIZONTAL)
1387	self.box_sld = wx.StaticBox(self, -1,
1388	str("Mean SLD"))
1389	self.box_node = wx.StaticBox(self, -1, str("Nodes"))
1390	self.boxsizer_sld = wx.StaticBoxSizer(self.box_sld, wx.VERTICAL)
1391	self.box_stepsize = wx.StaticBox(self, -1, str("Step Size"))
1392	self.boxsizer_node = wx.StaticBoxSizer(self.box_node, wx.VERTICAL)
1393	self.boxsizer_stepsize = wx.StaticBoxSizer(self.box_stepsize,
1394	wx.VERTICAL)
1395	self.sld_sizer = wx.BoxSizer(wx.HORIZONTAL)
1396	self.node_sizer = wx.BoxSizer(wx.HORIZONTAL)
1397	self.step_sizer = wx.BoxSizer(wx.HORIZONTAL)
1398	self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)
1399	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1400
1401	def _layout_npix(self):
1402	"""
1403	Build No of pixels sizer
1404	"""
1405	num_pix_text = wx.StaticText(self, -1, "No. of Pixels: ")
1406	self.npix_ctl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1407	style=wx.TE_PROCESS_ENTER)
1408	self._set_slddata_ctr_val(self.sld_data)
1409	self._set_omfdata_ctr(self.sld_data)
1410	self.npixels_sizer.AddMany([(num_pix_text, 0,
1411	wx.EXPAND\|wx.LEFT\|wx.TOP, 5),
1412	(self.npix_ctl, 0,
1413	wx.EXPAND\|wx.TOP, 5)])
1414
1415	def _layout_slds(self):
1416	"""
1417	Build nuclear sld sizer
1418	"""
1419	self.slds = []
1420	omfdata = self.sld_data
1421	if omfdata == None:
1422	raise
1423	sld_key_list = self._get_slds_key_list(omfdata)
1424	# Dic is not sorted
1425	key_list = [key for key in sld_key_list.keys()]
1426	# Sort here
1427	key_list.sort()
1428	is_data = self.sld_data.is_data
1429	sizer = wx.GridBagSizer(2, 3)
1430	ix = 0
1431	iy = -1
1432	for key in key_list:
1433	value = sld_key_list[key]
1434	iy += 1
1435	ix = 0
1436	name = wx.StaticText(self, -1, key)
1437	sizer.Add(name, (iy, ix), (1, 1), \
1438	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1439	## add parameter value
1440	ix += 1
1441	ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1442	style=wx.TE_PROCESS_ENTER)
1443	ctl.SetValue(format_number(value, True))
1444	ctl.Enable(not is_data)
1445	sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1446	## add unit
1447	ix += 1
1448	s_unit = '[' + omfdata.sld_unit + ']'
1449	unit = wx.StaticText(self, -1, s_unit)
1450	sizer.Add(unit, (iy, ix), (1, 1), \
1451	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1452	self.slds.append([key, ctl, unit])
1453	self.sld_sizer.Add(sizer, 0, wx.LEFT, 10)
1454
1455	def _layout_nodes(self):
1456	"""
1457	Fill the sizer containing data's name
1458	"""
1459	self.nodes = []
1460	omfdata = self.sld_data
1461	if omfdata == None:
1462	raise
1463	key_list = self._get_nodes_key_list(omfdata)
1464	is_data = self.sld_data.is_data
1465	sizer = wx.GridBagSizer(2, 3)
1466	ix = 0
1467	iy = -1
1468	for key, value in key_list.iteritems():
1469	iy += 1
1470	ix = 0
1471	name = wx.StaticText(self, -1, key)
1472	sizer.Add(name, (iy, ix), (1, 1), \
1473	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1474	## add parameter value
1475	ix += 1
1476	ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1477	style=wx.TE_PROCESS_ENTER)
1478	ctl.Bind(wx.EVT_TEXT, self._onparamEnter )
1479	ctl.SetValue(format_number(value, True))
1480	ctl.Enable(not is_data)
1481	sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1482	## add unit
1483	ix += 1
1484	unit = wx.StaticText(self, -1, '')
1485	sizer.Add(unit, (iy, ix), (1, 1), \
1486	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1487	self.nodes.append([key, ctl, unit])
1488	self.node_sizer.Add(sizer, 0, wx.LEFT, 10)
1489
1490	def _layout_stepsize(self):
1491	"""
1492	Fill the sizer containing slit size information
1493	"""
1494	self.stepsize = []
1495	omfdata = self.sld_data
1496	if omfdata == None:
1497	raise
1498	key_list = self._get_step_key_list(omfdata)
1499	is_data = self.sld_data.is_data
1500	sizer = wx.GridBagSizer(2, 3)
1501	ix = 0
1502	iy = -1
1503	#key_list.sort()
1504	for key, value in key_list.iteritems():
1505	iy += 1
1506	ix = 0
1507	name = wx.StaticText(self, -1, key)
1508	sizer.Add(name, (iy, ix), (1, 1), \
1509	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1510	## add parameter value
1511	ix += 1
1512	ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1513	style=wx.TE_PROCESS_ENTER)
1514	ctl.Bind(wx.EVT_TEXT, self._onstepsize )
1515	ctl.SetValue(format_number(value, True))
1516	ctl.Enable(not is_data)
1517	sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1518	## add unit
1519	ix += 1
1520	p_unit = '[' + omfdata.pos_unit + ']'
1521	unit = wx.StaticText(self, -1, p_unit)
1522	sizer.Add(unit, (iy, ix), (1, 1), \
1523	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1524	self.stepsize.append([key, ctl, unit])
1525	self.step_sizer.Add(sizer, 0, wx.LEFT, 10)
1526
1527	def _layout_hint(self):
1528	"""
1529	Fill the sizer containing hint
1530	"""
1531	hint_msg = "Load an omf or 3d sld profile data file."
1532	self.hint_txt = wx.StaticText(self, -1, hint_msg)
1533	self.hint_sizer.AddMany([(self.hint_txt, 0, wx.LEFT, 15)])
1534
1535	def _layout_button(self):
1536	"""
1537	Do the layout for the button widgets
1538	"""
1539	self.bt_draw = wx.Button(self, wx.NewId(),'Draw Points')
1540	self.bt_draw.Bind(wx.EVT_BUTTON, self.on_sld_draw)
1541	self.bt_draw.SetToolTipString("Draw a scatter plot for sld profile.")
1542	self.bt_save = wx.Button(self, wx.NewId(),'Save SLD Data')
1543	self.bt_save.Bind(wx.EVT_BUTTON, self.on_save)
1544	self.bt_save.Enable(False)
1545	self.bt_save.SetToolTipString("Save SLD data.")
1546	self.button_sizer.AddMany([(self.bt_draw, 0, wx.LEFT, 10),
1547	(self.bt_save, 0, wx.LEFT, 10)])
1548
1549	def _do_layout(self):
1550	"""
1551	Draw omf panel content, used to define sld s.
1552
1553	"""
1554	self._define_structure()
1555	self._layout_nodes()
1556	self._layout_stepsize()
1557	self._layout_npix()
1558	self._layout_slds()
1559	#self._layout_hint()
1560	self._layout_button()
1561	self.boxsizer_node.AddMany([(self.node_sizer, 0,
1562	wx.EXPAND\|wx.TOP, 5),
1563	(self.hint_sizer, 0,
1564	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5)])
1565	self.boxsizer_stepsize.AddMany([(self.step_sizer, 0,
1566	wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5),])
1567	self.boxsizer_sld.AddMany([(self.sld_sizer, 0,
1568	wx.EXPAND\|wx.BOTTOM, 5),])
1569	self.main_sizer.AddMany([(self.npixels_sizer, 0, wx.EXPAND\|wx.ALL, 10),
1570	(self.boxsizer_sld, 0, wx.EXPAND\|wx.ALL, 10),
1571	(self.boxsizer_node, 0, wx.EXPAND\|wx.ALL, 10),
1572	(self.boxsizer_stepsize, 0, wx.EXPAND\|wx.ALL, 10),
1573	(self.button_sizer, 0, wx.EXPAND\|wx.TOP\|wx.BOTTOM, 5)])
1574	self.SetSizer(self.main_sizer)
1575	self.SetAutoLayout(True)
1576
1577	def _get_nodes_key_list(self, data):
1578	"""
1579	Return nodes key list
1580
1581	:Param data: OMFData
1582	"""
1583	key_list = {'xnodes' : data.xnodes,
1584	'ynodes' : data.ynodes,
1585	'znodes' : data.znodes}
1586	return key_list
1587
1588	def _get_slds_key_list(self, data):
1589	"""
1590	Return nodes key list
1591
1592	:Param data: OMFData
1593	"""
1594	key_list = {'Nucl.' : data.sld_n,
1595	'Mx' : data.sld_mx,
1596	'My' : data.sld_my,
1597	'Mz' : data.sld_mz}
1598	return key_list
1599
1600	def _get_step_key_list(self, data):
1601	"""
1602	Return step key list
1603
1604	:Param data: OMFData
1605	"""
1606	key_list = {'xstepsize' : data.xstepsize,
1607	'ystepsize' : data.ystepsize,
1608	'zstepsize' : data.zstepsize}
1609	return key_list
1610
1611	def set_sld_ctr(self, sld_data):
1612	"""
1613	Set sld textctrls
1614	"""
1615	if sld_data == None:
1616	for ctr_list in self.slds:
1617	ctr_list[1].Enable(False)
1618	#break
1619	return
1620
1621	self.sld_data = sld_data
1622	sld_list = self._get_slds_key_list(sld_data)
1623	for ctr_list in self.slds:
1624	for key in sld_list.keys():
1625	if ctr_list[0] == key:
1626	min_val = numpy.min(sld_list[key])
1627	max_val = numpy.max(sld_list[key])
1628	mean_val = numpy.mean(sld_list[key])
1629	enable = (min_val == max_val) and \
1630	sld_data.pix_type == 'pixel'
1631	ctr_list[1].SetValue(format_number(mean_val, True))
1632	ctr_list[1].Enable(enable)
1633	#ctr_list[2].SetLabel("[" + sld_data.sld_unit + "]")
1634	break
1635
1636	def on_sld_draw(self, event):
1637	"""
1638	Draw sld profile as scattered plot
1639	"""
1640	self.parent.sld_draw()
1641
1642	def on_save(self, event):
1643	"""
1644	Close the window containing this panel
1645	"""
1646	flag = True
1647	flag = self.check_inputs()
1648	if not flag:
1649	return
1650	self.sld_data = self.get_sld_val()
1651	self.parent.set_main_panel_sld_data(self.sld_data)
1652
1653	reader = sas_gen.SLDReader()
1654	extension = '*.sld'
1655	path = None
1656	data= None
1657	location = self.parent.get_path()
1658	dlg = wx.FileDialog(self, "Save sld file",
1659	location, "sld_file",
1660	extension,
1661	wx.SAVE)
1662	if dlg.ShowModal() == wx.ID_OK:
1663	path = dlg.GetPath()
1664	self.parent.set_file_location(os.path.dirname(path))
1665	else:
1666	return None
1667	dlg.Destroy()
1668	try:
1669	if path is None:
1670	return
1671
1672	data = self.parent.get_sld_data()
1673	fName = os.path.splitext(path)[0] + '.' + extension.split('.')[-1]
1674	if data != None:
1675	try:
1676	reader.write(fName, data)
1677	except:
1678	raise
1679	else:
1680	msg = "%s cannot write %s\n" % ('Generic Scattering', str(path))
1681	infor = 'Error'
1682	#logging.error(msg)
1683	if self.parent.parent != None:
1684	# inform msg to wx
1685	wx.PostEvent(self.parent.parent,
1686	StatusEvent(status=msg, info=infor))
1687	self.SetFocus()
1688	return
1689	except:
1690	msg = "Error occurred while saving. "
1691	infor = 'Error'
1692	if self.parent.parent != None:
1693	# inform msg to wx
1694	wx.PostEvent(self.parent.parent,
1695	StatusEvent(status=msg, info=infor))
1696	self.SetFocus()
1697
1698	def _onparamEnter(self, event):
1699	"""
1700	"""
1701	flag = True
1702	if event != None:
1703	event.Skip()
1704	ctl = event.GetEventObject()
1705	ctl.SetBackgroundColour("white")
1706	#_set_error(self, ctl)
1707	try:
1708	float(ctl.GetValue())
1709	except:
1710	flag = _set_error(self, ctl)
1711	if flag:
1712	npts = 1
1713	for item in self.nodes:
1714	n_val = float(item[1].GetValue())
1715	if n_val <= 0:
1716	item[1].SetBackgroundColour("pink")
1717	npts = -1
1718	break
1719	if numpy.isfinite(n_val):
1720	npts *= int(n_val)
1721	if npts > 0:
1722	nop = self.set_npts_from_slddata()
1723	if nop == None:
1724	nop = npts
1725	self.display_npts(nop)
1726
1727	ctl.Refresh()
1728	return flag
1729
1730	def _set_volume_ctr_val(self, npts):
1731	"""
1732	Set total volume
1733	"""
1734	total_volume = npts * self.sld_data.vol_pix[0]
1735	self.parent.set_volume_ctr_val(total_volume)
1736
1737	def _onstepsize(self, event):
1738	"""
1739	On stepsize event
1740	"""
1741	flag = True
1742	if event != None:
1743	event.Skip()
1744	ctl = event.GetEventObject()
1745	ctl.SetBackgroundColour("white")
1746
1747	if flag and not self.sld_data.is_data:#ctl.IsEnabled():
1748	s_size = 1.0
1749	try:
1750	for item in self.stepsize:
1751	s_val = float(item[1].GetValue())
1752	if s_val <= 0:
1753	item[1].SetBackgroundColour("pink")
1754	ctl.Refresh()
1755	return
1756	if numpy.isfinite(s_val):
1757	s_size *= s_val
1758	self.sld_data.set_pixel_volumes(s_size)
1759	if ctl.IsEnabled():
1760	total_volume = sum(self.sld_data.vol_pix)
1761	self.parent.set_volume_ctr_val(total_volume)
1762	except:
1763	pass
1764	ctl.Refresh()
1765
1766
1767	def set_npts_from_slddata(self):
1768	"""
1769	Set total n. of points form the sld data
1770	"""
1771	try:
1772	sld_data = self.parent.get_sld_from_omf()
1773	#nop = (nop * numpy.pi) / 6
1774	nop = len(sld_data.sld_n)
1775	except:
1776	nop = None
1777	return nop
1778
1779	def display_npts(self, nop):
1780	"""
1781	Displays Npts ctrl
1782	"""
1783	try:
1784	self.npix_ctl.SetValue(str(nop))
1785	self.npix_ctl.Refresh()
1786	self.parent.set_etime()
1787	wx.CallAfter(self._set_volume_ctr_val, nop)
1788	except:
1789	# On Init
1790	pass
1791
1792	def check_inputs(self):
1793	"""
1794	check if the inputs are valid
1795	"""
1796	flag = self._check_input_helper(self.slds)
1797	if flag:
1798	flag = self._check_input_helper(self.nodes)
1799	if flag:
1800	flag = self._check_input_helper(self.stepsize)
1801	return flag
1802
1803	def _check_input_helper(self, list):
1804	"""
1805	Check list values
1806	"""
1807	flag = True
1808	for item in list:
1809	item[1].SetBackgroundColour("white")
1810	item[1].Refresh()
1811	try:
1812	float(item[1].GetValue())
1813	except:
1814	flag = _set_error(self, item[1])
1815	break
1816	return flag
1817
1818	class SasGenWindow(widget.CHILD_FRAME):
1819	"""
1820	GEN SAS main window
1821	"""
1822	def __init__(self, parent=None, manager= None, title="Generic Scattering Calculator",
1823	size=(PANEL_WIDTH * 1.4, PANEL_HEIGHT * 1.65), args, *kwds):
1824	"""
1825	Init
1826	"""
1827	kwds['size'] = size
1828	kwds['title'] = title
1829	widget.CHILD_FRAME.__init__(self, parent, args, *kwds)
1830	self.parent = parent
1831	self.base = manager
1832	self.omfpanel = OmfPanel(parent=self)
1833	self.panel = SasGenPanel(parent=self)
1834	self.data = None
1835	self.omfdata = sas_gen.OMFData()
1836	self.sld_data = None
1837	self._default_save_location = os.getcwd()
1838
1839	self._mgr = aui.AuiManager(self)
1840	self._mgr.SetDockSizeConstraint(0.5, 0.5)
1841	self._plot_title = ''
1842	self.scale2d = 'log_{10}'
1843	self.Bind(wx.EVT_CLOSE, self.on_close)
1844
1845
1846	self.build_panels()
1847	self.SetPosition((20, 5))
1848	self.Show(True)
1849
1850	def build_panels(self):
1851	"""
1852	"""
1853
1854	self.set_sld_data(self.sld_data)
1855	self._mgr.AddPane(self.panel, aui.AuiPaneInfo().
1856	Name(self.panel.window_name).
1857	CenterPane().
1858	# This is where we set the size of
1859	# the application window
1860	BestSize(wx.Size(PANEL_WIDTH,
1861	PANEL_HEIGHT)).
1862	Show())
1863	self._mgr.AddPane(self.omfpanel, aui.AuiPaneInfo().
1864	Name(self.omfpanel.window_name).
1865	Caption(self.omfpanel.window_caption).
1866	CloseButton(False).
1867	Right().
1868	Floatable(False).
1869	BestSize(wx.Size(PANEL_WIDTH/2.5, PANEL_HEIGHT)).
1870	Show())
1871	self._mgr.Update()
1872
1873	def get_sld_data(self):
1874	"""
1875	Return slddata
1876	"""
1877	return self.sld_data
1878
1879	def get_sld_from_omf(self):
1880	"""
1881	"""
1882	self.sld_data = self.omfpanel.get_sld_val()
1883	return self.sld_data
1884
1885	def set_sld_n(self, sld):
1886	"""
1887	"""
1888	self.panel.sld_data = sld
1889	self.panel.model.set_sld_data(sld)
1890
1891	def set_sld_data(self, data):
1892	"""
1893	Set omfdata
1894	"""
1895	if data == None:
1896	return
1897	self.sld_data = data
1898	enable = (not data==None)
1899	self._set_omfpanel_sld_data(self.sld_data)
1900	self.omfpanel.bt_save.Enable(enable)
1901	self.set_etime()
1902
1903	def set_omfpanel_npts(self):
1904	"""
1905	Set Npts in omf panel
1906	"""
1907	nop = self.omfpanel.set_npts_from_slddata()
1908	self.omfpanel.display_npts(nop)
1909
1910	def _set_omfpanel_sld_data(self, data):
1911	"""
1912	Set sld_data in omf panel
1913	"""
1914	self.omfpanel.set_slddata(data)
1915	self.omfpanel.set_sld_ctr(data)
1916
1917	def check_omfpanel_inputs(self):
1918	"""
1919	Check OMF panel inputs
1920	"""
1921	return self.omfpanel.check_inputs()
1922
1923	def set_main_panel_sld_data(self, sld_data):
1924	"""
1925	"""
1926	self.sld_data = sld_data
1927
1928	def set_file_location(self, path):
1929	"""
1930	File location
1931	"""
1932	self._default_save_location = path
1933
1934	def get_path(self):
1935	"""
1936	File location
1937	"""
1938	return self._default_save_location
1939
1940	def draw_graph(self, plot, title=''):
1941	"""
1942	"""
1943	try:
1944	wx.PostEvent(self.parent, NewPlotEvent(plot=plot, title=title))
1945	except:
1946	# standalone
1947	frame = PlotFrame(self, -1, 'testView', self.scale2d)
1948	#add_icon(self.parent, frame)
1949	frame.add_plot(plot)
1950	frame.SetTitle(title)
1951	frame.Show(True)
1952	frame.SetFocus()
1953
1954	def set_schedule_full_draw(self, panel=None, func='del'):
1955	"""
1956	Send full draw to gui frame
1957	"""
1958	if self.parent != None:
1959	self.parent.set_schedule_full_draw(panel, func)
1960
1961	def get_npix(self):
1962	"""
1963	Get no. of pixels from omf panel
1964	"""
1965	n_pix = self.omfpanel.npix_ctl.GetValue()
1966	return n_pix
1967
1968	def get_pix_volumes(self):
1969	"""
1970	Get a pixel volume
1971	"""
1972	vol = self.omfpanel.get_pix_volumes()
1973	return vol
1974
1975	def set_volume_ctr_val(self, val):
1976	"""
1977	Set volume txtctl value
1978	"""
1979	try:
1980	self.panel.set_volume_ctl_val(str(val))
1981	except:
1982	print "self.panel is not initialized yet"
1983
1984	def set_omfpanel_default_shap(self, shape):
1985	"""
1986	Set default_shape in omfpanel
1987	"""
1988	self.omfpanel.default_shape = shape
1989
1990	def set_etime(self):
1991	"""
1992	Sets est. computation time on panel
1993	"""
1994	self.panel.set_est_time()
1995
1996	def get_sld_data_from_omf(self):
1997	"""
1998	"""
1999	data = self.omfpanel.get_sld_val()
2000	return data
2001
2002	def set_scale2d(self, scale):
2003	"""
2004	"""
2005	self.scale2d = scale
2006
2007	def on_panel_close(self, event):
2008	"""
2009	"""
2010	#Not implemented
2011
2012	def on_open_file(self, event):
2013	"""
2014	On Open
2015	"""
2016	self.panel.on_load_data(event)
2017
2018	def sld_draw(self):
2019	"""
2020	sld draw
2021	"""
2022	self.panel.sld_draw(event=None, has_arrow=False)
2023
2024	def on_save_file(self, event):
2025	"""
2026	On Close
2027	"""
2028	self.omfpanel.on_save(event)
2029
2030	def on_close(self, event):
2031	"""
2032	Close
2033	"""
2034	if self.base != None:
2035	self.base.gen_frame = None
2036	self.Destroy()
2037
2038	# def on_help(self, event):
2039	# """
2040	# Gen scatter angle help panel
2041	# """
2042	# from sas.perspectives.calculator.help_panel import HelpWindow
2043	# # Get models help model_function path
2044	# import sas.perspectives.calculator as calmedia
2045	#
2046	# media = calmedia.get_data_path(media='media')
2047	# path = os.path.join(media,"gen_sas_help.html")
2048	# name = "Generic Scattering Calculator"
2049	# frame = HelpWindow(self, -1,
2050	# title=' Help: GenSAS',
2051	# pageToOpen=path, size=(865, 450))
2052	# try:
2053	# frame.splitter.DetachWindow(frame.lpanel)
2054	# # Display only the right side one
2055	# frame.lpanel.Hide()
2056	# frame.Show(True)
2057	# add_icon(self.parent, frame)
2058	# except:
2059	# frame.Destroy()
2060	# msg = 'Display Error\n'
2061	# info = "Info"
2062	# wx.MessageBox(msg, info)
2063
2064	if __name__ == "__main__":
2065	app = wx.PySimpleApp()
2066	widget.CHILD_FRAME = wx.Frame
2067	SGframe = SasGenWindow()
2068	SGframe.Show(True)
2069	app.MainLoop()

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

SasView

source: sasview/src/sas/perspectives/calculator/gen_scatter_panel.py @ 418e59f

Download in other formats: