inversion_state.py @ 01cda57

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since 01cda57 was 7432acb, checked in by andyfaff, 8 years ago
MAINT: search+replace '!= None' by 'is not None'
Property mode set to `100644`
File size: 18.3 KB

Line
1	"""
2	Handling of P(r) inversion states
3	"""
4	################################################################################
5	#This software was developed by the University of Tennessee as part of the
6	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
7	#project funded by the US National Science Foundation.
8	#
9	#See the license text in license.txt
10	#
11	#copyright 2009, University of Tennessee
12	################################################################################
13
14
15	import time
16	import os
17	import sys
18	import logging
19	from lxml import etree
20	from sas.sasgui.guiframe.dataFitting import Data1D
21	from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader
22	from sas.sascalc.dataloader.readers.cansas_reader import get_content
23
24	logger = logging.getLogger(__name__)
25
26	PRNODE_NAME = 'pr_inversion'
27	CANSAS_NS = "cansas1d/1.0"
28
29	# Translation of names between stored and object data
30	## List of P(r) inversion inputs
31	in_list = [["nterms", "nfunc"],
32	["d_max", "d_max"],
33	["alpha", "alpha"],
34	["slit_width", "width"],
35	["slit_height", "height"],
36	["qmin", "qmin"],
37	["qmax", "qmax"],
38	["estimate_bck", "estimate_bck"]]
39
40	## List of P(r) inversion outputs
41	out_list = [["elapsed", "elapsed"],
42	["rg", "rg"],
43	["iq0", "iq0"],
44	["bck", "bck"],
45	["chi2", "chi2"],
46	["osc", "osc"],
47	["pos", "pos"],
48	["pos_err", "pos_err"],
49	["alpha_estimate", "alpha_estimate"],
50	["nterms_estimate", "nterms_estimate"]]
51
52	class InversionState(object):
53	"""
54	Class to hold the state information of the InversionControl panel.
55	"""
56	def __init__(self):
57	"""
58	Default values
59	"""
60	# Input
61	self.file = None
62	self.estimate_bck = False
63	self.timestamp = time.time()
64
65	# Inversion parameters
66	self.nfunc = None
67	self.d_max = None
68	self.alpha = None
69
70	# Slit parameters
71	self.height = None
72	self.width = None
73
74	# Q range
75	self.qmin = None
76	self.qmax = None
77
78	# Outputs
79	self.elapsed = None
80	self.rg = None
81	self.iq0 = None
82	self.bck = None
83	self.chi2 = None
84	self.osc = None
85	self.pos = None
86	self.pos_err = None
87
88	# Estimates
89	self.alpha_estimate = None
90	self.nterms_estimate = None
91
92	# Data
93	self.q = None
94	self.iq_obs = None
95	self.iq_calc = None
96
97	# Coefficients
98	self.coefficients = None
99	self.covariance = None
100
101	def __str__(self):
102	"""
103	Pretty print
104
105	:return: string representing the state
106
107	"""
108	state = "File: %s\n" % self.file
109	state += "Timestamp: %s\n" % self.timestamp
110	state += "Estimate bck: %s\n" % str(self.estimate_bck)
111	state += "No. terms: %s\n" % str(self.nfunc)
112	state += "D_max: %s\n" % str(self.d_max)
113	state += "Alpha: %s\n" % str(self.alpha)
114
115	state += "Slit height: %s\n" % str(self.height)
116	state += "Slit width: %s\n" % str(self.width)
117
118	state += "Qmin: %s\n" % str(self.qmin)
119	state += "Qmax: %s\n" % str(self.qmax)
120
121	state += "\nEstimates:\n"
122	state += " Alpha: %s\n" % str(self.alpha_estimate)
123	state += " Nterms: %s\n" % str(self.nterms_estimate)
124
125	state += "\nOutputs:\n"
126	state += " Elapsed: %s\n" % str(self.elapsed)
127	state += " Rg: %s\n" % str(self.rg)
128	state += " I(q=0): %s\n" % str(self.iq0)
129	state += " Bck: %s\n" % str(self.bck)
130	state += " Chi^2: %s\n" % str(self.chi2)
131	state += " Oscillation:%s\n" % str(self.osc)
132	state += " Positive: %s\n" % str(self.pos)
133	state += " 1-sigma pos:%s\n" % str(self.pos_err)
134
135	return state
136
137	def toXML(self, file="pr_state.prv", doc=None, entry_node=None):
138	"""
139	Writes the state of the InversionControl panel to file, as XML.
140
141	Compatible with standalone writing, or appending to an
142	already existing XML document. In that case, the XML document
143	is required. An optional entry node in the XML document
144	may also be given.
145
146	:param file: file to write to
147	:param doc: XML document object [optional]
148	:param entry_node: XML node within the XML document at which
149	we will append the data [optional]
150
151	"""
152	#TODO: Get this to work
153	from xml.dom.minidom import getDOMImplementation
154
155	# Check whether we have to write a standalone XML file
156	if doc is None:
157	impl = getDOMImplementation()
158
159	doc_type = impl.createDocumentType(PRNODE_NAME, "1.0", "1.0")
160
161	newdoc = impl.createDocument(None, PRNODE_NAME, doc_type)
162	top_element = newdoc.documentElement
163	else:
164	# We are appending to an existing document
165	newdoc = doc
166	top_element = newdoc.createElement(PRNODE_NAME)
167	if entry_node is None:
168	newdoc.documentElement.appendChild(top_element)
169	else:
170	entry_node.appendChild(top_element)
171
172	attr = newdoc.createAttribute("version")
173	attr.nodeValue = '1.0'
174	top_element.setAttributeNode(attr)
175
176	# File name
177	element = newdoc.createElement("filename")
178	if self.file is not None:
179	element.appendChild(newdoc.createTextNode(str(self.file)))
180	else:
181	element.appendChild(newdoc.createTextNode(str(file)))
182	top_element.appendChild(element)
183
184	element = newdoc.createElement("timestamp")
185	element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp)))
186	attr = newdoc.createAttribute("epoch")
187	attr.nodeValue = str(self.timestamp)
188	element.setAttributeNode(attr)
189	top_element.appendChild(element)
190
191	# Inputs
192	inputs = newdoc.createElement("inputs")
193	top_element.appendChild(inputs)
194
195	for item in in_list:
196	element = newdoc.createElement(item[0])
197	element.appendChild(newdoc.createTextNode(str(getattr(self, item[1]))))
198	inputs.appendChild(element)
199
200	# Outputs
201	outputs = newdoc.createElement("outputs")
202	top_element.appendChild(outputs)
203
204	for item in out_list:
205	element = newdoc.createElement(item[0])
206	element.appendChild(newdoc.createTextNode(str(getattr(self, item[1]))))
207	outputs.appendChild(element)
208
209	# Save output coefficients and its covariance matrix
210	element = newdoc.createElement("coefficients")
211	element.appendChild(newdoc.createTextNode(str(self.coefficients)))
212	outputs.appendChild(element)
213	element = newdoc.createElement("covariance")
214	element.appendChild(newdoc.createTextNode(str(self.covariance)))
215	outputs.appendChild(element)
216
217	# Save the file
218	if doc is None:
219	fd = open(file, 'w')
220	fd.write(newdoc.toprettyxml())
221	fd.close()
222	return None
223	else:
224	return newdoc
225
226	def fromXML(self, file=None, node=None):
227	"""
228	Load a P(r) inversion state from a file
229
230	:param file: .prv file
231	:param node: node of a XML document to read from
232
233	"""
234	if file is not None:
235	msg = "InversionState no longer supports non-CanSAS"
236	msg += " format for P(r) files"
237	raise RuntimeError, msg
238
239	if node.get('version') and node.get('version') == '1.0':
240
241	# Get file name
242	entry = get_content('ns:filename', node)
243	if entry is not None:
244	self.file = entry.text.strip()
245
246	# Get time stamp
247	entry = get_content('ns:timestamp', node)
248	if entry is not None and entry.get('epoch'):
249	try:
250	self.timestamp = float(entry.get('epoch'))
251	except:
252	msg = "InversionState.fromXML: Could not read "
253	msg += "timestamp\n %s" % sys.exc_value
254	logger.error(msg)
255
256	# Parse inversion inputs
257	entry = get_content('ns:inputs', node)
258	if entry is not None:
259	for item in in_list:
260	input_field = get_content('ns:%s' % item[0], entry)
261	if input_field is not None:
262	try:
263	setattr(self, item[1], float(input_field.text.strip()))
264	except:
265	setattr(self, item[1], None)
266	input_field = get_content('ns:estimate_bck', entry)
267	if input_field is not None:
268	try:
269	self.estimate_bck = input_field.text.strip() == 'True'
270	except:
271	self.estimate_bck = False
272
273	# Parse inversion outputs
274	entry = get_content('ns:outputs', node)
275	if entry is not None:
276	# Output parameters (scalars)
277	for item in out_list:
278	input_field = get_content('ns:%s' % item[0], entry)
279	if input_field is not None:
280	try:
281	setattr(self, item[1], float(input_field.text.strip()))
282	except:
283	setattr(self, item[1], None)
284
285	# Look for coefficients
286	# Format is [value, value, value, value]
287	coeff = get_content('ns:coefficients', entry)
288	if coeff is not None:
289	# Remove brackets
290	c_values = coeff.text.strip().replace('[', '')
291	c_values = c_values.replace(']', '')
292	toks = c_values.split()
293	self.coefficients = []
294	for c in toks:
295	try:
296	self.coefficients.append(float(c))
297	except:
298	# Bad data, skip. We will count the number of
299	# coefficients at the very end and deal with
300	# inconsistencies then.
301	pass
302	# Sanity check
303	if not len(self.coefficients) == self.nfunc:
304	# Inconsistent number of coefficients.
305	# Don't keep the data.
306	err_msg = "InversionState.fromXML: inconsistant "
307	err_msg += "number of coefficients: "
308	err_msg += "%d %d" % (len(self.coefficients),
309	self.nfunc)
310	logger.error(err_msg)
311	self.coefficients = None
312
313	# Look for covariance matrix
314	# Format is [ [value, value], [value, value] ]
315	coeff = get_content('ns:covariance', entry)
316	if coeff is not None:
317	# Parse rows
318	rows = coeff.text.strip().split('[')
319	self.covariance = []
320	for row in rows:
321	row = row.strip()
322	if len(row) == 0: continue
323	# Remove end bracket
324	row = row.replace(']', '')
325	c_values = row.split()
326	cov_row = []
327	for c in c_values:
328	try:
329	cov_row.append(float(c))
330	except:
331	# Bad data, skip. We will count the number of
332	# coefficients at the very end and deal with
333	# inconsistencies then.
334	pass
335	# Sanity check: check the number of entries in the row
336	if len(cov_row) == self.nfunc:
337	self.covariance.append(cov_row)
338	# Sanity check: check the number of rows in the covariance
339	# matrix
340	if not len(self.covariance) == self.nfunc:
341	# Inconsistent dimensions of the covariance matrix.
342	# Don't keep the data.
343	err_msg = "InversionState.fromXML: "
344	err_msg += "inconsistant dimensions of the "
345	err_msg += " covariance matrix: "
346	err_msg += "%d %d" % (len(self.covariance), self.nfunc)
347	logger.error(err_msg)
348	self.covariance = None
349
350	class Reader(CansasReader):
351	"""
352	Class to load a .prv P(r) inversion file
353	"""
354	## File type
355	type_name = "P(r)"
356
357	## Wildcards
358	type = ["P(r) files (.prv)\|.prv",
359	"SASView files (.svs)\|.svs"]
360	## List of allowed extensions
361	ext = ['.prv', '.PRV', '.svs', '.SVS']
362
363	def __init__(self, call_back, cansas=True):
364	"""
365	Initialize the call-back method to be called
366	after we load a file
367
368	:param call_back: call-back method
369	:param cansas: True = files will be written/read in CanSAS format
370	False = write CanSAS format
371
372	"""
373	## Call back method to be executed after a file is read
374	self.call_back = call_back
375	## CanSAS format flag
376	self.cansas = cansas
377	self.state = None
378
379	def read(self, path):
380	"""
381	Load a new P(r) inversion state from file
382
383	:param path: file path
384
385	:return: None
386
387	"""
388	if self.cansas == True:
389	return self._read_cansas(path)
390	else:
391	return self._read_standalone(path)
392
393	def _read_standalone(self, path):
394	"""
395	Load a new P(r) inversion state from file.
396	The P(r) node is assumed to be the top element.
397
398	:param path: file path
399
400	:return: None
401
402	"""
403	# Read the new state from file
404	state = InversionState()
405	state.fromXML(file=path)
406
407	# Call back to post the new state
408	self.state = state
409	#self.call_back(state)
410	return None
411
412	def _parse_prstate(self, entry):
413	"""
414	Read a p(r) inversion result from an XML node
415
416	:param entry: XML node to read from
417
418	:return: InversionState object
419
420	"""
421	state = None
422
423	# Locate the P(r) node
424	try:
425	nodes = entry.xpath('ns:%s' % PRNODE_NAME,
426	namespaces={'ns': CANSAS_NS})
427	if nodes != []:
428	# Create an empty state
429	state = InversionState()
430	state.fromXML(node=nodes[0])
431	except:
432	msg = "XML document does not contain P(r) "
433	msg += "information.\n %s" % sys.exc_value
434	logger.info(msg)
435
436	return state
437
438	def _read_cansas(self, path):
439	"""
440	Load data and P(r) information from a CanSAS XML file.
441
442	:param path: file path
443
444	:return: Data1D object if a single SASentry was found,
445	or a list of Data1D objects if multiple entries were found,
446	or None of nothing was found
447
448	:raise RuntimeError: when the file can't be opened
449	:raise ValueError: when the length of the data vectors are inconsistent
450
451	"""
452	output = []
453
454	if os.path.isfile(path):
455	basename = os.path.basename(path)
456	root, extension = os.path.splitext(basename)
457	#TODO: eventually remove the check for .xml once
458	# the P(r) writer/reader is truly complete.
459	if extension.lower() in self.ext or extension.lower() == '.xml':
460
461	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
462	# Check the format version number
463	# Specifying the namespace will take care of the file
464	#format version
465	root = tree.getroot()
466
467	entry_list = root.xpath('/ns:SASroot/ns:SASentry',
468	namespaces={'ns': CANSAS_NS})
469
470	for entry in entry_list:
471	sas_entry, _ = self._parse_entry(entry)
472	prstate = self._parse_prstate(entry)
473	#prstate could be None when .svs file is loaded
474	#in this case, skip appending to output
475	if prstate is not None:
476	sas_entry.meta_data['prstate'] = prstate
477	sas_entry.filename = prstate.file
478	output.append(sas_entry)
479	else:
480	raise RuntimeError, "%s is not a file" % path
481
482	# Return output consistent with the loader's api
483	if len(output) == 0:
484	return None
485	elif len(output) == 1:
486	# Call back to post the new state
487	self.call_back(output[0].meta_data['prstate'], datainfo=output[0])
488	#self.state = output[0].meta_data['prstate']
489	return output[0]
490	else:
491	return output
492
493
494	def write(self, filename, datainfo=None, prstate=None):
495	"""
496	Write the content of a Data1D as a CanSAS XML file
497
498	:param filename: name of the file to write
499	:param datainfo: Data1D object
500	:param prstate: InversionState object
501
502	"""
503	# Sanity check
504	if self.cansas == True:
505	doc = self.write_toXML(datainfo, prstate)
506	# Write the XML document
507	fd = open(filename, 'w')
508	fd.write(doc.toprettyxml())
509	fd.close()
510	else:
511	prstate.toXML(file=filename)
512
513	def write_toXML(self, datainfo=None, state=None):
514	"""
515	Write toXML, a helper for write()
516
517	: return: xml doc
518	"""
519	if datainfo is None:
520	datainfo = Data1D(x=[], y=[])
521	elif not issubclass(datainfo.__class__, Data1D):
522	msg = "The cansas writer expects a Data1D "
523	msg += "instance: %s" % str(datainfo.__class__.__name__)
524	raise RuntimeError, msg
525
526	# Create basic XML document
527	doc, sasentry = self._to_xml_doc(datainfo)
528
529	# Add the invariant information to the XML document
530	if state is not None:
531	doc = state.toXML(doc=doc, entry_node=sasentry)
532
533	return doc

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

SasView

source: sasview/src/sas/sasgui/perspectives/pr/inversion_state.py @ 01cda57

Download in other formats: