invariant_panel.py @ 23ff8d5

Last change on this file since 23ff8d5 was 44e8f48, checked in by krzywon, 6 years ago
Be sure image handler is initialized in invariant panel and code cleanup.
Property mode set to `100644`
File size: 78.0 KB

Rev	Line
[959eb01]	1	"""
	2	This module provides the GUI for the invariant perspective panel
	3
	4	"""
	5	import copy
	6	import time
	7	import sys
	8	import os
	9	import wx
	10	import logging
	11
	12	from wx.lib.scrolledpanel import ScrolledPanel
	13	from sas.sascalc.invariant import invariant
	14
	15	from sas.sasgui.guiframe.utils import format_number
	16	from sas.sasgui.guiframe.utils import check_float
	17	from sas.sasgui.guiframe.events import StatusEvent
	18	from sas.sasgui.guiframe.events import AppendBookmarkEvent
	19	from sas.sasgui.perspectives.invariant.invariant_details import InvariantDetailsPanel
	20	from sas.sasgui.perspectives.invariant.invariant_details import InvariantContainer
	21	from sas.sasgui.perspectives.invariant.invariant_widgets import OutputTextCtrl
	22	from sas.sasgui.perspectives.invariant.invariant_widgets import InvTextCtrl
	23	from sas.sasgui.perspectives.invariant.invariant_state import InvariantState as IState
	24	from sas.sasgui.guiframe.panel_base import PanelBase
	25	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
[fa412df]	26	from sas.sasgui.guiframe.report_image_handler import ReportImageHandler
[959eb01]	27
	28	logger = logging.getLogger(__name__)
	29
	30	# The minimum q-value to be used when extrapolating
	31	Q_MINIMUM = 1e-5
	32	# The maximum q-value to be used when extrapolating
	33	Q_MAXIMUM = 10
	34	# the ratio of maximum q value/(qmax of data) to plot the theory data
	35	Q_MAXIMUM_PLOT = 3
	36	# the number of points to consider during fit
	37	NPTS = 10
	38	#Default value for background
	39	BACKGROUND = 0.0
	40	#default value for the scale
	41	SCALE = 1.0
	42	#default value of the contrast
	43	CONTRAST = 1.0
	44	#default value of the power used for power law
	45	POWER = 4.0
	46	#Invariant panel size
	47	_BOX_WIDTH = 76
	48
	49
	50	if sys.platform.count("win32") > 0:
	51	_STATICBOX_WIDTH = 450
	52	PANEL_WIDTH = 500
	53	PANEL_HEIGHT = 700
	54	FONT_VARIANT = 0
	55	else:
	56	_STATICBOX_WIDTH = 490
	57	PANEL_WIDTH = 530
	58	PANEL_HEIGHT = 700
	59	FONT_VARIANT = 1
	60
	61
	62	class InvariantPanel(ScrolledPanel, PanelBase):
	63	"""
	64	Main class defining the sizers (wx "panels") used to draw the
	65	Invariant GUI.
	66	"""
	67	## Internal nickname for the window, used by the AUI manager
	68	window_name = "Invariant"
	69	## Name to appear on the window title bar
	70	window_caption = "Invariant"
	71	## Flag to tell the AUI manager to put this panel in the center pane
	72	CENTER_PANE = True
	73	def __init__(self, parent, data=None, manager=None, args, *kwds):
	74	kwds["size"] = (PANEL_WIDTH, PANEL_HEIGHT)
	75	kwds["style"] = wx.FULL_REPAINT_ON_RESIZE
	76	ScrolledPanel.__init__(self, parent=parent, args, *kwds)
	77	PanelBase.__init__(self, parent)
	78	self.SetupScrolling()
	79	#Font size
	80	self.SetWindowVariant(variant=FONT_VARIANT)
	81	#Object that receive status event
	82	self.parent = parent.parent
	83	#plug-in using this panel
	84	self._manager = manager
	85	#Data uses for computation
	86	self._data = data
	87	self._scale = SCALE
	88	self._background = BACKGROUND
	89	self._bmark = None
	90	self.bookmark_num = 0
	91	self.state = None
	92	self.popUpMenu = None
	93	self._set_bookmark_menu()
	94	#Init state
	95	self.set_state()
	96	# default flags for state
	97	self.new_state = False
	98	self.is_state_data = False
	99	self.is_power_out = False
	100	self._set_analysis(False)
	101
	102	#container of invariant value
	103	self.inv_container = None
	104	#sizers
	105	self.main_sizer = None
	106	self.outputs_sizer = None
	107	self.data_name_boxsizer = None
	108	self.hint_msg_sizer = None
	109	self.data_name_sizer = None
	110	self.data_range_sizer = None
	111	self.sizer_input = None
	112	self.inputs_sizer = None
	113	self.extrapolation_sizer = None
	114	self.extrapolation_range_sizer = None
	115	self.extrapolation_low_high_sizer = None
	116	self.low_extrapolation_sizer = None
	117	self.low_q_sizer = None
	118	self.high_extrapolation_sizer = None
	119	self.high_q_sizer = None
	120	self.volume_surface_sizer = None
	121	self.invariant_sizer = None
	122	self.button_sizer = None
	123	self.save_button_sizer = None
	124	self.hint_msg_txt = None
	125	self.data_name_tcl = None
	126	self.data_min_tcl = None
	127	self.data_max_tcl = None
	128	#Draw the panel
	129	self._do_layout()
	130	self.reset_panel()
	131	self._reset_state_list()
	132	## Default file location for save
	133	self._default_save_location = os.getcwd()
	134	if self.parent is not None:
	135	msg = ""
	136	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info"))
	137	self._default_save_location = \
	138	self.parent.get_save_location()
	139
	140	self._set_bookmark_flag(False)
	141
	142	def get_data(self):
	143	"""
	144	"""
	145	return self._manager.get_data()
	146
	147	def get_state(self):
	148	"""
	149	"""
	150	return self.state
	151
	152	def set_data(self, data):
	153	"""
	154	Set the data
	155	"""
	156	self._data = data
	157	#edit the panel
	158	if self._data is not None:
	159	self._delete_bookmark_items()
	160	self.get_state_by_num(0)
	161	data_name = self._data.name
	162	data_qmin = min(self._data.x)
	163	data_qmax = max(self._data.x)
	164	self.data_name_tcl.SetValue(str(data_name))
	165	self.data_min_tcl.SetValue(str(data_qmin))
	166	self.data_max_tcl.SetValue(str(data_qmax))
	167	self.reset_panel()
	168	self.compute_invariant(event=None)
	169	self.state.file = self._data.name
	170	#Reset the list of states
	171	self.state.data = copy.deepcopy(data)
	172	self._set_save_flag(True)
	173	self._set_preview_flag(False)
	174	self._reset_state_list()
	175	self._set_bookmark_flag(True)
	176	self._set_analysis(True)
	177	return True
	178
	179	def _delete_bookmark_items(self):
	180	"""
	181	Delete bookmark menu items
	182	"""
	183	# delete toolbar menu
	184	self.parent.reset_bookmark_menu(self)
	185	self.parent._update_toolbar_helper()
	186	# delete popUpMenu items
	187	pos = 0
	188	for item in self.popUpMenu.GetMenuItems():
	189	pos += 1
	190	if pos < 3:
	191	continue
	192	self.popUpMenu.DestroyItem(item)
	193
	194	def set_message(self):
	195	"""
	196	Display warning message if available
	197	"""
	198	if self.inv_container is not None:
	199	if self.inv_container.existing_warning:
	200	msg = "Warning! Computations on invariant require your "
	201	msg += "attention.\nPlease click on Details button."
	202	self.hint_msg_txt.SetForegroundColour("red")
	203
	204	wx.PostEvent(self.parent,
	205	StatusEvent(status=msg, info="warning"))
	206	else:
	207	msg = "For more information, click on Details button."
	208	self.hint_msg_txt.SetForegroundColour("black")
	209	wx.PostEvent(self.parent,
	210	StatusEvent(status=msg, info="info"))
	211	self.hint_msg_txt.SetLabel(msg)
	212	self.Layout()
	213
	214	def set_manager(self, manager):
	215	"""
	216	set value for the manager
	217	"""
	218	self._manager = manager
	219
	220	def save_project(self, doc=None):
	221	"""
	222	return an xml node containing state of the panel
	223	that guiframe can write to file
	224	"""
	225	data = self.get_data()
	226	state = self.get_state()
	227	if data is not None:
	228	new_doc = self._manager.state_reader.write_toXML(data, state)
	229	if new_doc is not None:
	230	if doc is not None and hasattr(doc, "firstChild"):
	231	child = new_doc.getElementsByTagName("SASentry")
	232	for item in child:
	233	doc.firstChild.appendChild(item)
	234	else:
	235	doc = new_doc
	236	return doc
	237
	238	def set_state(self, state=None, data=None):
	239	"""
	240	set state when loading it from a .inv/.svs file
	241	"""
	242
[235f514]	243	if state is None and data is None:
[959eb01]	244	self.state = IState()
[235f514]	245	elif state is None or data is None:
[959eb01]	246	return
	247	else:
	248	new_state = copy.deepcopy(state)
	249	self.new_state = True
	250	if not self.set_data(data):
	251	return
	252
	253	self.state = new_state
	254	self.state.file = data.name
	255
	256	num = self.state.saved_state['state_num']
	257	if int(num) > 0:
	258	self._set_undo_flag(True)
	259	if int(num) < len(state.state_list) - 1:
	260	self._set_redo_flag(True)
	261
	262	# get bookmarks
	263	self.bookmark_num = len(self.state.bookmark_list)
	264	total_bookmark_num = self.bookmark_num + 1
	265
	266	for ind in range(1, total_bookmark_num):
	267	#bookmark_num = ind
	268	value = self.state.bookmark_list[ind]
	269	name = "%d] bookmarked at %s on %s" % (ind, value[0], value[1])
	270	# append it to menu
	271	id = wx.NewId()
	272	self.popUpMenu.Append(id, name, str(''))
	273	wx.EVT_MENU(self, id, self._back_to_bookmark)
	274	wx.PostEvent(self.parent,
	275	AppendBookmarkEvent(title=name,
	276	hint='',
	277	handler=self._back_to_bookmark))
	278
	279	self.get_state_by_num(state_num=str(num))
	280
	281	self._get_input_list()
	282	#make sure that the data is reset (especially
	283	# when loaded from a inv file)
	284	self.state.data = self._data
	285	self._set_preview_flag(False)
	286	self.new_state = False
	287	self.is_state_data = False
	288	self._set_analysis(True)
	289
	290	def clear_panel(self):
	291	"""
	292	Clear panel to defaults, used by set_state of manager
	293	"""
	294
	295	self._data = None
	296	# default data testctrl
	297	self.hint_msg_txt.SetLabel('')
	298	data_name = ''
	299	data_qmin = ''
	300	data_qmax = ''
	301	self.data_name_tcl.SetValue(str(data_name))
	302	self.data_min_tcl.SetValue(str(data_qmin))
	303	self.data_max_tcl.SetValue(str(data_qmax))
	304	#reset output textctrl
	305	self._reset_output()
	306	#reset panel
	307	self.reset_panel()
	308	#reset state w/o data
	309	self.set_state()
	310	# default flags for state
	311	self.new_state = False
	312	self.is_state_data = False
	313	self.is_power_out = False
	314
	315	def get_background(self):
	316	"""
	317	return the background textcrtl value as a float
	318	"""
	319	background = self.background_tcl.GetValue().lstrip().rstrip()
	320	if background == "":
	321	raise ValueError, "Need a background"
	322	if check_float(self.background_tcl):
	323	return float(background)
	324	else:
	325	msg = "Receive invalid value for background : %s" % (background)
	326	raise ValueError, msg
	327
	328	def get_scale(self):
	329	"""
	330	return the scale textcrtl value as a float
	331	"""
	332	scale = self.scale_tcl.GetValue().lstrip().rstrip()
	333	if scale == "":
	334	raise ValueError, "Need a background"
	335	if check_float(self.scale_tcl):
	336	if float(scale) <= 0.0:
	337	self.scale_tcl.SetBackgroundColour("pink")
	338	self.scale_tcl.Refresh()
	339	msg = "Receive invalid value for scale: %s" % (scale)
	340	raise ValueError, msg
	341	return float(scale)
	342	else:
	343	raise ValueError, "Receive invalid value for scale : %s" % (scale)
	344
	345	def get_contrast(self):
	346	"""
	347	return the contrast textcrtl value as a float
	348	"""
	349	par_str = self.contrast_tcl.GetValue().strip()
	350	contrast = None
	351	if par_str != " " and check_float(self.contrast_tcl):
	352	contrast = float(par_str)
	353	return contrast
	354
	355	def get_extrapolation_type(self, low_q, high_q):
	356	"""
	357	get extrapolation type
	358	"""
	359	extrapolation = None
	360	if low_q and not high_q:
	361	extrapolation = "low"
	362	elif not low_q and high_q:
	363	extrapolation = "high"
	364	elif low_q and high_q:
	365	extrapolation = "both"
	366	return extrapolation
	367
	368	def get_porod_const(self):
	369	"""
	370	return the porod constant textcrtl value as a float
	371	"""
	372	par_str = self.porod_constant_tcl.GetValue().strip()
	373	porod_const = None
	374	if par_str != "" and check_float(self.porod_constant_tcl):
	375	porod_const = float(par_str)
	376	return porod_const
	377
	378	def get_volume(self, inv, contrast, extrapolation):
	379	"""
	380	get volume fraction
	381	"""
	382	if contrast is not None:
	383	try:
	384	v, dv = inv.get_volume_fraction_with_error(contrast=contrast,
	385	extrapolation=extrapolation)
	386	self.volume_tcl.SetValue(format_number(v))
	387	self.volume_err_tcl.SetValue(format_number(dv))
	388	except:
	389	self.volume_tcl.SetValue(format_number(None))
	390	self.volume_err_tcl.SetValue(format_number(None))
	391	msg = "Error occurred computing volume "
	392	msg += " fraction: %s" % sys.exc_value
	393	wx.PostEvent(self.parent, StatusEvent(status=msg,
	394	info="error",
	395	type="stop"))
	396
	397	def get_surface(self, inv, contrast, porod_const, extrapolation):
	398	"""
	399	get surface value
	400	"""
	401	if contrast is not None and porod_const is not None:
	402	try:
	403	s, ds = inv.get_surface_with_error(contrast=contrast,
	404	porod_const=porod_const,
	405	extrapolation=extrapolation)
	406	self.surface_tcl.SetValue(format_number(s))
	407	self.surface_err_tcl.SetValue(format_number(ds))
	408	except:
	409	self.surface_tcl.SetValue(format_number(None))
	410	self.surface_err_tcl.SetValue(format_number(None))
	411	msg = "Error occurred computing "
	412	msg += "specific surface: %s" % sys.exc_value
	413	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
	414	type="stop"))
	415
	416	def get_total_qstar(self, inv, extrapolation):
	417	"""
	418	get total qstar
	419	"""
	420	try:
	421	qstar_total, qstar_total_err = \
	422	inv.get_qstar_with_error(extrapolation)
	423	self.invariant_total_tcl.SetValue(format_number(qstar_total))
	424	self.invariant_total_err_tcl.SetValue(\
	425	format_number(qstar_total_err))
	426	self.inv_container.qstar_total = qstar_total
	427	self.inv_container.qstar_total_err = qstar_total_err
	428	except:
	429	self.inv_container.qstar_total = "Error"
	430	self.inv_container.qstar_total_err = "Error"
	431	self.invariant_total_tcl.SetValue(format_number(None))
	432	self.invariant_total_err_tcl.SetValue(format_number(None))
	433	msg = "Error occurred computing invariant using"
	434	msg += " extrapolation: %s" % sys.exc_value
	435	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
	436
	437	def get_low_qstar(self, inv, npts_low, low_q=False):
	438	"""
	439	get low qstar
	440	"""
	441	if low_q:
	442	try:
	443	qstar_low, qstar_low_err = inv.get_qstar_low()
	444	self.inv_container.qstar_low = qstar_low
	445	self.inv_container.qstar_low_err = qstar_low_err
	446	extrapolated_data = inv.get_extra_data_low(npts_in=npts_low)
	447	power_low = inv.get_extrapolation_power(range='low')
	448	if self.power_law_low.GetValue():
	449	self.power_low_tcl.SetValue(format_number(power_low))
	450	self._manager.plot_theory(data=extrapolated_data,
	451	name="Low-Q extrapolation")
	452	except:
	453	self.inv_container.qstar_low = "ERROR"
	454	self.inv_container.qstar_low_err = "ERROR"
	455	self._manager.plot_theory(name="Low-Q extrapolation")
	456	msg = "Error occurred computing low-Q "
	457	msg += "invariant: %s" % sys.exc_value
	458	wx.PostEvent(self.parent,
	459	StatusEvent(status=msg, type="stop"))
	460	raise
	461	else:
	462	try:
	463	self._manager.plot_theory(name="Low-Q extrapolation")
	464	except:
	465	logger.error(sys.exc_value)
	466
	467	def get_high_qstar(self, inv, high_q=False):
	468	"""
	469	get high qstar
	470	"""
	471	if high_q:
	472	try:
	473	qmax_plot = Q_MAXIMUM_PLOT * max(self._data.x)
	474	if qmax_plot > Q_MAXIMUM:
	475	qmax_plot = Q_MAXIMUM
	476	qstar_high, qstar_high_err = inv.get_qstar_high()
	477	self.inv_container.qstar_high = qstar_high
	478	self.inv_container.qstar_high_err = qstar_high_err
	479	power_high = inv.get_extrapolation_power(range='high')
	480	self.power_high_tcl.SetValue(format_number(power_high))
	481	high_out_data = inv.get_extra_data_high(q_end=qmax_plot,
	482	npts=500)
	483	self._manager.plot_theory(data=high_out_data,
	484	name="High-Q extrapolation")
	485	except:
	486	#raise
	487	self.inv_container.qstar_high = "ERROR"
	488	self.inv_container.qstar_high_err = "ERROR"
	489	self._manager.plot_theory(name="High-Q extrapolation")
	490	msg = "Error occurred computing high-Q "
	491	msg += "invariant: %s" % sys.exc_value
	492	wx.PostEvent(self.parent, StatusEvent(status=msg,
	493	type="stop"))
	494	raise
	495	else:
	496	try:
	497	self._manager.plot_theory(name="High-Q extrapolation")
	498	except:
	499	logger.error(sys.exc_value)
	500
	501	def get_qstar(self, inv):
	502	"""
	503	get qstar
	504	"""
	505	qstar, qstar_err = inv.get_qstar_with_error()
	506	self.inv_container.qstar = qstar
	507	self.inv_container.qstar_err = qstar_err
	508
	509	def set_extrapolation_low(self, inv, low_q=False):
	510	"""
	511	return float value necessary to compute invariant a low q
	512	"""
	513	#get funtion
	514	if self.guinier.GetValue():
	515	function_low = "guinier"
	516	# get the function
	517	power_low = None #2.0/3.0
	518	if self.power_law_low.GetValue():
	519	function_low = "power_law"
	520	if self.fit_enable_low.GetValue():
	521	#set value of power_low to none to allow fitting
	522	power_low = None
	523	else:
	524	power_low = self.power_low_tcl.GetValue().lstrip().rstrip()
	525	if check_float(self.power_low_tcl):
	526	power_low = float(power_low)
	527	else:
	528	if low_q:
	529	#Raise error only when qstar at low q is requested
	530	msg = "Expect float for power at low q, "
	531	msg += " got %s" % (power_low)
	532	wx.PostEvent(self.parent,
	533	StatusEvent(status=msg,
	534	info="error",
	535	type="stop"))
	536
	537	#Get the number of points to extrapolated
	538	npts_low = self.npts_low_tcl.GetValue().lstrip().rstrip()
	539	if check_float(self.npts_low_tcl):
	540	npts_low = float(npts_low)
	541	else:
	542	if low_q:
	543	msg = "Expect float for number of points at low q,"
	544	msg += " got %s" % (npts_low)
	545	wx.PostEvent(self.parent,
	546	StatusEvent(status=msg,
	547	info="error",
	548	type="stop"))
	549	#Set the invariant calculator
	550	inv.set_extrapolation(range="low", npts=npts_low,
	551	function=function_low, power=power_low)
	552	return inv, npts_low
	553
	554
	555	def set_extrapolation_high(self, inv, high_q=False):
	556	"""
	557	return float value necessary to compute invariant a high q
	558	"""
	559	power_high = None
	560	#if self.power_law_high.GetValue():
	561	function_high = "power_law"
	562	if self.fit_enable_high.GetValue():
	563	#set value of power_high to none to allow fitting
	564	power_high = None
	565	else:
	566	power_high = self.power_high_tcl.GetValue().lstrip().rstrip()
	567	if check_float(self.power_high_tcl):
	568	power_high = float(power_high)
	569	else:
	570	if high_q:
	571	#Raise error only when qstar at high q is requested
	572	msg = "Expect float for power at high q,"
	573	msg += " got %s" % (power_high)
	574	wx.PostEvent(self.parent,
	575	StatusEvent(status=msg,
	576	info="error",
	577	type="stop"))
	578
	579	npts_high = self.npts_high_tcl.GetValue().lstrip().rstrip()
	580	if check_float(self.npts_high_tcl):
	581	npts_high = float(npts_high)
	582	else:
	583	if high_q:
	584	msg = "Expect float for number of points at high q,"
	585	msg += " got %s" % (npts_high)
	586	wx.PostEvent(self.parent, StatusEvent(status=msg,
	587	info="error",
	588	type="stop"))
	589	inv.set_extrapolation(range="high", npts=npts_high,
	590	function=function_high, power=power_high)
	591	return inv, npts_high
	592
	593	def display_details(self, event):
	594	"""
	595	open another panel for more details on invariant calculation
	596	"""
	597	panel = InvariantDetailsPanel(parent=self,
	598	qstar_container=self.inv_container)
	599	panel.ShowModal()
	600	panel.Destroy()
	601	self.button_calculate.SetFocus()
	602
	603	def compute_invariant(self, event=None):
	604	"""
	605	compute invariant
	606	"""
[235f514]	607	if self._data is None:
[959eb01]	608	msg = "\n\nData must be loaded first in order"
	609	msg += " to perform a compution..."
	610	wx.PostEvent(self.parent, StatusEvent(status=msg))
	611	# set a state for this computation for saving
[7432acb]	612	elif event is not None:
[959eb01]	613	self._set_compute_state(state='compute')
	614	self._set_bookmark_flag(True)
	615	msg = "\n\nStarting a new invariant computation..."
	616	wx.PostEvent(self.parent, StatusEvent(status=msg))
	617
	618
	619	if self._data is None:
	620	return
	621	self.button_details.Enable()
	622	#clear outputs textctrl
	623	self._reset_output()
	624	try:
	625	background = self.get_background()
	626	scale = self.get_scale()
	627	except:
	628	msg = "Invariant Error: %s" % (sys.exc_value)
	629	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
	630	return
	631
	632	low_q = self.enable_low_cbox.GetValue()
	633	high_q = self.enable_high_cbox.GetValue()
	634	temp_data = copy.deepcopy(self._data)
	635
	636	#set invariant calculator
	637	inv = invariant.InvariantCalculator(data=temp_data,
	638	background=background,
	639	scale=scale)
	640	try:
	641	inv, npts_low = self.set_extrapolation_low(inv=inv, low_q=low_q)
	642	inv, npts_high = self.set_extrapolation_high(inv=inv, high_q=high_q)
	643	except:
	644	msg = "Error occurred computing invariant: %s" % sys.exc_value
	645	wx.PostEvent(self.parent, StatusEvent(status=msg,
	646	info="warning", type="stop"))
	647	return
	648	#check the type of extrapolation
	649	extrapolation = self.get_extrapolation_type(low_q=low_q, high_q=high_q)
	650
	651	#Compute invariant
	652	try:
	653	self.get_qstar(inv=inv)
	654	except:
	655	msg = "Error occurred computing invariant: %s" % sys.exc_value
	656	wx.PostEvent(self.parent, StatusEvent(status=msg,
	657	info="warning",
	658	type="stop"))
	659	return
	660	#self.Show(False)
	661	r_msg = ''
	662	try:
	663	r_msg = 'Low Q: '
	664	#Compute qstar extrapolated to low q range
	665	self.get_low_qstar(inv=inv, npts_low=npts_low, low_q=low_q)
	666	r_msg = 'High Q: '
	667	#Compute qstar extrapolated to high q range
	668	self.get_high_qstar(inv=inv, high_q=high_q)
	669	r_msg = ''
	670	#Compute qstar extrapolated to total q range
	671	#and set value to txtcrtl
	672	self.get_total_qstar(inv=inv, extrapolation=extrapolation)
	673	# Parse additional parameters
	674	porod_const = self.get_porod_const()
	675	contrast = self.get_contrast()
	676	except:
	677	msg = r_msg + "Error occurred computing invariant: %s" % \
	678	sys.exc_value
	679	wx.PostEvent(self.parent, StatusEvent(status=msg,
	680	info="error",
	681	type="stop"))
	682	try:
	683	#Compute volume and set value to txtcrtl
	684	self.get_volume(inv=inv, contrast=contrast,
	685	extrapolation=extrapolation)
	686	#compute surface and set value to txtcrtl
	687	except:
	688	msg = "Error occurred computing invariant: %s" % sys.exc_value
	689	wx.PostEvent(self.parent, StatusEvent(status=msg,
	690	info="warning",
	691	type="stop"))
	692	try:
	693	self.get_surface(inv=inv, contrast=contrast,
	694	porod_const=porod_const,
	695	extrapolation=extrapolation)
	696
	697	except:
	698	msg = "Error occurred computing invariant: %s" % sys.exc_value
	699	wx.PostEvent(self.parent, StatusEvent(status=msg,
	700	info="warning",
	701	type="stop"))
	702
	703	#compute percentage of each invariant
	704	self.inv_container.compute_percentage()
	705
	706	#display a message
	707	self.set_message()
	708
	709	# reset power_out to default to get ready for another '_on_text'
[2469df7]	710	if self.is_power_out:
[959eb01]	711	self.state.container = copy.deepcopy(self.inv_container)
	712	self.state.timestamp = self._get_time_stamp()
	713	msg = self.state.__str__()
	714	self.state.set_report_string()
	715	self.is_power_out = False
	716	wx.PostEvent(self.parent, StatusEvent(status=msg))
	717
	718	#enable the button_ok for more details
	719	self._set_preview_flag(True)
	720
[7432acb]	721	if event is not None:
[959eb01]	722	self._set_preview_flag(True)
	723	self._set_save_flag(True)
	724	wx.PostEvent(self.parent,
	725	StatusEvent(status='\nFinished invariant computation...'))
	726	#self.Show(True)
	727	self.Refresh()
	728
	729	def on_undo(self, event=None):
	730	"""
	731	Go back to the previous state
	732
	733	: param event: undo button event
	734	"""
	735	if self.state.state_num < 0:
	736	return
	737	self.is_power_out = True
	738	# get the previous state_num
	739	pre_state_num = int(self.state.saved_state['state_num']) - 1
	740
	741	self.get_state_by_num(state_num=str(pre_state_num))
	742
	743	if float(pre_state_num) <= 0:
	744	self._set_undo_flag(False)
	745	else:
	746	self._set_undo_flag(True)
	747	self._set_redo_flag(True)
	748	self.is_power_out = False
	749	self._info_state_num()
	750
	751
	752	def on_redo(self, event=None):
	753	"""
	754	Go forward to the previous state
	755
	756	: param event: redo button event
	757	"""
	758	self.is_power_out = True
	759	# get the next state_num
	760	next_state_num = int(self.state.saved_state['state_num']) + 1
	761
	762	self.get_state_by_num(state_num=str(next_state_num))
	763
	764	if float(next_state_num) + 2 > len(self.state.state_list):
	765	self._set_redo_flag(False)
	766	else:
	767	self._set_redo_flag(True)
	768
	769	self._set_undo_flag(True)
	770	self.is_power_out = False
	771	self._info_state_num()
	772
	773	def on_preview(self, event=None):
	774	"""
	775	Invoke report dialog panel
	776
	777	: param event: report button event
	778	"""
	779	from sas.sasgui.perspectives.invariant.report_dialog import ReportDialog
	780
	781	self.state.set_report_string()
	782	report_html_str = self.state.report_str
	783	report_text_str = self.state.__str__()
	784	report_img = self.state.image
	785	report_list = [report_html_str, report_text_str, report_img]
[44e8f48]	786	ReportImageHandler.check_for_empty_instance()
[fa412df]	787	imgRAM = ReportImageHandler.instance.img_holder
[ec4b19c]	788	refs = [self.state.wximgbmp]
	789	dialog = ReportDialog(report_list, imgRAM, refs, None, wx.ID_ANY, "")
[959eb01]	790	dialog.Show()
	791
	792	def get_state_by_num(self, state_num=None):
	793	"""
	794	Get the state given by number
	795
	796	: param state_num: the given state number
	797	"""
[235f514]	798	if state_num is None:
[959eb01]	799	return
	800
	801	backup_state_list = copy.deepcopy(self.state.state_list)
	802
	803	# get the previous state
	804	try:
	805	current_state = copy.deepcopy(self.state.state_list[str(state_num)])
	806	# get the previously computed state number
	807	#(computation before the state changes happened)
	808	current_compute_num = str(current_state['compute_num'])
	809	except:
	810	raise
	811
	812	# get the state at pre_compute_num
	813	comp_state = copy.deepcopy(self.state.state_list[current_compute_num])
	814
	815	# set the parameters
	816	for key in comp_state:
	817	value = comp_state[key]
	818	self._set_property_value(key, value)
	819
	820	self.compute_invariant(event=None)
	821
	822	# set the input params at the state at pre_state_num
	823	for key in current_state:
	824	# set the inputs and boxes
	825	value = current_state[key]
	826	self._set_property_value(key, value)
	827
	828	self._enable_high_q_section(event=None)
	829	self._enable_low_q_section(event=None)
	830	self.state.state_list = backup_state_list
	831	self.state.saved_state = current_state
	832	self.state.state_num = state_num
	833
	834	def _set_property_value(self, key, value):
	835	"""
	836	Set a property value
	837	:param key: property name
	838	:param value: value of the property
	839	"""
	840	try:
	841	if key in ['compute_num', 'file', 'is_time_machine', 'state_num']:
	842	return
	843	else:
	844	attr = getattr(self, key)
	845	if attr.__class__.__name__ == "StaticText":
	846	return
	847	if value in ["True", "False", True, False]:
	848	value = bool(value)
	849	else:
	850	value = str(value)
	851	attr.SetValue(value)
	852	except:
	853	logger.error("Invariant state: %s", sys.exc_value)
	854
	855	def get_bookmark_by_num(self, num=None):
	856	"""
	857	Get the bookmark state given by number
	858
	859	: param num: the given bookmark number
	860
	861	"""
	862	current_state = {}
	863	comp_state = {}
	864	backup_state_list = copy.deepcopy(self.state.state_list)
	865
	866	# get the previous state
	867	try:
	868	_, _, current_state, comp_state = self.state.bookmark_list[int(num)]
	869	except:
	870	logger.error(sys.exc_value)
	871	raise ValueError, "No such bookmark exists"
	872
	873	# set the parameters
	874	for key in comp_state:
	875	value = comp_state[key]
	876	self._set_property_value(key, value)
	877
	878	self.compute_invariant(event=None)
	879	# set the input params at the state of pre_state_num
	880	for key in current_state:
	881	value = current_state[key]
	882	self._set_property_value(key, value)
	883	self.state.saved_state = copy.deepcopy(current_state)
	884
	885	self._enable_high_q_section(event=None)
	886	self._enable_low_q_section(event=None)
	887	self.state.state_list = backup_state_list
	888	#self.state.saved_state = current_state
	889	#self.state.state_num = state_num
	890
	891	def reset_panel(self):
	892	"""
	893	set the panel at its initial state.
	894	"""
	895	self.background_tcl.SetValue(str(BACKGROUND))
	896	self.scale_tcl.SetValue(str(SCALE))
	897	self.contrast_tcl.SetValue(str(CONTRAST))
	898	self.porod_constant_tcl.SetValue('')
	899	self.npts_low_tcl.SetValue(str(NPTS))
	900	self.enable_low_cbox.SetValue(False)
	901	self.fix_enable_low.SetValue(True)
	902	self.power_low_tcl.SetValue(str(POWER))
	903	self.guinier.SetValue(True)
	904	self.power_low_tcl.Disable()
	905	self.enable_high_cbox.SetValue(False)
	906	self.fix_enable_high.SetValue(True)
	907	self.power_high_tcl.SetValue(str(POWER))
	908	self.npts_high_tcl.SetValue(str(NPTS))
	909	self.button_details.Disable()
	910	#Change the state of txtcrtl to enable/disable
	911	self._enable_low_q_section()
	912	#Change the state of txtcrtl to enable/disable
	913	self._enable_high_q_section()
	914	self._reset_output()
	915	self._set_undo_flag(False)
	916	self._set_redo_flag(False)
	917	self._set_bookmark_flag(False)
	918	self._set_preview_flag(False)
	919	self._set_save_flag(False)
	920	self.button_calculate.SetFocus()
	921	#self.SetupScrolling()
	922	self._set_analysis(False)
	923
	924	def _set_state(self, event):
	925	"""
	926	Set the state list
	927
	928	:param event: rb/cb event
	929	"""
[235f514]	930	if event is None:
[959eb01]	931	return
	932	obj = event.GetEventObject()
	933	name = str(obj.GetName())
	934	value = str(obj.GetValue())
	935	rb_list = [['power_law_low', 'guinier'],
	936	['fit_enable_low', 'fix_enable_low'],
	937	['fit_enable_high', 'fix_enable_high']]
	938
	939	try:
[235f514]	940	if value is None or value.lstrip().rstrip() == '':
[959eb01]	941	value = 'None'
	942	setattr(self.state, name, str(value))
	943	self.state.saved_state[name] = str(value)
	944
	945	# set the count part of radio button clicked
	946	#False for the saved_state
	947	for title, content in rb_list:
	948	if name == title:
	949	name = content
	950	value = False
	951	elif name == content:
	952	name = title
	953	value = False
	954	self.state.saved_state[name] = str(value)
	955
	956	# Instead of changing the future, create a new future.
	957	max_state_num = len(self.state.state_list) - 1
	958	self.state.saved_state['state_num'] = max_state_num
	959
	960	self.state.saved_state['state_num'] += 1
	961	self.state.state_num = self.state.saved_state['state_num']
	962	self.state.state_list[str(self.state.state_num)] = \
	963	self.state.clone_state()
	964	except:
	965	logger.error(sys.exc_value)
	966
	967	self._set_undo_flag(True)
	968	self._set_redo_flag(False)
	969	#event.Skip()
	970
	971	def _set_compute_state(self, state=None):
	972	"""
	973	Notify the compute_invariant state to self.state
	974
	975	: param state: set 'compute' when the computation is
	976	activated by the 'compute' button, else None
	977
	978	"""
	979	# reset the default
	980	if state != 'compute':
	981	self.new_state = False
	982	self.is_power_out = False
	983	else:
	984	self.is_power_out = True
	985	# Instead of changing the future, create a new future.
	986	max_state_num = len(self.state.state_list) - 1
	987	self.state.saved_state['state_num'] = max_state_num
	988	# A new computation is also A state
	989	#copy.deepcopy(self.state.saved_state)
	990	temp_saved_states = self.state.clone_state()
	991	temp_saved_states['state_num'] += 1
	992	self.state.state_num = temp_saved_states['state_num']
	993
	994
	995	# set the state number of the computation
	996	if state == 'compute':
	997	temp_saved_states['compute_num'] = self.state.state_num
	998	self.state.saved_state = copy.deepcopy(temp_saved_states)
	999	#copy.deepcopy(self.state.saved_state)
	1000	self.state.state_list[str(self.state.state_num)] = \
	1001	self.state.clone_state()
	1002
	1003	# A computation is a new state, so delete the states with any higher
	1004	# state numbers
	1005	for i in range(self.state.state_num + 1, len(self.state.state_list)):
	1006	try:
	1007	del self.state.state_list[str(i)]
	1008	except:
	1009	logger.error(sys.exc_value)
	1010	# Enable the undo button if it was not
	1011	self._set_undo_flag(True)
	1012	self._set_redo_flag(False)
	1013
	1014	def _reset_state_list(self, data=None):
	1015	"""
	1016	Reset the state_list just before data was loading:
	1017	Used in 'set_current_data()'
	1018	"""
[235f514]	1019	#if data is None: return
[959eb01]	1020	#temp_state = self.state.clone_state()
	1021	#copy.deepcopy(self.state.saved_state)
	1022	# Clear the list
	1023	self.state.state_list.clear()
	1024	self.state.bookmark_list.clear()
	1025	# Set defaults
	1026	self.state.saved_state['state_num'] = 0
	1027	self.state.saved_state['compute_num'] = 0
[7432acb]	1028	if self._data is not None:
[959eb01]	1029	self.state.saved_state['file'] = str(self._data.name)
	1030	else:
	1031	self.state.saved_state['file'] = 'None'
	1032	self.state.file = self.state.saved_state['file']
	1033
	1034	self.state.state_num = self.state.saved_state['state_num']
	1035	self.state.timestamp = "('00:00:00', '00/00/0000')"
	1036
	1037	# Put only the current state in the list
	1038	#copy.deepcopy(self.state.saved_state)
	1039	self.state.state_list[str(self.state.state_num)] = \
	1040	self.state.clone_state()
	1041	self._set_undo_flag(False)
	1042	self._set_redo_flag(False)
	1043	self._set_bookmark_flag(False)
	1044	self._set_preview_flag(False)
	1045	self._set_save_flag(False)
	1046
	1047
	1048	def _on_text(self, event):
	1049	"""
	1050	Catch text change event to add the state to the state_list
	1051
	1052	:param event: txtctr event ; assumes not None
	1053
	1054	"""
[235f514]	1055	if self._data is None:
[959eb01]	1056	return
	1057	# check if this event is from do/undo button
	1058	if self.state.saved_state['is_time_machine'] or self.new_state:
	1059	#event.Skip()
	1060	return
	1061
	1062	# get the object
	1063	obj = event.GetEventObject()
	1064	name = str(obj.GetName())
	1065	value = str(obj.GetValue())
	1066	state_num = self.state.saved_state['state_num']
	1067
	1068	# text event is a new state, so delete the states with higher state_num
	1069	# i.e., change the future
	1070	for i in range(int(state_num) + 1, len(self.state.state_list)):
	1071	try:
	1072	del self.state.state_list[str(i)]
	1073	except:
	1074	logger.error(sys.exc_value)
	1075
	1076	# try to add new state of the text changes in the state_list
	1077	try:
[235f514]	1078	if value.strip() is None:
[959eb01]	1079	value = ''
	1080	setattr(self.state, name, str(value))
	1081	self.state.saved_state[name] = str(value)
	1082	self.state.input_list[name] = str(value)
	1083	if not self.is_power_out:
	1084	if name != 'power_low_tcl' and name != 'power_high_tcl':
	1085	self.state.saved_state['state_num'] += 1
	1086	self.state.state_num = self.state.saved_state['state_num']
	1087	self.state.state_list[str(self.state.state_num)] = self.state.clone_state()
	1088	except:
	1089	logger.error(sys.exc_value)
	1090
	1091	self._set_undo_flag(True)
	1092	self._set_redo_flag(False)
	1093	self._set_bookmark_flag(True)
	1094	self._set_preview_flag(False)
	1095
	1096	def _on_out_text(self, event):
	1097	"""
	1098	Catch ouput text change to add the state
	1099
	1100	:param event: txtctr event ; assumes not None
	1101
	1102	"""
	1103	# get the object
	1104	obj = event.GetEventObject()
	1105	name = str(obj.GetName())
	1106	value = str(obj.GetValue())
	1107	try:
	1108	self.state.saved_state[name] = str(value)
	1109	self.state.state_list[str(self.state.state_num)] = self.state.clone_state()
	1110	except:
	1111	logger.error(sys.exc_value)
	1112
	1113	def _get_input_list(self):
	1114	"""
	1115	get input_list; called by set_state
	1116	"""
	1117	# get state num of the last compute state
	1118	compute_num = self.state.saved_state['compute_num']
	1119	# find values and put into the input list
	1120	for key1, value1 in self.state.state_list[str(compute_num)].iteritems():
	1121	for key, _ in self.state.input_list.iteritems():
	1122	if key == key1:
	1123	self.state.input_list[key] = value1
	1124	break
	1125
	1126	def _set_bookmark_menu(self):
	1127	"""
	1128	Setup 'bookmark' context menu
	1129	"""
	1130	## Create context menu for page
	1131	self.popUpMenu = wx.Menu()
	1132	id = wx.NewId()
	1133	self._bmark = wx.MenuItem(self.popUpMenu, id, "BookMark",
	1134	" Bookmark the panel to recall it later")
	1135	self.popUpMenu.AppendItem(self._bmark)
	1136	self._bmark.Enable(True)
	1137	wx.EVT_MENU(self, id, self.on_bookmark)
	1138	self.popUpMenu.AppendSeparator()
	1139	self.Bind(wx.EVT_CONTEXT_MENU, self._on_context_menu)
	1140
	1141	def on_bookmark(self, event):
	1142	"""
	1143	Save the panel state in memory and add the list on
	1144	the popup menu on bookmark context menu event
	1145	"""
[235f514]	1146	if self._data is None:
[959eb01]	1147	return
[235f514]	1148	if event is None:
[959eb01]	1149	return
	1150	self.bookmark_num += 1
	1151	# date and time of the event
	1152	my_time, date = self._get_time_stamp()
	1153	_ = self.state.state_num
	1154	compute_num = self.state.saved_state['compute_num']
	1155	# name and message of the bookmark list
	1156	msg = "State saved at %s on %s" % (my_time, date)
	1157	## post help message for the selected model
	1158	msg += " Right click on the panel to retrieve this state"
	1159	#wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
	1160	name = "%d] bookmarked at %s on %s" % (self.bookmark_num, my_time, date)
	1161
	1162	# append it to menu
	1163	id = wx.NewId()
	1164	self.popUpMenu.Append(id, name, str(msg))
	1165	wx.EVT_MENU(self, id, self._back_to_bookmark)
	1166	state = self.state.clone_state()
	1167	comp_state = copy.deepcopy(self.state.state_list[str(compute_num)])
	1168	self.state.bookmark_list[self.bookmark_num] = [my_time, date,
	1169	state, comp_state]
	1170	self.state.toXML(self, doc=None, entry_node=None)
	1171
	1172	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info"))
	1173	wx.PostEvent(self.parent,
	1174	AppendBookmarkEvent(title=name,
	1175	hint=str(msg),
	1176	handler=self._back_to_bookmark))
	1177
	1178	def _back_to_bookmark(self, event):
	1179	"""
	1180	Bring the panel back to the state of bookmarked requested by
	1181	context menu event
	1182	and set it as a new state
	1183	"""
	1184	self._manager.on_perspective(event)
	1185	menu = event.GetEventObject()
	1186	## post help message for the selected model
	1187	msg = menu.GetHelpString(event.GetId())
	1188	msg += " reloaded"
	1189	wx.PostEvent(self.parent, StatusEvent(status=msg))
	1190
	1191	name = menu.GetLabel(event.GetId())
	1192
	1193	num, _ = name.split(']')
	1194	current_state_num = self.state.state_num
	1195	self.get_bookmark_by_num(num)
	1196	state_num = int(current_state_num) + 1
	1197
	1198	self.state.saved_state['state_num'] = state_num
	1199	#copy.deepcopy(self.state.saved_state)
	1200	self.state.state_list[str(state_num)] = self.state.clone_state()
	1201	self.state.state_num = state_num
	1202
	1203	self._set_undo_flag(True)
	1204	self._info_bookmark_num(event)
	1205
	1206	def _info_bookmark_num(self, event=None):
	1207	"""
	1208	print the bookmark number in info
	1209
	1210	: event: popUpMenu event
	1211	"""
[235f514]	1212	if event is None:
[959eb01]	1213	return
	1214	# get the object
	1215	menu = event.GetEventObject()
	1216	item = menu.FindItemById(event.GetId())
	1217	text = item.GetText()
	1218	num = text.split(']')[0]
	1219	msg = "bookmark num = %s " % num
	1220
	1221	wx.PostEvent(self.parent, StatusEvent(status=msg))
	1222
	1223	def _info_state_num(self):
	1224	"""
	1225	print the current state number in info
	1226	"""
	1227	msg = "state num = "
	1228	msg += self.state.state_num
	1229
	1230	wx.PostEvent(self.parent, StatusEvent(status=msg))
	1231
	1232	def _get_time_stamp(self):
	1233	"""
	1234	return time and date stings
	1235	"""
	1236	# date and time
	1237	year, month, day, hour, minute, second, _, _, _ = \
	1238	time.localtime()
	1239	my_time = str(hour) + ":" + str(minute) + ":" + str(second)
	1240	date = str(month) + "/" + str(day) + "/" + str(year)
	1241	return my_time, date
	1242
	1243
	1244	def on_save(self, evt=None):
	1245	"""
	1246	Save invariant state into a file
	1247	"""
	1248	# Ask the user the location of the file to write to.
	1249	path = None
[7432acb]	1250	if self.parent is not None:
[959eb01]	1251	self._default_save_location = self.parent.get_save_location()
[235f514]	1252	if self._default_save_location is None:
[959eb01]	1253	self._default_save_location = os.getcwd()
	1254	dlg = wx.FileDialog(self, "Choose a file",
	1255	self._default_save_location, \
	1256	self.window_caption, "*.inv", wx.SAVE)
	1257	if dlg.ShowModal() == wx.ID_OK:
	1258	path = dlg.GetPath()
	1259	self._default_save_location = os.path.dirname(path)
[7432acb]	1260	if self.parent is not None:
[959eb01]	1261	self.parent._default_save_location = \
	1262	self._default_save_location
	1263	else:
	1264	return None
	1265
	1266	dlg.Destroy()
	1267	# MAC always needs the extension for saving
	1268	extens = ".inv"
	1269	# Make sure the ext included in the file name
	1270	fName = os.path.splitext(path)[0] + extens
	1271	self._manager.save_file(filepath=fName, state=self.state)
	1272
	1273	def _show_message(self, mssg='', msg='Warning'):
	1274	"""
	1275	Show warning message when resetting data
	1276	"""
	1277	# no message for now
	1278	return True
	1279
	1280	def _reset_output(self):
	1281	"""
	1282	clear outputs textcrtl
	1283	"""
	1284	self.invariant_total_tcl.Clear()
	1285	self.invariant_total_err_tcl.Clear()
	1286	self.volume_tcl.Clear()
	1287	self.volume_err_tcl.Clear()
	1288	self.surface_tcl.Clear()
	1289	self.surface_err_tcl.Clear()
	1290	#prepare a new container to put result of invariant
	1291	self.inv_container = InvariantContainer()
	1292
	1293
	1294	def _on_context_menu(self, event):
	1295	"""
	1296	On context menu
	1297	"""
	1298	pos = event.GetPosition()
	1299	pos = self.ScreenToClient(pos)
	1300
	1301	self.PopupMenu(self.popUpMenu, pos)
	1302
	1303	def _define_structure(self):
	1304	"""
	1305	Define main sizers needed for this panel
	1306	"""
	1307	## Box sizers must be defined first before
	1308	#defining buttons/textctrls (MAC).
	1309	self.main_sizer = wx.BoxSizer(wx.VERTICAL)
	1310	#Sizer related to outputs
	1311	outputs_box = wx.StaticBox(self, -1, "Outputs")
	1312	self.outputs_sizer = wx.StaticBoxSizer(outputs_box, wx.VERTICAL)
	1313	self.outputs_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
	1314	#Sizer related to data
	1315	data_name_box = wx.StaticBox(self, -1, "I(q) Data Source")
	1316	self.data_name_boxsizer = wx.StaticBoxSizer(data_name_box, wx.VERTICAL)
	1317	self.data_name_boxsizer.SetMinSize((_STATICBOX_WIDTH, -1))
	1318	self.hint_msg_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1319	self.data_name_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1320
	1321	self.data_range_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1322	#Sizer related to inputs
	1323	self.sizer_input = wx.FlexGridSizer(2, 6, 0, 0)
	1324	#Sizer related to inputs
	1325	inputs_box = wx.StaticBox(self, -1, "Customized Inputs")
	1326	self.inputs_sizer = wx.StaticBoxSizer(inputs_box, wx.VERTICAL)
	1327	self.inputs_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
	1328	#Sizer related to extrapolation
	1329	extrapolation_box = wx.StaticBox(self, -1, "Extrapolation")
	1330	self.extrapolation_sizer = wx.StaticBoxSizer(extrapolation_box,
	1331	wx.VERTICAL)
	1332	self.extrapolation_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
	1333	self.extrapolation_range_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1334	self.extrapolation_low_high_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1335	#Sizer related to extrapolation at low q range
	1336	low_q_box = wx.StaticBox(self, -1, "Low Q")
	1337	self.low_extrapolation_sizer = wx.StaticBoxSizer(low_q_box, wx.VERTICAL)
	1338
	1339	self.low_q_sizer = wx.GridBagSizer(5, 5)
	1340	#Sizer related to extrapolation at low q range
	1341	high_q_box = wx.StaticBox(self, -1, "High Q")
	1342	self.high_extrapolation_sizer = wx.StaticBoxSizer(high_q_box,
	1343	wx.VERTICAL)
	1344	self.high_q_sizer = wx.GridBagSizer(5, 5)
	1345	#sizer to define outputs
	1346	self.volume_surface_sizer = wx.GridBagSizer(5, 5)
	1347	#Sizer related to invariant output
	1348	self.invariant_sizer = wx.GridBagSizer(5, 5)
	1349	#Sizer related to button
	1350	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1351	self.button_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
	1352	#Sizer related to save button
	1353	self.save_button_sizer = wx.BoxSizer(wx.HORIZONTAL)
	1354
	1355	def _layout_data_name(self):
	1356	"""
	1357	Draw widgets related to data's name
	1358	"""
	1359	#Sizer hint
	1360	hint_msg = ""
	1361
	1362	self.hint_msg_txt = wx.StaticText(self, -1, hint_msg)
	1363	self.hint_msg_txt.SetForegroundColour("red")
	1364	msg = "Highlight = mouse the mouse's cursor on the data until"
	1365	msg += " the plot's color changes to yellow"
	1366	self.hint_msg_txt.SetToolTipString(msg)
	1367	self.hint_msg_sizer.Add(self.hint_msg_txt)
	1368	#Data name [string]
	1369	data_name_txt = wx.StaticText(self, -1, 'Name:')
	1370
	1371	self.data_name_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH * 4, 20),
	1372	style=0)
	1373	self.data_name_tcl.SetToolTipString("Data's name.")
	1374	self.data_name_sizer.AddMany([(data_name_txt, 0, wx.LEFT \| wx.RIGHT, 10),
	1375	(self.data_name_tcl, 0, wx.EXPAND)])
	1376	#Data range [string]
	1377	data_range_txt = wx.StaticText(self, -1, 'Total Q Range (1/A): ')
	1378	data_min_txt = wx.StaticText(self, -1, 'Min : ')
	1379	self.data_min_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
	1380	style=0, name='data_min_tcl')
	1381	self.data_min_tcl.SetToolTipString("The minimum value of q range.")
	1382	data_max_txt = wx.StaticText(self, -1, 'Max : ')
	1383	self.data_max_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
	1384	style=0, name='data_max_tcl')
	1385	self.data_max_tcl.SetToolTipString("The maximum value of q range.")
	1386	self.data_range_sizer.AddMany([(data_range_txt, 0, wx.RIGHT, 5),
	1387	(data_min_txt, 0, wx.RIGHT, 5),
	1388	(self.data_min_tcl, 0, wx.RIGHT, 20),
	1389	(data_max_txt, 0, wx.RIGHT, 5),
	1390	(self.data_max_tcl, 0, wx.RIGHT, 10)])
	1391	self.data_name_boxsizer.AddMany([(self.hint_msg_sizer, 0, wx.ALL, 5),
	1392	(self.data_name_sizer, 0, wx.ALL, 10),
	1393	(self.data_range_sizer, 0, wx.ALL, 10)])
	1394
	1395	def _enable_fit_power_law_low(self, event=None):
	1396	"""
	1397	Enable and disable the power value editing
	1398	"""
[7432acb]	1399	if event is not None:
[959eb01]	1400	self._set_bookmark_flag(True)
	1401	self._set_preview_flag(False)
	1402
	1403	if self.fix_enable_low.IsEnabled():
	1404
	1405	if self.fix_enable_low.GetValue():
	1406	self.fit_enable_low.SetValue(False)
	1407	self.power_low_tcl.Enable()
	1408	else:
	1409	self.fit_enable_low.SetValue(True)
	1410	self.power_low_tcl.Disable()
	1411	self._set_state(event=event)
	1412
	1413	def _enable_low_q_section(self, event=None):
	1414	"""
	1415	Disable or enable some button if the user enable low q extrapolation
	1416	"""
[7432acb]	1417	if event is not None:
[959eb01]	1418	self._set_bookmark_flag(True)
	1419	self._set_preview_flag(False)
	1420
	1421	if self.enable_low_cbox.GetValue():
	1422	self.npts_low_tcl.Enable()
	1423	self.fix_enable_low.Enable()
	1424	self.fit_enable_low.Enable()
	1425	self.guinier.Enable()
	1426	self.power_law_low.Enable()
	1427
	1428	else:
	1429	self.npts_low_tcl.Disable()
	1430	self.fix_enable_low.Disable()
	1431	self.fit_enable_low.Disable()
	1432	self.guinier.Disable()
	1433	self.power_law_low.Disable()
	1434
	1435	self._enable_power_law_low()
	1436	self._enable_fit_power_law_low()
	1437	self._set_state(event=event)
	1438	self.button_calculate.SetFocus()
	1439
	1440	def _enable_power_law_low(self, event=None):
	1441	"""
	1442	Enable editing power law section at low q range
	1443	"""
[7432acb]	1444	if event is not None:
[959eb01]	1445	self._set_bookmark_flag(True)
	1446	self._set_preview_flag(False)
	1447	if self.guinier.GetValue():
	1448	self.power_law_low.SetValue(False)
	1449	self.fix_enable_low.Disable()
	1450	self.fit_enable_low.Disable()
	1451	self.power_low_tcl.Disable()
	1452	else:
	1453	self.power_law_low.SetValue(True)
	1454	self.fix_enable_low.Enable()
	1455	self.fit_enable_low.Enable()
	1456	self.power_low_tcl.Enable()
	1457	self._enable_fit_power_law_low()
	1458	self._set_state(event=event)
	1459
	1460	def _layout_extrapolation_low(self):
	1461	"""
	1462	Draw widgets related to extrapolation at low q range
	1463	"""
	1464	self.enable_low_cbox = wx.CheckBox(self, -1,
	1465	"Enable Extrapolate Low Q",
	1466	name='enable_low_cbox')
	1467	wx.EVT_CHECKBOX(self, self.enable_low_cbox.GetId(),
	1468	self._enable_low_q_section)
	1469	self.fix_enable_low = wx.RadioButton(self, -1, 'Fix',
	1470	(10, 10), style=wx.RB_GROUP,
	1471	name='fix_enable_low')
	1472	self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_low,
	1473	id=self.fix_enable_low.GetId())
	1474	self.fit_enable_low = wx.RadioButton(self, -1, 'Fit', (10, 10),
	1475	name='fit_enable_low')
	1476	self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_low,
	1477	id=self.fit_enable_low.GetId())
	1478	self.guinier = wx.RadioButton(self, -1, 'Guinier',
	1479	(10, 10), style=wx.RB_GROUP,
	1480	name='guinier')
	1481	self.Bind(wx.EVT_RADIOBUTTON, self._enable_power_law_low,
	1482	id=self.guinier.GetId())
	1483	self.power_law_low = wx.RadioButton(self, -1, 'Power Law',
	1484	(10, 10), name='power_law_low')
	1485	self.Bind(wx.EVT_RADIOBUTTON, self._enable_power_law_low,
	1486	id=self.power_law_low.GetId())
	1487
	1488	npts_low_txt = wx.StaticText(self, -1, 'Npts')
	1489	self.npts_low_tcl = InvTextCtrl(self, -1,
	1490	size=(_BOX_WIDTH * 2 / 3, -1),
	1491	name='npts_low_tcl')
	1492	wx.EVT_TEXT(self, self.npts_low_tcl.GetId(), self._on_text)
	1493	msg_hint = "Number of Q points to consider"
	1494	msg_hint += "while extrapolating the low-Q region"
	1495	self.npts_low_tcl.SetToolTipString(msg_hint)
	1496	power_txt = wx.StaticText(self, -1, 'Power')
	1497	self.power_low_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH * 2 / 3, -1),
	1498	name='power_low_tcl')
	1499	wx.EVT_TEXT(self, self.power_low_tcl.GetId(), self._on_text)
	1500
	1501	power_hint_txt = "Exponent to apply to the Power_law function."
	1502	self.power_low_tcl.SetToolTipString(power_hint_txt)
	1503	iy = 0
	1504	ix = 0
	1505	self.low_q_sizer.Add(self.enable_low_cbox, (iy, ix), (1, 5),
	1506	wx.TOP \| wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1507	iy += 1
	1508	ix = 0
	1509	self.low_q_sizer.Add(npts_low_txt, (iy, ix), (1, 1),
	1510	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1511	ix += 1
	1512	self.low_q_sizer.Add(self.npts_low_tcl, (iy, ix), (1, 1),
	1513	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1514	iy += 1
	1515	ix = 0
	1516	self.low_q_sizer.Add(self.guinier, (iy, ix), (1, 2),
	1517	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1518	iy += 1
	1519	ix = 0
	1520	self.low_q_sizer.Add(self.power_law_low, (iy, ix), (1, 2),
	1521	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1522	# Parameter controls for power law
	1523	ix = 1
	1524	iy += 1
	1525	self.low_q_sizer.Add(self.fix_enable_low, (iy, ix), (1, 1),
	1526	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1527	ix += 1
	1528	self.low_q_sizer.Add(self.fit_enable_low, (iy, ix), (1, 1),
	1529	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1530	ix = 1
	1531	iy += 1
	1532	self.low_q_sizer.Add(power_txt, (iy, ix), (1, 1),
	1533	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1534	ix += 1
	1535	self.low_q_sizer.Add(self.power_low_tcl, (iy, ix), (1, 1),
	1536	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1537	self.low_extrapolation_sizer.Add(self.low_q_sizer)
	1538
	1539	def _enable_fit_power_law_high(self, event=None):
	1540	"""
	1541	Enable and disable the power value editing
	1542	"""
[7432acb]	1543	if event is not None:
[959eb01]	1544	self._set_bookmark_flag(True)
	1545
	1546	self._set_preview_flag(False)
	1547	if self.fix_enable_high.IsEnabled():
	1548	if self.fix_enable_high.GetValue():
	1549	self.fit_enable_high.SetValue(False)
	1550	self.power_high_tcl.Enable()
	1551	else:
	1552	self.fit_enable_high.SetValue(True)
	1553	self.power_high_tcl.Disable()
	1554	self._set_state(event=event)
	1555
	1556	def _enable_high_q_section(self, event=None):
	1557	"""
	1558	Disable or enable some button if the user enable high q extrapolation
	1559	"""
[7432acb]	1560	if event is not None:
[959eb01]	1561	self._set_bookmark_flag(True)
	1562	self._set_preview_flag(False)
	1563	if self.enable_high_cbox.GetValue():
	1564	self.npts_high_tcl.Enable()
	1565	self.power_law_high.Enable()
	1566	self.power_high_tcl.Enable()
	1567	self.fix_enable_high.Enable()
	1568	self.fit_enable_high.Enable()
	1569	else:
	1570	self.npts_high_tcl.Disable()
	1571	self.power_law_high.Disable()
	1572	self.power_high_tcl.Disable()
	1573	self.fix_enable_high.Disable()
	1574	self.fit_enable_high.Disable()
	1575	self._enable_fit_power_law_high()
	1576	self._set_state(event=event)
	1577	self.button_calculate.SetFocus()
	1578
	1579	def _layout_extrapolation_high(self):
	1580	"""
	1581	Draw widgets related to extrapolation at high q range
	1582	"""
	1583	self.enable_high_cbox = wx.CheckBox(self, -1,
	1584	"Enable Extrapolate high-Q",
	1585	name='enable_high_cbox')
	1586	wx.EVT_CHECKBOX(self, self.enable_high_cbox.GetId(),
	1587	self._enable_high_q_section)
	1588	self.fix_enable_high = wx.RadioButton(self, -1, 'Fix',
	1589	(10, 10), style=wx.RB_GROUP,
	1590	name='fix_enable_high')
	1591	self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_high,
	1592	id=self.fix_enable_high.GetId())
	1593	self.fit_enable_high = wx.RadioButton(self, -1, 'Fit', (10, 10),
	1594	name='fit_enable_high')
	1595	self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_high,
	1596	id=self.fit_enable_high.GetId())
	1597
	1598	self.power_law_high = wx.StaticText(self, -1, 'Power Law')
	1599	msg_hint = "Check to extrapolate data at high-Q"
	1600	self.power_law_high.SetToolTipString(msg_hint)
	1601	npts_high_txt = wx.StaticText(self, -1, 'Npts')
	1602	self.npts_high_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH * 2 / 3, -1),
	1603	name='npts_high_tcl')
	1604	wx.EVT_TEXT(self, self.npts_high_tcl.GetId(), self._on_text)
	1605	msg_hint = "Number of Q points to consider"
	1606	msg_hint += "while extrapolating the high-Q region"
	1607	self.npts_high_tcl.SetToolTipString(msg_hint)
	1608	power_txt = wx.StaticText(self, -1, 'Power')
	1609	self.power_high_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH * 2 / 3, -1),
	1610	name='power_high_tcl')
	1611	wx.EVT_TEXT(self, self.power_high_tcl.GetId(), self._on_text)
	1612	power_hint_txt = "Exponent to apply to the Power_law function."
	1613	self.power_high_tcl.SetToolTipString(power_hint_txt)
	1614	iy = 0
	1615	ix = 0
	1616	self.high_q_sizer.Add(self.enable_high_cbox, (iy, ix), (1, 5),
	1617	wx.TOP \| wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1618	iy += 1
	1619	ix = 0
	1620	self.high_q_sizer.Add(npts_high_txt, (iy, ix), (1, 1),
	1621	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1622	ix += 1
	1623	self.high_q_sizer.Add(self.npts_high_tcl, (iy, ix), (1, 1),
	1624	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1625	iy += 1
	1626	ix = 0
	1627	self.high_q_sizer.Add(self.power_law_high, (iy, ix), (1, 2),
	1628	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1629
	1630	# Parameter controls for power law
	1631	ix = 1
	1632	iy += 1
	1633	self.high_q_sizer.Add(self.fix_enable_high, (iy, ix), (1, 1),
	1634	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1635	ix += 1
	1636	self.high_q_sizer.Add(self.fit_enable_high, (iy, ix), (1, 1),
	1637	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1638	ix = 1
	1639	iy += 1
	1640	self.high_q_sizer.Add(power_txt, (iy, ix), (1, 1),
	1641	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1642	ix += 1
	1643	self.high_q_sizer.Add(self.power_high_tcl, (iy, ix), (1, 1),
	1644	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	1645	self.high_extrapolation_sizer.Add(self.high_q_sizer, 0,
	1646	wx.BOTTOM, 20)
	1647
	1648	def _layout_extrapolation(self):
	1649	"""
	1650	Draw widgets related to extrapolation
	1651	"""
	1652	extra_hint = "Extrapolation \nMaximum Q Range [1/A]:"
	1653	extra_hint_txt = wx.StaticText(self, -1, extra_hint)
	1654	#Extrapolation range [string]
	1655	extrapolation_min_txt = wx.StaticText(self, -1, 'Min:')
	1656	self.extrapolation_min_tcl = OutputTextCtrl(self, -1,
	1657	size=(_BOX_WIDTH, 20), style=0,
	1658	name='extrapolation_min_tcl')
	1659	self.extrapolation_min_tcl.SetValue(str(Q_MINIMUM))
	1660	hint_msg = "The minimum extrapolated q value."
	1661	self.extrapolation_min_tcl.SetToolTipString(hint_msg)
	1662	extrapolation_max_txt = wx.StaticText(self, -1, 'Max:')
	1663	self.extrapolation_max_tcl = OutputTextCtrl(self, -1,
	1664	size=(_BOX_WIDTH, 20),
	1665	style=0,
	1666	name='extrapolation_max_tcl')
	1667	self.extrapolation_max_tcl.SetValue(str(Q_MAXIMUM))
	1668	hint_msg = "The maximum extrapolated q value."
	1669	self.extrapolation_max_tcl.SetToolTipString(hint_msg)
	1670	self.extrapolation_range_sizer.AddMany([(extra_hint_txt, 0,
	1671	wx.LEFT, 5),
	1672	(extrapolation_min_txt, 0,
	1673	wx.LEFT, 10),
	1674	(self.extrapolation_min_tcl,
	1675	0, wx.LEFT, 5),
	1676	(extrapolation_max_txt, 0,
	1677	wx.LEFT, 20),
	1678	(self.extrapolation_max_tcl,
	1679	0, wx.LEFT, 5)])
	1680	self._layout_extrapolation_low()
	1681	self._layout_extrapolation_high()
	1682	self.extrapolation_low_high_sizer.AddMany([(self.low_extrapolation_sizer,
	1683	0, wx.LEFT \| wx.BOTTOM \| wx.TOP, 5),
	1684	(self.high_extrapolation_sizer,
	1685	0, wx.LEFT \| wx.BOTTOM \| wx.TOP, 5)])
	1686	self.extrapolation_sizer.AddMany([(self.extrapolation_range_sizer),
	1687	(self.extrapolation_low_high_sizer)])
	1688
	1689	def _layout_volume_surface_sizer(self):
	1690	"""
	1691	Draw widgets related to volume and surface
	1692	"""
	1693	unit_volume = ''
	1694	unit_surface = '[1/A]'
	1695	uncertainty = "+/-"
	1696	volume_txt = wx.StaticText(self, -1, 'Volume Fraction')
	1697	self.volume_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
	1698	name='volume_tcl')
	1699	wx.EVT_TEXT(self, self.volume_tcl.GetId(), self._on_out_text)
	1700	self.volume_tcl.SetToolTipString("Volume fraction.")
	1701	self.volume_err_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
	1702	name='volume_err_tcl')
	1703	wx.EVT_TEXT(self, self.volume_err_tcl.GetId(), self._on_out_text)
	1704	hint_msg = "Uncertainty on the volume fraction."
	1705	self.volume_err_tcl.SetToolTipString(hint_msg)
	1706	volume_units_txt = wx.StaticText(self, -1, unit_volume)
	1707
	1708	surface_txt = wx.StaticText(self, -1, 'Specific Surface')
	1709	self.surface_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
	1710	name='surface_tcl')
	1711	wx.EVT_TEXT(self, self.surface_tcl.GetId(), self._on_out_text)
	1712	self.surface_tcl.SetToolTipString("Specific surface value.")
	1713	self.surface_err_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
	1714	name='surface_err_tcl')
	1715	wx.EVT_TEXT(self, self.surface_err_tcl.GetId(), self._on_out_text)
	1716	hint_msg = "Uncertainty on the specific surface."
	1717	self.surface_err_tcl.SetToolTipString(hint_msg)
	1718	surface_units_txt = wx.StaticText(self, -1, unit_surface)
	1719	iy = 0
	1720	ix = 0
	1721	self.volume_surface_sizer.Add(volume_txt, (iy, ix), (1, 1),
	1722	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1723	ix += 1
	1724	self.volume_surface_sizer.Add(self.volume_tcl, (iy, ix), (1, 1),
	1725	wx.EXPAND \| wx.ADJUST_MINSIZE, 20)
	1726	ix += 1
	1727	self.volume_surface_sizer.Add(wx.StaticText(self, -1, uncertainty),
	1728	(iy, ix), (1, 1), wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1729	ix += 1
	1730	self.volume_surface_sizer.Add(self.volume_err_tcl, (iy, ix), (1, 1),
	1731	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1732	ix += 1
	1733	self.volume_surface_sizer.Add(volume_units_txt, (iy, ix), (1, 1),
	1734	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1735	iy += 1
	1736	ix = 0
	1737	self.volume_surface_sizer.Add(surface_txt, (iy, ix), (1, 1),
	1738	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1739	ix += 1
	1740	self.volume_surface_sizer.Add(self.surface_tcl, (iy, ix), (1, 1),
	1741	wx.EXPAND \| wx.ADJUST_MINSIZE, 20)
	1742	ix += 1
	1743	self.volume_surface_sizer.Add(wx.StaticText(self, -1, uncertainty),
	1744	(iy, ix), (1, 1), wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1745	ix += 1
	1746	self.volume_surface_sizer.Add(self.surface_err_tcl, (iy, ix), (1, 1),
	1747	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1748	ix += 1
	1749	self.volume_surface_sizer.Add(surface_units_txt, (iy, ix), (1, 1),
	1750	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1751	static_line = wx.StaticLine(self, -1)
	1752	iy += 1
	1753	ix = 0
	1754
	1755	def _layout_invariant_sizer(self):
	1756	"""
	1757	Draw widgets related to invariant
	1758	"""
	1759	uncertainty = "+/-"
	1760	unit_invariant = '[1/(cm*A^3)]'
	1761	invariant_total_txt = wx.StaticText(self, -1, 'Invariant Total [Q*]')
	1762	self.invariant_total_tcl = OutputTextCtrl(self, -1,
	1763	size=(_BOX_WIDTH, -1),
	1764	name='invariant_total_tcl')
	1765	msg_hint = "Total invariant [Q*], including extrapolated regions."
	1766	self.invariant_total_tcl.SetToolTipString(msg_hint)
	1767	self.invariant_total_err_tcl = OutputTextCtrl(self, -1,
	1768	size=(_BOX_WIDTH, -1),
	1769	name='invariant_total_err_tcl')
	1770	hint_msg = "Uncertainty on invariant."
	1771	self.invariant_total_err_tcl.SetToolTipString(hint_msg)
	1772	invariant_total_units_txt = wx.StaticText(self, -1, unit_invariant,
	1773	size=(80, -1))
	1774
	1775	#Invariant total
	1776	iy = 0
	1777	ix = 0
	1778	self.invariant_sizer.Add(invariant_total_txt, (iy, ix), (1, 1),
	1779	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	1780	ix += 1
	1781	self.invariant_sizer.Add(self.invariant_total_tcl, (iy, ix), (1, 1),
	1782	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1783	ix += 1
	1784	self.invariant_sizer.Add(wx.StaticText(self, -1, uncertainty),
	1785	(iy, ix), (1, 1), wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1786	ix += 1
	1787	self.invariant_sizer.Add(self.invariant_total_err_tcl, (iy, ix), (1, 1),
	1788	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1789	ix += 1
	1790	self.invariant_sizer.Add(invariant_total_units_txt, (iy, ix), (1, 1),
	1791	wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
	1792
	1793	def _layout_inputs_sizer(self):
	1794	"""
	1795	Draw widgets related to inputs
	1796	"""
	1797	contrast_txt = wx.StaticText(self, -1, 'Contrast:')
	1798	self.contrast_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
	1799	style=0, name='contrast_tcl')
	1800	wx.EVT_TEXT(self, self.contrast_tcl.GetId(), self._on_text)
	1801	contrast_hint_txt = "Contrast"
	1802	self.contrast_tcl.SetToolTipString(contrast_hint_txt)
	1803	contrast_unit_txt = wx.StaticText(self, -1, '[1/A^2]', size=(40, -1))
	1804	porod_const_txt = wx.StaticText(self, -1,
	1805	'Porod\nConstant:\n(optional)\n')
	1806	porod_unit_txt = wx.StaticText(self, -1, '[1/(cm*A^4)]', size=(80, -1))
	1807	self.porod_constant_tcl = InvTextCtrl(self, -1,
	1808	size=(_BOX_WIDTH, 20), style=0,
	1809	name='porod_constant_tcl')
	1810	wx.EVT_TEXT(self, self.porod_constant_tcl.GetId(), self._on_text)
	1811	porod_const_hint_txt = "Porod Constant"
	1812	self.porod_constant_tcl.SetToolTipString(porod_const_hint_txt)
	1813
	1814	background_txt = wx.StaticText(self, -1, 'Background:')
	1815	self.background_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
	1816	style=0, name='background_tcl')
	1817	wx.EVT_TEXT(self, self.background_tcl.GetId(), self._on_text)
	1818	background_hint_txt = "Background"
	1819	self.background_tcl.SetToolTipString(background_hint_txt)
	1820	background_unit_txt = wx.StaticText(self, -1, '[1/cm]')
	1821	scale_txt = wx.StaticText(self, -1, 'Scale:')
	1822	self.scale_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20), style=0,
	1823	name='scale_tcl')
	1824	wx.EVT_TEXT(self, self.scale_tcl.GetId(), self._on_text)
	1825	scale_hint_txt = "Scale"
	1826	self.scale_tcl.SetToolTipString(scale_hint_txt)
	1827	self.sizer_input.AddMany([(background_txt, 0, wx.LEFT \| wx.BOTTOM, 5),
	1828	(self.background_tcl, 0, wx.LEFT \| wx.BOTTOM, 5),
	1829	(background_unit_txt, 0, wx.LEFT \| wx.BOTTOM, 5),
	1830	(scale_txt, 0, wx.LEFT \| wx.BOTTOM, 10),
	1831	(self.scale_tcl, 0, wx.LEFT \| wx.BOTTOM \| wx.RIGHT, 5),
	1832	(10, 10),
	1833	(contrast_txt, 0, wx.LEFT \| wx.BOTTOM, 5),
	1834	(self.contrast_tcl, 0, wx.LEFT \| wx.BOTTOM, 5),
	1835	(contrast_unit_txt, 0, wx.LEFT \| wx.BOTTOM, 5),
	1836	(porod_const_txt, 0, wx.LEFT, 10),
	1837	(self.porod_constant_tcl, 0, wx.LEFT \| wx.BOTTOM \| wx.RIGHT, 5),
	1838	(porod_unit_txt, 0, wx.LEFT \| wx.BOTTOM, 5)])
	1839	self.inputs_sizer.Add(self.sizer_input)
	1840
	1841	def _layout_outputs_sizer(self):
	1842	"""
	1843	Draw widgets related to outputs
	1844	"""
	1845	self._layout_volume_surface_sizer()
	1846	self._layout_invariant_sizer()
	1847	static_line = wx.StaticLine(self, -1)
	1848	self.outputs_sizer.AddMany([(self.volume_surface_sizer,
	1849	0, wx.TOP \| wx.BOTTOM, 10),
	1850	(static_line, 0, wx.EXPAND, 0),
	1851	(self.invariant_sizer, 0, wx.TOP \| wx.BOTTOM, 10)])
	1852	def _layout_button(self):
	1853	"""
	1854	Do the layout for the button widgets
	1855	"""
	1856	#compute button
	1857	id = wx.NewId()
	1858	self.button_calculate = wx.Button(self, id, "Compute",
	1859	name='compute_invariant')
	1860	self.button_calculate.SetToolTipString("Compute invariant")
	1861	self.Bind(wx.EVT_BUTTON, self.compute_invariant, id=id)
	1862	#detail button
	1863	id = wx.NewId()
	1864	self.button_details = wx.Button(self, id, "Details?")
	1865	hint_msg = "Get more details of computation such as fraction from extrapolation"
	1866	self.button_details.SetToolTipString(hint_msg)
	1867	self.Bind(wx.EVT_BUTTON, self.display_details, id=id)
	1868	#help button
	1869	id = wx.NewId()
	1870	self.button_help = wx.Button(self, id, "HELP")
	1871	self.button_help.SetToolTipString("Invariant Documentation")
	1872	self.Bind(wx.EVT_BUTTON, self.on_help, id=id)
	1873	self.button_sizer.AddMany([((20, 20), 1, wx.EXPAND \| wx.ADJUST_MINSIZE, 0),
	1874	(self.button_details, 0, wx.ALL, 10),
	1875	(self.button_calculate, 0,
	1876	wx.RIGHT \| wx.TOP \| wx.BOTTOM, 10),
	1877	(self.button_help, 0,
	1878	wx.RIGHT \| wx.TOP \| wx.BOTTOM, 10),])
	1879	def _do_layout(self):
	1880	"""
	1881	Draw window content
	1882	"""
	1883	self._define_structure()
	1884	self._layout_data_name()
	1885	self._layout_extrapolation()
	1886	self._layout_inputs_sizer()
	1887	self._layout_outputs_sizer()
	1888	self._layout_button()
	1889	self.main_sizer.AddMany([(self.data_name_boxsizer, 0, wx.ALL, 10),
	1890	(self.outputs_sizer, 0,
	1891	wx.LEFT \| wx.RIGHT \| wx.BOTTOM, 10),
	1892	(self.button_sizer, 0, wx.LEFT \| wx.RIGHT, 15),
	1893	(self.inputs_sizer, 0,
	1894	wx.LEFT \| wx.RIGHT \| wx.BOTTOM, 10),
	1895	(self.extrapolation_sizer, 0,
	1896	wx.LEFT \| wx.RIGHT \| wx.BOTTOM, 10)])
	1897	self.SetSizer(self.main_sizer)
	1898	self.SetAutoLayout(True)
	1899
	1900	def on_help(self, event):
	1901	"""
	1902	Bring up the Invariant Documentation whenever the HELP button is
	1903	clicked.
	1904
	1905	Calls DocumentationWindow with the path of the location within the
	1906	documentation tree (after /doc/ ....". Note that when using old
	1907	versions of Wx (before 2.9) and thus not the release version of
	1908	installers, the help comes up at the top level of the file as
	1909	webbrowser does not pass anything past the # to the browser when it is
	1910	running "file:///...."
	1911
	1912	:param evt: Triggers on clicking the help button
	1913	"""
	1914
	1915	_TreeLocation = "user/sasgui/perspectives/invariant/invariant_help.html"
	1916	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, "",
	1917	"Invariant Help")
	1918
	1919
	1920	class InvariantDialog(wx.Dialog):
	1921	"""
	1922	Invariant Dialog
	1923	"""
	1924	def __init__(self, parent=None, id=1, graph=None,
	1925	data=None, title="Invariant", base=None):
	1926	wx.Dialog.__init__(self, parent, id, title, size=(PANEL_WIDTH,
	1927	PANEL_HEIGHT))
	1928	self.panel = InvariantPanel(self)
	1929	self.Centre()
	1930	self.Show(True)
	1931
	1932	class InvariantWindow(wx.Frame):
	1933	"""
	1934	Invariant Window
	1935	"""
	1936	def __init__(self, parent=None, id=1, graph=None,
	1937	data=None, title="Invariant", base=None):
	1938
	1939	wx.Frame.__init__(self, parent, id, title, size=(PANEL_WIDTH + 100,
	1940	PANEL_HEIGHT + 100))
	1941	from sas.sascalc.dataloader.loader import Loader
	1942	self.loader = Loader()
	1943	path = "C:/ECLPS/workspace/trunk/sasdataloader/test/ascii_test_3.txt"
	1944	data = self.loader.load(path)
	1945	self.panel = InvariantPanel(self)
	1946
	1947	data.name = data.filename
	1948	self.panel.set_data(data)
	1949	self.Centre()
	1950	self.Show(True)
	1951
	1952	class MyApp(wx.App):
	1953	"""
	1954	Test App
	1955	"""
	1956	def OnInit(self):
	1957	"""
	1958	Init
	1959	"""
	1960	wx.InitAllImageHandlers()
	1961	frame = InvariantWindow()
	1962	frame.Show(True)
	1963	self.SetTopWindow(frame)
	1964
	1965	return True
	1966
	1967	# end of class MyApp
	1968
	1969	if __name__ == "__main__":
	1970	app = MyApp(0)
	1971	app.MainLoop()

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

SasView

source: sasview/src/sas/sasgui/perspectives/invariant/invariant_panel.py @ 23ff8d5

Download in other formats: