pagestate.py @ 783c1b5

Last change on this file since 783c1b5 was 959eb01, checked in by ajj, 8 years ago
normalising line endings
Property mode set to `100644`
File size: 56.7 KB

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

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/pagestate.py @ 783c1b5

Download in other formats: