pagestate.py @ ffe5345

ticket-1009

Last change on this file since ffe5345 was ffe5345, checked in by gonzalezm, 5 years ago
Added number of points and sigmas in PD distribution to report
Property mode set to `100644`
File size: 55.8 KB

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

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

SasView

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

Download in other formats: