pagestate.py @ 2ada16c

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.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 2ada16c was b7c6a4a, checked in by Jae Cho <jhjcho@…>, 13 years ago
changed time stamp string format
Property mode set to `100644`
File size: 67.7 KB

Rev	Line
[c77d859]	1
	2
[5062bbf]	3	################################################################################
	4	#This software was developed by the University of Tennessee as part of the
	5	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
	6	#project funded by the US National Science Foundation.
	7	#
	8	#See the license text in license.txt
	9	#
	10	#copyright 2009, University of Tennessee
	11	################################################################################
	12
[11a7e11]	13	import time
	14	import os
	15	import sys
[6f023e8]	16	import copy
[11a7e11]	17	import logging
[df7ed14]	18	import numpy
[c77d859]	19
[35b556d]	20	import xml.dom.minidom
[11a7e11]	21	from xml.dom.minidom import parse
	22	from lxml import etree
	23
[c21e87b]	24	import sans.dataloader
	25	from sans.dataloader.readers.cansas_reader import Reader as CansasReader
	26	from sans.dataloader.readers.cansas_reader import get_content, write_node
	27	from sans.dataloader.data_info import Data2D, Detector
[61cada5]	28
[11a7e11]	29	#Information to read/write state as xml
[61cada5]	30	FITTING_NODE_NAME = 'fitting_plug_in'
	31	CANSAS_NS = "cansas1d/1.0"
	32
[26f3dd5]	33	list_of_data_attributes = [["is_data", "is_data", "bool"],
[61cada5]	34	["group_id", "data_group_id", "string"],
	35	["data_name", "data_name", "string"],
	36	["data_id", "data_id", "string"],
	37	["name", "name", "string"],
[26f3dd5]	38	["data_name", "data_name", "string"]]
[e3d1423]	39	list_of_state_attributes = [["engine_type", "engine_type", "string"],
	40	["qmin", "qmin", "float"],
[61cada5]	41	["qmax", "qmax", "float"],
	42	["npts", "npts", "float"],
	43	["shape_rbutton", "shape_rbutton", "bool"],
	44	["shape_indep_rbutton", "shape_indep_rbutton", "bool"],
	45	["plugin_rbutton", "plugin_rbutton","bool"],
	46	["struct_rbutton", "struct_rbutton", "bool"],
[0b12abb5]	47	["formfactorcombobox", "formfactorcombobox", "float"],
	48	["structurecombobox", "structurecombobox", "float"],
[c0ff8cc]	49	["multi_factor","multi_factor","float"],
[26f3dd5]	50	["enable_smearer","enable_smearer","bool"],
	51	["disable_smearer","disable_smearer","bool"],
	52	["pinhole_smearer","pinhole_smearer","bool"],
	53	["slit_smearer","slit_smearer","bool"],
	54	["enable_disp","enable_disp","bool"],
	55	["disable_disp","disable_disp","bool"],
[55bb249c]	56	["dI_noweight","dI_noweight","bool"],
	57	["dI_didata","dI_didata","bool"],
	58	["dI_sqrdata","dI_sqrdata","bool"],
	59	["dI_idata","dI_idata","bool"],
[26f3dd5]	60	["enable2D","enable2D","bool"],
	61	["cb1","cb1","bool"],
[5cc7001]	62	["tcChi","tcChi","float"],
[55bb249c]	63	["smearer", "smearer", "float"],
	64	["smear_type","smear_type", "string"],
	65	["dq_l", "dq_l", "string"],
	66	["dq_r","dq_r", "string"]]
[5cc7001]	67
[11a7e11]	68	list_of_model_attributes = [["values", "values"],
	69	["weights", "weights"]]
	70
[2296316]	71	list_of_obj_dic = [["disp_obj_dict", "_disp_obj_dict", "string"]]
	72
[fb59ed9]	73	list_of_state_parameters = [["parameters", "parameters"] ,
	74	["str_parameters", "str_parameters"] ,
[61cada5]	75	["orientation_parameters", "orientation_params"],
	76	["dispersity_parameters", "orientation_params_disp"],
	77	["fixed_param", "fixed_param"],
	78	["fittable_param","fittable_param"]]
[df7ed14]	79	list_of_data_2d_attr = [["xmin", "xmin","float"],
	80	["xmax","xmax","float"],
	81	["ymin","ymin","float"],
	82	["ymax","ymax","float"],
	83	["_xaxis","_xaxis", "string"],
	84	["_xunit", "_xunit", "string"],
	85	["_yaxis","_yaxis","string"],
	86	["_yunit","_yunit","string"],
	87	["_zaxis","_zaxis","string"],
	88	["_zunit","_zunit","string"]]
	89	list_of_data2d_values = [["qx_data","qx_data","float"],
	90	["qy_data","qy_data","float"],
	91	["dqx_data","dqx_data","float"],
	92	["dqy_data","dqy_data","float"],
	93	["data","data","float"],
	94	["q_data","q_data","float"],
	95	["err_data","err_data","float"],
	96	["mask","mask","bool"]]
[61cada5]	97
[0b12abb5]	98	def parse_entry_helper( node, item):
	99	"""
	100	Create a numpy list from value extrated from the node
	101
	102	:param node: node from each the value is stored
	103	:param item: list name of three strings.the two first are name of data
	104	attribute and the third one is the type of the value of that
	105	attribute. type can be string, float, bool, etc.
	106
	107	: return: numpy array
	108	"""
	109	if node is not None:
	110	if item[2] == "string":
	111	return str(node.get(item[0]).strip())
	112	elif item[2] == "bool":
	113	try:
[e3d1423]	114	return node.get(item[0]).strip() == "True"
	115
[0b12abb5]	116	except:
	117	return None
	118	else:
	119	try:
	120	return float(node.get(item[0]))
	121	except:
	122	return None
	123
	124
[cfc0913]	125	class PageState(object):
[c77d859]	126	"""
[5062bbf]	127	Contains information to reconstruct a page of the fitpanel.
[c77d859]	128	"""
[61cada5]	129	def __init__(self, parent=None, model=None, data=None):
[c77d859]	130
	131	"""
[5062bbf]	132	Initialize the current state
	133
	134	:param model: a selected model within a page
	135	:param data:
	136
[c77d859]	137	"""
[61cada5]	138	self.file = None
[11a7e11]	139	#Time of state creation
	140	self.timestamp = time.time()
[c77d859]	141	## Data member to store the dispersion object created
	142	self._disp_obj_dict = {}
[61cada5]	143	#------------------------
[c77d859]	144	#Data used for fitting
	145	self.data = data
[2296316]	146	# model data
	147	self.theory_data = None
	148	#Is 2D
	149	self.is_2D = False
	150	self.images = None
	151
[61cada5]	152	#save additional information on data that dataloader.reader does not read
	153	self.is_data = None
	154	self.data_name = ""
[c0ff8cc]	155
[61cada5]	156	if self.data is not None:
	157	self.data_name = self.data.name
	158	self.data_id = None
	159	if self.data is not None and hasattr(self.data, "id"):
	160	self.data_id = self.data.id
	161	self.data_group_id = None
	162	if self.data is not None and hasattr(self.data, "group_id"):
	163	self.data_group_id = self.data.group_id
[0b12abb5]	164
[61cada5]	165	## reset True change the state of exsiting button
	166	self.reset = False
	167
[c99a6c5]	168	#engine type
	169	self.engine_type = None
[c77d859]	170	# flag to allow data2D plot
[cfc0913]	171	self.enable2D = False
[c77d859]	172	# model on which the fit would be performed
	173	self.model = model
[dce84c0]	174	#list of process done to model
	175	self.process = []
[c77d859]	176	#fit page manager
	177	self.manager = None
	178	#Store the parent of this panel parent
	179	# For this application fitpanel is the parent
	180	self.parent = parent
	181	# Event_owner is the owner of model event
	182	self.event_owner = None
[c9a4377]	183	##page name
[cfc0913]	184	self.page_name = ""
[c77d859]	185	# Contains link between model ,all its parameters, and panel organization
[61cada5]	186	self.parameters = []
[fb59ed9]	187	# String parameter list that can not be fitted
	188	self.str_parameters = []
[c77d859]	189	# Contains list of parameters that cannot be fitted and reference to
	190	#panel objects
[61cada5]	191	self.fixed_param = []
[c77d859]	192	# Contains list of parameters with dispersity and reference to
	193	#panel objects
[61cada5]	194	self.fittable_param = []
[60132ef]	195	## orientation parameters
[61cada5]	196	self.orientation_params = []
[fc6ea43]	197	## orientation parmaters for gaussian dispersity
[61cada5]	198	self.orientation_params_disp = []
[3370922]	199	## smearer info
[61cada5]	200	self.smearer = None
[7609f1a]	201	self.smear_type = None
	202	self.dq_l = None
	203	self.dq_r = None
	204
[c77d859]	205	#list of dispersion paramaters
[cfc0913]	206	self.disp_list =[]
[61cada5]	207	if self.model is not None:
[71f0373]	208	self.disp_list = self.model.getDispParamList()
[2296316]	209
[61cada5]	210	self.disp_cb_dict = {}
[2296316]	211	self.values = {}
	212	self.weights = {}
[dad49a0]	213
[c77d859]	214	#contains link between a model and selected parameters to fit
[61cada5]	215	self.param_toFit = []
[a074145]	216	##dictionary of model type and model class
[cfc0913]	217	self.model_list_box = None
[a074145]	218	## save the state of the context menu
[61cada5]	219	self.saved_states = {}
[240b9966]	220	## save selection of combobox
[3b9e023]	221	self.formfactorcombobox = None
	222	self.structurecombobox = None
[c0ff8cc]	223
[240b9966]	224	## radio box to select type of model
	225	self.shape_rbutton = False
	226	self.shape_indep_rbutton = False
	227	self.struct_rbutton = False
	228	self.plugin_rbutton = False
[b787e68c]	229	## the indice of the current selection
	230	self.disp_box = 0
[c77d859]	231	## Qrange
[cfc0913]	232	## Q range
[61cada5]	233	self.qmin = 0.001
	234	self.qmax = 0.1
[0b12abb5]	235	#reset data range
	236	self.qmax_x = None
	237	self.qmin_x = None
	238
[cfc0913]	239	self.npts = None
[61cada5]	240	self.name = ""
[4523b68]	241	self.multi_factor = None
[cfc0913]	242	## enable smearering state
	243	self.enable_smearer = False
[fc6ea43]	244	self.disable_smearer = True
[7609f1a]	245	self.pinhole_smearer = False
	246	self.slit_smearer = False
[55bb249c]	247	# weighting options
	248	self.dI_noweight = False
	249	self.dI_didata = True
	250	self.dI_sqrdata = False
	251	self.dI_idata = False
[cfc0913]	252	## disperity selection
[61cada5]	253	self.enable_disp = False
	254	self.disable_disp = True
[11a7e11]	255
[cfc0913]	256	## state of selected all check button
	257	self.cb1 = False
[0aeabc6]	258	## store value of chisqr
[61cada5]	259	self.tcChi = None
[240b9966]	260
[6f023e8]	261	def clone(self):
[61cada5]	262	"""
[5062bbf]	263	Create a new copy of the current object
[61cada5]	264	"""
	265	model = None
	266	if self.model is not None:
[6f023e8]	267	model = self.model.clone()
[bb70474]	268	model.name = self.model.name
[61cada5]	269	obj = PageState(self.parent, model=model)
	270	obj.file = copy.deepcopy(self.file)
[6f023e8]	271	obj.data = copy.deepcopy(self.data)
[61cada5]	272	if self.data is not None:
	273	self.data_name = self.data.name
	274	obj.data_name = self.data_name
	275	obj.is_data = self.is_data
[dcf29d7]	276	obj.model_list_box = copy.deepcopy(self.model_list_box)
[c99a6c5]	277	obj.engine_type = copy.deepcopy(self.engine_type)
[240b9966]	278
[61cada5]	279	obj.formfactorcombobox = self.formfactorcombobox
	280	obj.structurecombobox = self.structurecombobox
[240b9966]	281
	282	obj.shape_rbutton = self.shape_rbutton
	283	obj.shape_indep_rbutton = self.shape_indep_rbutton
	284	obj.struct_rbutton = self.struct_rbutton
	285	obj.plugin_rbutton = self.plugin_rbutton
	286
[dcf29d7]	287	obj.manager = self.manager
	288	obj.event_owner = self.event_owner
[71f0373]	289	obj.disp_list = copy.deepcopy(self.disp_list)
[fc6ea43]	290
[c477b31]	291	obj.enable2D = copy.deepcopy(self.enable2D)
[cfc0913]	292	obj.parameters = copy.deepcopy(self.parameters)
[fb59ed9]	293	obj.str_parameters = copy.deepcopy(self.str_parameters)
[cfc0913]	294	obj.fixed_param = copy.deepcopy(self.fixed_param)
	295	obj.fittable_param = copy.deepcopy(self.fittable_param)
[60132ef]	296	obj.orientation_params = copy.deepcopy(self.orientation_params)
[fc6ea43]	297	obj.orientation_params_disp = copy.deepcopy(self.orientation_params_disp)
[b787e68c]	298	obj.enable_disp = copy.deepcopy(self.enable_disp)
[fc6ea43]	299	obj.disable_disp = copy.deepcopy(self.disable_disp)
[0aeabc6]	300	obj.tcChi = self.tcChi
	301
[c477b31]	302	if len(self._disp_obj_dict)>0:
	303	for k , v in self._disp_obj_dict.iteritems():
	304	obj._disp_obj_dict[k]= v
[dad49a0]	305	if len(self.disp_cb_dict)>0:
	306	for k , v in self.disp_cb_dict.iteritems():
	307	obj.disp_cb_dict[k]= v
[2296316]	308	if len(self.values)>0:
	309	for k , v in self.values.iteritems():
	310	obj.values[k] = v
	311	if len(self.weights)>0:
	312	for k , v in self.weights.iteritems():
	313	obj.weights[k] = v
[b787e68c]	314	obj.enable_smearer = copy.deepcopy(self.enable_smearer)
[fc6ea43]	315	obj.disable_smearer = copy.deepcopy(self.disable_smearer)
[7609f1a]	316	obj.pinhole_smearer = copy.deepcopy(self.pinhole_smearer)
	317	obj.slit_smearer = copy.deepcopy(self.slit_smearer)
	318	obj.smear_type = copy.deepcopy(self.smear_type)
[55bb249c]	319	obj.dI_noweight = copy.deepcopy(self.dI_noweight)
	320	obj.dI_didata = copy.deepcopy(self.dI_didata)
	321	obj.dI_sqrdata = copy.deepcopy(self.dI_sqrdata)
	322	obj.dI_idata = copy.deepcopy(self.dI_idata)
[7609f1a]	323	obj.dq_l = copy.deepcopy(self.dq_l)
	324	obj.dq_r = copy.deepcopy(self.dq_r)
	325
[b787e68c]	326	obj.disp_box = copy.deepcopy(self.disp_box)
	327	obj.qmin = copy.deepcopy(self.qmin)
	328	obj.qmax = copy.deepcopy(self.qmax)
[c0ff8cc]	329	obj.multi_factor = self.multi_factor
[b787e68c]	330	obj.npts = copy.deepcopy(self.npts )
	331	obj.cb1 = copy.deepcopy(self.cb1)
[3370922]	332	obj.smearer = copy.deepcopy(self.smearer)
	333
[a074145]	334	for name, state in self.saved_states.iteritems():
	335	copy_name = copy.deepcopy(name)
	336	copy_state = state.clone()
	337	obj.saved_states[copy_name]= copy_state
[6f023e8]	338	return obj
[61cada5]	339
	340	def _repr_helper(self, list, rep):
	341	"""
[5062bbf]	342	Helper method to print a state
[61cada5]	343	"""
	344	for item in list:
[240b9966]	345	rep += "parameter name: %s \n"%str(item[1])
	346	rep += "value: %s\n"%str(item[2])
	347	rep += "selected: %s\n"%str(item[0])
	348	rep += "error displayed : %s \n"%str(item[4][0])
	349	rep += "error value:%s \n"%str(item[4][1])
	350	rep += "minimum displayed : %s \n"%str(item[5][0])
	351	rep += "minimum value : %s \n"%str(item[5][1])
	352	rep += "maximum displayed : %s \n"%str(item[6][0])
	353	rep += "maximum value : %s \n"%str(item[6][1])
	354	rep += "parameter unit: %s\n\n"%str(item[7])
	355	return rep
[c0ff8cc]	356
[61cada5]	357	def __repr__(self):
[11a7e11]	358	"""
[5062bbf]	359	output string for printing
[11a7e11]	360	"""
	361	rep = "\nState name: %s\n"%self.file
	362	t = time.localtime(self.timestamp)
[b7c6a4a]	363	time_str = time.strftime("%H;%M - %b %d - %Y", t)
[c0ff8cc]	364
[b7c6a4a]	365	rep += "State created: %s\n"%time_str
[11a7e11]	366	rep += "State form factor combobox selection: %s\n"%self.formfactorcombobox
	367	rep += "State structure factor combobox selection: %s\n"%self.structurecombobox
	368	rep += "is data : %s\n"%self.is_data
	369	rep += "data's name : %s\n"%self.data_name
	370	rep += "data's id : %s\n"%self.data_id
	371	rep += "model type (form factor) selected: %s\n"%self.shape_rbutton
[c0ff8cc]	372	rep += "multi_factor : %s\n"% str(self.multi_factor)
[11a7e11]	373	rep += "model type (shape independent) selected: %s\n"%self.shape_indep_rbutton
	374	rep += "model type (structure factor) selected: %s\n"%self.struct_rbutton
	375	rep += "model type (plug-in ) selected: %s\n"%self.plugin_rbutton
	376	rep += "data : %s\n"% str(self.data)
	377	rep += "Plotting Range: min: %s, max: %s, steps: %s\n"%(str(self.qmin),
	378	str(self.qmax),str(self.npts))
[0b12abb5]	379	rep += "Dispersion selection : %s\n"%str(self.disp_box)
	380	rep += "Smearing enable : %s\n"%str(self.enable_smearer)
	381	rep += "Smearing disable : %s\n"%str(self.disable_smearer)
	382	rep += "Pinhole smearer enable : %s\n"%str(self.pinhole_smearer)
	383	rep += "Slit smearer enable : %s\n"%str(self.slit_smearer)
	384	rep += "Dispersity enable : %s\n"%str(self.enable_disp)
	385	rep += "Dispersity disable : %s\n"%str(self.disable_disp)
	386	rep += "Slit smearer enable: %s\n"%str(self.slit_smearer)
[55bb249c]	387
	388	rep += "dI_noweight : %s\n"%str(self.dI_noweight)
	389	rep += "dI_didata : %s\n"%str(self.dI_didata)
	390	rep += "dI_sqrdata : %s\n"%str(self.dI_sqrdata)
	391	rep += "dI_idata : %s\n"%str(self.dI_idata)
	392
	393
[0b12abb5]	394	rep += "2D enable : %s\n"%str(self.enable2D)
	395	rep += "All parameters checkbox selected: %s\n"%(self.cb1)
	396	rep += "Value of Chisqr : %s\n"%str(self.tcChi)
	397	rep += "Smear object : %s\n"%str(self.smearer)
	398	rep += "Smear type : %s\n"%(self.smear_type)
	399	rep += "dq_l : %s\n"%self.dq_l
	400	rep += "dq_r : %s\n"%self.dq_r
	401
[11a7e11]	402	rep += "model : %s\n\n"% str(self.model)
[2296316]	403	temp_parameters = []
	404	temp_fittable_param = []
	405	if self.data.__class__.__name__ == "Data2D":
	406	self.is_2D = True
	407	else:
	408	self.is_2D = False
	409	if self.data is not None:
	410	if not self.is_2D:
	411	for item in self.parameters:
	412	if not item in self.orientation_params:
	413	temp_parameters.append(item)
	414	for item in self.fittable_param:
	415	if not item in self.orientation_params_disp:
	416	temp_fittable_param.append(item)
	417	else:
	418	temp_parameters = self.parameters
	419	temp_fittable_param = self.fittable_param
	420
	421	rep += "number parameters(self.parameters): %s\n"%len(temp_parameters)
	422	rep = self._repr_helper( list=temp_parameters, rep=rep)
	423	rep += "number str_parameters(self.str_parameters): %s\n"%len(self.str_parameters)
	424	rep = self._repr_helper( list=self.str_parameters, rep=rep)
	425	rep += "number fittable_param(self.fittable_param): %s\n"%len(temp_fittable_param)
	426	rep = self._repr_helper( list=temp_fittable_param, rep=rep)
	427	"""
	428	if is_2D:
	429	rep += "number orientation parameters"
	430	rep += "(self.orientation_params): %s\n"%len(self.orientation_params)
	431	rep = self._repr_helper( list=self.orientation_params, rep=rep)
	432	rep += "number dispersity parameters"
	433	rep += "(self.orientation_params_disp): %s\n"%len(self.orientation_params_disp)
	434	rep = self._repr_helper( list=self.orientation_params_disp, rep=rep)
	435	"""
[61cada5]	436	return rep
[2296316]	437
	438	def set_report_string(self):
	439	"""
	440	Get the values (strings) from __str__ for report
	441	"""
	442	# Dictionary of teh report strings
	443	repo_time = ""
	444	model_name = ""
	445	title = ""
	446	title_name = ""
	447	file_name = ""
	448	param_string = ""
	449	paramval_string = ""
	450	chi2_string = ""
[c0ff8cc]	451	multi_factor_string = ""
[2296316]	452	q_range = ""
	453	strings = self.__repr__()
	454	lines = strings.split('\n')
	455
	456	# get all string values from __str__()
	457	for line in lines:
	458	value = ""
	459	content = line.split(":")
	460	name = content[0]
	461	try:
	462	value = content[1]
	463	except:
	464	pass
[b7c6a4a]	465	if name.count("State created"):
	466	repo_time = "" + value
[2296316]	467	if name.count("parameter name"):
	468	val_name = value.split(".")
	469	if len(val_name) > 1:
	470	if val_name[1].count("width"):
	471	param_string += value + ','
	472	else:
	473	continue
	474	else:
	475	param_string += value + ','
	476	if name == "value":
	477	param_string += value + ','
	478	if name == "error value":
	479	param_string += value + ','
	480	if name == "parameter unit":
	481	param_string += value + ':'
	482	if name == "Value of Chisqr ":
	483	chi2 = ("Chi2/Npts = " + value)
	484	chi2_string = CENTRE % chi2
[c0ff8cc]	485	if name == "multi_factor ":
	486	muti_factor = ("muti_factor = " + value)
	487	muti_factor_string = CENTRE % muti_factor
[2296316]	488	if name == "Title":
	489	if len(value.strip()) == 0:
	490	continue
	491	title = value + " [" + repo_time + "]"
	492	title_name = HEADER % title
	493	if name == "data ":
	494	try:
	495	file = ("File name:" + content[2])
	496	file_name = CENTRE % file
	497	if len(title) == 0:
	498	title = content[2] + " [" + repo_time + "]"
	499	title_name = HEADER % title
	500	except:
	501	pass
	502	if name == "Plotting Range":
	503	try:
	504	q_range = content[1] + " = " + content[2] \
	505	+ " = " + content[3].split(",")[0]
	506	q_name = ("Q Range: " + q_range)
	507	q_range = CENTRE % q_name
	508	except:
	509	pass
	510	paramval = ""
[8e671c39]	511	paramval_string += "<table> <tr>"
[2296316]	512	for lines in param_string.split(":"):
	513	line = lines.split(",")
	514	if len(lines) > 0:
	515	param = line[0]
	516	param += " = " + line[1]
	517	if len(line[2].split()) > 0 and not line[2].count("None"):
	518	param += " +- " + line[2]
	519	if len(line[3].split()) > 0 and not line[3].count("None"):
	520	param += " " + line[3]
	521	if not paramval.count(param):
	522	paramval += param + "\n"
	523	paramval_string += CENTRE % param + "\n"
[8e671c39]	524	paramval_string += '</tr>'
	525	paramval_string += '</table>'
[f5bdb4a]	526	text_string = "\n\n\n" + title + "\n\n" + file + \
	527	"\n" + q_name + \
	528	"\n" + chi2 + \
	529	"\n\n" + paramval
	530
	531	title_name = self._check_html_format(title_name)
	532	file_name = self._check_html_format(file_name)
	533	title = self._check_html_format(title)
	534
[2296316]	535	html_string = title_name + "\n" + file_name + \
	536	"\n" + q_range + \
	537	"\n" + chi2_string + \
	538	"\n" + ELINE + \
	539	"\n" + paramval_string + \
	540	"\n" + ELINE + \
	541	"\n" + FEET_1 % title + \
	542	"\n" + FEET_2
[f5bdb4a]	543
[2296316]	544	return html_string, text_string, title
	545
[f5bdb4a]	546	def _check_html_format(self, name):
	547	"""
	548	Check string '%' for html format
	549	"""
	550	if name.count('%'):
	551	name = name.replace('%', '&#37')
	552
	553	return name
	554
	555
[2296316]	556	def report(self, figs=None, canvases=None):
	557	"""
	558	Invoke report dialog panel
	559
	560	: param figs: list of pylab figures [list]
	561	"""
	562	from report_dialog import ReportDialog
	563	# get the strings for report
	564	html_str, text_str, title = self.set_report_string()
	565	# Allow 2 figures to append
	566	if len(figs) == 1:
	567	add_str = FEET_3
	568	elif len(figs) == 2:
	569	add_str = ELINE
	570	add_str += FEET_2 % ("%s")
	571	add_str += ELINE
	572	add_str += FEET_3
	573	elif len(figs) > 2:
	574	add_str = ELINE
	575	add_str += FEET_2 % ("%s")
	576	add_str += ELINE
	577	add_str += FEET_2 % ("%s")
	578	add_str += ELINE
	579	add_str += FEET_3
	580	else:
	581	add_str = ""
[c0ff8cc]	582
[2296316]	583	# final report html strings
	584	report_str = html_str % ("%s") + add_str
	585
	586	# make plot image
	587	images = self.set_plot_state(figs, canvases)
	588	report_list = [report_str, text_str, images ]
	589	dialog = ReportDialog(report_list, None, -1, "")
	590	dialog.ShowModal()
[c0ff8cc]	591
	592
[61cada5]	593	def _toXML_helper(self, list, element, newdoc):
	594	"""
[5062bbf]	595	Helper method to create xml file for saving state
[61cada5]	596	"""
	597	for item in list:
	598	sub_element = newdoc.createElement('parameter')
	599	sub_element.setAttribute('name', str(item[1]))
	600	sub_element.setAttribute('value', str(item[2]))
	601	sub_element.setAttribute('selected_to_fit', str(item[0]))
	602	sub_element.setAttribute('error_displayed', str(item[4][0]))
	603	sub_element.setAttribute('error_value', str(item[4][1]))
	604	sub_element.setAttribute('minimum_displayed', str(item[5][0]))
	605	sub_element.setAttribute('minimum_value', str(item[5][1]))
	606	sub_element.setAttribute('maximum_displayed', str(item[6][0]))
	607	sub_element.setAttribute('maximum_value', str(item[6][1]))
	608	sub_element.setAttribute('unit', str(item[7]))
	609	element.appendChild(sub_element)
	610
	611	def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None):
	612	"""
[5062bbf]	613	Writes the state of the InversionControl panel to file, as XML.
	614
	615	Compatible with standalone writing, or appending to an
	616	already existing XML document. In that case, the XML document
	617	is required. An optional entry node in the XML document may also be given.
	618
	619	:param file: file to write to
	620	:param doc: XML document object [optional]
	621	:param entry_node: XML node within the XML document at which we will append the data [optional]
	622
[61cada5]	623	"""
	624	from xml.dom.minidom import getDOMImplementation
[71f0373]	625
[61cada5]	626	# Check whether we have to write a standalone XML file
	627	if doc is None:
	628	impl = getDOMImplementation()
	629	doc_type = impl.createDocumentType(FITTING_NODE_NAME, "1.0", "1.0")
	630	newdoc = impl.createDocument(None, FITTING_NODE_NAME, doc_type)
	631	top_element = newdoc.documentElement
	632	else:
	633	# We are appending to an existing document
	634	newdoc = doc
	635	top_element = newdoc.createElement(FITTING_NODE_NAME)
	636	if entry_node is None:
	637	newdoc.documentElement.appendChild(top_element)
	638	else:
	639	entry_node.appendChild(top_element)
	640
	641	attr = newdoc.createAttribute("version")
	642	attr.nodeValue = '1.0'
	643	top_element.setAttributeNode(attr)
[cfc0913]	644
[61cada5]	645	# File name
	646	element = newdoc.createElement("filename")
	647	if self.file is not None:
	648	element.appendChild(newdoc.createTextNode(str(self.file)))
	649	else:
	650	element.appendChild(newdoc.createTextNode(str(file)))
	651	top_element.appendChild(element)
[11a7e11]	652
	653	element = newdoc.createElement("timestamp")
	654	element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp)))
	655	attr = newdoc.createAttribute("epoch")
	656	attr.nodeValue = str(self.timestamp)
	657	element.setAttributeNode(attr)
	658	top_element.appendChild(element)
[61cada5]	659	# Inputs
	660	inputs = newdoc.createElement("Attributes")
	661	top_element.appendChild(inputs)
	662
[0b12abb5]	663
[61cada5]	664	if self.data is not None and hasattr(self.data, "group_id"):
	665	self.data_group_id = self.data.group_id
	666	if self.data is not None and hasattr(self.data, "is_data"):
	667	self.is_data = self.data.is_data
	668	if self.data is not None:
	669	self.data_name = self.data.name
	670	if self.data is not None and hasattr(self.data, "id"):
	671	self.data_id = self.data.id
	672
[26f3dd5]	673	for item in list_of_data_attributes:
[0b12abb5]	674	element = newdoc.createElement(item[0])
[2296316]	675	exec "element.setAttribute(item[0], str(self.%s))" % (item[1])
[0b12abb5]	676	inputs.appendChild(element)
[26f3dd5]	677
	678	for item in list_of_state_attributes:
	679	element = newdoc.createElement(item[0])
[2296316]	680	exec "element.setAttribute(item[0], str(self.%s))" % (item[1])
[26f3dd5]	681	inputs.appendChild(element)
[c0ff8cc]	682
[2296316]	683	# For self.values ={ disp_param_name: [vals,...],...}
[c0ff8cc]	684	# and for self.weights ={ disp_param_name: [weights,...],...}
[11a7e11]	685	for item in list_of_model_attributes:
	686	element = newdoc.createElement(item[0])
[2296316]	687	exec "list = self.%s" % item[1]
	688	for key, value in list.iteritems():
	689	sub_element = newdoc.createElement(key)
	690	sub_element.setAttribute('name', str(key))
	691	for val in value:
	692	com = "sub_element.appendChild"
	693	com += "(newdoc.createTextNode(str(%s)))"
	694	exec com % val
	695
	696	element.appendChild(sub_element)
[11a7e11]	697	inputs.appendChild(element)
[2296316]	698
	699	# Create doc for the dictionary of self._disp_obj_dic
	700	for item in list_of_obj_dic:
	701	element = newdoc.createElement(item[0])
	702	exec "list = self.%s" % item[1]
	703	for key, val in list.iteritems():
	704	value = repr(val)
	705	sub_element = newdoc.createElement(key)
	706	sub_element.setAttribute('name', str(key))
	707	sub_element.setAttribute('value', str(value))
	708	element.appendChild(sub_element)
	709	inputs.appendChild(element)
	710
[61cada5]	711	for item in list_of_state_parameters:
	712	element = newdoc.createElement(item[0])
[2296316]	713	com = "self._toXML_helper(list=self.%s,"
	714	com += " element=element, newdoc=newdoc)"
	715	exec com % item[1]
[61cada5]	716	inputs.appendChild(element)
[c0ff8cc]	717
[61cada5]	718	# Save the file
	719	if doc is None:
	720	fd = open(file, 'w')
	721	fd.write(newdoc.toprettyxml())
	722	fd.close()
	723	return None
	724	else:
	725	return newdoc.toprettyxml()
	726
	727	def _fromXML_helper(self, node, list):
	728	"""
[5062bbf]	729	Helper function to write state to xml
[61cada5]	730	"""
	731	for item in node:
[0b12abb5]	732	try:
	733	name = item.get('name')
	734	except:
	735	name = None
	736	try:
	737	value = item.get('value')
	738	except:
	739	value = None
	740	try:
[3ad91de]	741	selected_to_fit = (item.get('selected_to_fit') == "True")
[0b12abb5]	742	except:
	743	selected_to_fit = None
	744	try:
[3ad91de]	745	error_displayed = (item.get('error_displayed') == "True")
[0b12abb5]	746	except:
	747	error_displayed = None
	748	try:
	749	error_value = item.get('error_value')
	750	except:
	751	error_value = None
	752	try:
[3ad91de]	753	minimum_displayed = (item.get('minimum_displayed')== "True")
[0b12abb5]	754	except:
	755	minimum_displayed = None
	756	try:
	757	minimum_value = item.get('minimum_value')
	758	except:
	759	minimum_value = None
	760	try:
[3ad91de]	761	maximum_displayed = (item.get('maximum_displayed') == "True")
[0b12abb5]	762	except:
	763	maximum_displayed = None
	764	try:
	765	maximum_value = item.get('maximum_value')
	766	except:
	767	maximum_value = None
	768	try:
	769	unit = item.get('unit')
	770	except:
	771	unit = None
[2296316]	772	list.append([selected_to_fit, name, value, "+/-",
	773	[error_displayed, error_value],
	774	[minimum_displayed,minimum_value],
	775	[maximum_displayed,maximum_value], unit])
[cfc0913]	776
[61cada5]	777	def fromXML(self, file=None, node=None):
	778	"""
[5062bbf]	779	Load fitting state from a file
	780
	781	:param file: .fitv file
	782	:param node: node of a XML document to read from
	783
[61cada5]	784	"""
	785	if file is not None:
[11a7e11]	786	msg = "PageState no longer supports non-CanSAS"
	787	msg += " format for fitting files"
	788	raise RuntimeError, msg
[61cada5]	789
[11a7e11]	790	if node.get('version')and node.get('version') == '1.0':
[61cada5]	791
	792	# Get file name
	793	entry = get_content('ns:filename', node)
	794	if entry is not None:
	795	self.file = entry.text.strip()
[11a7e11]	796
	797	# Get time stamp
	798	entry = get_content('ns:timestamp', node)
	799	if entry is not None and entry.get('epoch'):
	800	try:
	801	self.timestamp = float(entry.get('epoch'))
	802	except:
	803	msg = "PageState.fromXML: Could not"
	804	msg += " read timestamp\n %s" % sys.exc_value
	805	logging.error(msg)
	806
[61cada5]	807	# Parse fitting attributes
	808	entry = get_content('ns:Attributes', node)
[0b12abb5]	809	for item in list_of_data_attributes:
	810	node = get_content('ns:%s'%item[0], entry)
	811	try:
[2296316]	812	exec "self.%s = parse_entry_helper(node, item)" % item[0]
[0b12abb5]	813
	814	except:
	815	raise
[2296316]	816
[61cada5]	817	if entry is not None:
[0b12abb5]	818
[61cada5]	819	for item in list_of_state_attributes:
[2296316]	820	node = get_content('ns:%s' % item[0], entry)
[0b12abb5]	821	try:
[2296316]	822	exec "self.%s = parse_entry_helper(node, item)" % \
	823	str(item[0])
[0b12abb5]	824	except:
	825	raise
	826
[2296316]	827	for item in list_of_state_parameters:
	828	node = get_content("ns:%s" % item[0], entry)
	829	exec "self._fromXML_helper(node=node, list=self.%s)" % \
	830	item[1]
	831
	832	# Recover _disp_obj_dict from xml file
	833	self._disp_obj_dict = {}
	834	for item in list_of_obj_dic:
	835	# Get node
	836	node = get_content("ns:%s" % item[0], entry)
	837	for attr in node:
	838	name = attr.get('name')
	839	val = attr.get('value')
	840	value = val.split(" instance")[0]
	841	disp_name = value.split("<")[1]
[11a7e11]	842	try:
[2296316]	843	# Try to recover disp_model object from strings
	844	com = "from sans.models.dispersion_models "
	845	com += "import %s as disp"
	846	com_name = disp_name.split(".")[3]
	847	exec com % com_name
	848	disp_model = disp()
	849	exec "self.%s['%s'] = com_name" % (item[1], name)
[11a7e11]	850	except:
[2296316]	851	pass
	852
	853	# get self.values and self.weights dic. if exists
	854	for item in list_of_model_attributes:
	855	node = get_content("ns:%s" % item[0], entry)
	856	dic = {}
	857	list = []
	858	for par in node:
	859	name = par.get('name')
	860	values = par.text.split('\n')
	861	# Get lines only with numbers
	862	for line in values:
	863	try:
	864	val= float(line)
	865	list.append(val)
	866	except:
	867	# pass if line is empty (it happens)
	868	pass
	869	dic[name] = numpy.array(list)
	870	exec "self.%s = dic" % item[1]
	871
	872	def set_plot_state(self, figs, canvases):
	873	"""
	874	Build image state that wx.html understand
	875	by plotting, putting it into wx.FileSystem image object
	876
	877	"""
	878	images = []
	879	# some imports
	880	import wx
	881
	882	# Reset memory
	883	self.imgRAM = None
	884	wx.MemoryFSHandler()
	885
	886	# For no figures in the list, prepare empty plot
	887	if figs == None or len(figs) == 0:
	888	figs = [None]
	889
	890	# Loop over the list of figures
	891	# use wx.MemoryFSHandler
	892	self.imgRAM = wx.MemoryFSHandler()
	893	for fig in figs:
	894	if figs != None:
	895	#fig.set_facecolor('w')
	896	ind = figs.index(fig)
	897	canvas = canvases[ind]
[0b12abb5]	898
[2296316]	899	#bmp = wx.BitmapDataObject()
	900	#bmp.SetBitmap(canvas.bitmap)
	901	#store the image in wx.FileSystem Object
	902	wx.FileSystem.AddHandler(wx.MemoryFSHandler())
	903
	904	# index of the fig
	905	ind = figs.index(fig)
	906
	907	#AddFile, image can be retrieved with 'memory:filename'
	908	self.imgRAM.AddFile('img_fit%s.png' % ind ,
	909	canvas.bitmap, wx.BITMAP_TYPE_PNG)
	910
	911	#append figs
	912	images.append(fig)
	913
[c0ff8cc]	914	return images
[61cada5]	915
	916	class Reader(CansasReader):
	917	"""
[5062bbf]	918	Class to load a .fitv fitting file
[61cada5]	919	"""
	920	## File type
	921	type_name = "Fitting"
	922
	923	## Wildcards
[b35d3d1]	924	type = ["Fitting files (.fitv)\|.fitv"
	925	"SANSView file (.svs)\|.svs"]
[61cada5]	926	## List of allowed extensions
[b35d3d1]	927	ext=['.fitv', '.FITV', '.svs', 'SVS']
[61cada5]	928
	929	def __init__(self, call_back=None, cansas=True):
[df7ed14]	930	CansasReader.__init__(self)
[61cada5]	931	"""
[5062bbf]	932	Initialize the call-back method to be called
	933	after we load a file
	934
	935	:param call_back: call-back method
	936	:param cansas: True = files will be written/read in CanSAS format
	937	False = write CanSAS format
[61cada5]	938
	939	"""
	940	## Call back method to be executed after a file is read
	941	self.call_back = call_back
	942	## CanSAS format flag
	943	self.cansas = cansas
[75fbd17]	944	self.state = None
	945	def get_state(self):
	946	return self.state
[61cada5]	947
	948	def read(self, path):
	949	"""
[5062bbf]	950	Load a new P(r) inversion state from file
	951
	952	:param path: file path
	953
[61cada5]	954	"""
[e9b12eaf]	955	if self.cansas == True:
[61cada5]	956	return self._read_cansas(path)
[e9b12eaf]	957
	958	def _data2d_to_xml_doc(self, datainfo):
[61cada5]	959	"""
[5062bbf]	960	Create an XML document to contain the content of a Data2D
	961
	962	:param datainfo: Data2D object
	963
[61cada5]	964	"""
	965	if not issubclass(datainfo.__class__, Data2D):
	966	raise RuntimeError, "The cansas writer expects a Data2D instance"
	967
	968	doc = xml.dom.minidom.Document()
	969	main_node = doc.createElement("SASroot")
	970	main_node.setAttribute("version", self.version)
[df7ed14]	971	main_node.setAttribute("xmlns", "cansas1d/%s" % self.version)
	972	main_node.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
	973	main_node.setAttribute("xsi:schemaLocation", "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version)
	974
[61cada5]	975	doc.appendChild(main_node)
	976
	977	entry_node = doc.createElement("SASentry")
	978	main_node.appendChild(entry_node)
[df7ed14]	979
[61cada5]	980	write_node(doc, entry_node, "Title", datainfo.title)
[df7ed14]	981	if datainfo is not None:
	982	write_node(doc, entry_node, "data_class", datainfo.__class__.__name__)
[61cada5]	983	for item in datainfo.run:
	984	runname = {}
	985	if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item]))>1:
	986	runname = {'name': datainfo.run_name[item] }
	987	write_node(doc, entry_node, "Run", item, runname)
	988	# Data info
[df7ed14]	989	new_node = doc.createElement("SASdata")
	990	entry_node.appendChild(new_node)
[e9b12eaf]	991	for item in list_of_data_2d_attr:
	992	element = doc.createElement(item[0])
	993	exec "element.setAttribute(item[0], str(datainfo.%s))"%(item[1])
[df7ed14]	994	new_node.appendChild(element)
	995
[e9b12eaf]	996	for item in list_of_data2d_values:
[df7ed14]	997	root_node = doc.createElement(item[0])
	998	new_node.appendChild(root_node)
	999
[35b556d]	1000	exec "temp_list = datainfo.%s"%item[1]
[df7ed14]	1001
[35b556d]	1002	if temp_list is None or len(temp_list)== 0:
[df7ed14]	1003	element = doc.createElement(item[0])
[35b556d]	1004	exec "element.appendChild(doc.createTextNode(str(%s)))"%temp_list
[df7ed14]	1005	root_node.appendChild(element)
[35b556d]	1006	else:
	1007	for value in temp_list:
[df7ed14]	1008	element = doc.createElement(item[0])
	1009	exec "element.setAttribute(item[0], str(%s))"%value
	1010	root_node.appendChild(element)
	1011
[61cada5]	1012	# Sample info
	1013	sample = doc.createElement("SASsample")
	1014	if datainfo.sample.name is not None:
	1015	sample.setAttribute("name", str(datainfo.sample.name))
	1016	entry_node.appendChild(sample)
	1017	write_node(doc, sample, "ID", str(datainfo.sample.ID))
	1018	write_node(doc, sample, "thickness", datainfo.sample.thickness, {"unit":datainfo.sample.thickness_unit})
	1019	write_node(doc, sample, "transmission", datainfo.sample.transmission)
	1020	write_node(doc, sample, "temperature", datainfo.sample.temperature, {"unit":datainfo.sample.temperature_unit})
	1021
	1022	for item in datainfo.sample.details:
	1023	write_node(doc, sample, "details", item)
	1024
	1025	pos = doc.createElement("position")
	1026	written = write_node(doc, pos, "x", datainfo.sample.position.x, {"unit":datainfo.sample.position_unit})
	1027	written = written \| write_node(doc, pos, "y", datainfo.sample.position.y, {"unit":datainfo.sample.position_unit})
	1028	written = written \| write_node(doc, pos, "z", datainfo.sample.position.z, {"unit":datainfo.sample.position_unit})
	1029	if written == True:
	1030	sample.appendChild(pos)
	1031
	1032	ori = doc.createElement("orientation")
	1033	written = write_node(doc, ori, "roll", datainfo.sample.orientation.x, {"unit":datainfo.sample.orientation_unit})
	1034	written = written \| write_node(doc, ori, "pitch", datainfo.sample.orientation.y, {"unit":datainfo.sample.orientation_unit})
	1035	written = written \| write_node(doc, ori, "yaw", datainfo.sample.orientation.z, {"unit":datainfo.sample.orientation_unit})
	1036	if written == True:
	1037	sample.appendChild(ori)
	1038
	1039	# Instrument info
	1040	instr = doc.createElement("SASinstrument")
	1041	entry_node.appendChild(instr)
	1042
	1043	write_node(doc, instr, "name", datainfo.instrument)
	1044
	1045	# Source
	1046	source = doc.createElement("SASsource")
	1047	if datainfo.source.name is not None:
	1048	source.setAttribute("name", str(datainfo.source.name))
	1049	instr.appendChild(source)
	1050
	1051	write_node(doc, source, "radiation", datainfo.source.radiation)
	1052	write_node(doc, source, "beam_shape", datainfo.source.beam_shape)
	1053	size = doc.createElement("beam_size")
	1054	if datainfo.source.beam_size_name is not None:
	1055	size.setAttribute("name", str(datainfo.source.beam_size_name))
	1056	written = write_node(doc, size, "x", datainfo.source.beam_size.x, {"unit":datainfo.source.beam_size_unit})
	1057	written = written \| write_node(doc, size, "y", datainfo.source.beam_size.y, {"unit":datainfo.source.beam_size_unit})
	1058	written = written \| write_node(doc, size, "z", datainfo.source.beam_size.z, {"unit":datainfo.source.beam_size_unit})
	1059	if written == True:
	1060	source.appendChild(size)
	1061
	1062	write_node(doc, source, "wavelength", datainfo.source.wavelength, {"unit":datainfo.source.wavelength_unit})
	1063	write_node(doc, source, "wavelength_min", datainfo.source.wavelength_min, {"unit":datainfo.source.wavelength_min_unit})
	1064	write_node(doc, source, "wavelength_max", datainfo.source.wavelength_max, {"unit":datainfo.source.wavelength_max_unit})
	1065	write_node(doc, source, "wavelength_spread", datainfo.source.wavelength_spread, {"unit":datainfo.source.wavelength_spread_unit})
	1066
	1067	# Collimation
	1068	for item in datainfo.collimation:
	1069	coll = doc.createElement("SAScollimation")
	1070	if item.name is not None:
	1071	coll.setAttribute("name", str(item.name))
	1072	instr.appendChild(coll)
	1073
	1074	write_node(doc, coll, "length", item.length, {"unit":item.length_unit})
	1075
	1076	for apert in item.aperture:
	1077	ap = doc.createElement("aperture")
	1078	if apert.name is not None:
	1079	ap.setAttribute("name", str(apert.name))
	1080	if apert.type is not None:
	1081	ap.setAttribute("type", str(apert.type))
	1082	coll.appendChild(ap)
	1083
	1084	write_node(doc, ap, "distance", apert.distance, {"unit":apert.distance_unit})
	1085
	1086	size = doc.createElement("size")
	1087	if apert.size_name is not None:
	1088	size.setAttribute("name", str(apert.size_name))
	1089	written = write_node(doc, size, "x", apert.size.x, {"unit":apert.size_unit})
	1090	written = written \| write_node(doc, size, "y", apert.size.y, {"unit":apert.size_unit})
	1091	written = written \| write_node(doc, size, "z", apert.size.z, {"unit":apert.size_unit})
	1092	if written == True:
	1093	ap.appendChild(size)
	1094
	1095	# Detectors
	1096	for item in datainfo.detector:
	1097	det = doc.createElement("SASdetector")
	1098	written = write_node(doc, det, "name", item.name)
	1099	written = written \| write_node(doc, det, "SDD", item.distance, {"unit":item.distance_unit})
	1100	written = written \| write_node(doc, det, "slit_length", item.slit_length, {"unit":item.slit_length_unit})
	1101	if written == True:
	1102	instr.appendChild(det)
	1103
	1104	off = doc.createElement("offset")
	1105	written = write_node(doc, off, "x", item.offset.x, {"unit":item.offset_unit})
	1106	written = written \| write_node(doc, off, "y", item.offset.y, {"unit":item.offset_unit})
	1107	written = written \| write_node(doc, off, "z", item.offset.z, {"unit":item.offset_unit})
	1108	if written == True:
	1109	det.appendChild(off)
	1110
	1111	center = doc.createElement("beam_center")
	1112	written = write_node(doc, center, "x", item.beam_center.x, {"unit":item.beam_center_unit})
	1113	written = written \| write_node(doc, center, "y", item.beam_center.y, {"unit":item.beam_center_unit})
	1114	written = written \| write_node(doc, center, "z", item.beam_center.z, {"unit":item.beam_center_unit})
	1115	if written == True:
	1116	det.appendChild(center)
	1117
	1118	pix = doc.createElement("pixel_size")
	1119	written = write_node(doc, pix, "x", item.pixel_size.x, {"unit":item.pixel_size_unit})
	1120	written = written \| write_node(doc, pix, "y", item.pixel_size.y, {"unit":item.pixel_size_unit})
	1121	written = written \| write_node(doc, pix, "z", item.pixel_size.z, {"unit":item.pixel_size_unit})
	1122	if written == True:
	1123	det.appendChild(pix)
	1124
	1125	ori = doc.createElement("orientation")
	1126	written = write_node(doc, ori, "roll", item.orientation.x, {"unit":item.orientation_unit})
	1127	written = written \| write_node(doc, ori, "pitch", item.orientation.y, {"unit":item.orientation_unit})
	1128	written = written \| write_node(doc, ori, "yaw", item.orientation.z, {"unit":item.orientation_unit})
	1129	if written == True:
	1130	det.appendChild(ori)
	1131
	1132	# Processes info
	1133	for item in datainfo.process:
	1134	node = doc.createElement("SASprocess")
	1135	entry_node.appendChild(node)
	1136
	1137	write_node(doc, node, "name", item.name)
	1138	write_node(doc, node, "date", item.date)
	1139	write_node(doc, node, "description", item.description)
	1140	for term in item.term:
	1141	value = term['value']
	1142	del term['value']
	1143	write_node(doc, node, "term", value, term)
	1144	for note in item.notes:
	1145	write_node(doc, node, "SASprocessnote", note)
	1146	# Return the document, and the SASentry node associated with
	1147	# the data we just wrote
	1148	return doc, entry_node
[e9b12eaf]	1149
[61cada5]	1150	def _parse_state(self, entry):
	1151	"""
[5062bbf]	1152	Read a fit result from an XML node
	1153
	1154	:param entry: XML node to read from
	1155
	1156	:return: PageState object
[61cada5]	1157	"""
	1158	# Create an empty state
[b35d3d1]	1159	state = None
[61cada5]	1160	# Locate the P(r) node
	1161	try:
	1162	nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, namespaces={'ns': CANSAS_NS})
[b35d3d1]	1163	if nodes !=[]:
	1164	# Create an empty state
	1165	state = PageState()
	1166	state.fromXML(node=nodes[0])
[61cada5]	1167	except:
	1168	logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value)
	1169
	1170	return state
	1171
[0b12abb5]	1172
[df7ed14]	1173
	1174	def _parse_entry(self, dom):
[e9b12eaf]	1175	"""
[5062bbf]	1176	Parse a SASentry
	1177
	1178	:param node: SASentry node
	1179
[df7ed14]	1180	:return: Data1D/Data2D object
[5062bbf]	1181
[e9b12eaf]	1182	"""
[df7ed14]	1183	node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS})
	1184	if not node or node[0].text.lstrip().rstrip() != "Data2D":
	1185	return CansasReader._parse_entry(self, dom)
	1186
	1187	#Parse 2D
[e9b12eaf]	1188	data_info = Data2D()
	1189
	1190	# Look up title
	1191	self._store_content('ns:Title', dom, 'title', data_info)
	1192
	1193	# Look up run number
	1194	nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS})
	1195	for item in nodes:
	1196	if item.text is not None:
	1197	value = item.text.strip()
	1198	if len(value) > 0:
	1199	data_info.run.append(value)
	1200	if item.get('name') is not None:
	1201	data_info.run_name[value] = item.get('name')
	1202
	1203	# Look up instrument name
	1204	self._store_content('ns:SASinstrument/ns:name', dom, 'instrument', data_info)
	1205
	1206	# Notes
	1207	note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS})
	1208	for note in note_list:
	1209	try:
	1210	if note.text is not None:
	1211	note_value = note.text.strip()
	1212	if len(note_value) > 0:
	1213	data_info.notes.append(note_value)
	1214	except:
	1215	err_mess = "cansas_reader.read: error processing entry notes\n %s" % sys.exc_value
	1216	self.errors.append(err_mess)
	1217	logging.error(err_mess)
	1218
	1219	# Sample info ###################
	1220	entry = get_content('ns:SASsample', dom)
	1221	if entry is not None:
	1222	data_info.sample.name = entry.get('name')
	1223
	1224	self._store_content('ns:SASsample/ns:ID',
	1225	dom, 'ID', data_info.sample)
	1226	self._store_float('ns:SASsample/ns:thickness',
	1227	dom, 'thickness', data_info.sample)
	1228	self._store_float('ns:SASsample/ns:transmission',
	1229	dom, 'transmission', data_info.sample)
	1230	self._store_float('ns:SASsample/ns:temperature',
	1231	dom, 'temperature', data_info.sample)
	1232
	1233	nodes = dom.xpath('ns:SASsample/ns:details', namespaces={'ns': CANSAS_NS})
	1234	for item in nodes:
	1235	try:
	1236	if item.text is not None:
	1237	detail_value = item.text.strip()
	1238	if len(detail_value) > 0:
	1239	data_info.sample.details.append(detail_value)
	1240	except:
	1241	err_mess = "cansas_reader.read: error processing sample details\n %s" % sys.exc_value
	1242	self.errors.append(err_mess)
	1243	logging.error(err_mess)
	1244
	1245	# Position (as a vector)
	1246	self._store_float('ns:SASsample/ns:position/ns:x',
	1247	dom, 'position.x', data_info.sample)
	1248	self._store_float('ns:SASsample/ns:position/ns:y',
	1249	dom, 'position.y', data_info.sample)
	1250	self._store_float('ns:SASsample/ns:position/ns:z',
	1251	dom, 'position.z', data_info.sample)
	1252
	1253	# Orientation (as a vector)
	1254	self._store_float('ns:SASsample/ns:orientation/ns:roll',
	1255	dom, 'orientation.x', data_info.sample)
	1256	self._store_float('ns:SASsample/ns:orientation/ns:pitch',
	1257	dom, 'orientation.y', data_info.sample)
	1258	self._store_float('ns:SASsample/ns:orientation/ns:yaw',
	1259	dom, 'orientation.z', data_info.sample)
	1260
	1261	# Source info ###################
	1262	entry = get_content('ns:SASinstrument/ns:SASsource', dom)
	1263	if entry is not None:
	1264	data_info.source.name = entry.get('name')
	1265
	1266	self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation',
	1267	dom, 'radiation', data_info.source)
	1268	self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape',
	1269	dom, 'beam_shape', data_info.source)
	1270	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength',
	1271	dom, 'wavelength', data_info.source)
	1272	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min',
	1273	dom, 'wavelength_min', data_info.source)
	1274	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max',
	1275	dom, 'wavelength_max', data_info.source)
	1276	self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread',
	1277	dom, 'wavelength_spread', data_info.source)
	1278
	1279	# Beam size (as a vector)
	1280	entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom)
	1281	if entry is not None:
	1282	data_info.source.beam_size_name = entry.get('name')
	1283
	1284	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x',
	1285	dom, 'beam_size.x', data_info.source)
	1286	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y',
	1287	dom, 'beam_size.y', data_info.source)
	1288	self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z',
	1289	dom, 'beam_size.z', data_info.source)
	1290
	1291	# Collimation info ###################
	1292	nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', namespaces={'ns': CANSAS_NS})
	1293	for item in nodes:
	1294	collim = Collimation()
	1295	if item.get('name') is not None:
	1296	collim.name = item.get('name')
	1297	self._store_float('ns:length', item, 'length', collim)
	1298
	1299	# Look for apertures
	1300	apert_list = item.xpath('ns:aperture', namespaces={'ns': CANSAS_NS})
	1301	for apert in apert_list:
	1302	aperture = Aperture()
	1303
	1304	# Get the name and type of the aperture
	1305	aperture.name = apert.get('name')
	1306	aperture.type = apert.get('type')
	1307
	1308	self._store_float('ns:distance', apert, 'distance', aperture)
	1309
	1310	entry = get_content('ns:size', apert)
	1311	if entry is not None:
	1312	aperture.size_name = entry.get('name')
	1313
	1314	self._store_float('ns:size/ns:x', apert, 'size.x', aperture)
	1315	self._store_float('ns:size/ns:y', apert, 'size.y', aperture)
	1316	self._store_float('ns:size/ns:z', apert, 'size.z', aperture)
	1317
	1318	collim.aperture.append(aperture)
	1319
	1320	data_info.collimation.append(collim)
	1321
	1322	# Detector info ######################
	1323	nodes = dom.xpath('ns:SASinstrument/ns:SASdetector', namespaces={'ns': CANSAS_NS})
	1324	for item in nodes:
	1325
	1326	detector = Detector()
	1327
	1328	self._store_content('ns:name', item, 'name', detector)
	1329	self._store_float('ns:SDD', item, 'distance', detector)
	1330
	1331	# Detector offset (as a vector)
	1332	self._store_float('ns:offset/ns:x', item, 'offset.x', detector)
	1333	self._store_float('ns:offset/ns:y', item, 'offset.y', detector)
	1334	self._store_float('ns:offset/ns:z', item, 'offset.z', detector)
	1335
	1336	# Detector orientation (as a vector)
	1337	self._store_float('ns:orientation/ns:roll', item, 'orientation.x', detector)
	1338	self._store_float('ns:orientation/ns:pitch', item, 'orientation.y', detector)
	1339	self._store_float('ns:orientation/ns:yaw', item, 'orientation.z', detector)
	1340
	1341	# Beam center (as a vector)
	1342	self._store_float('ns:beam_center/ns:x', item, 'beam_center.x', detector)
	1343	self._store_float('ns:beam_center/ns:y', item, 'beam_center.y', detector)
	1344	self._store_float('ns:beam_center/ns:z', item, 'beam_center.z', detector)
	1345
	1346	# Pixel size (as a vector)
	1347	self._store_float('ns:pixel_size/ns:x', item, 'pixel_size.x', detector)
	1348	self._store_float('ns:pixel_size/ns:y', item, 'pixel_size.y', detector)
	1349	self._store_float('ns:pixel_size/ns:z', item, 'pixel_size.z', detector)
	1350
	1351	self._store_float('ns:slit_length', item, 'slit_length', detector)
	1352
	1353	data_info.detector.append(detector)
	1354
	1355	# Processes info ######################
	1356	nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS})
	1357	for item in nodes:
	1358	process = Process()
	1359	self._store_content('ns:name', item, 'name', process)
	1360	self._store_content('ns:date', item, 'date', process)
	1361	self._store_content('ns:description', item, 'description', process)
	1362
	1363	term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS})
	1364	for term in term_list:
	1365	try:
	1366	term_attr = {}
	1367	for attr in term.keys():
	1368	term_attr[attr] = term.get(attr).strip()
	1369	if term.text is not None:
	1370	term_attr['value'] = term.text.strip()
	1371	process.term.append(term_attr)
	1372	except:
	1373	err_mess = "cansas_reader.read: error processing process term\n %s" % sys.exc_value
	1374	self.errors.append(err_mess)
	1375	logging.error(err_mess)
	1376
	1377	note_list = item.xpath('ns:SASprocessnote', namespaces={'ns': CANSAS_NS})
	1378	for note in note_list:
	1379	if note.text is not None:
	1380	process.notes.append(note.text.strip())
	1381
	1382	data_info.process.append(process)
	1383
	1384
	1385	# Data info ######################
	1386	nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS})
	1387	if len(nodes)>1:
	1388	raise RuntimeError, "CanSAS reader is not compatible with multiple SASdata entries"
[df7ed14]	1389
	1390	for entry in nodes:
	1391	for item in list_of_data_2d_attr:
	1392	#get node
	1393	node = get_content('ns:%s'%item[0], entry)
[0b12abb5]	1394	exec "data_info.%s = parse_entry_helper(node, item)"%(item[1])
[e9b12eaf]	1395
[df7ed14]	1396	for item in list_of_data2d_values:
	1397	field = get_content('ns:%s'%item[0], entry)
	1398	list = []
	1399	if field is not None:
[0b12abb5]	1400	list = [parse_entry_helper(node, item) for node in field]
[df7ed14]	1401	exec "data_info.%s = numpy.array(list)"%item[0]
[e9b12eaf]	1402
	1403	return data_info
	1404
[61cada5]	1405	def _read_cansas(self, path):
	1406	"""
[5062bbf]	1407	Load data and P(r) information from a CanSAS XML file.
	1408
	1409	:param path: file path
	1410
	1411	:return: Data1D object if a single SASentry was found,
	1412	or a list of Data1D objects if multiple entries were found,
	1413	or None of nothing was found
	1414
	1415	:raise RuntimeError: when the file can't be opened
	1416	:raise ValueError: when the length of the data vectors are inconsistent
	1417
[61cada5]	1418	"""
	1419	output = []
[b63dc6e]	1420	basename = os.path.basename(path)
	1421	root, extension = os.path.splitext(basename)
	1422	ext = extension.lower()
[61cada5]	1423	try:
	1424	if os.path.isfile(path):
[b63dc6e]	1425
[61cada5]	1426	#TODO: eventually remove the check for .xml once
	1427	# the P(r) writer/reader is truly complete.
[b63dc6e]	1428	if ext in self.ext or \
	1429	ext == '.xml':
[61cada5]	1430
	1431	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
	1432	# Check the format version number
	1433	# Specifying the namespace will take care of the file format version
	1434	root = tree.getroot()
[df7ed14]	1435	entry_list = root.xpath('ns:SASentry', namespaces={'ns': CANSAS_NS})
[b35d3d1]	1436	for entry in entry_list:
[e9b12eaf]	1437	try:
	1438	sas_entry = self._parse_entry(entry)
	1439	except:
[df7ed14]	1440	raise
[61cada5]	1441	fitstate = self._parse_state(entry)
[b35d3d1]	1442
	1443	#state could be None when .svs file is loaded
	1444	#in this case, skip appending to output
	1445	if fitstate != None:
	1446	sas_entry.meta_data['fitstate'] = fitstate
	1447	sas_entry.filename = fitstate.file
	1448	output.append(sas_entry)
[61cada5]	1449	else:
[b63dc6e]	1450	self.call_back(format=ext)
[61cada5]	1451	raise RuntimeError, "%s is not a file" % path
[b35d3d1]	1452
[61cada5]	1453	# Return output consistent with the loader's api
	1454	if len(output)==0:
[b63dc6e]	1455	self.call_back(state=None, datainfo=None,format=ext)
[61cada5]	1456	return None
	1457	else:
[b35d3d1]	1458	for ind in range(len(output)):
	1459	# Call back to post the new state
	1460	state = output[ind].meta_data['fitstate']
	1461	t = time.localtime(state.timestamp)
	1462	time_str = time.strftime("%b %d %H:%M", t)
	1463	# Check that no time stamp is already appended
	1464	max_char = state.file.find("[")
	1465	if max_char < 0:
	1466	max_char = len(state.file)
[ef16f59]	1467	original_fname = state.file[0:max_char]
	1468	state.file = original_fname +' [' + time_str + ']'
[b35d3d1]	1469
	1470
	1471	if state is not None and state.is_data is not None:
	1472	exec 'output[%d].is_data = state.is_data'% ind
	1473
	1474	output[ind].filename = state.file
	1475	state.data = output[ind]
	1476	state.data.name = output[ind].filename #state.data_name
	1477	state.data.id = state.data_id
	1478	if state.is_data is not None:
	1479	state.data.is_data = state.is_data
[ef16f59]	1480	if output[ind].run_name is not None and len(output[ind].run_name) != 0 :
	1481	name = output[ind].run_name
	1482	else:
	1483	name=original_fname
	1484	state.data.group_id = name
	1485	#store state in fitting
[90a7bbd]	1486	self.call_back(state=state, datainfo=output[ind],format=ext)
[75fbd17]	1487	self.state= state
[ef16f59]	1488	return output
[b35d3d1]	1489
[61cada5]	1490	except:
[4bee68d]	1491	self.call_back(format=ext)
	1492	#self.state= state
[61cada5]	1493	raise
	1494
	1495	def write(self, filename, datainfo=None, fitstate=None):
	1496	"""
[b35d3d1]	1497	Write the content of a Data1D as a CanSAS XML file only for standalone
[5062bbf]	1498
	1499	:param filename: name of the file to write
	1500	:param datainfo: Data1D object
	1501	:param fitstate: PageState object
	1502
[61cada5]	1503	"""
	1504	# Sanity check
	1505	if self.cansas == True:
	1506
	1507	# Add fitting information to the XML document
[ef16f59]	1508	doc = self.write_toXML(datainfo, fitstate)
[61cada5]	1509	# Write the XML document
	1510	fd = open(filename, 'w')
	1511	fd.write(doc.toprettyxml())
	1512	fd.close()
	1513	else:
	1514	fitstate.toXML(file=filename)
	1515
[b35d3d1]	1516	def write_toXML(self, datainfo=None, state=None):
	1517	"""
	1518	Write toXML, a helper for write() , could be used by guimanager._on_save()
	1519
	1520	: return: xml doc
	1521	"""
[3c44c66]	1522
[b35d3d1]	1523	if state.data is None:
[c21e87b]	1524	data = sans.dataloader.data_info.Data1D(x=[], y=[])
[b35d3d1]	1525	else:
	1526	#make sure title and data run is filled up.
[028a0e8]	1527	if state.data.title == None or state.data.title=='': state.data.title = state.data.name
	1528	if state.data.run_name == None or state.data.run_name=={}:
	1529	state.data.run = [str(state.data.name)]
	1530	state.data.run_name[0] = state.data.name
[b35d3d1]	1531
[c21e87b]	1532	if issubclass(state.data.__class__, sans.dataloader.data_info.Data1D):
[028a0e8]	1533
[b35d3d1]	1534	data = state.data
	1535	doc, sasentry = self._to_xml_doc(data)
	1536	else:
	1537	data = state.data
	1538	doc, sasentry = self._data2d_to_xml_doc(data)
	1539
	1540
	1541	if state is not None:
	1542	state.toXML(doc=doc, file=data.name, entry_node=sasentry)
	1543
	1544	return doc
[2296316]	1545
	1546	# Simple html report templet
	1547	HEADER = "<html>\n"
	1548	HEADER += "<head>\n"
	1549	HEADER += "<meta http-equiv=Content-Type content='text/html; "
	1550	HEADER += "charset=windows-1252'> \n"
	1551	HEADER += "<meta name=Generator >\n"
	1552	HEADER += "</head>\n"
	1553	HEADER += "<body lang=EN-US>\n"
	1554	HEADER += "<div class=WordSection1>\n"
	1555	HEADER += "<p class=MsoNormal><b><span ><center>"
	1556	HEADER += "%s</center></span></center></b></p>"
	1557	HEADER += "<p class=MsoNormal> </p>"
	1558	PARA = "<p class=MsoNormal> %s \n"
	1559	PARA += "</p>"
[8e671c39]	1560	CENTRE = "<center> %s \n"
	1561	CENTRE += "</center>"
[2296316]	1562	FEET_1 = \
	1563	"""
	1564	<p class=MsoNormal><b><span ><center> Graph</span></center></b></p>
	1565	<center>
	1566	<br>Model Computation<br>
	1567	<br>Data: "%s"<br>
	1568	"""
	1569	FEET_2 = \
	1570	"""
	1571	<img src="%s" >
	1572	</img>
	1573	"""
	1574	FEET_3 = \
	1575	"""
	1576	</center>
	1577	</div>
	1578	</body>
	1579	</html>
	1580	"""
	1581	ELINE = "<p class=MsoNormal> </p>"
	1582
[3c44c66]	1583	if __name__ == "__main__":
	1584	state = PageState(parent=None)
	1585	#state.toXML()
	1586	"""
[5062bbf]	1587
[3c44c66]	1588	file = open("test_state", "w")
	1589	pickle.dump(state, file)
	1590	print pickle.dumps(state)
	1591	state.data_name = "hello---->"
	1592	pickle.dump(state, file)
	1593	file = open("test_state", "r")
	1594	new_state= pickle.load(file)
	1595	print "new state", new_state
	1596	new_state= pickle.load(file)
	1597	print "new state", new_state
	1598	#print "state", state
	1599	"""
	1600	import bsddb
	1601	import pickle
	1602	db= bsddb.btopen('file_state.db', 'c')
	1603	val = (pickle.dumps(state), "hello", "hi")
	1604	db['state1']= pickle.dumps(val)
	1605	print pickle.loads(db['state1'])
	1606	state.data_name = "hello---->22"
	1607	db['state2']= pickle.dumps(state)
	1608	state.data_name = "hello---->2"
	1609	db['state3']= pickle.dumps(state)
	1610	del db['state3']
	1611	state.data_name = "hello---->3"
	1612	db['state4']= pickle.dumps(state)
	1613	new_state = pickle.loads(db['state1'])
	1614	#print db.last()
	1615	db.set_location('state2')
	1616	state.data_name = "hello---->5"
	1617	db['aastate5']= pickle.dumps(state)
	1618	db.keys().sort()
	1619	print pickle.loads(db['state2'])
	1620
	1621	db.close()

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

SasView

source: sasview/fittingview/src/sans/perspectives/fitting/pagestate.py @ 2ada16c

Download in other formats: