invariant_state.py @ 82d88d5

magnetic_scattrelease-4.2.2ticket-1009ticket-1249

Last change on this file since 82d88d5 was 5251ec6, checked in by Paul Kienzle <pkienzle@…>, 6 years ago
improved support for py37 in sasgui
Property mode set to `100644`
File size: 30.7 KB

Line
1	"""
2	State class for the invariant UI
3	"""
4	from __future__ import print_function
5
6	# import time
7	import os
8	import sys
9	import logging
10	import copy
11	import sas.sascalc.dataloader
12	# from xml.dom.minidom import parse
13	from lxml import etree
14	from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader
15	from sas.sasgui.guiframe.report_image_handler import ReportImageHandler
16	from sas.sascalc.dataloader.readers.cansas_reader import get_content
17	from sas.sasgui.guiframe.utils import format_number
18	from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
19	from sas.sasgui.guiframe.dataFitting import Data1D
20
21	logger = logging.getLogger(__name__)
22
23	INVNODE_NAME = 'invariant'
24	CANSAS_NS = "cansas1d/1.0"
25
26	# default state
27	DEFAULT_STATE = {'file': 'None',
28	'compute_num':0,
29	'state_num':0,
30	'is_time_machine':False,
31	'background_tcl':0.0,
32	'scale_tcl':1.0,
33	'contrast_tcl':1.0,
34	'porod_constant_tcl':'',
35	'npts_low_tcl':10,
36	'npts_high_tcl':10,
37	'power_high_tcl':4.0,
38	'power_low_tcl': 4.0,
39	'enable_high_cbox':False,
40	'enable_low_cbox':False,
41	'guinier': True,
42	'power_law_high': False,
43	'power_law_low': False,
44	'fit_enable_high': False,
45	'fit_enable_low': False,
46	'fix_enable_high':True,
47	'fix_enable_low':True,
48	'volume_tcl':'',
49	'volume_err_tcl':'',
50	'surface_tcl':'',
51	'surface_err_tcl':''}
52	# list of states: This list will be filled as panel
53	# init and the number of states increases
54	state_list = {}
55	bookmark_list = {}
56	# list of input parameters (will be filled up on panel init) used by __str__
57	input_list = {'background_tcl':0,
58	'scale_tcl':0,
59	'contrast_tcl':0,
60	'porod_constant_tcl':'',
61	'npts_low_tcl':0,
62	'npts_high_tcl':0,
63	'power_high_tcl':0,
64	'power_low_tcl': 0}
65	# list of output parameters (order sensitive) used by __str__
66	output_list = [["qstar_low", "Q* from low Q extrapolation [1/(cm*A)]"],
67	["qstar_low_err", "dQ* from low Q extrapolation"],
68	["qstar_low_percent", "Q* percent from low Q extrapolation"],
69	["qstar", "Q* from data [1/(cm*A)]"],
70	["qstar_err", "dQ* from data"],
71	["qstar_percent", "Q* percent from data"],
72	["qstar_high", "Q* from high Q extrapolation [1/(cm*A)]"],
73	["qstar_high_err", "dQ* from high Q extrapolation"],
74	["qstar_high_percent", "Q* percent from low Q extrapolation"],
75	["qstar_total", "total Q* [1/(cm*A)]"],
76	["qstar_total_err", "total dQ*"],
77	["volume", "volume fraction"],
78	["volume_err", "volume fraction error"],
79	["surface", "specific surface"],
80	["surface_err", "specific surface error"]]
81
82
83
84	class InvariantState(object):
85	"""
86	Class to hold the state information of the InversionControl panel.
87	"""
88	def __init__(self):
89	"""
90	Default values
91	"""
92	# Input
93	self.file = None
94	self.data = Data1D(x=[], y=[], dx=None, dy=None)
95	self.theory_lowQ = Data1D(x=[], y=[], dy=None)
96	self.theory_lowQ.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
97	self.theory_highQ = Data1D(x=[], y=[], dy=None)
98	self.theory_highQ.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
99	# self.is_time_machine = False
100	self.saved_state = DEFAULT_STATE
101	self.state_list = state_list
102	self.bookmark_list = bookmark_list
103	self.input_list = input_list
104	self.output_list = output_list
105
106	self.compute_num = 0
107	self.state_num = 0
108	self.timestamp = ('00:00:00', '00/00/0000')
109	self.container = None
110	# plot image
111	self.wximbmp = None
112	# report_html strings
113	import sas.sasgui.perspectives.invariant as invariant
114	path = invariant.get_data_path(media='media')
115	path_report_html = os.path.join(path, "report_template.html")
116	html_template = open(path_report_html, "r")
117	self.template_str = html_template.read()
118	self.report_str = self.template_str
119	# self.report_str_save = None
120	html_template.close()
121
122	def __str__(self):
123	"""
124	Pretty print
125
126	: return: string representing the state
127	"""
128	# Input string
129	compute_num = self.saved_state['compute_num']
130	compute_state = self.state_list[str(compute_num)]
131	my_time, date = self.timestamp
132	file_name = self.file
133	from sas.sasview.__init__ import __version__ as sasview_version
134
135	state_num = int(self.saved_state['state_num'])
136	state = "\n[Invariant computation for %s: " % file_name
137	state += "performed at %s on %s] " % (my_time, date)
138	state += "[SasView v%s]\n" % (sasview_version)
139	state += "State No.: %d \n" % state_num
140	state += "\n=== Inputs ===\n"
141
142	# text ctl general inputs ( excluding extrapolation text ctl)
143	for key, value in self.input_list.items():
144	if value == '':
145	continue
146	key_split = key.split('_')
147	max_ind = len(key_split) - 1
148	if key_split[max_ind] == 'tcl':
149	name = ""
150	if key_split[1] == 'low' or key_split[1] == 'high':
151	continue
152	for ind in range(0, max_ind):
153	name += " %s" % key_split[ind]
154	state += "%s: %s\n" % (name.lstrip(" "), value)
155
156	# other input parameters
157	extra_lo = compute_state['enable_low_cbox']
158	if compute_state['enable_low_cbox']:
159	if compute_state['guinier']:
160	extra_lo = 'Guinier'
161	else:
162	extra_lo = 'Power law'
163	extra_hi = compute_state['enable_high_cbox']
164	if compute_state['enable_high_cbox']:
165	extra_hi = 'Power law'
166	state += "\nExtrapolation: High=%s; Low=%s\n" % (extra_hi, extra_lo)
167	low_off = False
168	high_off = False
169	for key, value in self.input_list.items():
170	key_split = key.split('_')
171	max_ind = len(key_split) - 1
172	if key_split[max_ind] == 'tcl':
173	name = ""
174	# check each buttons whether or not ON or OFF
175	if key_split[1] == 'low' or key_split[1] == 'high':
176	if not compute_state['enable_low_cbox'] and \
177	key_split[max_ind - 1] == 'low':
178	low_off = True
179	continue
180	elif not compute_state['enable_high_cbox'] and \
181	key_split[max_ind - 1] == 'high':
182	high_off = True
183	continue
184	elif extra_lo == 'Guinier' and key_split[0] == 'power' and \
185	key_split[max_ind - 1] == 'low':
186	continue
187	for ind in range(0, max_ind):
188	name += " %s" % key_split[ind]
189	name = name.lstrip(" ")
190	if name == "power low":
191	if compute_state['fix_enable_low']:
192	name += ' (Fixed)'
193	else:
194	name += ' (Fitted)'
195	if name == "power high":
196	if compute_state['fix_enable_high']:
197	name += ' (Fixed)'
198	else:
199	name += ' (Fitted)'
200	state += "%s: %s\n" % (name, value)
201	# Outputs
202	state += "\n=== Outputs ==="
203	for item in output_list:
204	item_split = item[0].split('_')
205	# Exclude the extrapolation that turned off
206	if len(item_split) > 1:
207	if low_off and item_split[1] == 'low':
208	continue
209	if high_off and item_split[1] == 'high':
210	continue
211	max_ind = len(item_split) - 1
212	value = None
213	if hasattr(self.container, item[0]):
214	# Q* outputs
215	value = getattr(self.container, item[0])
216	else:
217	# other outputs than Q*
218	name = item[0] + "_tcl"
219	if name in self.saved_state:
220	value = self.saved_state[name]
221
222	# Exclude the outputs w/''
223	if value == '':
224	continue
225	# Error outputs
226	if item_split[max_ind] == 'err':
227	state += "+- %s " % format_number(value)
228	# Percentage outputs
229	elif item_split[max_ind] == 'percent':
230	value = float(value) * 100
231	state += "(%s %s)" % (format_number(value), '%')
232	# Outputs
233	else:
234	state += "\n%s: %s " % (item[1],
235	format_number(value, high=True))
236	# Include warning msg
237	if self.container is not None:
238	state += "\n\nNote:\n" + self.container.warning_msg
239	return state
240
241	def clone_state(self):
242	"""
243	deepcopy the state
244	"""
245	return copy.deepcopy(self.saved_state)
246
247	def toXML(self, file="inv_state.inv", doc=None, entry_node=None):
248	"""
249	Writes the state of the InversionControl panel to file, as XML.
250
251	Compatible with standalone writing, or appending to an
252	already existing XML document. In that case, the XML document
253	is required. An optional entry node in the XML document
254	may also be given.
255
256	: param file: file to write to
257	: param doc: XML document object [optional]
258	: param entry_node: XML node within the document at which we will append the data [optional]
259	"""
260	# TODO: Get this to work
261	from xml.dom.minidom import getDOMImplementation
262	import time
263	timestamp = time.time()
264	# Check whether we have to write a standalone XML file
265	if doc is None:
266	impl = getDOMImplementation()
267
268	doc_type = impl.createDocumentType(INVNODE_NAME, "1.0", "1.0")
269
270	newdoc = impl.createDocument(None, INVNODE_NAME, doc_type)
271	top_element = newdoc.documentElement
272	else:
273	# We are appending to an existing document
274	newdoc = doc
275	top_element = newdoc.createElement(INVNODE_NAME)
276	if entry_node is None:
277	newdoc.documentElement.appendChild(top_element)
278	else:
279	entry_node.appendChild(top_element)
280
281	attr = newdoc.createAttribute("version")
282	attr.nodeValue = '1.0'
283	top_element.setAttributeNode(attr)
284
285	# File name
286	element = newdoc.createElement("filename")
287	if self.file is not None and self.file != '':
288	element.appendChild(newdoc.createTextNode(str(self.file)))
289	else:
290	element.appendChild(newdoc.createTextNode(str(file)))
291	top_element.appendChild(element)
292
293	element = newdoc.createElement("timestamp")
294	element.appendChild(newdoc.createTextNode(time.ctime(timestamp)))
295	attr = newdoc.createAttribute("epoch")
296	attr.nodeValue = str(timestamp)
297	element.setAttributeNode(attr)
298	top_element.appendChild(element)
299
300	# Current state
301	state = newdoc.createElement("state")
302	top_element.appendChild(state)
303
304	for name, value in self.saved_state.items():
305	element = newdoc.createElement(str(name))
306	element.appendChild(newdoc.createTextNode(str(value)))
307	state.appendChild(element)
308
309	# State history list
310	history = newdoc.createElement("history")
311	top_element.appendChild(history)
312
313	for name, value in self.state_list.items():
314	history_element = newdoc.createElement('state_' + str(name))
315	for state_name, state_value in value.items():
316	state_element = newdoc.createElement(str(state_name))
317	child = newdoc.createTextNode(str(state_value))
318	state_element.appendChild(child)
319	history_element.appendChild(state_element)
320	# history_element.appendChild(state_list_element)
321	history.appendChild(history_element)
322
323	# Bookmarks bookmark_list[self.bookmark_num] = [\
324	# my_time,date,state,comp_state]
325	bookmark = newdoc.createElement("bookmark")
326	top_element.appendChild(bookmark)
327	item_list = ['time', 'date', 'state', 'comp_state']
328	for name, value_list in self.bookmark_list.items():
329	element = newdoc.createElement('mark_' + str(name))
330	_, date, state, comp_state = value_list
331	time_element = newdoc.createElement('time')
332	time_element.appendChild(newdoc.createTextNode(str(value_list[0])))
333	date_element = newdoc.createElement('date')
334	date_element.appendChild(newdoc.createTextNode(str(value_list[1])))
335	state_list_element = newdoc.createElement('state')
336	comp_state_list_element = newdoc.createElement('comp_state')
337	for state_name, state_value in value_list[2].items():
338	state_element = newdoc.createElement(str(state_name))
339	child = newdoc.createTextNode(str(state_value))
340	state_element.appendChild(child)
341	state_list_element.appendChild(state_element)
342	for comp_name, comp_value in value_list[3].items():
343	comp_element = newdoc.createElement(str(comp_name))
344	comp_element.appendChild(newdoc.createTextNode(str(comp_value)))
345	comp_state_list_element.appendChild(comp_element)
346	element.appendChild(time_element)
347	element.appendChild(date_element)
348	element.appendChild(state_list_element)
349	element.appendChild(comp_state_list_element)
350	bookmark.appendChild(element)
351
352	# Save the file
353	if doc is None:
354	fd = open('test000', 'w')
355	fd.write(newdoc.toprettyxml())
356	fd.close()
357	return None
358	else:
359	return newdoc
360
361	def fromXML(self, file=None, node=None):
362	"""
363	Load invariant states from a file
364
365	: param file: .inv file
366	: param node: node of a XML document to read from
367	"""
368	if file is not None:
369	msg = "InvariantSate no longer supports non-CanSAS"
370	msg += " format for invariant files"
371	raise RuntimeError(msg)
372
373	if node.get('version')\
374	and node.get('version') == '1.0':
375
376	# Get file name
377	entry = get_content('ns:filename', node)
378	if entry is not None:
379	file_name = entry.text.strip()
380
381	# Get time stamp
382	entry = get_content('ns:timestamp', node)
383	if entry is not None and entry.get('epoch'):
384	try:
385	timestamp = (entry.get('epoch'))
386	except Exception as exc:
387	msg = "InvariantSate.fromXML: Could not read"
388	msg += " timestamp\n %s" % exc
389	logger.error(msg)
390
391	# Parse bookmarks
392	entry_bookmark = get_content('ns:bookmark', node)
393
394	for ind in range(1, len(entry_bookmark) + 1):
395	temp_state = {}
396	temp_bookmark = {}
397	entry = get_content('ns:mark_%s' % ind, entry_bookmark)
398
399	if entry is not None:
400	my_time = get_content('ns:time', entry)
401	val_time = str(my_time.text.strip())
402	date = get_content('ns:date', entry)
403	val_date = str(date.text.strip())
404	state_entry = get_content('ns:state', entry)
405	for item in DEFAULT_STATE:
406	input_field = get_content('ns:%s' % item, state_entry)
407	val = str(input_field.text.strip())
408	if input_field is not None:
409	temp_state[item] = val
410	comp_entry = get_content('ns:comp_state', entry)
411
412	for item in DEFAULT_STATE:
413	input_field = get_content('ns:%s' % item, comp_entry)
414	val = str(input_field.text.strip())
415	if input_field is not None:
416	temp_bookmark[item] = val
417	try:
418	self.bookmark_list[ind] = [val_time, val_date, temp_state, temp_bookmark]
419	except:
420	raise "missing components of bookmarks..."
421	# Parse histories
422	entry_history = get_content('ns:history', node)
423
424	for ind in range(0, len(entry_history)):
425	temp_state = {}
426	entry = get_content('ns:state_%s' % ind, entry_history)
427
428	if entry is not None:
429	for item in DEFAULT_STATE:
430	input_field = get_content('ns:%s' % item, entry)
431	if input_field.text is not None:
432	val = str(input_field.text.strip())
433	else:
434	val = ''
435	if input_field is not None:
436	temp_state[item] = val
437	self.state_list[str(ind)] = temp_state
438
439	# Parse current state (ie, saved_state)
440	entry = get_content('ns:state', node)
441	if entry is not None:
442	for item in DEFAULT_STATE:
443	input_field = get_content('ns:%s' % item, entry)
444	if input_field.text is not None:
445	val = str(input_field.text.strip())
446	else:
447	val = ''
448	if input_field is not None:
449	self.set_saved_state(name=item, value=val)
450	self.file = file_name
451
452	def set_report_string(self):
453	"""
454	Get the values (strings) from __str__ for report
455	"""
456	# default string values
457	s = {num: 'NA' for num in range(1, 19)}
458	# get all string values from __str__()
459	lines = str(self).split('\n')
460	for line_num, line in enumerate(lines):
461	if line_num == 1:
462	s[1] = line
463	elif line_num == 2:
464	s[2] = line
465	else:
466	item = line.split(':')
467	item[0] = item[0].strip()
468	if item[0] == "scale":
469	s[3] = item[1]
470	elif item[0] == "porod constant":
471	s[4] = item[1]
472	elif item[0] == "background":
473	s[5] = item[1]
474	elif item[0] == "contrast":
475	s[6] = item[1]
476	elif item[0] == "Extrapolation":
477	extra = item[1].split(";")
478	bool_0 = extra[0].split("=")
479	bool_1 = extra[1].split("=")
480	s[8] = " " + bool_0[0] + "Q region = " + bool_0[1]
481	s[7] = " " + bool_1[0] + "Q region = " + bool_1[1]
482	elif item[0] == "npts low":
483	s[9] = item[1]
484	elif item[0] == "npts high":
485	s[10] = item[1]
486	elif item[0] == "volume fraction":
487	val = item[1].split("+-")[0].strip()
488	error = item[1].split("+-")[1].strip()
489	s[17] = val + " ± " + error
490	elif item[0] == "specific surface":
491	val = item[1].split("+-")[0].strip()
492	error = item[1].split("+-")[1].strip()
493	s[18] = val + " ± " + error
494	elif item[0].split("(")[0].strip() == "power low":
495	s[11] = item[0] + " =" + item[1]
496	elif item[0].split("(")[0].strip() == "power high":
497	s[12] = item[0] + " =" + item[1]
498	elif item[0].split("[")[0].strip() == "Q* from low Q extrapolation":
499	# looks messy but this way the symbols +_ and % work on html
500	val = item[1].split("+-")[0].strip()
501	error = item[1].split("+-")[1].strip()
502	err = error.split("%")[0].strip()
503	percent = error.split("%")[1].strip()
504	s[13] = val + " ± " + err + "&#37" + percent
505	elif item[0].split("[")[0].strip() == "Q* from data":
506	val = item[1].split("+-")[0].strip()
507	error = item[1].split("+-")[1].strip()
508	err = error.split("%")[0].strip()
509	percent = error.split("%")[1].strip()
510	s[14] = val + " ± " + err + "&#37" + percent
511	elif item[0].split("[")[0].strip() == "Q* from high Q extrapolation":
512	val = item[1].split("+-")[0].strip()
513	error = item[1].split("+-")[1].strip()
514	err = error.split("%")[0].strip()
515	percent = error.split("%")[1].strip()
516	s[15] = val + " ± " + err + "&#37" + percent
517	elif item[0].split("[")[0].strip() == "total Q*":
518	val = item[1].split("+-")[0].strip()
519	error = item[1].split("+-")[1].strip()
520	s[16] = val + " ± " + error
521	else:
522	continue
523
524	s[1] = self._check_html_format(s[1])
525	file_name = self._check_html_format(self.file)
526
527	# make plot image
528	self.set_plot_state(extra_high=bool_0[1], extra_low=bool_1[1])
529	# get ready for report with setting all the html strings
530	self.report_str = str(self.template_str) % (
531	s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
532	s[12], s[13], s[14], s[15], s[16], s[17], s[18], file_name, "%s")
533
534	def _check_html_format(self, name):
535	"""
536	Check string '%' for html format
537	"""
538	if name.count('%'):
539	name = name.replace('%', '&#37')
540
541	return name
542
543	def set_saved_state(self, name, value):
544	"""
545	Set the state list
546
547	: param name: name of the state component
548	: param value: value of the state component
549	"""
550	rb_list = [['power_law_low', 'guinier'],
551	['fit_enable_low', 'fix_enable_low'],
552	['fit_enable_high', 'fix_enable_high']]
553
554	self.name = value
555	self.saved_state[name] = value
556	# set the count part of radio button clicked
557	# False for the saved_state
558	for title, content in rb_list:
559	if name == title:
560	name = content
561	value = False
562	elif name == content:
563	name = title
564	value = False
565	self.saved_state[name] = value
566	self.state_num = self.saved_state['state_num']
567
568	def set_plot_state(self, extra_high=False, extra_low=False):
569	"""
570	Build image state that wx.html understand
571	by plotting, putting it into wx.FileSystem image object
572
573	: extrap_high,extra_low: low/high extrapolations
574	are possible extra-plots
575	"""
576	# some imports
577	import wx
578	import matplotlib.pyplot as plt
579	from matplotlib.backends.backend_agg import FigureCanvasAgg
580
581	# we use simple plot, not plotpanel
582	# make matlab figure
583	fig = plt.figure()
584	fig.set_facecolor('w')
585	graph = fig.add_subplot(111)
586
587	# data plot
588	graph.errorbar(self.data.x, self.data.y, yerr=self.data.dy, fmt='o')
589	# low Q extrapolation fit plot
590	if not extra_low == 'False':
591	graph.plot(self.theory_lowQ.x, self.theory_lowQ.y)
592	# high Q extrapolation fit plot
593	if not extra_high == 'False':
594	graph.plot(self.theory_highQ.x, self.theory_highQ.y)
595	graph.set_xscale("log", nonposx='clip')
596	graph.set_yscale("log", nonposy='clip')
597	graph.set_xlabel('$\\rm{Q}(\\AA^{-1})$', fontsize=12)
598	graph.set_ylabel('$\\rm{Intensity}(cm^{-1})$', fontsize=12)
599	canvas = FigureCanvasAgg(fig)
600	# actually make image
601	canvas.draw()
602
603	# make python.Image object
604	# size
605	w, h = canvas.get_width_height()
606	# convert to wx.Image
607	wximg = wx.EmptyImage(w, h)
608	# wxim.SetData(img.convert('RGB').tostring() )
609	wximg.SetData(canvas.tostring_rgb())
610	# get the dynamic image for the htmlwindow
611	wximgbmp = wx.BitmapFromImage(wximg)
612	# store the image in wx.FileSystem Object
613	imgs, refs = ReportImageHandler.set_figs([fig], [wximgbmp], 'inv')
614
615	self.wximgbmp = refs[0]
616	self.image = imgs[0]
617
618	class Reader(CansasReader):
619	"""
620	Class to load a .inv invariant file
621	"""
622	# # File type
623	type_name = "Invariant"
624
625	# # Wildcards
626	type = ["Invariant file (.inv)\|.inv",
627	"SASView file (.svs)\|.svs"]
628	# # List of allowed extensions
629	ext = ['.inv', '.INV', '.svs', 'SVS']
630
631	def __init__(self, call_back, cansas=True):
632	"""
633	Initialize the call-back method to be called
634	after we load a file
635
636	: param call_back: call-back method
637	: param cansas: True = files will be written/read in CanSAS format
638	False = write CanSAS format
639	"""
640	# # Call back method to be executed after a file is read
641	self.call_back = call_back
642	# # CanSAS format flag
643	self.cansas = cansas
644	self.state = None
645
646	def read(self, path):
647	"""
648	Load a new invariant state from file
649
650	: param path: file path
651	: return: None
652	"""
653	if self.cansas:
654	return self._read_cansas(path)
655	else:
656	return self._read_standalone(path)
657
658	def _read_standalone(self, path):
659	"""
660	Load a new invariant state from file.
661	The invariant node is assumed to be the top element.
662
663	: param path: file path
664	: return: None
665	"""
666	# Read the new state from file
667	state = InvariantState()
668
669	state.fromXML(file=path)
670
671	# Call back to post the new state
672	self.call_back(state)
673	return None
674
675	def _parse_state(self, entry):
676	"""
677	Read an invariant result from an XML node
678
679	: param entry: XML node to read from
680	: return: InvariantState object
681	"""
682	state = None
683	# Locate the invariant node
684	try:
685	nodes = entry.xpath('ns:%s' % INVNODE_NAME,
686	namespaces={'ns': CANSAS_NS})
687	# Create an empty state
688	if nodes != []:
689	state = InvariantState()
690	state.fromXML(node=nodes[0])
691	except Exception as exc:
692	msg = "XML document does not contain invariant"
693	msg += " information.\n %s" % exc
694	logger.info(msg)
695	return state
696
697	def _read_cansas(self, path):
698	"""
699	Load data and invariant information from a CanSAS XML file.
700
701	: param path: file path
702	: return: Data1D object if a single SASentry was found,
703	or a list of Data1D objects if multiple entries were found,
704	or None of nothing was found
705	: raise RuntimeError: when the file can't be opened
706	: raise ValueError: when the length of the data vectors are inconsistent
707	"""
708	output = []
709	if os.path.isfile(path):
710	basename = os.path.basename(path)
711	root, extension = os.path.splitext(basename)
712
713	if extension.lower() in self.ext or \
714	extension.lower() == '.xml':
715	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
716
717	# Check the format version number
718	# Specifying the namespace will take care of
719	# the file format version
720	root = tree.getroot()
721
722	entry_list = root.xpath('/ns:SASroot/ns:SASentry',
723	namespaces={'ns': CANSAS_NS})
724
725	for entry in entry_list:
726	invstate = self._parse_state(entry)
727	# invstate could be None when .svs file is loaded
728	# in this case, skip appending to output
729	if invstate is not None:
730	sas_entry, _ = self._parse_entry(entry)
731	sas_entry.meta_data['invstate'] = invstate
732	sas_entry.filename = invstate.file
733	output.append(sas_entry)
734	else:
735	raise RuntimeError("%s is not a file" % path)
736
737	# Return output consistent with the loader's api
738	if len(output) == 0:
739	return None
740	elif len(output) == 1:
741	# Call back to post the new state
742	self.state = output[0].meta_data['invstate']
743	self.call_back(state=output[0].meta_data['invstate'],
744	datainfo=output[0])
745	return output[0]
746	else:
747	return output
748
749	def get_state(self):
750	return self.state
751
752	def write(self, filename, datainfo=None, invstate=None):
753	"""
754	Write the content of a Data1D as a CanSAS XML file
755
756	: param filename: name of the file to write
757	: param datainfo: Data1D object
758	: param invstate: InvariantState object
759	"""
760	# Sanity check
761	if self.cansas:
762	doc = self.write_toXML(datainfo, invstate)
763	# Write the XML document
764	fd = open(filename, 'w')
765	fd.write(doc.toprettyxml())
766	fd.close()
767	else:
768	invstate.toXML(file=filename)
769
770	def write_toXML(self, datainfo=None, state=None):
771	"""
772	Write toXML, a helper for write()
773
774	: return: xml doc
775	"""
776	if datainfo is None:
777	datainfo = sas.sascalc.dataloader.data_info.Data1D(x=[], y=[])
778	elif not issubclass(datainfo.__class__, sas.sascalc.dataloader.data_info.Data1D):
779	msg = "The cansas writer expects a Data1D"
780	msg += " instance: %s" % str(datainfo.__class__.__name__)
781	raise RuntimeError(msg)
782	# make sure title and data run is filled up.
783	if datainfo.title is None or datainfo.title == '':
784	datainfo.title = datainfo.name
785	if datainfo.run_name is None or datainfo.run_name == {}:
786	datainfo.run = [str(datainfo.name)]
787	datainfo.run_name[0] = datainfo.name
788	# Create basic XML document
789	doc, sasentry = self._to_xml_doc(datainfo)
790	# Add the invariant information to the XML document
791	if state is not None:
792	doc = state.toXML(datainfo.name, doc=doc, entry_node=sasentry)
793	return doc

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

SasView

source: sasview/src/sas/sasgui/perspectives/invariant/invariant_state.py @ 82d88d5

Download in other formats: