pagestate.py @ 18da4a8

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 18da4a8 was 6d2b50b, checked in by krzywon, 8 years ago
Change the elif block to a dictionary search to minimize the number of checks.
Property mode set to `100644`
File size: 57.6 KB

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

Download in other formats: