pagestate.py @ 1dc134e6

ticket-1094-headless

Last change on this file since 1dc134e6 was 1dc134e6, checked in by Paul Kienzle <pkienzle@…>, 6 years ago
Merge branch 'master' into ticket-1094-headless
Property mode set to `100644`
File size: 60.6 KB

Line
1	"""
2	Class that holds a fit page state
3
4	Pagestate fields reflect the names of the gui controls from the sasview 3.x
5	fit page, so they are somewhat difficult to interpret.
6
7	Pagestate attributes are as follows:
8
9	# =>name: desc indicates the attribute is derived
10	# name(xml): desc indicates the attribute name differs from the xml tag
11
12	# SasView version which saved the file
13	version: (4, 1, 2) from <fitting_plug_in version="major.minor.point">
14
15	# Session information
16	group_id: unique id for fit page in running system (int)
17	=> data_group_id: unique id for data item in running system (None)
18
19	# Data file
20	data: contents of <SASdata> (Data1D or Data2D)
21	data_name: filename + [num] (latex_smeared.xml [1])
22	data_id: filename + [num] + timestamp (latex_smeared.xml [1]1523303027.73)
23	file: filename + [date time] (latex_smeared.xml [Apr 09 15:45])
24	name: ?? (None)
25	npts: number of points (float)
26	enable2D: True if data is 2D (or if model is 2D and no data)
27	is_data: True (pagestate will not save if there is no data attached)
28
29	# Data weighting
30	dI_didata: True if dy = data.dy
31	dI_idata: True if dy = data.y
32	dI_noweight: True if dy = 1
33	dI_sqrdata: True if dy = sqrt(data.y)
34
35	# Data selection
36	qmax: maximum q (float)
37	qmin: minimum q (float)
38	=> qmax_x: ?? (None)
39	=> qmin_x: ?? (None)
40
41	# Resolution smearing
42	enable_smearer: True if use data.dx
43	disable_smearer: True if no smearing
44	pinhole_smearer: True if custom pinhole smear
45	slit_smearer: True if custom slit smear
46	dq_l: 2D resolution <dQp>
47	dq_r: 2D resolution <dQs>
48	dx_old: True for 3.x version of custom pinhole, which used dx_min rather
49	than dx_percent, with dx_percent interpreted as 100 * dx_percent/q[0]
50	dx_percent: custom pinhole resolution percentage
51	dxl: slit height for custom slit resolution
52	dxw: slit width for custom slit resolution
53	smearer: repr() for active smearer (None on load)
54	smear_type: None (None on load)
55
56	# Model selection
57	categorycombobox: model category
58	formfactorcombobox: model name (could be "[plug-in] name")
59	structurecombobox: structure factor model name (string or None or "None")
60	multi_factor: multiplicity (integer or None)
61	magnetic_on: True if model is magnetic (only for 2D data for now)
62	=> model: active model object (None on load)
63
64	# Model parameters
65	# Parameter is a tuple with the following structure. The parentheses
66	# indicate xml attribute for the <parameter .../> tag:
67	# fitted(selected_to_fit): True if parameter is fitted
68	# name(name): display name for the parameter (string)
69	# value(value): displayed parameter value (string)
70	# => plusminus: '+/-' (constant string)
71	# => uncertainty: tuple
72	# (uncertainty_displayed): True if there is an uncertainty
73	# (uncertainty_value): displayed uncertainty (string)
74	# => lower: tuple
75	# (minimum_displayed): True if there is a lower bound
76	# (minimum_value): displayed lower bound (string)
77	# => upper: tuple
78	# (maximum_displayed): True if there is a upper bound
79	# (maximum_value): displayed upper bound (string)
80	# units(unit): displayed units
81	parameters: list of normal parameters
82	fixed_param: list of non-fitting parameters (nsigma, npts in dispersity)
83	fittable_param: list of fittable dispersity parameters (distribution width)
84	str_parameters: list of selection parameters (e.g, shell forms in spherical_sld)
85	orientation_params(orientation_parameters): list of orientation and
86	magnetic parameters (already included in parameters, so safe to ignore)
87	orientation_params_disp(dispersity_parameters): list of orientation
88	disperisty parameters (already included in fixed_param and
89	fittable_param so safe to ignore)
90
91	# Dispersity controls
92	enable_disp: True if dispersity parameters
93	disable_disp: True if no dispersity parameters
94	disp_obj_dict(disp_obj): {'parameter.width': 'dispersity distribution'}
95	values: {'parameter.width': [array distribution parameter values] }
96	weights: {'parameter.width': [array distribution parameter weights] }
97	=> disp_box 0
98	=> disp_cb_dict {}
99	=> disp_list []
100
101	# Simultaneous fitting
102
103	=> images: None (initialized but unused?)
104	=> reset: False (initialized but unused?)
105	=> event_owner None
106	=> m_name None
107	=> manager None
108	=> page_name
109	=> param_toFit: []
110	=> process: list of process done on object [] (maybe managed by guiframe?)
111	=> saved_states {}
112	=> cb1: False (simfit cb1 is now stored in select_all)
113
114	tcChi 1.3463
115	theory_data None
116	timestamp 1523303103.74
117
118	Constraint attributes are as follows:
119
120	constraint_dict {}
121	constraints_list
122	{'model_cbox': 'M2', 'param_cbox': 'scale', 'egal_txt': ' = ', 'constraint': 'M1.scale'}
123	{'model_cbox': 'M2', 'param_cbox': 'radius', 'egal_txt': ' = ', 'constraint': 'M1.radius'}
124	{'model_cbox': 'M2', 'param_cbox': 'radius.width', 'egal_txt': ' = ', 'constraint': 'M1.radius.width'}
125	fit_page_no None
126	model_list
127	{'fit_number': '393', 'checked': 'True', 'fit_page_source': 'M2', 'name': 'latex_smeared.xml [1]1523535051.03', 'model_name': 'sphere'}
128	{'fit_number': '335', 'checked': 'True', 'fit_page_source': 'M1', 'name': 'latex_smeared.xml 1523535050.03', 'model_name': 'sphere'}
129	model_to_fit
130	no_constraint 0
131	select_all True
132
133
134	"""
135	# TODO: Refactor code so we don't need to use getattr/setattr
136	################################################################################
137	# This software was developed by the University of Tennessee as part of the
138	# Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
139	# project funded by the US National Science Foundation.
140	#
141	# See the license text in license.txt
142	#
143	# copyright 2009, University of Tennessee
144	################################################################################
145	import time
146	import re
147	import os
148	import sys
149	import copy
150	import logging
151	import numpy as np
152	import traceback
153
154	import xml.dom.minidom
155	from xml.dom.minidom import parseString
156	from xml.dom.minidom import getDOMImplementation
157	from lxml import etree
158
159	from sasmodels import convert
160	import sasmodels.weights
161
162	from sas.sasview import __version__ as SASVIEW_VERSION
163
164	import sas.sascalc.dataloader
165	from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader
166	from sas.sascalc.dataloader.readers.cansas_reader import get_content, write_node
167	from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector
168	from sas.sascalc.dataloader.data_info import Process, Aperture
169
170	logger = logging.getLogger(__name__)
171
172	# Information to read/write state as xml
173	FITTING_NODE_NAME = 'fitting_plug_in'
174	CANSAS_NS = {"ns": "cansas1d/1.0"}
175
176	CUSTOM_MODEL = 'Plugin Models'
177	CUSTOM_MODEL_OLD = 'Customized Models'
178
179	LIST_OF_DATA_ATTRIBUTES = [["is_data", "is_data", "bool"],
180	["group_id", "data_group_id", "string"],
181	["data_name", "data_name", "string"],
182	["data_id", "data_id", "string"],
183	["name", "name", "string"],
184	["data_name", "data_name", "string"]]
185	LIST_OF_STATE_ATTRIBUTES = [["qmin", "qmin", "float"],
186	["qmax", "qmax", "float"],
187	["npts", "npts", "float"],
188	["categorycombobox", "categorycombobox", "string"],
189	["formfactorcombobox", "formfactorcombobox",
190	"string"],
191	["structurecombobox", "structurecombobox",
192	"string"],
193	["multi_factor", "multi_factor", "float"],
194	["magnetic_on", "magnetic_on", "bool"],
195	["enable_smearer", "enable_smearer", "bool"],
196	["disable_smearer", "disable_smearer", "bool"],
197	["pinhole_smearer", "pinhole_smearer", "bool"],
198	["slit_smearer", "slit_smearer", "bool"],
199	["enable_disp", "enable_disp", "bool"],
200	["disable_disp", "disable_disp", "bool"],
201	["dI_noweight", "dI_noweight", "bool"],
202	["dI_didata", "dI_didata", "bool"],
203	["dI_sqrdata", "dI_sqrdata", "bool"],
204	["dI_idata", "dI_idata", "bool"],
205	["enable2D", "enable2D", "bool"],
206	["cb1", "cb1", "bool"],
207	["tcChi", "tcChi", "float"],
208	["dq_l", "dq_l", "float"],
209	["dq_r", "dq_r", "float"],
210	["dx_percent", "dx_percent", "float"],
211	["dxl", "dxl", "float"],
212	["dxw", "dxw", "float"]]
213
214	LIST_OF_MODEL_ATTRIBUTES = [["values", "values"],
215	["weights", "weights"]]
216
217	DISPERSION_LIST = [["disp_obj_dict", "disp_obj_dict", "string"]]
218
219	LIST_OF_STATE_PARAMETERS = [["parameters", "parameters"],
220	["str_parameters", "str_parameters"],
221	["orientation_parameters", "orientation_params"],
222	["dispersity_parameters",
223	"orientation_params_disp"],
224	["fixed_param", "fixed_param"],
225	["fittable_param", "fittable_param"]]
226	LIST_OF_DATA_2D_ATTR = [["xmin", "xmin", "float"],
227	["xmax", "xmax", "float"],
228	["ymin", "ymin", "float"],
229	["ymax", "ymax", "float"],
230	["_xaxis", "_xaxis", "string"],
231	["_xunit", "_xunit", "string"],
232	["_yaxis", "_yaxis", "string"],
233	["_yunit", "_yunit", "string"],
234	["_zaxis", "_zaxis", "string"],
235	["_zunit", "_zunit", "string"]]
236	LIST_OF_DATA_2D_VALUES = [["qx_data", "qx_data", "float"],
237	["qy_data", "qy_data", "float"],
238	["dqx_data", "dqx_data", "float"],
239	["dqy_data", "dqy_data", "float"],
240	["data", "data", "float"],
241	["q_data", "q_data", "float"],
242	["err_data", "err_data", "float"],
243	["mask", "mask", "bool"]]
244
245
246	def parse_entry_helper(node, item):
247	"""
248	Create a numpy list from value extrated from the node
249
250	:param node: node from each the value is stored
251	:param item: list name of three strings.the two first are name of data
252	attribute and the third one is the type of the value of that
253	attribute. type can be string, float, bool, etc.
254
255	: return: numpy array
256	"""
257	if node is not None:
258	if item[2] == "string":
259	return str(node.get(item[0]).strip())
260	elif item[2] == "bool":
261	try:
262	return node.get(item[0]).strip() == "True"
263	except Exception:
264	return None
265	else:
266	try:
267	return float(node.get(item[0]))
268	except Exception:
269	return None
270
271
272	class PageState(object):
273	"""
274	Contains information to reconstruct a page of the fitpanel.
275	"""
276	def __init__(self, model=None, data=None):
277	"""
278	Initialize the current state
279
280	:param model: a selected model within a page
281	:param data:
282
283	"""
284	self.file = None
285	# Time of state creation
286	self.timestamp = time.time()
287	# Data member to store the dispersion object created
288	self.disp_obj_dict = {}
289	# ------------------------
290	# Data used for fitting
291	self.data = data
292	# model data
293	self.theory_data = None
294	# Is 2D
295	self.images = None
296
297	# save additional information on data that dataloader.reader
298	# does not read
299	self.is_data = None
300	self.data_name = ""
301
302	if self.data is not None:
303	self.data_name = self.data.name
304	self.data_id = None
305	if self.data is not None and hasattr(self.data, "id"):
306	self.data_id = self.data.id
307	self.data_group_id = None
308	if self.data is not None and hasattr(self.data, "group_id"):
309	self.data_group_id = self.data.group_id
310
311	# reset True change the state of existing button
312	self.reset = False
313
314	# flag to allow data2D plot
315	self.enable2D = False
316	# model on which the fit would be performed
317	self.model = model
318	self.m_name = None
319	# list of process done to model
320	self.process = []
321	# fit page manager
322	self.manager = None
323	# Event_owner is the owner of model event
324	self.event_owner = None
325	# page name
326	self.page_name = ""
327	# Contains link between model, its parameters, and panel organization
328	self.parameters = []
329	# String parameter list that can not be fitted
330	self.str_parameters = []
331	# Contains list of parameters that cannot be fitted and reference to
332	# panel objects
333	self.fixed_param = []
334	# Contains list of parameters with dispersity and reference to
335	# panel objects
336	self.fittable_param = []
337	# orientation parameters
338	self.orientation_params = []
339	# orientation parameters for gaussian dispersity
340	self.orientation_params_disp = []
341	self.dq_l = None
342	self.dq_r = None
343	self.dx_percent = None
344	self.dx_old = False
345	self.dxl = None
346	self.dxw = None
347	# list of dispersion parameters
348	self.disp_list = []
349	if self.model is not None:
350	self.disp_list = self.model.getDispParamList()
351
352	self.disp_cb_dict = {}
353	self.values = {}
354	self.weights = {}
355
356	# contains link between a model and selected parameters to fit
357	self.param_toFit = []
358	# save the state of the context menu
359	self.saved_states = {}
360	# save selection of combobox
361	self.formfactorcombobox = None
362	self.categorycombobox = None
363	self.structurecombobox = None
364
365	# radio box to select type of model
366	# self.shape_rbutton = False
367	# self.shape_indep_rbutton = False
368	# self.struct_rbutton = False
369	# self.plugin_rbutton = False
370	# the indice of the current selection
371	self.disp_box = 0
372	# Qrange
373	# Q range
374	self.qmin = 0.001
375	self.qmax = 0.1
376	# reset data range
377	self.qmax_x = None
378	self.qmin_x = None
379
380	self.npts = None
381	self.name = ""
382	self.multi_factor = None
383	self.magnetic_on = False
384	# enable smearering state
385	self.enable_smearer = False
386	self.disable_smearer = True
387	self.pinhole_smearer = False
388	self.slit_smearer = False
389	# weighting options
390	self.dI_noweight = False
391	self.dI_didata = True
392	self.dI_sqrdata = False
393	self.dI_idata = False
394	# disperity selection
395	self.enable_disp = False
396	self.disable_disp = True
397
398	# state of selected all check button
399	self.cb1 = False
400	# store value of chisqr
401	self.tcChi = None
402	self.version = (1, 0, 0)
403
404	def clone(self):
405	"""
406	Create a new copy of the current object
407	"""
408	model = None
409	if self.model is not None:
410	model = self.model.clone()
411	model.name = self.model.name
412	obj = PageState(model=model)
413	obj.file = copy.deepcopy(self.file)
414	obj.data = copy.deepcopy(self.data)
415	if self.data is not None:
416	self.data_name = self.data.name
417	obj.data_name = self.data_name
418	obj.is_data = self.is_data
419
420	obj.categorycombobox = self.categorycombobox
421	obj.formfactorcombobox = self.formfactorcombobox
422	obj.structurecombobox = self.structurecombobox
423
424	# obj.shape_rbutton = self.shape_rbutton
425	# obj.shape_indep_rbutton = self.shape_indep_rbutton
426	# obj.struct_rbutton = self.struct_rbutton
427	# obj.plugin_rbutton = self.plugin_rbutton
428
429	obj.manager = self.manager
430	obj.event_owner = self.event_owner
431	obj.disp_list = copy.deepcopy(self.disp_list)
432
433	obj.enable2D = copy.deepcopy(self.enable2D)
434	obj.parameters = copy.deepcopy(self.parameters)
435	obj.str_parameters = copy.deepcopy(self.str_parameters)
436	obj.fixed_param = copy.deepcopy(self.fixed_param)
437	obj.fittable_param = copy.deepcopy(self.fittable_param)
438	obj.orientation_params = copy.deepcopy(self.orientation_params)
439	obj.orientation_params_disp = \
440	copy.deepcopy(self.orientation_params_disp)
441	obj.enable_disp = copy.deepcopy(self.enable_disp)
442	obj.disable_disp = copy.deepcopy(self.disable_disp)
443	obj.tcChi = self.tcChi
444
445	if len(self.disp_obj_dict) > 0:
446	for k, v in self.disp_obj_dict.items():
447	obj.disp_obj_dict[k] = v
448	if len(self.disp_cb_dict) > 0:
449	for k, v in self.disp_cb_dict.items():
450	obj.disp_cb_dict[k] = v
451	if len(self.values) > 0:
452	for k, v in self.values.items():
453	obj.values[k] = v
454	if len(self.weights) > 0:
455	for k, v in self.weights.items():
456	obj.weights[k] = v
457	obj.enable_smearer = copy.deepcopy(self.enable_smearer)
458	obj.disable_smearer = copy.deepcopy(self.disable_smearer)
459	obj.pinhole_smearer = copy.deepcopy(self.pinhole_smearer)
460	obj.slit_smearer = copy.deepcopy(self.slit_smearer)
461	obj.dI_noweight = copy.deepcopy(self.dI_noweight)
462	obj.dI_didata = copy.deepcopy(self.dI_didata)
463	obj.dI_sqrdata = copy.deepcopy(self.dI_sqrdata)
464	obj.dI_idata = copy.deepcopy(self.dI_idata)
465	obj.dq_l = copy.deepcopy(self.dq_l)
466	obj.dq_r = copy.deepcopy(self.dq_r)
467	obj.dx_percent = copy.deepcopy(self.dx_percent)
468	obj.dx_old = copy.deepcopy(self.dx_old)
469	obj.dxl = copy.deepcopy(self.dxl)
470	obj.dxw = copy.deepcopy(self.dxw)
471	obj.disp_box = copy.deepcopy(self.disp_box)
472	obj.qmin = copy.deepcopy(self.qmin)
473	obj.qmax = copy.deepcopy(self.qmax)
474	obj.multi_factor = self.multi_factor
475	obj.magnetic_on = self.magnetic_on
476	obj.npts = copy.deepcopy(self.npts)
477	obj.cb1 = copy.deepcopy(self.cb1)
478	obj.version = copy.deepcopy(self.version)
479
480	for name, state in self.saved_states.items():
481	copy_name = copy.deepcopy(name)
482	copy_state = state.clone()
483	obj.saved_states[copy_name] = copy_state
484	return obj
485
486	def _old_first_model(self):
487	"""
488	Handle save states from 4.0.1 and before where the first item in the
489	selection boxes of category, formfactor and structurefactor were not
490	saved.
491	:return: None
492	"""
493	if self.categorycombobox == CUSTOM_MODEL_OLD:
494	self.categorycombobox = CUSTOM_MODEL
495	if self.formfactorcombobox == '':
496	FIRST_FORM = {
497	'Shapes' : 'BCCrystalModel',
498	'Uncategorized' : 'LineModel',
499	'StructureFactor' : 'HardsphereStructure',
500	'Ellipsoid' : 'core_shell_ellipsoid',
501	'Lamellae' : 'lamellar',
502	'Paracrystal' : 'bcc_paracrystal',
503	'Parallelepiped' : 'core_shell_parallelepiped',
504	'Shape Independent' : 'be_polyelectrolyte',
505	'Sphere' : 'adsorbed_layer',
506	'Structure Factor' : 'hardsphere',
507	CUSTOM_MODEL : ''
508	}
509	if self.categorycombobox == '':
510	if len(self.parameters) == 3:
511	self.categorycombobox = "Shape-Independent"
512	self.formfactorcombobox = 'PowerLawAbsModel'
513	elif len(self.parameters) == 9:
514	self.categorycombobox = 'Cylinder'
515	self.formfactorcombobox = 'barbell'
516	else:
517	msg = "Save state does not have enough information to load"
518	msg += " the all of the data."
519	logger.warning(msg=msg)
520	else:
521	self.formfactorcombobox = FIRST_FORM[self.categorycombobox]
522
523	@staticmethod
524	def param_remap_to_sasmodels_convert(params, is_string=False):
525	"""
526	Remaps the parameters for sasmodels conversion
527
528	:param params: list of parameters (likely self.parameters)
529	:return: remapped dictionary of parameters
530	"""
531	p = dict()
532	for fittable, name, value, _, uncert, lower, upper, units in params:
533	if not value:
534	value = np.nan
535	if not uncert or uncert[1] == '' or uncert[1] == 'None':
536	uncert[0] = False
537	uncert[1] = np.nan
538	if not upper or upper[1] == '' or upper[1] == 'None':
539	upper[0] = False
540	upper[1] = np.nan
541	if not lower or lower[1] == '' or lower[1] == 'None':
542	lower[0] = False
543	lower[1] = np.nan
544	if is_string:
545	p[name] = str(value)
546	else:
547	p[name] = float(value)
548	p[name + ".fittable"] = bool(fittable)
549	p[name + ".std"] = float(uncert[1])
550	p[name + ".upper"] = float(upper[1])
551	p[name + ".lower"] = float(lower[1])
552	p[name + ".units"] = units
553	return p
554
555	@staticmethod
556	def param_remap_from_sasmodels_convert(params):
557	"""
558	Converts {name : value} map back to [] param list
559	:param params: parameter map returned from sasmodels
560	:return: None
561	"""
562	p_map = []
563	for name, info in params.items():
564	if ".fittable" in name or ".std" in name or ".upper" in name or \
565	".lower" in name or ".units" in name:
566	pass
567	else:
568	fittable = params.get(name + ".fittable", True)
569	std = params.get(name + ".std", '0.0')
570	upper = params.get(name + ".upper", 'inf')
571	lower = params.get(name + ".lower", '-inf')
572	units = params.get(name + ".units")
573	if std is not None and std is not np.nan:
574	std = [True, str(std)]
575	else:
576	std = [False, '']
577	if lower is not None and lower is not np.nan:
578	lower = [True, str(lower)]
579	else:
580	lower = [True, '-inf']
581	if upper is not None and upper is not np.nan:
582	upper = [True, str(upper)]
583	else:
584	upper = [True, 'inf']
585	param_list = [bool(fittable), str(name), str(info),
586	"+/-", std, lower, upper, str(units)]
587	p_map.append(param_list)
588	return p_map
589
590	def _convert_to_sasmodels(self):
591	"""
592	Convert parameters to a form usable by sasmodels converter
593
594	:return: None
595	"""
596	# Create conversion dictionary to send to sasmodels
597	self._old_first_model()
598	p = self.param_remap_to_sasmodels_convert(self.parameters)
599	structurefactor, params = convert.convert_model(self.structurecombobox,
600	p, False, self.version)
601	formfactor, params = convert.convert_model(self.formfactorcombobox,
602	params, False, self.version)
603	if len(self.str_parameters) > 0:
604	str_pars = self.param_remap_to_sasmodels_convert(
605	self.str_parameters, True)
606	formfactor, str_params = convert.convert_model(
607	self.formfactorcombobox, str_pars, False, self.version)
608	for key, value in str_params.items():
609	params[key] = value
610
611	if self.formfactorcombobox == 'SphericalSLDModel':
612	self.multi_factor += 1
613	self.formfactorcombobox = formfactor
614	self.structurecombobox = structurefactor
615	self.parameters = []
616	self.parameters = self.param_remap_from_sasmodels_convert(params)
617
618	def _repr_helper(self, list, rep):
619	"""
620	Helper method to print a state
621	"""
622	for item in list:
623	rep += "parameter name: %s \n" % str(item[1])
624	rep += "value: %s\n" % str(item[2])
625	rep += "selected: %s\n" % str(item[0])
626	rep += "error displayed : %s \n" % str(item[4][0])
627	rep += "error value:%s \n" % str(item[4][1])
628	rep += "minimum displayed : %s \n" % str(item[5][0])
629	rep += "minimum value : %s \n" % str(item[5][1])
630	rep += "maximum displayed : %s \n" % str(item[6][0])
631	rep += "maximum value : %s \n" % str(item[6][1])
632	rep += "parameter unit: %s\n\n" % str(item[7])
633	return rep
634
635	def __repr__(self):
636	"""
637	output string for printing
638	"""
639	rep = "\nState name: %s\n" % self.file
640	t = time.localtime(self.timestamp)
641	time_str = time.strftime("%b %d %Y %H:%M:%S ", t)
642
643	rep += "State created: %s\n" % time_str
644	rep += "State form factor combobox selection: %s\n" % \
645	self.formfactorcombobox
646	rep += "State structure factor combobox selection: %s\n" % \
647	self.structurecombobox
648	rep += "is data : %s\n" % self.is_data
649	rep += "data's name : %s\n" % self.data_name
650	rep += "data's id : %s\n" % self.data_id
651	if self.model is not None:
652	m_name = self.model.__class__.__name__
653	if m_name == 'Model':
654	m_name = self.m_name
655	rep += "model name : %s\n" % m_name
656	else:
657	rep += "model name : None\n"
658	rep += "multi_factor : %s\n" % str(self.multi_factor)
659	rep += "magnetic_on : %s\n" % str(self.magnetic_on)
660	rep += "model type (Category) selected: %s\n" % self.categorycombobox
661	rep += "data : %s\n" % str(self.data)
662	rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % \
663	(str(self.qmin), str(self.qmax), str(self.npts))
664	rep += "Dispersion selection : %s\n" % str(self.disp_box)
665	rep += "Smearing enable : %s\n" % str(self.enable_smearer)
666	rep += "Smearing disable : %s\n" % str(self.disable_smearer)
667	rep += "Pinhole smearer enable : %s\n" % str(self.pinhole_smearer)
668	rep += "Slit smearer enable : %s\n" % str(self.slit_smearer)
669	rep += "Dispersity enable : %s\n" % str(self.enable_disp)
670	rep += "Dispersity disable : %s\n" % str(self.disable_disp)
671	rep += "Slit smearer enable: %s\n" % str(self.slit_smearer)
672
673	rep += "dI_noweight : %s\n" % str(self.dI_noweight)
674	rep += "dI_didata : %s\n" % str(self.dI_didata)
675	rep += "dI_sqrdata : %s\n" % str(self.dI_sqrdata)
676	rep += "dI_idata : %s\n" % str(self.dI_idata)
677
678	rep += "2D enable : %s\n" % str(self.enable2D)
679	rep += "All parameters checkbox selected: %s\n" % self.cb1
680	rep += "Value of Chisqr : %s\n" % str(self.tcChi)
681	rep += "dq_l : %s\n" % self.dq_l
682	rep += "dq_r : %s\n" % self.dq_r
683	rep += "dx_percent : %s\n" % str(self.dx_percent)
684	rep += "dxl : %s\n" % str(self.dxl)
685	rep += "dxw : %s\n" % str(self.dxw)
686	rep += "model : %s\n\n" % str(self.model)
687	temp_parameters = []
688	temp_fittable_param = []
689	if self.data is not None:
690	is_2D = (self.data.__class__.__name__ == "Data2D")
691	if not is_2D:
692	for item in self.parameters:
693	if item not in self.orientation_params:
694	temp_parameters.append(item)
695	for item in self.fittable_param:
696	if item not in self.orientation_params_disp:
697	temp_fittable_param.append(item)
698	else:
699	temp_parameters = self.parameters
700	temp_fittable_param = self.fittable_param
701
702	rep += "number parameters(self.parameters): %s\n" % \
703	len(temp_parameters)
704	rep = self._repr_helper(list=temp_parameters, rep=rep)
705	rep += "number str_parameters(self.str_parameters): %s\n" % \
706	len(self.str_parameters)
707	rep = self._repr_helper(list=self.str_parameters, rep=rep)
708	rep += "number fittable_param(self.fittable_param): %s\n" % \
709	len(temp_fittable_param)
710	rep = self._repr_helper(list=temp_fittable_param, rep=rep)
711	return rep
712
713	def _get_report_string(self):
714	"""
715	Get the values (strings) from __str__ for report
716	"""
717	# Dictionary of the report strings
718	repo_time = ""
719	model_name = ""
720	title = ""
721	title_name = ""
722	file_name = ""
723	param_string = ""
724	paramval_string = ""
725	chi2_string = ""
726	q_range = ""
727	strings = self.__repr__()
728	fixed_parameter = False
729	lines = strings.split('\n')
730	# get all string values from __str__()
731	for line in lines:
732	# Skip lines which are not key: value pairs, which includes
733	# blank lines and freeform notes in SASNotes fields.
734	if not ':' in line:
735	#msg = "Report string expected 'name: value' but got %r" % line
736	#logger.error(msg)
737	continue
738
739	name, value = [s.strip() for s in line.split(":", 1)]
740	if name == "State created":
741	repo_time = value
742	elif name == "parameter name":
743	val_name = value.split(".")
744	if len(val_name) > 1:
745	if val_name[1].count("width"):
746	param_string += value + ','
747	else:
748	continue
749	else:
750	param_string += value + ','
751	elif name == "value":
752	param_string += value + ','
753	elif name == "selected":
754	# remember if it is fixed when reporting error value
755	fixed_parameter = (value == u'False')
756	elif name == "error value":
757	if fixed_parameter:
758	param_string += '(fixed),'
759	else:
760	param_string += value + ','
761	elif name == "parameter unit":
762	param_string += value + ':'
763	elif name == "Value of Chisqr":
764	chi2 = ("Chi2/Npts = " + value)
765	chi2_string = CENTRE % chi2
766	elif name == "Title":
767	if len(value.strip()) == 0:
768	continue
769	title = (value + " [" + repo_time + "] [SasView v" +
770	SASVIEW_VERSION + "]")
771	title_name = HEADER % title
772	elif name == "data":
773	try:
774	# parsing "data : File: filename [mmm dd hh:mm]"
775	name = value.split(':', 1)[1].strip()
776	file_value = "File name:" + name
777	#Truncating string so print doesn't complain of being outside margins
778	if sys.platform != "win32":
779	MAX_STRING_LENGHT = 50
780	if len(file_value) > MAX_STRING_LENGHT:
781	file_value = "File name:.."+file_value[-MAX_STRING_LENGHT+10:]
782	file_name = CENTRE % file_value
783	if len(title) == 0:
784	title = name + " [" + repo_time + "]"
785	title_name = HEADER % title
786	except Exception:
787	msg = "While parsing 'data: ...'\n"
788	logger.error(msg + traceback.format_exc())
789	elif name == "model name":
790	try:
791	modelname = "Model name:" + value
792	except Exception:
793	modelname = "Model name:" + " NAN"
794	model_name = CENTRE % modelname
795
796	elif name == "Plotting Range":
797	try:
798	parts = value.split(':')
799	q_range = parts[0] + " = " + parts[1] \
800	+ " = " + parts[2].split(",")[0]
801	q_name = ("Q Range: " + q_range)
802	q_range = CENTRE % q_name
803	except Exception:
804	msg = "While parsing 'Plotting Range: ...'\n"
805	logger.error(msg + traceback.format_exc())
806
807	paramval = ""
808	for lines in param_string.split(":"):
809	line = lines.split(",")
810	if len(lines) > 0:
811	param = line[0]
812	param += " = " + line[1]
813	if len(line[2].split()) > 0 and not line[2].count("None"):
814	param += " +- " + line[2]
815	if len(line[3].split()) > 0 and not line[3].count("None"):
816	param += " " + line[3]
817	if not paramval.count(param):
818	paramval += param + "\n"
819	paramval_string += CENTRE % param + "\n"
820
821	text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % \
822	(title, file, q_name, chi2, paramval)
823
824	title_name = self._check_html_format(title_name)
825	file_name = self._check_html_format(file_name)
826	title = self._check_html_format(title)
827
828	html_string = title_name + "\n" + file_name + \
829	"\n" + model_name + \
830	"\n" + q_range + \
831	"\n" + chi2_string + \
832	"\n" + ELINE + \
833	"\n" + paramval_string + \
834	"\n" + ELINE + \
835	"\n" + FEET_1 % title
836
837	return html_string, text_string, title
838
839	def _check_html_format(self, name):
840	"""
841	Check string '%' for html format
842	"""
843	if name.count('%'):
844	name = name.replace('%', '&#37')
845
846	return name
847
848	def report(self, fig_urls):
849	"""
850	Invoke report dialog panel
851
852	: param figs: list of pylab figures [list]
853	"""
854	# get the strings for report
855	html_str, text_str, title = self._get_report_string()
856	# Allow 2 figures to append
857	#Constraining image width for OSX and linux, so print doesn't complain of being outside margins
858	if sys.platform == "win32":
859	image_links = [FEET_2%fig for fig in fig_urls]
860	else:
861	image_links = [FEET_2_unix%fig for fig in fig_urls]
862	# final report html strings
863	report_str = html_str + ELINE.join(image_links)
864	report_str += FEET_3
865	return report_str, text_str
866
867	def _to_xml_helper(self, thelist, element, newdoc):
868	"""
869	Helper method to create xml file for saving state
870	"""
871	for item in thelist:
872	sub_element = newdoc.createElement('parameter')
873	sub_element.setAttribute('name', str(item[1]))
874	sub_element.setAttribute('value', str(item[2]))
875	sub_element.setAttribute('selected_to_fit', str(item[0]))
876	sub_element.setAttribute('error_displayed', str(item[4][0]))
877	sub_element.setAttribute('error_value', str(item[4][1]))
878	sub_element.setAttribute('minimum_displayed', str(item[5][0]))
879	sub_element.setAttribute('minimum_value', str(item[5][1]))
880	sub_element.setAttribute('maximum_displayed', str(item[6][0]))
881	sub_element.setAttribute('maximum_value', str(item[6][1]))
882	sub_element.setAttribute('unit', str(item[7]))
883	element.appendChild(sub_element)
884
885	def to_xml(self, file="fitting_state.fitv", doc=None,
886	entry_node=None, batch_fit_state=None):
887	"""
888	Writes the state of the fit panel to file, as XML.
889
890	Compatible with standalone writing, or appending to an
891	already existing XML document. In that case, the XML document is
892	required. An optional entry node in the XML document may also be given.
893
894	:param file: file to write to
895	:param doc: XML document object [optional]
896	:param entry_node: XML node within the XML document at which we
897	will append the data [optional]
898	:param batch_fit_state: simultaneous fit state
899	"""
900	# Check whether we have to write a standalone XML file
901	if doc is None:
902	impl = getDOMImplementation()
903	doc_type = impl.createDocumentType(FITTING_NODE_NAME, "1.0", "1.0")
904	newdoc = impl.createDocument(None, FITTING_NODE_NAME, doc_type)
905	top_element = newdoc.documentElement
906	else:
907	# We are appending to an existing document
908	newdoc = doc
909	try:
910	top_element = newdoc.createElement(FITTING_NODE_NAME)
911	except Exception:
912	string = etree.tostring(doc, pretty_print=True)
913	newdoc = parseString(string)
914	top_element = newdoc.createElement(FITTING_NODE_NAME)
915	if entry_node is None:
916	newdoc.documentElement.appendChild(top_element)
917	else:
918	try:
919	entry_node.appendChild(top_element)
920	except Exception:
921	node_name = entry_node.tag
922	node_list = newdoc.getElementsByTagName(node_name)
923	entry_node = node_list.item(0)
924	entry_node.appendChild(top_element)
925
926	attr = newdoc.createAttribute("version")
927	attr.nodeValue = SASVIEW_VERSION
928	# attr.nodeValue = '1.0'
929	top_element.setAttributeNode(attr)
930
931	# File name
932	element = newdoc.createElement("filename")
933	if self.file is not None:
934	element.appendChild(newdoc.createTextNode(str(self.file)))
935	else:
936	element.appendChild(newdoc.createTextNode(str(file)))
937	top_element.appendChild(element)
938
939	element = newdoc.createElement("timestamp")
940	element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp)))
941	attr = newdoc.createAttribute("epoch")
942	attr.nodeValue = str(self.timestamp)
943	element.setAttributeNode(attr)
944	top_element.appendChild(element)
945
946	# Inputs
947	inputs = newdoc.createElement("Attributes")
948	top_element.appendChild(inputs)
949
950	if self.data is not None and hasattr(self.data, "group_id"):
951	self.data_group_id = self.data.group_id
952	if self.data is not None and hasattr(self.data, "is_data"):
953	self.is_data = self.data.is_data
954	if self.data is not None:
955	self.data_name = self.data.name
956	if self.data is not None and hasattr(self.data, "id"):
957	self.data_id = self.data.id
958
959	for item in LIST_OF_DATA_ATTRIBUTES:
960	element = newdoc.createElement(item[0])
961	element.setAttribute(item[0], str(getattr(self, item[1])))
962	inputs.appendChild(element)
963
964	for item in LIST_OF_STATE_ATTRIBUTES:
965	element = newdoc.createElement(item[0])
966	element.setAttribute(item[0], str(getattr(self, item[1])))
967	inputs.appendChild(element)
968
969	# For self.values ={ disp_param_name: [vals,...],...}
970	# and for self.weights ={ disp_param_name: [weights,...],...}
971	for item in LIST_OF_MODEL_ATTRIBUTES:
972	element = newdoc.createElement(item[0])
973	value_list = getattr(self, item[1])
974	for key, value in value_list.items():
975	sub_element = newdoc.createElement(key)
976	sub_element.setAttribute('name', str(key))
977	for val in value:
978	sub_element.appendChild(newdoc.createTextNode(str(val)))
979
980	element.appendChild(sub_element)
981	inputs.appendChild(element)
982
983	# Create doc for the dictionary of self.disp_obj_dic
984	for tagname, varname, tagtype in DISPERSION_LIST:
985	element = newdoc.createElement(tagname)
986	value_list = getattr(self, varname)
987	for key, value in value_list.items():
988	sub_element = newdoc.createElement(key)
989	sub_element.setAttribute('name', str(key))
990	sub_element.setAttribute('value', str(value))
991	element.appendChild(sub_element)
992	inputs.appendChild(element)
993
994	for item in LIST_OF_STATE_PARAMETERS:
995	element = newdoc.createElement(item[0])
996	self._to_xml_helper(thelist=getattr(self, item[1]),
997	element=element, newdoc=newdoc)
998	inputs.appendChild(element)
999
1000	# Combined and Simultaneous Fit Parameters
1001	if batch_fit_state is not None:
1002	batch_combo = newdoc.createElement('simultaneous_fit')
1003	top_element.appendChild(batch_combo)
1004
1005	# Simultaneous Fit Number For Linking Later
1006	element = newdoc.createElement('sim_fit_number')
1007	element.setAttribute('fit_number', str(batch_fit_state.fit_page_no))
1008	batch_combo.appendChild(element)
1009
1010	# Save constraints
1011	constraints = newdoc.createElement('constraints')
1012	batch_combo.appendChild(constraints)
1013	for constraint in batch_fit_state.constraints_list:
1014	if constraint.model_cbox.GetValue() != "":
1015	# model_cbox, param_cbox, egal_txt, constraint,
1016	# btRemove, sizer
1017	doc_cons = newdoc.createElement('constraint')
1018	doc_cons.setAttribute('model_cbox',
1019	str(constraint.model_cbox.GetValue()))
1020	doc_cons.setAttribute('param_cbox',
1021	str(constraint.param_cbox.GetValue()))
1022	doc_cons.setAttribute('egal_txt',
1023	str(constraint.egal_txt.GetLabel()))
1024	doc_cons.setAttribute('constraint',
1025	str(constraint.constraint.GetValue()))
1026	constraints.appendChild(doc_cons)
1027
1028	# Save all models
1029	models = newdoc.createElement('model_list')
1030	batch_combo.appendChild(models)
1031	for model in batch_fit_state.model_list:
1032	doc_model = newdoc.createElement('model_list_item')
1033	doc_model.setAttribute('checked', str(model[0].GetValue()))
1034	keys = model[1].keys()
1035	doc_model.setAttribute('name', str(keys[0]))
1036	values = model[1].get(keys[0])
1037	doc_model.setAttribute('fit_number', str(model[2]))
1038	doc_model.setAttribute('fit_page_source', str(model[3]))
1039	doc_model.setAttribute('model_name', str(values.model.id))
1040	models.appendChild(doc_model)
1041
1042	# Select All Checkbox
1043	element = newdoc.createElement('select_all')
1044	if batch_fit_state.select_all:
1045	element.setAttribute('checked', 'True')
1046	else:
1047	element.setAttribute('checked', 'False')
1048	batch_combo.appendChild(element)
1049
1050	# Save the file
1051	if doc is None:
1052	fd = open(file, 'w')
1053	fd.write(newdoc.toprettyxml())
1054	fd.close()
1055	return None
1056	else:
1057	return newdoc
1058
1059	def _from_xml_helper(self, node, list):
1060	"""
1061	Helper function to write state to xml
1062	"""
1063	for item in node:
1064	name = item.get('name')
1065	value = item.get('value')
1066	selected_to_fit = (item.get('selected_to_fit') == "True")
1067	error_displayed = (item.get('error_displayed') == "True")
1068	error_value = item.get('error_value')
1069	minimum_displayed = (item.get('minimum_displayed') == "True")
1070	minimum_value = item.get('minimum_value')
1071	maximum_displayed = (item.get('maximum_displayed') == "True")
1072	maximum_value = item.get('maximum_value')
1073	unit = item.get('unit')
1074	list.append([selected_to_fit, name, value, "+/-",
1075	[error_displayed, error_value],
1076	[minimum_displayed, minimum_value],
1077	[maximum_displayed, maximum_value], unit])
1078
1079	def from_xml(self, file=None, node=None):
1080	"""
1081	Load fitting state from a file
1082
1083	:param file: .fitv file
1084	:param node: node of a XML document to read from
1085	"""
1086	if file is not None:
1087	msg = "PageState no longer supports non-CanSAS"
1088	msg += " format for fitting files"
1089	raise RuntimeError(msg)
1090
1091	if node.get('version'):
1092	# Get the version for model conversion purposes
1093	x = re.sub('[^\d.]', '', node.get('version'))
1094	self.version = tuple(int(e) for e in str.split(x, "."))
1095	# The tuple must be at least 3 items long
1096	while len(self.version) < 3:
1097	ver_list = list(self.version)
1098	ver_list.append(0)
1099	self.version = tuple(ver_list)
1100
1101	# Get file name
1102	entry = get_content('ns:filename', node)
1103	if entry is not None and entry.text:
1104	self.file = entry.text.strip()
1105	else:
1106	self.file = ''
1107
1108	# Get time stamp
1109	entry = get_content('ns:timestamp', node)
1110	if entry is not None and entry.get('epoch'):
1111	try:
1112	self.timestamp = float(entry.get('epoch'))
1113	except Exception:
1114	msg = "PageState.fromXML: Could not"
1115	msg += " read timestamp\n %s" % sys.exc_value
1116	logger.error(msg)
1117
1118	if entry is not None:
1119	# Parse fitting attributes
1120	entry = get_content('ns:Attributes', node)
1121	for item in LIST_OF_DATA_ATTRIBUTES:
1122	node = get_content('ns:%s' % item[0], entry)
1123	setattr(self, item[0], parse_entry_helper(node, item))
1124
1125	dx_old_node = get_content('ns:%s' % 'dx_min', entry)
1126	for item in LIST_OF_STATE_ATTRIBUTES:
1127	if item[0] == "dx_percent" and dx_old_node is not None:
1128	dxmin = ["dx_min", "dx_min", "float"]
1129	setattr(self, item[0], parse_entry_helper(dx_old_node,
1130	dxmin))
1131	self.dx_old = True
1132	else:
1133	node = get_content('ns:%s' % item[0], entry)
1134	setattr(self, item[0], parse_entry_helper(node, item))
1135
1136	for item in LIST_OF_STATE_PARAMETERS:
1137	node = get_content("ns:%s" % item[0], entry)
1138	self._from_xml_helper(node=node,
1139	list=getattr(self, item[1]))
1140
1141	# Recover disp_obj_dict from xml file
1142	self.disp_obj_dict = {}
1143	for tagname, varname, tagtype in DISPERSION_LIST:
1144	node = get_content("ns:%s" % tagname, entry)
1145	for attr in node:
1146	parameter = str(attr.get('name'))
1147	value = attr.get('value')
1148	if value.startswith("<"):
1149	try:
1150	# <path.to.NamedDistribution object/instance...>
1151	cls_name = value[1:].split()[0].split('.')[-1]
1152	cls = getattr(sasmodels.weights, cls_name)
1153	value = cls.type
1154	except Exception:
1155	base = "unable to load distribution %r for %s"
1156	logger.error(base, value, parameter)
1157	continue
1158	disp_obj_dict = getattr(self, varname)
1159	disp_obj_dict[parameter] = value
1160
1161	# get self.values and self.weights dic. if exists
1162	for tagname, varname in LIST_OF_MODEL_ATTRIBUTES:
1163	node = get_content("ns:%s" % tagname, entry)
1164	dic = {}
1165	value_list = []
1166	for par in node:
1167	name = par.get('name')
1168	values = par.text.split()
1169	# Get lines only with numbers
1170	for line in values:
1171	try:
1172	val = float(line)
1173	value_list.append(val)
1174	except Exception:
1175	# pass if line is empty (it happens)
1176	msg = ("Error reading %r from %s %s\n"
1177	% (line, tagname, name))
1178	logger.error(msg + traceback.format_exc())
1179	dic[name] = np.array(value_list)
1180	setattr(self, varname, dic)
1181
1182	class SimFitPageState(object):
1183	"""
1184	State of the simultaneous fit page for saving purposes
1185	"""
1186
1187	def __init__(self):
1188	# Sim Fit Page Number
1189	self.fit_page_no = None
1190	# Select all data
1191	self.select_all = False
1192	# Data sets sent to fit page
1193	self.model_list = []
1194	# Data sets to be fit
1195	self.model_to_fit = []
1196	# Number of constraints
1197	self.no_constraint = 0
1198	# Dictionary of constraints
1199	self.constraint_dict = {}
1200	# List of constraints
1201	self.constraints_list = []
1202
1203	def __repr__(self):
1204	# TODO: should use __str__, not __repr__ (similarly for PageState)
1205	# TODO: could use a nicer representation
1206	repr = """\
1207	fit page number : %(fit_page_no)s
1208	select all : %(select_all)s
1209	model_list : %(model_list)s
1210	model to fit : %(model_to_fit)s
1211	number of construsts : %(no_constraint)s
1212	constraint dict : %(constraint_dict)s
1213	constraints list : %(constraints_list)s
1214	"""%self.__dict__
1215	return repr
1216
1217	class Reader(CansasReader):
1218	"""
1219	Class to load a .fitv fitting file
1220	"""
1221	# File type
1222	type_name = "Fitting"
1223
1224	# Wildcards
1225	type = ["Fitting files (.fitv)\|.fitv"
1226	"SASView file (.svs)\|.svs"]
1227	# List of allowed extensions
1228	ext = ['.fitv', '.FITV', '.svs', 'SVS']
1229
1230	def __init__(self, call_back=None, cansas=True):
1231	CansasReader.__init__(self)
1232	"""
1233	Initialize the call-back method to be called
1234	after we load a file
1235
1236	:param call_back: call-back method
1237	:param cansas: True = files will be written/read in CanSAS format
1238	False = write CanSAS format
1239
1240	"""
1241	# Call back method to be executed after a file is read
1242	self.call_back = call_back
1243	# CanSAS format flag
1244	self.cansas = cansas
1245	self.state = None
1246	# batch fitting params for saving
1247	self.batchfit_params = []
1248
1249	def get_state(self):
1250	return self.state
1251
1252	def read(self, path):
1253	"""
1254	Load a new P(r) inversion state from file
1255
1256	:param path: file path
1257
1258	"""
1259	if self.cansas:
1260	return self._read_cansas(path)
1261
1262	def _parse_state(self, entry):
1263	"""
1264	Read a fit result from an XML node
1265
1266	:param entry: XML node to read from
1267	:return: PageState object
1268	"""
1269	# Create an empty state
1270	state = None
1271	# Locate the P(r) node
1272	try:
1273	nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME,
1274	namespaces=CANSAS_NS)
1275	if nodes:
1276	# Create an empty state
1277	state = PageState()
1278	state.from_xml(node=nodes[0])
1279
1280	except Exception:
1281	logger.info("XML document does not contain fitting information.\n"
1282	+ traceback.format_exc())
1283
1284	return state
1285
1286	def _parse_simfit_state(self, entry):
1287	"""
1288	Parses the saved data for a simultaneous fit
1289	:param entry: XML object to read from
1290	:return: XML object for a simultaneous fit or None
1291	"""
1292	nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME,
1293	namespaces=CANSAS_NS)
1294	if nodes:
1295	simfitstate = nodes[0].xpath('ns:simultaneous_fit',
1296	namespaces=CANSAS_NS)
1297	if simfitstate:
1298	sim_fit_state = SimFitPageState()
1299	simfitstate_0 = simfitstate[0]
1300	all = simfitstate_0.xpath('ns:select_all',
1301	namespaces=CANSAS_NS)
1302	atts = all[0].attrib
1303	checked = atts.get('checked')
1304	sim_fit_state.select_all = bool(checked)
1305	model_list = simfitstate_0.xpath('ns:model_list',
1306	namespaces=CANSAS_NS)
1307	model_list_items = model_list[0].xpath('ns:model_list_item',
1308	namespaces=CANSAS_NS)
1309	for model in model_list_items:
1310	attrs = model.attrib
1311	sim_fit_state.model_list.append(attrs)
1312
1313	constraints = simfitstate_0.xpath('ns:constraints',
1314	namespaces=CANSAS_NS)
1315	constraint_list = constraints[0].xpath('ns:constraint',
1316	namespaces=CANSAS_NS)
1317	for constraint in constraint_list:
1318	attrs = constraint.attrib
1319	sim_fit_state.constraints_list.append(attrs)
1320
1321	return sim_fit_state
1322	else:
1323	return None
1324
1325	def _parse_save_state_entry(self, dom):
1326	"""
1327	Parse a SASentry
1328
1329	:param node: SASentry node
1330
1331	:return: Data1D/Data2D object
1332
1333	"""
1334	node = dom.xpath('ns:data_class', namespaces=CANSAS_NS)
1335	return_value, _ = self._parse_entry(dom)
1336	return return_value, _
1337
1338	def _read_cansas(self, path):
1339	"""
1340	Load data and fitting information from a CanSAS XML file.
1341
1342	:param path: file path
1343	:return: Data1D object if a single SASentry was found,
1344	or a list of Data1D objects if multiple entries were found,
1345	or None of nothing was found
1346	:raise RuntimeError: when the file can't be opened
1347	:raise ValueError: when the length of the data vectors are inconsistent
1348	"""
1349	output = []
1350	simfitstate = None
1351	basename = os.path.basename(path)
1352	root, extension = os.path.splitext(basename)
1353	ext = extension.lower()
1354	try:
1355	if os.path.isfile(path):
1356	if ext in self.ext or ext == '.xml':
1357	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
1358	# Check the format version number
1359	# Specifying the namespace will take care of the file
1360	# format version
1361	root = tree.getroot()
1362	entry_list = root.xpath('ns:SASentry',
1363	namespaces=CANSAS_NS)
1364	for entry in entry_list:
1365	fitstate = self._parse_state(entry)
1366	# state could be None when .svs file is loaded
1367	# in this case, skip appending to output
1368	if fitstate is not None:
1369	try:
1370	sas_entry, _ = self._parse_save_state_entry(
1371	entry)
1372	except:
1373	raise
1374	sas_entry.meta_data['fitstate'] = fitstate
1375	sas_entry.filename = fitstate.file
1376	output.append(sas_entry)
1377
1378	else:
1379	self.call_back(format=ext)
1380	raise RuntimeError("%s is not a file" % path)
1381
1382	# Return output consistent with the loader's api
1383	if len(output) == 0:
1384	self.call_back(state=None, datainfo=None, format=ext)
1385	return None
1386	else:
1387	for data in output:
1388	# Call back to post the new state
1389	state = data.meta_data['fitstate']
1390	t = time.localtime(state.timestamp)
1391	time_str = time.strftime("%b %d %H:%M", t)
1392	# Check that no time stamp is already appended
1393	max_char = state.file.find("[")
1394	if max_char < 0:
1395	max_char = len(state.file)
1396	original_fname = state.file[0:max_char]
1397	state.file = original_fname + ' [' + time_str + ']'
1398
1399	if state is not None and state.is_data is not None:
1400	data.is_data = state.is_data
1401
1402	data.filename = state.file
1403	state.data = data
1404	state.data.name = data.filename # state.data_name
1405	state.data.id = state.data_id
1406	if state.is_data is not None:
1407	state.data.is_data = state.is_data
1408	if data.run_name is not None and len(data.run_name) != 0:
1409	if isinstance(data.run_name, dict):
1410	# Note: key order in dict is not guaranteed, so sort
1411	name = data.run_name.keys()[0]
1412	else:
1413	name = data.run_name
1414	else:
1415	name = original_fname
1416	state.data.group_id = name
1417	state.version = fitstate.version
1418	# store state in fitting
1419	self.call_back(state=state, datainfo=data, format=ext)
1420	self.state = state
1421	simfitstate = self._parse_simfit_state(entry)
1422	if simfitstate is not None:
1423	self.call_back(state=simfitstate)
1424
1425	return output
1426	except:
1427	self.call_back(format=ext)
1428	raise
1429
1430	def write(self, filename, datainfo=None, fitstate=None):
1431	"""
1432	Write the content of a Data1D as a CanSAS XML file only for standalone
1433
1434	:param filename: name of the file to write
1435	:param datainfo: Data1D object
1436	:param fitstate: PageState object
1437
1438	"""
1439	# Sanity check
1440	if self.cansas:
1441	# Add fitting information to the XML document
1442	doc = self.write_toXML(datainfo, fitstate)
1443	# Write the XML document
1444	else:
1445	doc = fitstate.to_xml(file=filename)
1446
1447	# Save the document no matter the type
1448	fd = open(filename, 'w')
1449	fd.write(doc.toprettyxml())
1450	fd.close()
1451
1452	def write_toXML(self, datainfo=None, state=None, batchfit=None):
1453	"""
1454	Write toXML, a helper for write(),
1455	could be used by guimanager._on_save()
1456
1457	: return: xml doc
1458	"""
1459
1460	self.batchfit_params = batchfit
1461	if state.data is None or not state.data.is_data:
1462	return None
1463	# make sure title and data run are filled.
1464	if state.data.title is None or state.data.title == '':
1465	state.data.title = state.data.name
1466	if state.data.run_name is None or state.data.run_name == {}:
1467	state.data.run = [str(state.data.name)]
1468	state.data.run_name[0] = state.data.name
1469
1470	data = state.data
1471	doc, sasentry = self._to_xml_doc(data)
1472
1473	if state is not None:
1474	doc = state.to_xml(doc=doc, file=data.filename, entry_node=sasentry,
1475	batch_fit_state=self.batchfit_params)
1476
1477	return doc
1478
1479	# Simple html report template
1480	HEADER = "<html>\n"
1481	HEADER += "<head>\n"
1482	HEADER += "<meta http-equiv=Content-Type content='text/html; "
1483	HEADER += "charset=windows-1252'> \n"
1484	HEADER += "<meta name=Generator >\n"
1485	HEADER += "</head>\n"
1486	HEADER += "<body lang=EN-US>\n"
1487	HEADER += "<div class=WordSection1>\n"
1488	HEADER += "<p class=MsoNormal><b><span ><center><font size='4' >"
1489	HEADER += "%s</font></center></span></center></b></p>"
1490	HEADER += "<p class=MsoNormal> </p>"
1491	PARA = "<p class=MsoNormal><font size='4' > %s \n"
1492	PARA += "</font></p>"
1493	CENTRE = "<p class=MsoNormal><center><font size='4' > %s \n"
1494	CENTRE += "</font></center></p>"
1495	FEET_1 = \
1496	"""
1497	<p class=MsoNormal> </p>
1498	<br>
1499	<p class=MsoNormal><b><span ><center> <font size='4' > Graph
1500	</font></span></center></b></p>
1501	<p class=MsoNormal> </p>
1502	<center>
1503	<br><font size='4' >Model Computation</font>
1504	<br><font size='4' >Data: "%s"</font><br>
1505	"""
1506	FEET_2 = \
1507	"""<img src="%s"></img>
1508	"""
1509	FEET_2_unix = \
1510	"""<img src="%s" width="540"></img>
1511	"""
1512	FEET_3 = \
1513	"""</center>
1514	</div>
1515	</body>
1516	</html>
1517	"""
1518	ELINE = """<p class=MsoNormal> </p>
1519	"""

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

SasView

source: sasview/src/sas/sascalc/fit/pagestate.py @ 1dc134e6

Download in other formats: