gen_scatter_panel.py @ fa6a8d1

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 fa6a8d1 was 7a04dbb, checked in by krzywon, 10 years ago

Removed the last vestiges of the SANS references and ran run.py. Tested
loading multiple file types and ran fits, p(r) and inversion. Help
windows loaded properly. Saving and loading projects and analyses acted
the same as before the conversion.

All unit tests run by utest_sasview.py passed.

Property mode set to 100644

File size: 77.0 KB

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

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

SasView

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

Download in other formats: