pagestate.py @ db5294e

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

Download in other formats: