gen_scatter_panel.py @ 20fa5fe

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 20fa5fe was 20fa5fe, checked in by Stuart Prescott <stuart@…>, 6 years ago
Fix lots more typos in comments and docs
Property mode set to `100644`
File size: 71.2 KB

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

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

SasView

source: sasview/src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py @ 20fa5fe

Download in other formats: