pagestate.py @ 6fb6592

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 6fb6592 was 0b1d7d3, checked in by krzywon, 7 years ago
Plugin models are loaded properly (if they can be found) and fixed a bug in parameter setting routine.
Property mode set to `100644`
File size: 78.0 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
[2f4b430]	274
[6f023e8]	275	def clone(self):
[61cada5]	276	"""
[5062bbf]	277	Create a new copy of the current object
[61cada5]	278	"""
	279	model = None
	280	if self.model is not None:
[6f023e8]	281	model = self.model.clone()
[bb70474]	282	model.name = self.model.name
[61cada5]	283	obj = PageState(self.parent, model=model)
	284	obj.file = copy.deepcopy(self.file)
[6f023e8]	285	obj.data = copy.deepcopy(self.data)
[61cada5]	286	if self.data is not None:
	287	self.data_name = self.data.name
	288	obj.data_name = self.data_name
	289	obj.is_data = self.is_data
[dcf29d7]	290	obj.model_list_box = copy.deepcopy(self.model_list_box)
[2f4b430]	291
[ea5fa58]	292	obj.categorycombobox = self.categorycombobox
[61cada5]	293	obj.formfactorcombobox = self.formfactorcombobox
[f32d144]	294	obj.structurecombobox = self.structurecombobox
[2f4b430]	295
[a95ae9a]	296	# obj.shape_rbutton = self.shape_rbutton
	297	# obj.shape_indep_rbutton = self.shape_indep_rbutton
	298	# obj.struct_rbutton = self.struct_rbutton
	299	# obj.plugin_rbutton = self.plugin_rbutton
[2f4b430]	300
[dcf29d7]	301	obj.manager = self.manager
	302	obj.event_owner = self.event_owner
[71f0373]	303	obj.disp_list = copy.deepcopy(self.disp_list)
[2f4b430]	304
[c477b31]	305	obj.enable2D = copy.deepcopy(self.enable2D)
[cfc0913]	306	obj.parameters = copy.deepcopy(self.parameters)
[fb59ed9]	307	obj.str_parameters = copy.deepcopy(self.str_parameters)
[cfc0913]	308	obj.fixed_param = copy.deepcopy(self.fixed_param)
	309	obj.fittable_param = copy.deepcopy(self.fittable_param)
[f32d144]	310	obj.orientation_params = copy.deepcopy(self.orientation_params)
[c8e1996]	311	obj.orientation_params_disp = \
	312	copy.deepcopy(self.orientation_params_disp)
[b787e68c]	313	obj.enable_disp = copy.deepcopy(self.enable_disp)
[fc6ea43]	314	obj.disable_disp = copy.deepcopy(self.disable_disp)
[0aeabc6]	315	obj.tcChi = self.tcChi
[2f4b430]	316
[f32d144]	317	if len(self._disp_obj_dict) > 0:
	318	for k, v in self._disp_obj_dict.iteritems():
	319	obj._disp_obj_dict[k] = v
	320	if len(self.disp_cb_dict) > 0:
	321	for k, v in self.disp_cb_dict.iteritems():
	322	obj.disp_cb_dict[k] = v
	323	if len(self.values) > 0:
	324	for k, v in self.values.iteritems():
[2296316]	325	obj.values[k] = v
[f32d144]	326	if len(self.weights) > 0:
	327	for k, v in self.weights.iteritems():
[2296316]	328	obj.weights[k] = v
[b787e68c]	329	obj.enable_smearer = copy.deepcopy(self.enable_smearer)
[fc6ea43]	330	obj.disable_smearer = copy.deepcopy(self.disable_smearer)
[7609f1a]	331	obj.pinhole_smearer = copy.deepcopy(self.pinhole_smearer)
	332	obj.slit_smearer = copy.deepcopy(self.slit_smearer)
	333	obj.smear_type = copy.deepcopy(self.smear_type)
[55bb249c]	334	obj.dI_noweight = copy.deepcopy(self.dI_noweight)
	335	obj.dI_didata = copy.deepcopy(self.dI_didata)
	336	obj.dI_sqrdata = copy.deepcopy(self.dI_sqrdata)
	337	obj.dI_idata = copy.deepcopy(self.dI_idata)
[7609f1a]	338	obj.dq_l = copy.deepcopy(self.dq_l)
	339	obj.dq_r = copy.deepcopy(self.dq_r)
[db8fd5b]	340	obj.dx_max = copy.deepcopy(self.dx_max)
	341	obj.dx_min = copy.deepcopy(self.dx_min)
	342	obj.dxl = copy.deepcopy(self.dxl)
[2f4b430]	343	obj.dxw = copy.deepcopy(self.dxw)
[b787e68c]	344	obj.disp_box = copy.deepcopy(self.disp_box)
	345	obj.qmin = copy.deepcopy(self.qmin)
	346	obj.qmax = copy.deepcopy(self.qmax)
[c0ff8cc]	347	obj.multi_factor = self.multi_factor
[318b5bbb]	348	obj.magnetic_on = self.magnetic_on
[f32d144]	349	obj.npts = copy.deepcopy(self.npts)
[b787e68c]	350	obj.cb1 = copy.deepcopy(self.cb1)
[3370922]	351	obj.smearer = copy.deepcopy(self.smearer)
[2f4b430]	352
[a074145]	353	for name, state in self.saved_states.iteritems():
	354	copy_name = copy.deepcopy(name)
	355	copy_state = state.clone()
[f32d144]	356	obj.saved_states[copy_name] = copy_state
[6f023e8]	357	return obj
[2f4b430]	358
[8898558b]	359	def _is_sasmodels(self):
	360	"""
	361	A check to see if the loaded save state was saved in SasView v4_0+
	362	:return: None
	363	"""
	364	newname = convert._conversion_target(self.formfactorcombobox)
	365	if newname == None:
	366	return True
	367	else:
	368	return False
	369
[3d8c49a]	370	def _convert_to_sasmodels(self):
	371	"""
	372	Convert parameters to a form usable by sasmodels converter
	373
	374	:return: None
	375	"""
	376	# Create conversion dictionary to send to sasmodels
	377	p = dict()
	378	for fittable, name, value, _, uncert, lower, upper, units in \
	379	self.parameters:
	380	if not value:
	381	value = numpy.nan
	382	if not uncert or uncert[1] == '':
	383	uncert[0] = False
	384	uncert[1] = numpy.nan
	385	if not upper or upper[1] == '':
	386	upper[0] = False
	387	upper[1] = numpy.nan
	388	if not lower or lower[1] == '':
	389	lower[0] = False
	390	lower[1] = numpy.nan
[64c7f39]	391	p[name] = float(value)
	392	p[name + ".fittable"] = bool(fittable)
	393	p[name + ".std"] = float(uncert[1])
	394	p[name + ".upper"] = float(upper[1])
	395	p[name + ".lower"] = float(lower[1])
	396	p[name + ".units"] = units
[377c19a2]	397
	398	structurefactor, params = \
	399	convert.convert_model(self.structurecombobox, p)
	400	formfactor, params = \
	401	convert.convert_model(self.formfactorcombobox, params)
[0b1d7d3]	402	# if len(self.str_parameters) > 0:
	403	# formfactor, str_params = \
	404	# convert.convert_model(formfactor, self.str_parameters)
[3d8c49a]	405
	406	# Only convert if old != new, otherwise all the same
[377c19a2]	407	if formfactor != self.formfactorcombobox or \
	408	structurefactor != self.structurecombobox:
	409	self.formfactorcombobox = formfactor
	410	self.structurecombobox = structurefactor
[3d8c49a]	411	self.parameters = []
	412	for name, info in params.iteritems():
[64c7f39]	413	if ".fittable" in name or ".std" in name or ".upper" in name or\
	414	".lower" in name or ".units" in name:
	415	pass
[3d8c49a]	416	else:
[406644a]	417	fittable = params.get(name + ".fittable", True)
	418	std = params.get(name + ".std", '0.0')
	419	upper = params.get(name + ".upper", 'inf')
	420	lower = params.get(name + ".lower", '-inf')
[64c7f39]	421	units = params.get(name + ".units")
[b4fc0f9]	422	if std is not None and std is not numpy.nan:
[64c7f39]	423	std = [True, str(std)]
	424	else:
	425	std = [False, '']
[0b1d7d3]	426	if lower is not None and lower is not numpy.nan:
[64c7f39]	427	lower = [True, str(lower)]
	428	else:
[0b1d7d3]	429	lower = [True, '-inf']
	430	if upper is not None and upper is not numpy.nan:
[64c7f39]	431	upper = [True, str(upper)]
	432	else:
[0b1d7d3]	433	upper = [True, 'inf']
[64c7f39]	434	param_list = [bool(fittable), str(name), str(info),
	435	"+/-", std, lower, upper, str(units)]
	436	self.parameters.append(param_list)
[3d8c49a]	437
	438
[61cada5]	439	def _repr_helper(self, list, rep):
	440	"""
[5062bbf]	441	Helper method to print a state
[61cada5]	442	"""
	443	for item in list:
[f32d144]	444	rep += "parameter name: %s \n" % str(item[1])
	445	rep += "value: %s\n" % str(item[2])
	446	rep += "selected: %s\n" % str(item[0])
	447	rep += "error displayed : %s \n" % str(item[4][0])
	448	rep += "error value:%s \n" % str(item[4][1])
	449	rep += "minimum displayed : %s \n" % str(item[5][0])
	450	rep += "minimum value : %s \n" % str(item[5][1])
	451	rep += "maximum displayed : %s \n" % str(item[6][0])
	452	rep += "maximum value : %s \n" % str(item[6][1])
	453	rep += "parameter unit: %s\n\n" % str(item[7])
[240b9966]	454	return rep
[2f4b430]	455
[61cada5]	456	def __repr__(self):
[f32d144]	457	"""
[5062bbf]	458	output string for printing
[11a7e11]	459	"""
[f32d144]	460	rep = "\nState name: %s\n" % self.file
[11a7e11]	461	t = time.localtime(self.timestamp)
[deff488]	462	time_str = time.strftime("%b %d %Y %H;%M;%S ", t)
[c0ff8cc]	463
[f32d144]	464	rep += "State created: %s\n" % time_str
[998ca90]	465	rep += "State form factor combobox selection: %s\n" % \
	466	self.formfactorcombobox
	467	rep += "State structure factor combobox selection: %s\n" % \
	468	self.structurecombobox
[f32d144]	469	rep += "is data : %s\n" % self.is_data
	470	rep += "data's name : %s\n" % self.data_name
	471	rep += "data's id : %s\n" % self.data_id
[a95ae9a]	472	if self.model is not None:
[93f0a862]	473	m_name = self.model.__class__.__name__
	474	if m_name == 'Model':
	475	m_name = self.m_name
[f32d144]	476	rep += "model name : %s\n" % m_name
[74dc0a4]	477	else:
	478	rep += "model name : None\n"
[f32d144]	479	rep += "multi_factor : %s\n" % str(self.multi_factor)
[2f4b430]	480	rep += "magnetic_on : %s\n" % str(self.magnetic_on)
[ea5fa58]	481	rep += "model type (Category) selected: %s\n" % self.categorycombobox
[f32d144]	482	rep += "data : %s\n" % str(self.data)
[a95ae9a]	483	rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % \
[c8e1996]	484	(str(self.qmin), str(self.qmax), str(self.npts))
[f32d144]	485	rep += "Dispersion selection : %s\n" % str(self.disp_box)
	486	rep += "Smearing enable : %s\n" % str(self.enable_smearer)
	487	rep += "Smearing disable : %s\n" % str(self.disable_smearer)
	488	rep += "Pinhole smearer enable : %s\n" % str(self.pinhole_smearer)
	489	rep += "Slit smearer enable : %s\n" % str(self.slit_smearer)
	490	rep += "Dispersity enable : %s\n" % str(self.enable_disp)
	491	rep += "Dispersity disable : %s\n" % str(self.disable_disp)
	492	rep += "Slit smearer enable: %s\n" % str(self.slit_smearer)
[2f4b430]	493
[f32d144]	494	rep += "dI_noweight : %s\n" % str(self.dI_noweight)
	495	rep += "dI_didata : %s\n" % str(self.dI_didata)
	496	rep += "dI_sqrdata : %s\n" % str(self.dI_sqrdata)
	497	rep += "dI_idata : %s\n" % str(self.dI_idata)
[2f4b430]	498
[f32d144]	499	rep += "2D enable : %s\n" % str(self.enable2D)
[c8e1996]	500	rep += "All parameters checkbox selected: %s\n" % self.cb1
[f32d144]	501	rep += "Value of Chisqr : %s\n" % str(self.tcChi)
[c8e1996]	502	rep += "Smear object : %s\n" % self.smearer
	503	rep += "Smear type : %s\n" % self.smear_type
[f32d144]	504	rep += "dq_l : %s\n" % self.dq_l
	505	rep += "dq_r : %s\n" % self.dq_r
[db8fd5b]	506	rep += "dx_max : %s\n" % str(self.dx_max)
[2f4b430]	507	rep += "dx_min : %s\n" % str(self.dx_min)
[db8fd5b]	508	rep += "dxl : %s\n" % str(self.dxl)
[2f4b430]	509	rep += "dxw : %s\n" % str(self.dxw)
[f32d144]	510	rep += "model : %s\n\n" % str(self.model)
[2296316]	511	temp_parameters = []
	512	temp_fittable_param = []
	513	if self.data.__class__.__name__ == "Data2D":
	514	self.is_2D = True
	515	else:
	516	self.is_2D = False
	517	if self.data is not None:
	518	if not self.is_2D:
	519	for item in self.parameters:
[a95ae9a]	520	if item not in self.orientation_params:
[2296316]	521	temp_parameters.append(item)
	522	for item in self.fittable_param:
[a95ae9a]	523	if item not in self.orientation_params_disp:
[2296316]	524	temp_fittable_param.append(item)
	525	else:
	526	temp_parameters = self.parameters
	527	temp_fittable_param = self.fittable_param
[2f4b430]	528
[a95ae9a]	529	rep += "number parameters(self.parameters): %s\n" % \
	530	len(temp_parameters)
[f32d144]	531	rep = self._repr_helper(list=temp_parameters, rep=rep)
[a95ae9a]	532	rep += "number str_parameters(self.str_parameters): %s\n" % \
	533	len(self.str_parameters)
[f32d144]	534	rep = self._repr_helper(list=self.str_parameters, rep=rep)
[a95ae9a]	535	rep += "number fittable_param(self.fittable_param): %s\n" % \
	536	len(temp_fittable_param)
[f32d144]	537	rep = self._repr_helper(list=temp_fittable_param, rep=rep)
[61cada5]	538	return rep
[2296316]	539
	540	def set_report_string(self):
	541	"""
[f32d144]	542	Get the values (strings) from __str__ for report
[2296316]	543	"""
[d06ae30]	544	# Dictionary of the report strings
[2296316]	545	repo_time = ""
	546	model_name = ""
	547	title = ""
	548	title_name = ""
	549	file_name = ""
	550	param_string = ""
	551	paramval_string = ""
	552	chi2_string = ""
	553	q_range = ""
	554	strings = self.__repr__()
	555	lines = strings.split('\n')
	556
	557	# get all string values from __str__()
	558	for line in lines:
	559	value = ""
	560	content = line.split(":")
	561	name = content[0]
	562	try:
	563	value = content[1]
[7673ecd]	564	except Exception:
[c8e1996]	565	msg = "Report string expected 'name: value' but got %r" % line
[6c382da]	566	logging.error(msg)
[b7c6a4a]	567	if name.count("State created"):
	568	repo_time = "" + value
[2296316]	569	if name.count("parameter name"):
	570	val_name = value.split(".")
	571	if len(val_name) > 1:
	572	if val_name[1].count("width"):
	573	param_string += value + ','
	574	else:
	575	continue
	576	else:
	577	param_string += value + ','
	578	if name == "value":
	579	param_string += value + ','
[c8e1996]	580	fixed_parameter = False
[b1e609c]	581	if name == "selected":
	582	if value == u' False':
	583	fixed_parameter = True
[2296316]	584	if name == "error value":
[b1e609c]	585	if fixed_parameter:
	586	param_string += '(fixed),'
	587	else:
[d06ae30]	588	param_string += value + ','
[2296316]	589	if name == "parameter unit":
[f32d144]	590	param_string += value + ':'
[2296316]	591	if name == "Value of Chisqr ":
	592	chi2 = ("Chi2/Npts = " + value)
	593	chi2_string = CENTRE % chi2
	594	if name == "Title":
	595	if len(value.strip()) == 0:
	596	continue
	597	title = value + " [" + repo_time + "]"
	598	title_name = HEADER % title
	599	if name == "data ":
	600	try:
[b1e609c]	601	file_value = ("File name:" + content[2])
	602	file_name = CENTRE % file_value
[2296316]	603	if len(title) == 0:
	604	title = content[2] + " [" + repo_time + "]"
	605	title_name = HEADER % title
[7673ecd]	606	except Exception:
[6c382da]	607	msg = "While parsing 'data: ...'\n"
	608	logging.error(msg + traceback.format_exc())
[74dc0a4]	609	if name == "model name ":
	610	try:
	611	modelname = "Model name:" + content[1]
	612	except:
	613	modelname = "Model name:" + " NAN"
[f32d144]	614	model_name = CENTRE % modelname
[2f4b430]	615
[2296316]	616	if name == "Plotting Range":
	617	try:
	618	q_range = content[1] + " = " + content[2] \
	619	+ " = " + content[3].split(",")[0]
	620	q_name = ("Q Range: " + q_range)
	621	q_range = CENTRE % q_name
[7673ecd]	622	except Exception:
[6c382da]	623	msg = "While parsing 'Plotting Range: ...'\n"
	624	logging.error(msg + traceback.format_exc())
[2296316]	625	paramval = ""
[f32d144]	626	for lines in param_string.split(":"):
[2296316]	627	line = lines.split(",")
[f32d144]	628	if len(lines) > 0:
	629	param = line[0]
[2296316]	630	param += " = " + line[1]
	631	if len(line[2].split()) > 0 and not line[2].count("None"):
	632	param += " +- " + line[2]
	633	if len(line[3].split()) > 0 and not line[3].count("None"):
	634	param += " " + line[3]
	635	if not paramval.count(param):
[f32d144]	636	paramval += param + "\n"
[2296316]	637	paramval_string += CENTRE % param + "\n"
[2f4b430]	638
[a95ae9a]	639	text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % \
	640	(title, file, q_name, chi2, paramval)
[2f4b430]	641
[f5bdb4a]	642	title_name = self._check_html_format(title_name)
	643	file_name = self._check_html_format(file_name)
	644	title = self._check_html_format(title)
[2f4b430]	645
[2296316]	646	html_string = title_name + "\n" + file_name + \
[f32d144]	647	"\n" + model_name + \
[2296316]	648	"\n" + q_range + \
	649	"\n" + chi2_string + \
	650	"\n" + ELINE + \
	651	"\n" + paramval_string + \
	652	"\n" + ELINE + \
	653	"\n" + FEET_1 % title + \
[f32d144]	654	"\n" + FEET_2
[2f4b430]	655
[2296316]	656	return html_string, text_string, title
[2f4b430]	657
[f5bdb4a]	658	def _check_html_format(self, name):
	659	"""
	660	Check string '%' for html format
	661	"""
	662	if name.count('%'):
	663	name = name.replace('%', '&#37')
[2f4b430]	664
[f5bdb4a]	665	return name
[2f4b430]	666
[2296316]	667	def report(self, figs=None, canvases=None):
	668	"""
	669	Invoke report dialog panel
[2f4b430]	670
[2296316]	671	: param figs: list of pylab figures [list]
	672	"""
[d85c194]	673	from sas.sasgui.perspectives.fitting.report_dialog import ReportDialog
[2296316]	674	# get the strings for report
	675	html_str, text_str, title = self.set_report_string()
	676	# Allow 2 figures to append
	677	if len(figs) == 1:
[f32d144]	678	add_str = FEET_3
[2296316]	679	elif len(figs) == 2:
[f32d144]	680	add_str = ELINE
	681	add_str += FEET_2 % ("%s")
	682	add_str += ELINE
	683	add_str += FEET_3
[2296316]	684	elif len(figs) > 2:
[f32d144]	685	add_str = ELINE
	686	add_str += FEET_2 % ("%s")
	687	add_str += ELINE
	688	add_str += FEET_2 % ("%s")
	689	add_str += ELINE
	690	add_str += FEET_3
[2296316]	691	else:
	692	add_str = ""
[c0ff8cc]	693
[2296316]	694	# final report html strings
	695	report_str = html_str % ("%s") + add_str
	696
	697	# make plot image
	698	images = self.set_plot_state(figs, canvases)
[f32d144]	699	report_list = [report_str, text_str, images]
[6f16e25]	700	dialog = ReportDialog(report_list, None, wx.ID_ANY, "")
[d838715]	701	dialog.Show()
[2f4b430]	702
[c8e1996]	703	def _to_xml_helper(self, thelist, element, newdoc):
[61cada5]	704	"""
[5062bbf]	705	Helper method to create xml file for saving state
[61cada5]	706	"""
[eddb6ec]	707	for item in thelist:
[61cada5]	708	sub_element = newdoc.createElement('parameter')
	709	sub_element.setAttribute('name', str(item[1]))
	710	sub_element.setAttribute('value', str(item[2]))
	711	sub_element.setAttribute('selected_to_fit', str(item[0]))
	712	sub_element.setAttribute('error_displayed', str(item[4][0]))
	713	sub_element.setAttribute('error_value', str(item[4][1]))
	714	sub_element.setAttribute('minimum_displayed', str(item[5][0]))
	715	sub_element.setAttribute('minimum_value', str(item[5][1]))
	716	sub_element.setAttribute('maximum_displayed', str(item[6][0]))
	717	sub_element.setAttribute('maximum_value', str(item[6][1]))
	718	sub_element.setAttribute('unit', str(item[7]))
	719	element.appendChild(sub_element)
[2f4b430]	720
[c8e1996]	721	def to_xml(self, file="fitting_state.fitv", doc=None,
	722	entry_node=None, batch_fit_state=None):
[61cada5]	723	"""
[a95ae9a]	724	Writes the state of the fit panel to file, as XML.
[2f4b430]	725
[5062bbf]	726	Compatible with standalone writing, or appending to an
[998ca90]	727	already existing XML document. In that case, the XML document is
	728	required. An optional entry node in the XML document may also be given.
[2f4b430]	729
[5062bbf]	730	:param file: file to write to
	731	:param doc: XML document object [optional]
[998ca90]	732	:param entry_node: XML node within the XML document at which we
	733	will append the data [optional]
[c8e1996]	734	:param batch_fit_state: simultaneous fit state
[61cada5]	735	"""
	736	from xml.dom.minidom import getDOMImplementation
[71f0373]	737
[61cada5]	738	# Check whether we have to write a standalone XML file
	739	if doc is None:
	740	impl = getDOMImplementation()
[f32d144]	741	doc_type = impl.createDocumentType(FITTING_NODE_NAME, "1.0", "1.0")
[61cada5]	742	newdoc = impl.createDocument(None, FITTING_NODE_NAME, doc_type)
	743	top_element = newdoc.documentElement
	744	else:
	745	# We are appending to an existing document
	746	newdoc = doc
[ac5b69d]	747	try:
	748	top_element = newdoc.createElement(FITTING_NODE_NAME)
	749	except:
	750	string = etree.tostring(doc, pretty_print=True)
	751	newdoc = parseString(string)
	752	top_element = newdoc.createElement(FITTING_NODE_NAME)
[61cada5]	753	if entry_node is None:
	754	newdoc.documentElement.appendChild(top_element)
	755	else:
[ac5b69d]	756	try:
	757	entry_node.appendChild(top_element)
	758	except:
	759	node_name = entry_node.tag
	760	node_list = newdoc.getElementsByTagName(node_name)
	761	entry_node = node_list.item(0)
	762	entry_node.appendChild(top_element)
[2f4b430]	763
[61cada5]	764	attr = newdoc.createAttribute("version")
	765	attr.nodeValue = '1.0'
	766	top_element.setAttributeNode(attr)
[2f4b430]	767
[61cada5]	768	# File name
	769	element = newdoc.createElement("filename")
	770	if self.file is not None:
	771	element.appendChild(newdoc.createTextNode(str(self.file)))
	772	else:
	773	element.appendChild(newdoc.createTextNode(str(file)))
	774	top_element.appendChild(element)
[2f4b430]	775
[11a7e11]	776	element = newdoc.createElement("timestamp")
	777	element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp)))
	778	attr = newdoc.createAttribute("epoch")
	779	attr.nodeValue = str(self.timestamp)
	780	element.setAttributeNode(attr)
	781	top_element.appendChild(element)
[a95ae9a]	782
[61cada5]	783	# Inputs
	784	inputs = newdoc.createElement("Attributes")
	785	top_element.appendChild(inputs)
[2f4b430]	786
[61cada5]	787	if self.data is not None and hasattr(self.data, "group_id"):
	788	self.data_group_id = self.data.group_id
	789	if self.data is not None and hasattr(self.data, "is_data"):
	790	self.is_data = self.data.is_data
	791	if self.data is not None:
	792	self.data_name = self.data.name
	793	if self.data is not None and hasattr(self.data, "id"):
	794	self.data_id = self.data.id
[2f4b430]	795
[b1e609c]	796	for item in LIST_OF_DATA_ATTRIBUTES:
[0b12abb5]	797	element = newdoc.createElement(item[0])
[b1e609c]	798	element.setAttribute(item[0], str(getattr(self, item[1])))
[f32d144]	799	inputs.appendChild(element)
[2f4b430]	800
[b1e609c]	801	for item in LIST_OF_STATE_ATTRIBUTES:
[26f3dd5]	802	element = newdoc.createElement(item[0])
[b1e609c]	803	element.setAttribute(item[0], str(getattr(self, item[1])))
[26f3dd5]	804	inputs.appendChild(element)
[2f4b430]	805
[f32d144]	806	# For self.values ={ disp_param_name: [vals,...],...}
	807	# and for self.weights ={ disp_param_name: [weights,...],...}
[b1e609c]	808	for item in LIST_OF_MODEL_ATTRIBUTES:
[11a7e11]	809	element = newdoc.createElement(item[0])
[b1e609c]	810	value_list = getattr(self, item[1])
	811	for key, value in value_list.iteritems():
[2296316]	812	sub_element = newdoc.createElement(key)
	813	sub_element.setAttribute('name', str(key))
	814	for val in value:
[b1e609c]	815	sub_element.appendChild(newdoc.createTextNode(str(val)))
[2f4b430]	816
[f32d144]	817	element.appendChild(sub_element)
[11a7e11]	818	inputs.appendChild(element)
[2f4b430]	819
[2296316]	820	# Create doc for the dictionary of self._disp_obj_dic
[6c382da]	821	for tagname, varname, tagtype in DISPERSION_LIST:
	822	element = newdoc.createElement(tagname)
	823	value_list = getattr(self, varname)
	824	for key, value in value_list.iteritems():
[f32d144]	825	sub_element = newdoc.createElement(key)
	826	sub_element.setAttribute('name', str(key))
	827	sub_element.setAttribute('value', str(value))
	828	element.appendChild(sub_element)
	829	inputs.appendChild(element)
[2f4b430]	830
[b1e609c]	831	for item in LIST_OF_STATE_PARAMETERS:
[61cada5]	832	element = newdoc.createElement(item[0])
[c8e1996]	833	self._to_xml_helper(thelist=getattr(self, item[1]),
	834	element=element, newdoc=newdoc)
[61cada5]	835	inputs.appendChild(element)
[2f4b430]	836
[a95ae9a]	837	# Combined and Simultaneous Fit Parameters
	838	if batch_fit_state is not None:
	839	batch_combo = newdoc.createElement('simultaneous_fit')
	840	top_element.appendChild(batch_combo)
	841
	842	# Simultaneous Fit Number For Linking Later
	843	element = newdoc.createElement('sim_fit_number')
	844	element.setAttribute('fit_number', str(batch_fit_state.fit_page_no))
	845	batch_combo.appendChild(element)
	846
	847	# Save constraints
	848	constraints = newdoc.createElement('constraints')
	849	batch_combo.appendChild(constraints)
	850	for constraint in batch_fit_state.constraints_list:
[998ca90]	851	if constraint.model_cbox.GetValue() != "":
[c8e1996]	852	# model_cbox, param_cbox, egal_txt, constraint,
	853	# btRemove, sizer
[998ca90]	854	doc_cons = newdoc.createElement('constraint')
	855	doc_cons.setAttribute('model_cbox',
	856	str(constraint.model_cbox.GetValue()))
	857	doc_cons.setAttribute('param_cbox',
	858	str(constraint.param_cbox.GetValue()))
	859	doc_cons.setAttribute('egal_txt',
	860	str(constraint.egal_txt.GetLabel()))
	861	doc_cons.setAttribute('constraint',
	862	str(constraint.constraint.GetValue()))
	863	constraints.appendChild(doc_cons)
[a95ae9a]	864
	865	# Save all models
	866	models = newdoc.createElement('model_list')
	867	batch_combo.appendChild(models)
	868	for model in batch_fit_state.model_list:
	869	doc_model = newdoc.createElement('model_list_item')
	870	doc_model.setAttribute('checked', str(model[0].GetValue()))
	871	keys = model[1].keys()
	872	doc_model.setAttribute('name', str(keys[0]))
	873	values = model[1].get(keys[0])
	874	doc_model.setAttribute('fit_number', str(model[2]))
	875	doc_model.setAttribute('fit_page_source', str(model[3]))
	876	doc_model.setAttribute('model_name', str(values.model.id))
	877	models.appendChild(doc_model)
	878
	879	# Select All Checkbox
	880	element = newdoc.createElement('select_all')
	881	if batch_fit_state.select_all:
	882	element.setAttribute('checked', 'True')
	883	else:
	884	element.setAttribute('checked', 'False')
	885	batch_combo.appendChild(element)
	886
[61cada5]	887	# Save the file
	888	if doc is None:
	889	fd = open(file, 'w')
	890	fd.write(newdoc.toprettyxml())
	891	fd.close()
	892	return None
	893	else:
[ac5b69d]	894	return newdoc
[2f4b430]	895
[c8e1996]	896	def _from_xml_helper(self, node, list):
[61cada5]	897	"""
[5062bbf]	898	Helper function to write state to xml
[61cada5]	899	"""
	900	for item in node:
[0b12abb5]	901	try:
	902	name = item.get('name')
	903	except:
	904	name = None
	905	try:
	906	value = item.get('value')
	907	except:
	908	value = None
	909	try:
[3ad91de]	910	selected_to_fit = (item.get('selected_to_fit') == "True")
[0b12abb5]	911	except:
	912	selected_to_fit = None
	913	try:
[3ad91de]	914	error_displayed = (item.get('error_displayed') == "True")
[0b12abb5]	915	except:
	916	error_displayed = None
[f32d144]	917	try:
[0b12abb5]	918	error_value = item.get('error_value')
	919	except:
	920	error_value = None
	921	try:
[f32d144]	922	minimum_displayed = (item.get('minimum_displayed') == "True")
[0b12abb5]	923	except:
	924	minimum_displayed = None
	925	try:
	926	minimum_value = item.get('minimum_value')
	927	except:
	928	minimum_value = None
	929	try:
[3ad91de]	930	maximum_displayed = (item.get('maximum_displayed') == "True")
[0b12abb5]	931	except:
	932	maximum_displayed = None
	933	try:
	934	maximum_value = item.get('maximum_value')
	935	except:
	936	maximum_value = None
	937	try:
	938	unit = item.get('unit')
	939	except:
	940	unit = None
[2296316]	941	list.append([selected_to_fit, name, value, "+/-",
	942	[error_displayed, error_value],
[f32d144]	943	[minimum_displayed, minimum_value],
	944	[maximum_displayed, maximum_value], unit])
[2f4b430]	945
[c8e1996]	946	def from_xml(self, file=None, node=None):
[61cada5]	947	"""
[5062bbf]	948	Load fitting state from a file
[2f4b430]	949
[5062bbf]	950	:param file: .fitv file
	951	:param node: node of a XML document to read from
[61cada5]	952	"""
	953	if file is not None:
[11a7e11]	954	msg = "PageState no longer supports non-CanSAS"
	955	msg += " format for fitting files"
	956	raise RuntimeError, msg
[2f4b430]	957
[e89aed5]	958	if node.get('version') and node.get('version') == '1.0':
[2f4b430]	959
[61cada5]	960	# Get file name
	961	entry = get_content('ns:filename', node)
	962	if entry is not None:
	963	self.file = entry.text.strip()
[2f4b430]	964
[11a7e11]	965	# Get time stamp
	966	entry = get_content('ns:timestamp', node)
	967	if entry is not None and entry.get('epoch'):
	968	try:
	969	self.timestamp = float(entry.get('epoch'))
	970	except:
	971	msg = "PageState.fromXML: Could not"
	972	msg += " read timestamp\n %s" % sys.exc_value
	973	logging.error(msg)
[2f4b430]	974
[61cada5]	975	if entry is not None:
[c8e1996]	976	# Parse fitting attributes
	977	entry = get_content('ns:Attributes', node)
	978	for item in LIST_OF_DATA_ATTRIBUTES:
	979	node = get_content('ns:%s' % item[0], entry)
	980	setattr(self, item[0], parse_entry_helper(node, item))
	981
[b1e609c]	982	for item in LIST_OF_STATE_ATTRIBUTES:
[2296316]	983	node = get_content('ns:%s' % item[0], entry)
[b1e609c]	984	setattr(self, item[0], parse_entry_helper(node, item))
[2f4b430]	985
[b1e609c]	986	for item in LIST_OF_STATE_PARAMETERS:
[2296316]	987	node = get_content("ns:%s" % item[0], entry)
[c8e1996]	988	self._from_xml_helper(node=node,
	989	list=getattr(self, item[1]))
[2f4b430]	990
[f32d144]	991	# Recover _disp_obj_dict from xml file
	992	self._disp_obj_dict = {}
[6c382da]	993	for tagname, varname, tagtype in DISPERSION_LIST:
	994	node = get_content("ns:%s" % tagname, entry)
[2296316]	995	for attr in node:
[6c382da]	996	parameter = str(attr.get('name'))
	997	value = attr.get('value')
	998	if value.startswith("<"):
	999	try:
	1000	# <path.to.NamedDistribution object/instance...>
	1001	cls_name = value[1:].split()[0].split('.')[-1]
	1002	cls = getattr(sasmodels.weights, cls_name)
	1003	value = cls.type
	1004	except Exception:
[998ca90]	1005	base = "unable to load distribution %r for %s"
	1006	logging.error(base % (value, parameter))
[6c382da]	1007	continue
	1008	_disp_obj_dict = getattr(self, varname)
	1009	_disp_obj_dict[parameter] = value
[2f4b430]	1010
[f32d144]	1011	# get self.values and self.weights dic. if exists
[6c382da]	1012	for tagname, varname in LIST_OF_MODEL_ATTRIBUTES:
	1013	node = get_content("ns:%s" % tagname, entry)
[2296316]	1014	dic = {}
[b1e609c]	1015	value_list = []
[2296316]	1016	for par in node:
	1017	name = par.get('name')
[6c382da]	1018	values = par.text.split()
[2296316]	1019	# Get lines only with numbers
	1020	for line in values:
	1021	try:
[f32d144]	1022	val = float(line)
[b1e609c]	1023	value_list.append(val)
[7673ecd]	1024	except Exception:
[2296316]	1025	# pass if line is empty (it happens)
[6c382da]	1026	msg = ("Error reading %r from %s %s\n"
	1027	% (line, tagname, name))
	1028	logging.error(msg + traceback.format_exc())
[0e33a8d]	1029	dic[name] = numpy.array(value_list)
[6c382da]	1030	setattr(self, varname, dic)
[2f4b430]	1031
[2296316]	1032	def set_plot_state(self, figs, canvases):
	1033	"""
	1034	Build image state that wx.html understand
	1035	by plotting, putting it into wx.FileSystem image object
	1036
	1037	"""
	1038	images = []
	1039
	1040	# Reset memory
	1041	self.imgRAM = None
	1042	wx.MemoryFSHandler()
[2f4b430]	1043
[2296316]	1044	# For no figures in the list, prepare empty plot
[c8e1996]	1045	if figs is None or len(figs) == 0:
[2296316]	1046	figs = [None]
[2f4b430]	1047
[f32d144]	1048	# Loop over the list of figures
[2296316]	1049	# use wx.MemoryFSHandler
[f32d144]	1050	self.imgRAM = wx.MemoryFSHandler()
[2296316]	1051	for fig in figs:
[c8e1996]	1052	if fig is not None:
[2296316]	1053	ind = figs.index(fig)
	1054	canvas = canvases[ind]
[2f4b430]	1055
[c8e1996]	1056	# store the image in wx.FileSystem Object
[2296316]	1057	wx.FileSystem.AddHandler(wx.MemoryFSHandler())
[2f4b430]	1058
[2296316]	1059	# index of the fig
	1060	ind = figs.index(fig)
[2f4b430]	1061
[c8e1996]	1062	# AddFile, image can be retrieved with 'memory:filename'
[f32d144]	1063	self.imgRAM.AddFile('img_fit%s.png' % ind,
[2296316]	1064	canvas.bitmap, wx.BITMAP_TYPE_PNG)
[2f4b430]	1065
[c8e1996]	1066	# append figs
[2296316]	1067	images.append(fig)
[2f4b430]	1068
[c0ff8cc]	1069	return images
[61cada5]	1070
[f32d144]	1071
[61cada5]	1072	class Reader(CansasReader):
	1073	"""
[5062bbf]	1074	Class to load a .fitv fitting file
[61cada5]	1075	"""
[c8e1996]	1076	# File type
[61cada5]	1077	type_name = "Fitting"
[2f4b430]	1078
[c8e1996]	1079	# Wildcards
[b35d3d1]	1080	type = ["Fitting files (.fitv)\|.fitv"
[b9a5f0e]	1081	"SASView file (.svs)\|.svs"]
[c8e1996]	1082	# List of allowed extensions
[f32d144]	1083	ext = ['.fitv', '.FITV', '.svs', 'SVS']
[2f4b430]	1084
[61cada5]	1085	def __init__(self, call_back=None, cansas=True):
[df7ed14]	1086	CansasReader.__init__(self)
[61cada5]	1087	"""
[5062bbf]	1088	Initialize the call-back method to be called
	1089	after we load a file
[2f4b430]	1090
[5062bbf]	1091	:param call_back: call-back method
	1092	:param cansas: True = files will be written/read in CanSAS format
	1093	False = write CanSAS format
[2f4b430]	1094
[61cada5]	1095	"""
[c8e1996]	1096	# Call back method to be executed after a file is read
[61cada5]	1097	self.call_back = call_back
[c8e1996]	1098	# CanSAS format flag
[61cada5]	1099	self.cansas = cansas
[75fbd17]	1100	self.state = None
[a95ae9a]	1101	# batch fitting params for saving
	1102	self.batchfit_params = []
[2f4b430]	1103
[75fbd17]	1104	def get_state(self):
	1105	return self.state
[2f4b430]	1106
[61cada5]	1107	def read(self, path):
[f32d144]	1108	"""
[5062bbf]	1109	Load a new P(r) inversion state from file
[2f4b430]	1110
[5062bbf]	1111	:param path: file path
[2f4b430]	1112
[61cada5]	1113	"""
[c8e1996]	1114	if self.cansas:
[61cada5]	1115	return self._read_cansas(path)
[2f4b430]	1116
[e9b12eaf]	1117	def _data2d_to_xml_doc(self, datainfo):
[61cada5]	1118	"""
[5062bbf]	1119	Create an XML document to contain the content of a Data2D
[2f4b430]	1120
[5062bbf]	1121	:param datainfo: Data2D object
[2f4b430]	1122
[61cada5]	1123	"""
	1124	if not issubclass(datainfo.__class__, Data2D):
	1125	raise RuntimeError, "The cansas writer expects a Data2D instance"
[2f4b430]	1126
[998ca90]	1127	title = "cansas1d/%s" % self.version
	1128	title += "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd"
[61cada5]	1129	doc = xml.dom.minidom.Document()
	1130	main_node = doc.createElement("SASroot")
	1131	main_node.setAttribute("version", self.version)
[df7ed14]	1132	main_node.setAttribute("xmlns", "cansas1d/%s" % self.version)
[998ca90]	1133	main_node.setAttribute("xmlns:xsi",
	1134	"http://www.w3.org/2001/XMLSchema-instance")
	1135	main_node.setAttribute("xsi:schemaLocation", title)
[2f4b430]	1136
[61cada5]	1137	doc.appendChild(main_node)
[2f4b430]	1138
[61cada5]	1139	entry_node = doc.createElement("SASentry")
	1140	main_node.appendChild(entry_node)
[2f4b430]	1141
[61cada5]	1142	write_node(doc, entry_node, "Title", datainfo.title)
[df7ed14]	1143	if datainfo is not None:
[998ca90]	1144	write_node(doc, entry_node, "data_class",
	1145	datainfo.__class__.__name__)
[61cada5]	1146	for item in datainfo.run:
	1147	runname = {}
[c8e1996]	1148	if item in datainfo.run_name and \
[998ca90]	1149	len(str(datainfo.run_name[item])) > 1:
[b1e609c]	1150	runname = {'name': datainfo.run_name[item]}
[61cada5]	1151	write_node(doc, entry_node, "Run", item, runname)
	1152	# Data info
[df7ed14]	1153	new_node = doc.createElement("SASdata")
	1154	entry_node.appendChild(new_node)
[b1e609c]	1155	for item in LIST_OF_DATA_2D_ATTR:
[e9b12eaf]	1156	element = doc.createElement(item[0])
[b1e609c]	1157	element.setAttribute(item[0], str(getattr(datainfo, item[1])))
[df7ed14]	1158	new_node.appendChild(element)
[2f4b430]	1159
[b1e609c]	1160	for item in LIST_OF_DATA_2D_VALUES:
[df7ed14]	1161	root_node = doc.createElement(item[0])
	1162	new_node.appendChild(root_node)
[b1e609c]	1163	temp_list = getattr(datainfo, item[1])
[df7ed14]	1164
[2f4b430]	1165	if temp_list is None or len(temp_list) == 0:
[df7ed14]	1166	element = doc.createElement(item[0])
[b1e609c]	1167	element.appendChild(doc.createTextNode(str(temp_list)))
[df7ed14]	1168	root_node.appendChild(element)
[35b556d]	1169	else:
	1170	for value in temp_list:
[df7ed14]	1171	element = doc.createElement(item[0])
[b1e609c]	1172	element.setAttribute(item[0], str(value))
[df7ed14]	1173	root_node.appendChild(element)
[2f4b430]	1174
[61cada5]	1175	# Sample info
	1176	sample = doc.createElement("SASsample")
	1177	if datainfo.sample.name is not None:
	1178	sample.setAttribute("name", str(datainfo.sample.name))
	1179	entry_node.appendChild(sample)
	1180	write_node(doc, sample, "ID", str(datainfo.sample.ID))
[f32d144]	1181	write_node(doc, sample, "thickness", datainfo.sample.thickness,
	1182	{"unit": datainfo.sample.thickness_unit})
[61cada5]	1183	write_node(doc, sample, "transmission", datainfo.sample.transmission)
[f32d144]	1184	write_node(doc, sample, "temperature", datainfo.sample.temperature,
	1185	{"unit": datainfo.sample.temperature_unit})
[2f4b430]	1186
[61cada5]	1187	for item in datainfo.sample.details:
	1188	write_node(doc, sample, "details", item)
[2f4b430]	1189
[61cada5]	1190	pos = doc.createElement("position")
[f32d144]	1191	written = write_node(doc, pos, "x", datainfo.sample.position.x,
	1192	{"unit": datainfo.sample.position_unit})
	1193	written = written \| write_node(doc, pos, "y",
	1194	datainfo.sample.position.y,
	1195	{"unit": datainfo.sample.position_unit})
	1196	written = written \| write_node(doc, pos, "z",
	1197	datainfo.sample.position.z,
	1198	{"unit": datainfo.sample.position_unit})
[c8e1996]	1199	if written:
[61cada5]	1200	sample.appendChild(pos)
[2f4b430]	1201
[61cada5]	1202	ori = doc.createElement("orientation")
[f32d144]	1203	written = write_node(doc, ori, "roll", datainfo.sample.orientation.x,
	1204	{"unit": datainfo.sample.orientation_unit})
	1205	written = written \| write_node(doc, ori, "pitch",
	1206	datainfo.sample.orientation.y,
[c8e1996]	1207	{"unit":
	1208	datainfo.sample.orientation_unit})
[f32d144]	1209	written = written \| write_node(doc, ori, "yaw",
	1210	datainfo.sample.orientation.z,
[c8e1996]	1211	{"unit":
	1212	datainfo.sample.orientation_unit})
	1213	if written:
[61cada5]	1214	sample.appendChild(ori)
[2f4b430]	1215
[61cada5]	1216	# Instrument info
	1217	instr = doc.createElement("SASinstrument")
	1218	entry_node.appendChild(instr)
[2f4b430]	1219
[61cada5]	1220	write_node(doc, instr, "name", datainfo.instrument)
[2f4b430]	1221
[61cada5]	1222	# Source
	1223	source = doc.createElement("SASsource")
	1224	if datainfo.source.name is not None:
	1225	source.setAttribute("name", str(datainfo.source.name))
	1226	instr.appendChild(source)
[2f4b430]	1227
[61cada5]	1228	write_node(doc, source, "radiation", datainfo.source.radiation)
	1229	write_node(doc, source, "beam_shape", datainfo.source.beam_shape)
	1230	size = doc.createElement("beam_size")
	1231	if datainfo.source.beam_size_name is not None:
	1232	size.setAttribute("name", str(datainfo.source.beam_size_name))
[f32d144]	1233	written = write_node(doc, size, "x", datainfo.source.beam_size.x,
	1234	{"unit": datainfo.source.beam_size_unit})
	1235	written = written \| write_node(doc, size, "y",
	1236	datainfo.source.beam_size.y,
	1237	{"unit": datainfo.source.beam_size_unit})
	1238	written = written \| write_node(doc, size, "z",
	1239	datainfo.source.beam_size.z,
	1240	{"unit": datainfo.source.beam_size_unit})
[c8e1996]	1241	if written:
[61cada5]	1242	source.appendChild(size)
[2f4b430]	1243
[f32d144]	1244	write_node(doc, source, "wavelength", datainfo.source.wavelength,
	1245	{"unit": datainfo.source.wavelength_unit})
	1246	write_node(doc, source, "wavelength_min",
	1247	datainfo.source.wavelength_min,
	1248	{"unit": datainfo.source.wavelength_min_unit})
	1249	write_node(doc, source, "wavelength_max",
	1250	datainfo.source.wavelength_max,
	1251	{"unit": datainfo.source.wavelength_max_unit})
	1252	write_node(doc, source, "wavelength_spread",
	1253	datainfo.source.wavelength_spread,
	1254	{"unit": datainfo.source.wavelength_spread_unit})
[2f4b430]	1255
[61cada5]	1256	# Collimation
	1257	for item in datainfo.collimation:
	1258	coll = doc.createElement("SAScollimation")
	1259	if item.name is not None:
	1260	coll.setAttribute("name", str(item.name))
	1261	instr.appendChild(coll)
[2f4b430]	1262
[f32d144]	1263	write_node(doc, coll, "length", item.length,
	1264	{"unit": item.length_unit})
[2f4b430]	1265
[61cada5]	1266	for apert in item.aperture:
	1267	ap = doc.createElement("aperture")
	1268	if apert.name is not None:
	1269	ap.setAttribute("name", str(apert.name))
	1270	if apert.type is not None:
	1271	ap.setAttribute("type", str(apert.type))
	1272	coll.appendChild(ap)
[2f4b430]	1273
[f32d144]	1274	write_node(doc, ap, "distance", apert.distance,
	1275	{"unit": apert.distance_unit})
[2f4b430]	1276
[61cada5]	1277	size = doc.createElement("size")
	1278	if apert.size_name is not None:
	1279	size.setAttribute("name", str(apert.size_name))
[f32d144]	1280	written = write_node(doc, size, "x", apert.size.x,
	1281	{"unit": apert.size_unit})
	1282	written = written \| write_node(doc, size, "y", apert.size.y,
	1283	{"unit": apert.size_unit})
	1284	written = written \| write_node(doc, size, "z", apert.size.z,
	1285	{"unit": apert.size_unit})
[c8e1996]	1286	if written:
[61cada5]	1287	ap.appendChild(size)
	1288
	1289	# Detectors
	1290	for item in datainfo.detector:
	1291	det = doc.createElement("SASdetector")
	1292	written = write_node(doc, det, "name", item.name)
[f32d144]	1293	written = written \| write_node(doc, det, "SDD", item.distance,
	1294	{"unit": item.distance_unit})
	1295	written = written \| write_node(doc, det, "slit_length",
	1296	item.slit_length,
	1297	{"unit": item.slit_length_unit})
[c8e1996]	1298	if written:
[61cada5]	1299	instr.appendChild(det)
[2f4b430]	1300
[61cada5]	1301	off = doc.createElement("offset")
[f32d144]	1302	written = write_node(doc, off, "x", item.offset.x,
	1303	{"unit": item.offset_unit})
	1304	written = written \| write_node(doc, off, "y", item.offset.y,
	1305	{"unit": item.offset_unit})
	1306	written = written \| write_node(doc, off, "z", item.offset.z,
	1307	{"unit": item.offset_unit})
[c8e1996]	1308	if written:
[61cada5]	1309	det.appendChild(off)
[2f4b430]	1310
[61cada5]	1311	center = doc.createElement("beam_center")
[f32d144]	1312	written = write_node(doc, center, "x", item.beam_center.x,
	1313	{"unit": item.beam_center_unit})
	1314	written = written \| write_node(doc, center, "y",
	1315	item.beam_center.y,
	1316	{"unit": item.beam_center_unit})
	1317	written = written \| write_node(doc, center, "z",
	1318	item.beam_center.z,
	1319	{"unit": item.beam_center_unit})
[c8e1996]	1320	if written:
[61cada5]	1321	det.appendChild(center)
[2f4b430]	1322
[61cada5]	1323	pix = doc.createElement("pixel_size")
[f32d144]	1324	written = write_node(doc, pix, "x", item.pixel_size.x,
	1325	{"unit": item.pixel_size_unit})
	1326	written = written \| write_node(doc, pix, "y", item.pixel_size.y,
	1327	{"unit": item.pixel_size_unit})
	1328	written = written \| write_node(doc, pix, "z", item.pixel_size.z,
	1329	{"unit": item.pixel_size_unit})
[c8e1996]	1330	if written:
[61cada5]	1331	det.appendChild(pix)
[2f4b430]	1332
[61cada5]	1333	ori = doc.createElement("orientation")
[f32d144]	1334	written = write_node(doc, ori, "roll", item.orientation.x,
	1335	{"unit": item.orientation_unit})
	1336	written = written \| write_node(doc, ori, "pitch",
	1337	item.orientation.y,
	1338	{"unit": item.orientation_unit})
	1339	written = written \| write_node(doc, ori, "yaw", item.orientation.z,
	1340	{"unit": item.orientation_unit})
[c8e1996]	1341	if written:
[61cada5]	1342	det.appendChild(ori)
[2f4b430]	1343
[61cada5]	1344	# Processes info
	1345	for item in datainfo.process:
	1346	node = doc.createElement("SASprocess")
	1347	entry_node.appendChild(node)
	1348
	1349	write_node(doc, node, "name", item.name)
	1350	write_node(doc, node, "date", item.date)
	1351	write_node(doc, node, "description", item.description)
	1352	for term in item.term:
	1353	value = term['value']
	1354	del term['value']
	1355	write_node(doc, node, "term", value, term)
	1356	for note in item.notes:
	1357	write_node(doc, node, "SASprocessnote", note)
	1358	# Return the document, and the SASentry node associated with
	1359	# the data we just wrote
	1360	return doc, entry_node
[2f4b430]	1361
[61cada5]	1362	def _parse_state(self, entry):
	1363	"""
[5062bbf]	1364	Read a fit result from an XML node
[2f4b430]	1365
[f32d144]	1366	:param entry: XML node to read from
[5062bbf]	1367	:return: PageState object
[61cada5]	1368	"""
	1369	# Create an empty state
[2f4b430]	1370	state = None
[61cada5]	1371	# Locate the P(r) node
	1372	try:
[f32d144]	1373	nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME,
	1374	namespaces={'ns': CANSAS_NS})
[e89aed5]	1375	if nodes:
[b35d3d1]	1376	# Create an empty state
[f32d144]	1377	state = PageState()
[c8e1996]	1378	state.from_xml(node=nodes[0])
[2f4b430]	1379
[61cada5]	1380	except:
[6c382da]	1381	logging.info("XML document does not contain fitting information.\n"
	1382	+ traceback.format_exc())
[2f4b430]	1383
[61cada5]	1384	return state
[2f4b430]	1385
[e89aed5]	1386	def _parse_simfit_state(self, entry):
	1387	"""
	1388	Parses the saved data for a simultaneous fit
	1389	:param entry: XML object to read from
	1390	:return: XML object for a simultaneous fit or None
	1391	"""
	1392	nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME,
	1393	namespaces={'ns': CANSAS_NS})
	1394	if nodes:
	1395	simfitstate = nodes[0].xpath('ns:simultaneous_fit',
	1396	namespaces={'ns': CANSAS_NS})
	1397	if simfitstate:
	1398	from simfitpage import SimFitPageState
	1399	sim_fit_state = SimFitPageState()
	1400	simfitstate_0 = simfitstate[0]
	1401	all = simfitstate_0.xpath('ns:select_all',
[c8e1996]	1402	namespaces={'ns': CANSAS_NS})
[e89aed5]	1403	atts = all[0].attrib
	1404	checked = atts.get('checked')
	1405	sim_fit_state.select_all = bool(checked)
	1406	model_list = simfitstate_0.xpath('ns:model_list',
[c8e1996]	1407	namespaces={'ns': CANSAS_NS})
[e89aed5]	1408	model_list_items = model_list[0].xpath('ns:model_list_item',
[c8e1996]	1409	namespaces={'ns':
	1410	CANSAS_NS})
[e89aed5]	1411	for model in model_list_items:
	1412	attrs = model.attrib
	1413	sim_fit_state.model_list.append(attrs)
[998ca90]	1414
[e89aed5]	1415	constraints = simfitstate_0.xpath('ns:constraints',
	1416	namespaces={'ns': CANSAS_NS})
	1417	constraint_list = constraints[0].xpath('ns:constraint',
[998ca90]	1418	namespaces={'ns': CANSAS_NS})
[e89aed5]	1419	for constraint in constraint_list:
	1420	attrs = constraint.attrib
	1421	sim_fit_state.constraints_list.append(attrs)
	1422
	1423	return sim_fit_state
	1424	else:
	1425	return None
	1426
[ac5b69d]	1427	def _parse_save_state_entry(self, dom):
[e9b12eaf]	1428	"""
[5062bbf]	1429	Parse a SASentry
[2f4b430]	1430
[5062bbf]	1431	:param node: SASentry node
[2f4b430]	1432
[df7ed14]	1433	:return: Data1D/Data2D object
[2f4b430]	1434
[e9b12eaf]	1435	"""
[df7ed14]	1436	node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS})
	1437	if not node or node[0].text.lstrip().rstrip() != "Data2D":
[ac5b69d]	1438	return_value, _ = self._parse_entry(dom)
	1439	numpy.trim_zeros(return_value.x)
	1440	numpy.trim_zeros(return_value.y)
	1441	numpy.trim_zeros(return_value.dy)
	1442	size_dx = return_value.dx.size
	1443	size_dxl = return_value.dxl.size
	1444	size_dxw = return_value.dxw.size
	1445	if size_dxl == 0 and size_dxw == 0:
	1446	return_value.dxl = None
	1447	return_value.dxw = None
	1448	numpy.trim_zeros(return_value.dx)
	1449	elif size_dx == 0:
	1450	return_value.dx = None
	1451	size_dx = size_dxl
	1452	numpy.trim_zeros(return_value.dxl)
	1453	numpy.trim_zeros(return_value.dxw)
[2f4b430]	1454
[ac5b69d]	1455	return return_value, _
[2f4b430]	1456
[c8e1996]	1457	# Parse 2D
[e9b12eaf]	1458	data_info = Data2D()
[2f4b430]	1459
[f32d144]	1460	# Look up title
[e9b12eaf]	1461	self._store_content('ns:Title', dom, 'title', data_info)
[2f4b430]	1462
[f32d144]	1463	# Look up run number
[e9b12eaf]	1464	nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS})
[f32d144]	1465	for item in nodes:
[e9b12eaf]	1466	if item.text is not None:
	1467	value = item.text.strip()
	1468	if len(value) > 0:
	1469	data_info.run.append(value)
	1470	if item.get('name') is not None:
	1471	data_info.run_name[value] = item.get('name')
[2f4b430]	1472
[f32d144]	1473	# Look up instrument name
	1474	self._store_content('ns:SASinstrument/ns:name', dom,
	1475	'instrument', data_info)
[e9b12eaf]	1476
	1477	# Notes
	1478	note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS})
	1479	for note in note_list:
	1480	try:
	1481	if note.text is not None:
	1482	note_value = note.text.strip()
	1483	if len(note_value) > 0:
	1484	data_info.notes.append(note_value)
[7673ecd]	1485	except Exception:
[998ca90]	1486	err_mess = "cansas_reader.read: error processing entry notes\n"
	1487	err_mess += " %s" % sys.exc_value
[e9b12eaf]	1488	self.errors.append(err_mess)
	1489	logging.error(err_mess)
[2f4b430]	1490
[e9b12eaf]	1491	# Sample info ###################
	1492	entry = get_content('ns:SASsample', dom)
	1493	if entry is not None:
	1494	data_info.sample.name = entry.get('name')
[2f4b430]	1495
[b1e609c]	1496	self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample)
[998ca90]	1497	self._store_float('ns:SASsample/ns:thickness', dom, 'thickness',
	1498	data_info.sample)
	1499	self._store_float('ns:SASsample/ns:transmission', dom, 'transmission',
	1500	data_info.sample)
	1501	self._store_float('ns:SASsample/ns:temperature', dom, 'temperature',
	1502	data_info.sample)
	1503
	1504	nodes = dom.xpath('ns:SASsample/ns:details',
	1505	namespaces={'ns': CANSAS_NS})
[e9b12eaf]	1506	for item in nodes:
	1507	try:
	1508	if item.text is not None:
	1509	detail_value = item.text.strip()
	1510	if len(detail_value) > 0:
	1511	data_info.sample.details.append(detail_value)
[7673ecd]	1512	except Exception:
[998ca90]	1513	err_mess = "cansas_reader.read: error processing entry notes\n"
	1514	err_mess += " %s" % sys.exc_value
[e9b12eaf]	1515	self.errors.append(err_mess)
	1516	logging.error(err_mess)
[2f4b430]	1517
[e9b12eaf]	1518	# Position (as a vector)
[998ca90]	1519	self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x',
	1520	data_info.sample)
	1521	self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y',
	1522	data_info.sample)
	1523	self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z',
	1524	data_info.sample)
[2f4b430]	1525
[e9b12eaf]	1526	# Orientation (as a vector)
[f32d144]	1527	self._store_float('ns:SASsample/ns:orientation/ns:roll',
[b1e609c]	1528	dom, 'orientation.x', data_info.sample)
[f32d144]	1529	self._store_float('ns:SASsample/ns:orientation/ns:pitch',
[b1e609c]	1530	dom, 'orientation.y', data_info.sample)
[f32d144]	1531	self._store_float('ns:SASsample/ns:orientation/ns:yaw',
[b1e609c]	1532	dom, 'orientation.z', data_info.sample)
[2f4b430]	1533
[e9b12eaf]	1534	# Source info ###################
	1535	entry = get_content('ns:SASinstrument/ns:SASsource', dom)
	1536	if entry is not None:
	1537	data_info.source.name = entry.get('name')
[2f4b430]	1538
[f32d144]	1539	self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation',
[b1e609c]	1540	dom, 'radiation', data_info.source)
[f32d144]	1541	self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape',
[b1e609c]	1542	dom, 'beam_shape', data_info.source)
[f32d144]	1543	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength',
[b1e609c]	1544	dom, 'wavelength', data_info.source)
[f32d144]	1545	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min',
[b1e609c]	1546	dom, 'wavelength_min', data_info.source)
[f32d144]	1547	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max',
[b1e609c]	1548	dom, 'wavelength_max', data_info.source)
[f32d144]	1549	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread',
[b1e609c]	1550	dom, 'wavelength_spread', data_info.source)
[2f4b430]	1551
[f32d144]	1552	# Beam size (as a vector)
[e9b12eaf]	1553	entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom)
	1554	if entry is not None:
	1555	data_info.source.beam_size_name = entry.get('name')
[2f4b430]	1556
[f32d144]	1557	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x',
[b1e609c]	1558	dom, 'beam_size.x', data_info.source)
[f32d144]	1559	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y',
[b1e609c]	1560	dom, 'beam_size.y', data_info.source)
[f32d144]	1561	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z',
[b1e609c]	1562	dom, 'beam_size.z', data_info.source)
[2f4b430]	1563
[e9b12eaf]	1564	# Collimation info ###################
[f32d144]	1565	nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation',
	1566	namespaces={'ns': CANSAS_NS})
[e9b12eaf]	1567	for item in nodes:
	1568	collim = Collimation()
	1569	if item.get('name') is not None:
	1570	collim.name = item.get('name')
[f32d144]	1571	self._store_float('ns:length', item, 'length', collim)
[2f4b430]	1572
[e9b12eaf]	1573	# Look for apertures
[f32d144]	1574	apert_list = item.xpath('ns:aperture',
	1575	namespaces={'ns': CANSAS_NS})
[e9b12eaf]	1576	for apert in apert_list:
[f32d144]	1577	aperture = Aperture()
[2f4b430]	1578
[e9b12eaf]	1579	# Get the name and type of the aperture
	1580	aperture.name = apert.get('name')
	1581	aperture.type = apert.get('type')
[2f4b430]	1582
[f32d144]	1583	self._store_float('ns:distance', apert, 'distance', aperture)
[2f4b430]	1584
[e9b12eaf]	1585	entry = get_content('ns:size', apert)
	1586	if entry is not None:
	1587	aperture.size_name = entry.get('name')
[2f4b430]	1588
[f32d144]	1589	self._store_float('ns:size/ns:x', apert, 'size.x', aperture)
	1590	self._store_float('ns:size/ns:y', apert, 'size.y', aperture)
[e9b12eaf]	1591	self._store_float('ns:size/ns:z', apert, 'size.z', aperture)
[2f4b430]	1592
[e9b12eaf]	1593	collim.aperture.append(aperture)
[2f4b430]	1594
[e9b12eaf]	1595	data_info.collimation.append(collim)
[2f4b430]	1596
[e9b12eaf]	1597	# Detector info ######################
[f32d144]	1598	nodes = dom.xpath('ns:SASinstrument/ns:SASdetector',
	1599	namespaces={'ns': CANSAS_NS})
[e9b12eaf]	1600	for item in nodes:
[2f4b430]	1601
[e9b12eaf]	1602	detector = Detector()
[2f4b430]	1603
[e9b12eaf]	1604	self._store_content('ns:name', item, 'name', detector)
[f32d144]	1605	self._store_float('ns:SDD', item, 'distance', detector)
[2f4b430]	1606
[e9b12eaf]	1607	# Detector offset (as a vector)
[f32d144]	1608	self._store_float('ns:offset/ns:x', item, 'offset.x', detector)
	1609	self._store_float('ns:offset/ns:y', item, 'offset.y', detector)
	1610	self._store_float('ns:offset/ns:z', item, 'offset.z', detector)
[2f4b430]	1611
[e9b12eaf]	1612	# Detector orientation (as a vector)
[f32d144]	1613	self._store_float('ns:orientation/ns:roll', item,
	1614	'orientation.x', detector)
	1615	self._store_float('ns:orientation/ns:pitch', item,
	1616	'orientation.y', detector)
	1617	self._store_float('ns:orientation/ns:yaw', item,
	1618	'orientation.z', detector)
[2f4b430]	1619
[e9b12eaf]	1620	# Beam center (as a vector)
[f32d144]	1621	self._store_float('ns:beam_center/ns:x', item,
	1622	'beam_center.x', detector)
	1623	self._store_float('ns:beam_center/ns:y', item,
	1624	'beam_center.y', detector)
	1625	self._store_float('ns:beam_center/ns:z', item,
	1626	'beam_center.z', detector)
[2f4b430]	1627
[e9b12eaf]	1628	# Pixel size (as a vector)
[f32d144]	1629	self._store_float('ns:pixel_size/ns:x', item,
	1630	'pixel_size.x', detector)
	1631	self._store_float('ns:pixel_size/ns:y', item,
	1632	'pixel_size.y', detector)
	1633	self._store_float('ns:pixel_size/ns:z', item,
	1634	'pixel_size.z', detector)
[2f4b430]	1635
[e9b12eaf]	1636	self._store_float('ns:slit_length', item, 'slit_length', detector)
[2f4b430]	1637
[f32d144]	1638	data_info.detector.append(detector)
[e9b12eaf]	1639
	1640	# Processes info ######################
	1641	nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS})
	1642	for item in nodes:
	1643	process = Process()
	1644	self._store_content('ns:name', item, 'name', process)
	1645	self._store_content('ns:date', item, 'date', process)
	1646	self._store_content('ns:description', item, 'description', process)
[2f4b430]	1647
[e9b12eaf]	1648	term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS})
	1649	for term in term_list:
	1650	try:
	1651	term_attr = {}
	1652	for attr in term.keys():
	1653	term_attr[attr] = term.get(attr).strip()
	1654	if term.text is not None:
	1655	term_attr['value'] = term.text.strip()
	1656	process.term.append(term_attr)
	1657	except:
[998ca90]	1658	err_mess = "cansas_reader.read: error processing "
	1659	err_mess += "entry notes\n %s" % sys.exc_value
[e9b12eaf]	1660	self.errors.append(err_mess)
	1661	logging.error(err_mess)
[2f4b430]	1662
[f32d144]	1663	note_list = item.xpath('ns:SASprocessnote',
	1664	namespaces={'ns': CANSAS_NS})
[e9b12eaf]	1665	for note in note_list:
	1666	if note.text is not None:
	1667	process.notes.append(note.text.strip())
[2f4b430]	1668
[e9b12eaf]	1669	data_info.process.append(process)
[2f4b430]	1670
[e9b12eaf]	1671	# Data info ######################
	1672	nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS})
[f32d144]	1673	if len(nodes) > 1:
[a95ae9a]	1674	raise RuntimeError, "CanSAS reader is not compatible with" + \
	1675	" multiple SASdata entries"
[2f4b430]	1676
[df7ed14]	1677	for entry in nodes:
[b1e609c]	1678	for item in LIST_OF_DATA_2D_ATTR:
[c8e1996]	1679	# get node
[f32d144]	1680	node = get_content('ns:%s' % item[0], entry)
[b1e609c]	1681	setattr(data_info, item[1], parse_entry_helper(node, item))
[2f4b430]	1682
[b1e609c]	1683	for item in LIST_OF_DATA_2D_VALUES:
[f32d144]	1684	field = get_content('ns:%s' % item[0], entry)
[b1e609c]	1685	value_list = []
[df7ed14]	1686	if field is not None:
[998ca90]	1687	value_list = \
	1688	[parse_entry_helper(node, item) for node in field]
[b1e609c]	1689	if len(value_list) < 2:
	1690	setattr(data_info, item[0], None)
[44f7c1b]	1691	else:
[b1e609c]	1692	setattr(data_info, item[0], numpy.array(value_list))
[2f4b430]	1693
[e9b12eaf]	1694	return data_info
	1695
[61cada5]	1696	def _read_cansas(self, path):
[f32d144]	1697	"""
[e89aed5]	1698	Load data and fitting information from a CanSAS XML file.
[2f4b430]	1699
[5062bbf]	1700	:param path: file path
[f32d144]	1701	:return: Data1D object if a single SASentry was found,
[5062bbf]	1702	or a list of Data1D objects if multiple entries were found,
	1703	or None of nothing was found
	1704	:raise RuntimeError: when the file can't be opened
	1705	:raise ValueError: when the length of the data vectors are inconsistent
[61cada5]	1706	"""
	1707	output = []
[e89aed5]	1708	simfitstate = None
[f32d144]	1709	basename = os.path.basename(path)
[b63dc6e]	1710	root, extension = os.path.splitext(basename)
	1711	ext = extension.lower()
[61cada5]	1712	try:
	1713	if os.path.isfile(path):
[a95ae9a]	1714	if ext in self.ext or ext == '.xml':
[61cada5]	1715	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
	1716	# Check the format version number
[a95ae9a]	1717	# Specifying the namespace will take care of the file
	1718	# format version
[61cada5]	1719	root = tree.getroot()
[f32d144]	1720	entry_list = root.xpath('ns:SASentry',
	1721	namespaces={'ns': CANSAS_NS})
	1722	for entry in entry_list:
[e9b12eaf]	1723	try:
[ac5b69d]	1724	sas_entry, _ = self._parse_save_state_entry(entry)
[e9b12eaf]	1725	except:
[df7ed14]	1726	raise
[61cada5]	1727	fitstate = self._parse_state(entry)
[2f4b430]	1728
[a95ae9a]	1729	# state could be None when .svs file is loaded
	1730	# in this case, skip appending to output
	1731	if fitstate is not None:
[b35d3d1]	1732	sas_entry.meta_data['fitstate'] = fitstate
	1733	sas_entry.filename = fitstate.file
	1734	output.append(sas_entry)
[e89aed5]	1735
[61cada5]	1736	else:
[b63dc6e]	1737	self.call_back(format=ext)
[61cada5]	1738	raise RuntimeError, "%s is not a file" % path
[b35d3d1]	1739
[61cada5]	1740	# Return output consistent with the loader's api
[f32d144]	1741	if len(output) == 0:
	1742	self.call_back(state=None, datainfo=None, format=ext)
[61cada5]	1743	return None
	1744	else:
[b35d3d1]	1745	for ind in range(len(output)):
	1746	# Call back to post the new state
	1747	state = output[ind].meta_data['fitstate']
	1748	t = time.localtime(state.timestamp)
	1749	time_str = time.strftime("%b %d %H:%M", t)
	1750	# Check that no time stamp is already appended
	1751	max_char = state.file.find("[")
	1752	if max_char < 0:
	1753	max_char = len(state.file)
[ef16f59]	1754	original_fname = state.file[0:max_char]
[f32d144]	1755	state.file = original_fname + ' [' + time_str + ']'
[2f4b430]	1756
[b35d3d1]	1757	if state is not None and state.is_data is not None:
[b1e609c]	1758	output[ind].is_data = state.is_data
[2f4b430]	1759
[b35d3d1]	1760	output[ind].filename = state.file
	1761	state.data = output[ind]
[f32d144]	1762	state.data.name = output[ind].filename # state.data_name
[b35d3d1]	1763	state.data.id = state.data_id
	1764	if state.is_data is not None:
	1765	state.data.is_data = state.is_data
[f32d144]	1766	if output[ind].run_name is not None\
[c8e1996]	1767	and len(output[ind].run_name) != 0:
[654e8e0]	1768	if isinstance(output[ind].run_name, dict):
	1769	name = output[ind].run_name.keys()[0]
	1770	else:
	1771	name = output[ind].run_name
[f32d144]	1772	else:
	1773	name = original_fname
[ef16f59]	1774	state.data.group_id = name
[a95ae9a]	1775	# store state in fitting
[f32d144]	1776	self.call_back(state=state,
	1777	datainfo=output[ind], format=ext)
	1778	self.state = state
[e6de6b8]	1779	simfitstate = self._parse_simfit_state(entry)
[e89aed5]	1780	if simfitstate is not None:
	1781	self.call_back(state=simfitstate)
	1782
[ef16f59]	1783	return output
[61cada5]	1784	except:
[4bee68d]	1785	self.call_back(format=ext)
[61cada5]	1786	raise
[2f4b430]	1787
[61cada5]	1788	def write(self, filename, datainfo=None, fitstate=None):
	1789	"""
[b35d3d1]	1790	Write the content of a Data1D as a CanSAS XML file only for standalone
[2f4b430]	1791
[5062bbf]	1792	:param filename: name of the file to write
	1793	:param datainfo: Data1D object
	1794	:param fitstate: PageState object
[2f4b430]	1795
[61cada5]	1796	"""
	1797	# Sanity check
[a95ae9a]	1798	if self.cansas:
[61cada5]	1799	# Add fitting information to the XML document
[ef16f59]	1800	doc = self.write_toXML(datainfo, fitstate)
[61cada5]	1801	# Write the XML document
	1802	else:
[c8e1996]	1803	doc = fitstate.to_xml(file=filename)
[2f4b430]	1804
[ac5b69d]	1805	# Save the document no matter the type
	1806	fd = open(filename, 'w')
	1807	fd.write(doc.toprettyxml())
	1808	fd.close()
[2f4b430]	1809
[a95ae9a]	1810	def write_toXML(self, datainfo=None, state=None, batchfit=None):
[b35d3d1]	1811	"""
[f32d144]	1812	Write toXML, a helper for write(),
	1813	could be used by guimanager._on_save()
[2f4b430]	1814
[b35d3d1]	1815	: return: xml doc
	1816	"""
[3c44c66]	1817
[a95ae9a]	1818	self.batchfit_params = batchfit
	1819	if state.data is None or not state.data.is_data:
[3b148c3]	1820	return None
[a95ae9a]	1821	# make sure title and data run are filled.
	1822	if state.data.title is None or state.data.title == '':
	1823	state.data.title = state.data.name
	1824	if state.data.run_name is None or state.data.run_name == {}:
	1825	state.data.run = [str(state.data.name)]
	1826	state.data.run_name[0] = state.data.name
	1827
	1828	if issubclass(state.data.__class__,
	1829	sas.sascalc.dataloader.data_info.Data1D):
	1830	data = state.data
	1831	doc, sasentry = self._to_xml_doc(data)
[f32d144]	1832	else:
[a95ae9a]	1833	data = state.data
	1834	doc, sasentry = self._data2d_to_xml_doc(data)
[2f4b430]	1835
[b35d3d1]	1836	if state is not None:
[c8e1996]	1837	doc = state.to_xml(doc=doc, file=data.filename, entry_node=sasentry,
	1838	batch_fit_state=self.batchfit_params)
[2f4b430]	1839
[f32d144]	1840	return doc
[467202f]	1841
	1842	# Simple html report templet
	1843	HEADER = "<html>\n"
	1844	HEADER += "<head>\n"
	1845	HEADER += "<meta http-equiv=Content-Type content='text/html; "
	1846	HEADER += "charset=windows-1252'> \n"
	1847	HEADER += "<meta name=Generator >\n"
	1848	HEADER += "</head>\n"
	1849	HEADER += "<body lang=EN-US>\n"
	1850	HEADER += "<div class=WordSection1>\n"
	1851	HEADER += "<p class=MsoNormal><b><span ><center><font size='4' >"
	1852	HEADER += "%s</font></center></span></center></b></p>"
	1853	HEADER += "<p class=MsoNormal> </p>"
	1854	PARA = "<p class=MsoNormal><font size='4' > %s \n"
	1855	PARA += "</font></p>"
	1856	CENTRE = "<p class=MsoNormal><center><font size='4' > %s \n"
	1857	CENTRE += "</font></center></p>"
	1858	FEET_1 = \
	1859	"""
	1860	<p class=MsoNormal> </p>
	1861	<br>
	1862	<p class=MsoNormal><b><span ><center> <font size='4' > Graph
	1863	</font></span></center></b></p>
	1864	<p class=MsoNormal> </p>
	1865	<center>
	1866	<br><font size='4' >Model Computation</font>
	1867	<br><font size='4' >Data: "%s"</font><br>
	1868	"""
	1869	FEET_2 = \
	1870	"""
	1871	<img src="%s" >
	1872	</img>
	1873	"""
	1874	FEET_3 = \
	1875	"""
	1876	</center>
	1877	</div>
	1878	</body>
	1879	</html>
	1880	"""
[c8e1996]	1881	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 @ 6fb6592

Download in other formats: