fitting.py @ cbf01fd

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 cbf01fd was 269df2b, checked in by Jae Cho <jhjcho@…>, 13 years ago
on set data /select model reset smearer to None from custom smearer
Property mode set to `100644`
File size: 78.7 KB

Rev	Line
[5612152]	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
	13
[a0da535]	14	import re
[5536035]	15	import sys
	16	import wx
	17	import logging
	18	import numpy
	19	import string
[c3b4dcb]	20	import time
[edcbd467]	21	from copy import deepcopy
[f83b94a]	22	import models
	23	import fitpage
	24
[66ff250]	25
[c21e87b]	26	from sans.dataloader.loader import Loader
[c3b4dcb]	27	from sans.guiframe.dataFitting import Data2D
	28	from sans.guiframe.dataFitting import Data1D
[2dbffcc]	29	from sans.guiframe.dataFitting import check_data_validity
[6bbeacd4]	30	from sans.guiframe.events import NewPlotEvent
	31	from sans.guiframe.events import StatusEvent
[a0da535]	32	from sans.guiframe.events import EVT_SLICER_PANEL
	33	from sans.guiframe.events import EVT_SLICER_PARS_UPDATE
[6bbeacd4]	34	from sans.guiframe.gui_style import GUIFRAME_ID
	35	from sans.guiframe.plugin_base import PluginBase
[e68bfef]	36	from sans.guiframe.data_processor import BatchCell
[2dbffcc]	37	from sans.fit.Fitting import Fit
[cc31608]	38	from .console import ConsoleUpdate
[2dbffcc]	39	from .fitproblem import FitProblemDictionary
[a0da535]	40	from .fitpanel import FitPanel
[cc31608]	41	from .fit_thread import FitThread
[a0da535]	42	from .pagestate import Reader
	43	from .fitpage import Chi2UpdateEvent
[ed2ea6a]	44
[c26a64b]	45	MAX_NBR_DATA = 4
[2c6b224]	46	SANS_F_TOL = 5e-05
[5062bbf]	47
[6bbeacd4]	48	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
[92a5ac92]	49
[5062bbf]	50
[f6aee42]	51	if sys.platform.count("darwin")==0:
	52	ON_MAC = False
	53	else:
	54	ON_MAC = True
[3658abed]	55
	56	class Plugin(PluginBase):
[d89f09b]	57	"""
[5062bbf]	58	Fitting plugin is used to perform fit
[d89f09b]	59	"""
[3658abed]	60	def __init__(self, standalone=False):
[908b817]	61	PluginBase.__init__(self, name="Fitting", standalone=standalone)
[d89f09b]	62
[ed2ea6a]	63	#list of panel to send to guiframe
[f83b94a]	64	self.mypanels = []
[ed2ea6a]	65	# reference to the current running thread
[f83b94a]	66	self.calc_2D = None
	67	self.calc_1D = None
[9f4f8f4]	68
	69	self.color_dict = {}
	70
[66ff250]	71	self.fit_thread_list = {}
[2296316]	72	self.residuals = None
[55bb249c]	73	self.weight = None
[9466f2d6]	74	self.fit_panel = None
[d89f09b]	75	# Start with a good default
	76	self.elapsed = 0.022
[ed2ea6a]	77	# the type of optimizer selected, park or scipy
[d89f09b]	78	self.fitter = None
[2296316]	79	self.fit_panel = None
[c660493]	80	#let fit ready
	81	self.fitproblem_count = None
[ed2ea6a]	82	#Flag to let the plug-in know that it is running stand alone
[f83b94a]	83	self.standalone = True
[6f023e8]	84	## dictionary of page closed and id
[f83b94a]	85	self.closed_page_dict = {}
[d89f09b]	86	## Fit engine
[e9e914f]	87	self._fit_engine = 'scipy'
[7db52f1]	88	self._gui_engine = None
[2296316]	89	## Relative error desired in the sum of squares (float); scipy only
[2c6b224]	90	self.ftol = SANS_F_TOL
[7db52f1]	91	self.batch_reset_flag = True
[ed2ea6a]	92	#List of selected data
[f83b94a]	93	self.selected_data_list = []
[c3435b7f]	94	## list of slicer panel created to display slicer parameters and results
[f83b94a]	95	self.slicer_panels = []
[32d802f]	96	# model 2D view
[f83b94a]	97	self.model2D_id = None
[ed2ea6a]	98	#keep reference of the simultaneous fit page
[f83b94a]	99	self.sim_page = None
[ae4ade7]	100	self.index_model = 0
[9f4f8f4]	101	self.test_model_color = None
[f83b94a]	102	#Create a reader for fit page's state
[3bf4a032]	103	self.state_reader = None
[c8deee5]	104	self._extensions = '.fitv'
[0b6ae5f]	105	self.scipy_id = wx.NewId()
	106	self.park_id = wx.NewId()
[dafc36f]	107	self.menu1 = None
[0b6ae5f]	108
[4da35bc]	109	self.temp_state = []
[ef16f59]	110	self.state_index = 0
[b63dc6e]	111	self.sfile_ext = None
[6bbeacd4]	112	# take care of saving data, model and page associated with each other
	113	self.page_finder = {}
[f83b94a]	114	# Log startup
	115	logging.info("Fitting plug-in started")
[7360816]	116	self.batch_capable = self.get_batch_capable()
	117
	118	def get_batch_capable(self):
	119	"""
	120	Check if the plugin has a batch capability
	121	"""
	122	return True
[9f4f8f4]	123
[2dbffcc]	124	def create_fit_problem(self, page_id):
	125	"""
	126	Given an ID create a fitproblem container
	127	"""
	128	self.page_finder[page_id] = FitProblemDictionary()
	129
	130	def delete_fit_problem(self, page_id):
	131	"""
	132	Given an ID create a fitproblem container
	133	"""
	134	if page_id in self.page_finder.iterkeys():
	135	del self.page_finder[page_id]
	136
[9f4f8f4]	137	def add_color(self, color, id):
	138	"""
	139	adds a color as a key with a plot id as its value to a dictionary
	140	"""
	141	self.color_dict[id] = color
[2a8fac1]	142
[cc31608]	143	def on_batch_selection(self, flag):
	144	"""
	145	switch the the notebook of batch mode or not
	146	"""
	147	self.batch_on = flag
[2dbffcc]	148	if self.fit_panel is not None:
	149	self.fit_panel.batch_on = self.batch_on
[cc31608]	150
[cab076b]	151	def populate_menu(self, owner):
[d89f09b]	152	"""
[5062bbf]	153	Create a menu for the Fitting plug-in
	154
	155	:param id: id to create a menu
	156	:param owner: owner of menu
	157
	158	:return: list of information to populate the main menu
	159
[d89f09b]	160	"""
	161	#Menu for fitting
	162	self.menu1 = wx.Menu()
[0b6ae5f]	163	id1 = wx.NewId()
	164	simul_help = "Add new fit panel"
	165	self.menu1.Append(id1, '&New Fit Page',simul_help)
	166	wx.EVT_MENU(owner, id1, self.on_add_new_page)
[6f023e8]	167	self.menu1.AppendSeparator()
[dafc36f]	168	self.id_simfit = wx.NewId()
[6bbeacd4]	169	simul_help = "Simultaneous Fit"
[dafc36f]	170	self.menu1.Append(self.id_simfit, '&Simultaneous Fit',simul_help)
	171	wx.EVT_MENU(owner, self.id_simfit, self.on_add_sim_page)
	172	sim_menu = self.menu1.FindItemById(self.id_simfit)
	173	sim_menu.Enable(False)
	174
[f7e9af2]	175	self.menu1.AppendSeparator()
[0b6ae5f]	176	#Set park engine
	177	scipy_help= "Scipy Engine: Perform Simple fit. More in Help window...."
[2c6b224]	178	self.menu1.AppendCheckItem(self.scipy_id, "Simple FitEngine [LeastSq]",
	179	scipy_help)
[0b6ae5f]	180	wx.EVT_MENU(owner, self.scipy_id, self._onset_engine_scipy)
	181
	182	park_help = "Park Engine: Perform Complex fit. More in Help window...."
[2c6b224]	183	self.menu1.AppendCheckItem(self.park_id, "Complex FitEngine [ParkMC]",
	184	park_help)
[0b6ae5f]	185	wx.EVT_MENU(owner, self.park_id, self._onset_engine_park)
	186
	187	self.menu1.FindItemById(self.scipy_id).Check(True)
	188	self.menu1.FindItemById(self.park_id).Check(False)
[2c6b224]	189	self.menu1.AppendSeparator()
	190	self.id_tol = wx.NewId()
	191	ftol_help = "Change the current FTolerance (=%s) " % str(self.ftol)
	192	ftol_help += "of Simple FitEngine..."
[9a10c12]	193	self.menu1.Append(self.id_tol, "Change FTolerance",
[2c6b224]	194	ftol_help)
	195	wx.EVT_MENU(owner, self.id_tol, self.show_ftol_dialog)
[da6fd1a]	196	self.menu1.AppendSeparator()
[2c6b224]	197
[da6fd1a]	198	self.id_reset_flag = wx.NewId()
	199	resetf_help = "BatchFit: If checked, the initial param values will be "
	200	resetf_help += "propagated from the previous results. "
	201	resetf_help += "Otherwise, the same initial param values will be used "
	202	resetf_help += "for all fittings."
	203	self.menu1.AppendCheckItem(self.id_reset_flag, "Chain Fitting [BatchFit Only]",
	204	resetf_help)
	205	wx.EVT_MENU(owner, self.id_reset_flag, self.on_reset_batch_flag)
[70e439f]	206	chain_menu = self.menu1.FindItemById(self.id_reset_flag)
	207	chain_menu.Check(not self.batch_reset_flag)
	208	chain_menu.Enable(self.batch_on)
[3b19ac9]	209	#create menubar items
[908b817]	210	return [(self.menu1, self.sub_menu)]
[2db1d66]	211
[51d47b5]	212	def on_add_sim_page(self, event):
[ed2ea6a]	213	"""
[5062bbf]	214	Create a page to access simultaneous fit option
[ed2ea6a]	215	"""
[a0da535]	216	if self.sim_page != None:
[581d1d4]	217	self.sim_page.Show(True)
	218	self.sim_page.Refresh()
	219	self.sim_page.SetFocus()
	220	self.parent._mgr.Update()
[2140e68]	221	msg= "Simultaneous Fit page already opened"
	222	wx.PostEvent(self.parent, StatusEvent(status= msg))
	223	return
	224
[51d47b5]	225	self.sim_page= self.fit_panel.add_sim_page()
[b28717b]	226
[d89f09b]	227	def help(self, evt):
	228	"""
[5062bbf]	229	Show a general help dialog.
[d89f09b]	230	"""
[484faf7]	231	from help_panel import HelpWindow
[34ffeed]	232	frame = HelpWindow(None, -1, 'HelpWindow')
	233	if hasattr(frame, "IsIconized"):
	234	if not frame.IsIconized():
	235	try:
	236	icon = self.parent.GetIcon()
	237	frame.SetIcon(icon)
	238	except:
	239	pass
[2268d10]	240	frame.Show(True)
	241
[6bbeacd4]	242	def get_context_menu(self, plotpanel=None):
[d89f09b]	243	"""
[5062bbf]	244	Get the context menu items available for P(r).them allow fitting option
	245	for Data2D and Data1D only.
	246
	247	:param graph: the Graph object to which we attach the context menu
	248
	249	:return: a list of menu items with call-back function
	250
	251	:note: if Data1D was generated from Theory1D
	252	the fitting option is not allowed
	253
[d89f09b]	254	"""
[6bbeacd4]	255	graph = plotpanel.graph
[484faf7]	256	fit_option = "Select data for fitting"
	257	fit_hint = "Dialog with fitting parameters "
[6bbeacd4]	258
	259	if graph.selected_plottable not in plotpanel.plots:
	260	return []
	261	item = plotpanel.plots[graph.selected_plottable]
	262	if item.__class__.__name__ is "Data2D":
	263	if hasattr(item,"is_data"):
	264	if item.is_data:
	265	return [[fit_option, fit_hint, self._onSelect]]
	266	else:
	267	return []
	268	return [[fit_option, fit_hint, self._onSelect]]
	269	else:
	270
	271	# if is_data is true , this in an actual data loaded
	272	#else it is a data created from a theory model
	273	if hasattr(item,"is_data"):
	274	if item.is_data:
	275	return [[fit_option, fit_hint,
	276	self._onSelect]]
	277	else:
	278	return []
[d89f09b]	279	return []
	280
	281
	282	def get_panels(self, parent):
	283	"""
[5062bbf]	284	Create and return a list of panel objects
[d89f09b]	285	"""
	286	self.parent = parent
[75fbd17]	287	#self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
[d89f09b]	288	# Creation of the fit panel
[6bbeacd4]	289	self.fit_panel = FitPanel(parent=self.parent, manager=self)
	290	self.on_add_new_page(event=None)
[f93dfcb]	291	#Set the manager for the main panel
[d89f09b]	292	self.fit_panel.set_manager(self)
	293	# List of windows used for the perspective
	294	self.perspective = []
	295	self.perspective.append(self.fit_panel.window_name)
[6bbeacd4]	296
[3b19ac9]	297	#index number to create random model name
	298	self.index_model = 0
[264df67]	299	self.index_theory= 0
[32673ac]	300	self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
[848a2ef]	301	self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
[df4c3ad]	302	self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer)
[3bf4a032]	303	#Create reader when fitting panel are created
	304	self.state_reader = Reader(self.set_state)
	305	#append that reader to list of available reader
	306	loader = Loader()
	307	loader.associate_file_reader(".fitv", self.state_reader)
[f22e626]	308	#loader.associate_file_reader(".svs", self.state_reader)
[a436b2e]	309	#from sans.perspectives.calculator.sld_panel import SldPanel
[f93dfcb]	310	#Send the fitting panel to guiframe
[0912feab]	311	self.mypanels.append(self.fit_panel)
[a436b2e]	312	#self.mypanels.append(SldPanel(parent=self.parent, base=self.parent))
[568e1a5]	313	return self.mypanels
[232c3db]	314
[90a7bbd]	315	def clear_panel(self):
	316	"""
	317	"""
[81f00d7]	318	self.fit_panel.clear_panel()
[90a7bbd]	319
[1610976]	320	def set_default_perspective(self):
	321	"""
[5062bbf]	322	Call back method that True to notify the parent that the current plug-in
	323	can be set as default perspective.
	324	when returning False, the plug-in is not candidate for an automatic
	325	default perspective setting
[1610976]	326	"""
	327	return True
[a0da535]	328
[17553ae]	329	def delete_data(self, data):
[8ee56a9]	330	"""
	331	delete the given data from panel
	332	"""
	333	self.fit_panel.delete_data(data)
	334
[e88ebfd]	335	def set_data(self, data_list=None):
[a0da535]	336	"""
	337	receive a list of data to fit
	338	"""
[b2d9826]	339	if data_list is None:
	340	data_list = []
[c26a64b]	341	selected_data_list = []
[cc31608]	342	if self.batch_on:
	343	page = self.add_fit_page(data=data_list)
[c26a64b]	344	else:
[cc31608]	345	if len(data_list) > MAX_NBR_DATA:
	346	from fitting_widgets import DataDialog
	347	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
	348	if dlg.ShowModal() == wx.ID_OK:
	349	selected_data_list = dlg.get_data()
	350	dlg.Destroy()
	351
	352	else:
	353	selected_data_list = data_list
	354	try:
[5e48acb]	355	group_id = wx.NewId()
[cc31608]	356	for data in selected_data_list:
[5e48acb]	357	if data is not None:
	358	data.group_id = group_id
[14774db]	359	if group_id not in data.list_group_id:
	360	data.list_group_id.append(group_id)
	361	page = self.add_fit_page(data=[data])
[cc31608]	362	except:
	363	msg = "Fitting Set_data: " + str(sys.exc_value)
	364	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
[1b1bbf9]	365
	366	def set_top_panel(self):
	367	"""
	368	Close default (welcome) panel
	369	"""
	370	if 'default' in self.parent.panels:
	371	self.parent.on_close_welcome_panel()
	372
[5e48acb]	373
[e88ebfd]	374	def set_theory(self, theory_list=None):
	375	"""
	376	"""
	377	#set the model state for a given theory_state:
	378	for item in theory_list:
	379	try:
	380	_, theory_state = item
	381	self.fit_panel.set_model_state(theory_state)
	382	except:
	383	msg = "Fitting: cannot deal with the theory received"
	384	logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
	385	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
[a0da535]	386
[b63dc6e]	387	def set_state(self, state=None, datainfo=None, format=None):
[f83b94a]	388	"""
[5062bbf]	389	Call-back method for the fit page state reader.
[8897d66]	390	This method is called when a .fitv/.svs file is loaded.
[5062bbf]	391
[8897d66]	392	: param state: PageState object
	393	: param datainfo: data
[f83b94a]	394	"""
[90a7bbd]	395	#state = self.state_reader.get_state()
[b63dc6e]	396	if state != None:
[4bee68d]	397	state = state.clone()
[b63dc6e]	398	# store fitting state in temp_state
	399	self.temp_state.append(state)
	400	else:
	401	self.temp_state = []
[ef16f59]	402	# index to start with for a new set_state
	403	self.state_index = 0
[b63dc6e]	404	# state file format
	405	self.sfile_ext = format
[75fbd17]	406
	407	self.on_set_state_helper(event=None)
[ef16f59]	408
[75fbd17]	409	def on_set_state_helper(self,event=None):
[4da35bc]	410	"""
[0fd2f27]	411	Set_state_helper. This actually sets state
	412	after plotting data from state file.
[ef16f59]	413
[0fd2f27]	414	: event: FitStateUpdateEvent called
	415	by dataloader.plot_data from guiframe
[4da35bc]	416	"""
[7a07864]	417	if len(self.temp_state) == 0:
[0fd2f27]	418	if self.state_index==0 and len(self.mypanels) <= 0 \
	419	and self.sfile_ext =='.svs':
[9b18735]	420	self.fit_panel.add_default_pages()
[b63dc6e]	421	self.temp_state = []
	422	self.state_index = 0
[4da35bc]	423	return
[3eb2811]	424
[ef16f59]	425	try:
	426	# Load fitting state
	427	state = self.temp_state[self.state_index]
[3eb2811]	428	#panel state should have model selection to set_state
	429	if state.formfactorcombobox != None:
	430	#set state
[75fbd17]	431	data = self.parent.create_gui_data(state.data)
	432	data.group_id = state.data.group_id
[f95301b]	433	self.parent.add_data(data_list={data.id:data})
[75fbd17]	434	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
	435	title=data.title))
[f95301b]	436	#need to be fix later make sure we are sendind guiframe.data
	437	#to panel
	438	state.data = data
[3eb2811]	439	page = self.fit_panel.set_state(state)
	440	else:
	441	#just set data because set_state won't work
[75fbd17]	442	data = self.parent.create_gui_data(state.data)
	443	data.group_id = state.data.group_id
[f95301b]	444	self.parent.add_data(data_list={data.id:data})
	445	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
	446	title=data.title))
[cc31608]	447	page = self.add_fit_page([data])
[2dbffcc]	448	caption = page.window_caption
	449	self.store_data(uid=page.uid, data_list=page.get_data_list(),
	450	caption=caption)
[1b1bbf9]	451	self.mypanels.append(page)
[3eb2811]	452
[9b18735]	453	# get ready for the next set_state
[ef16f59]	454	self.state_index += 1
[9b18735]	455
[ef16f59]	456	#reset state variables to default when all set_state is finished.
	457	if len(self.temp_state) == self.state_index:
[9b18735]	458
[ef16f59]	459	self.temp_state = []
[b63dc6e]	460	#self.state_index = 0
[ef16f59]	461	# Make sure the user sees the fitting panel after loading
[75fbd17]	462	#self.parent.set_perspective(self.perspective)
	463	self.on_perspective(event=None)
[ef16f59]	464	except:
[b63dc6e]	465	self.state_index==0
[8897d66]	466	self.temp_state = []
[ef16f59]	467	raise
[1b14795]	468
	469	def set_param2fit(self, uid, param2fit):
	470	"""
	471	Set the list of param names to fit for fitprobelm
	472	"""
	473	self.page_finder[uid].set_param2fit(param2fit)
[5e48acb]	474
	475	def set_graph_id(self, uid, graph_id):
	476	"""
	477	Set graph_id for fitprobelm
	478	"""
	479	self.page_finder[uid].set_graph_id(graph_id)
	480
	481	def get_graph_id(self, uid):
	482	"""
	483	Set graph_id for fitprobelm
	484	"""
	485	return self.page_finder[uid].get_graph_id()
	486
[f83b94a]	487	def save_fit_state(self, filepath, fitstate):
	488	"""
[5062bbf]	489	save fit page state into file
[f83b94a]	490	"""
	491	self.state_reader.write(filename=filepath, fitstate=fitstate)
[55bb249c]	492
[f7ef313]	493	def set_fit_weight(self, uid, flag, is2d=False, fid=None):
[55bb249c]	494	"""
	495	Set the fit weights of a given page for all
	496	its data by default. If fid is provide then set the range
	497	only for the data with fid as id
	498	:param uid: id corresponding to a fit page
	499	:param fid: id corresponding to a fit problem (data, model)
	500	:param weight: current dy data
	501	"""
	502	if uid in self.page_finder.keys():
[f7ef313]	503	self.page_finder[uid].set_weight(flag=flag, is2d=is2d)
[55bb249c]	504
[2dbffcc]	505	def set_fit_range(self, uid, qmin, qmax, fid=None):
[ca7a626]	506	"""
[2dbffcc]	507	Set the fitting range of a given page for all
	508	its data by default. If fid is provide then set the range
	509	only for the data with fid as id
	510	:param uid: id corresponding to a fit page
	511	:param fid: id corresponding to a fit problem (data, model)
	512	:param qmin: minimum value of the fit range
	513	:param qmax: maximum value of the fit range
[ca7a626]	514	"""
[2dbffcc]	515	if uid in self.page_finder.keys():
[f6933b8]	516	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax, fid=fid)
	517
[2dbffcc]	518	def schedule_for_fit(self, value=0, uid=None):
[948add7]	519	"""
[5062bbf]	520	Set the fit problem field to 0 or 1 to schedule that problem to fit.
	521	Schedule the specified fitproblem or get the fit problem related to
	522	the current page and set value.
	523	:param value: integer 0 or 1
[2dbffcc]	524	:param uid: the id related to a page contaning fitting information
	525	"""
	526	if uid in self.page_finder.keys():
[66ff250]	527	self.page_finder[uid].schedule_tofit(value)
[ca7a626]	528
[d89f09b]	529	def get_page_finder(self):
[5062bbf]	530	"""
	531	return self.page_finder used also by simfitpage.py
	532	"""
[d89f09b]	533	return self.page_finder
	534
[3b19ac9]	535	def set_page_finder(self,modelname,names,values):
[d89f09b]	536	"""
[5062bbf]	537	Used by simfitpage.py to reset a parameter given the string constrainst.
	538
[0fd2f27]	539	:param modelname: the name ot the model for with the parameter
	540	has to reset
[5062bbf]	541	:param value: can be a string in this case.
	542	:param names: the paramter name
	543
	544	:note: expecting park used for fit.
	545
[d89f09b]	546	"""
[66ff250]	547	sim_page_id = self.sim_page.uid
	548	for uid, value in self.page_finder.iteritems():
	549	if uid != sim_page_id:
[6bbeacd4]	550	list = value.get_model()
[f93dfcb]	551	model = list[0]
[6bbeacd4]	552	if model.name == modelname:
	553	value.set_model_param(names, values)
[d89f09b]	554	break
[2db1d66]	555
[d89f09b]	556	def split_string(self,item):
	557	"""
[5062bbf]	558	receive a word containing dot and split it. used to split parameterset
	559	name into model name and parameter name example: ::
	560
[3b19ac9]	561	paramaterset (item) = M1.A
[5062bbf]	562	Will return model_name = M1 , parameter name = A
	563
[d89f09b]	564	"""
	565	if string.find(item,".")!=-1:
	566	param_names= re.split("\.",item)
[6d91073]	567	model_name=param_names[0]
	568	##Assume max len is 3; eg., M0.radius.width
	569	if len(param_names) == 3:
	570	param_name=param_names[1]+"."+param_names[2]
	571	else:
	572	param_name=param_names[1]
[d89f09b]	573	return model_name,param_name
[2296316]	574
	575	def set_ftol(self, ftol=None):
	576	"""
	577	Set ftol: Relative error desired in the sum of chi squares.
	578	"""
	579	# check if it is flaot
	580	try:
	581	f_tol = float(ftol)
	582	except:
	583	# default
[2c6b224]	584	f_tol = SANS_F_TOL
[2296316]	585
	586	self.ftol = f_tol
[2c6b224]	587	# update ftol menu help strings
	588	ftol_help = "Change the current FTolerance (=%s) " % str(self.ftol)
	589	ftol_help += "of Simple FitEngine..."
[dafc36f]	590	if self.menu1 != None:
	591	self.menu1.SetHelpString(self.id_tol, ftol_help)
[2c6b224]	592
	593	def show_ftol_dialog(self, event=None):
	594	"""
	595	Dialog to select ftol for Scipy
	596	"""
	597	#if event != None:
	598	# event.Skip()
	599	from ftol_dialog import ChangeFtol
	600	panel = ChangeFtol(self.parent, self)
	601	panel.ShowModal()
	602
[66ff250]	603	def stop_fit(self, uid):
[ed2ea6a]	604	"""
[5062bbf]	605	Stop the fit engine
[ed2ea6a]	606	"""
[66ff250]	607	if uid in self.fit_thread_list.keys():
	608	calc_fit = self.fit_thread_list[uid]
	609	if calc_fit is not None and calc_fit.isrunning():
	610	calc_fit.stop()
	611	msg = "Fit stop!"
	612	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
[3ddc2c4]	613	del self.fit_thread_list[uid]
[66ff250]	614	#set the fit button label of page when fit stop is trigger from
	615	#simultaneous fit pane
	616	if self.sim_page is not None and uid == self.sim_page.uid:
	617	for uid, value in self.page_finder.iteritems():
	618	if value.get_scheduled() == 1:
	619	if uid in self.fit_panel.opened_pages.keys():
	620	panel = self.fit_panel.opened_pages[uid]
	621	panel. _on_fit_complete()
[6bbeacd4]	622
[2dbffcc]	623	def set_smearer(self, uid, smearer, fid, qmin=None, qmax=None, draw=True,
	624	enable_smearer=False):
	625	"""
	626	Get a smear object and store it to a fit problem of fid as id. If proper
	627	flag is enable , will plot the theory with smearing information.
	628
	629	:param smearer: smear object to allow smearing data of id fid
	630	:param enable_smearer: Define whether or not all (data, model) contained
	631	in the structure of id uid will be smeared before fitting.
	632	:param qmin: the maximum value of the theory plotting range
	633	:param qmax: the maximum value of the theory plotting range
	634	:param draw: Determine if the theory needs to be plot
[ca7a626]	635	"""
[66ff250]	636	if uid not in self.page_finder.keys():
[2dbffcc]	637	return
	638	self.page_finder[uid].enable_smearing(flag=enable_smearer)
	639	self.page_finder[uid].set_smearer(smearer, fid=fid)
[6bbeacd4]	640	if draw:
	641	## draw model 1D with smeared data
[2dbffcc]	642	data = self.page_finder[uid].get_fit_data(fid=fid)
	643	if data is None:
	644	msg = "set_mearer requires at least data.\n"
	645	msg += "Got data = %s .\n" % str(data)
[269df2b]	646	return
	647	#raise ValueError, msg
[2dbffcc]	648	model = self.page_finder[uid].get_model(fid=fid)
[6bbeacd4]	649	if model is None:
	650	return
[2dbffcc]	651	enable1D = issubclass(data.__class__, Data1D)
	652	enable2D = issubclass(data.__class__, Data2D)
[6bbeacd4]	653	## if user has already selected a model to plot
	654	## redraw the model with data smeared
[2dbffcc]	655	smear = self.page_finder[uid].get_smearer(fid=fid)
[342dc442]	656
	657	# compute weight for the current data
	658	weight = self.page_finder[uid].get_weight(fid=fid)
	659
[66ff250]	660	self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
[ba1f0b2]	661	enable1D=enable1D, enable2D=enable2D,
[342dc442]	662	qmin=qmin, qmax=qmax, weight=weight)
[f6aee42]	663	self._mac_sleep(0.2)
	664
	665	def _mac_sleep(self, sec=0.2):
[2dbffcc]	666	"""
	667	Give sleep to MAC
	668	"""
[f6aee42]	669	if ON_MAC:
[2dbffcc]	670	time.sleep(sec)
	671
[66ff250]	672	def draw_model(self, model, page_id, data=None, smearer=None,
[67e258c]	673	enable1D=True, enable2D=False,
[5ef55d2]	674	state=None,
[f64a4b7]	675	fid=None,
[fa65e99]	676	toggle_mode_on=False,
[2dbffcc]	677	qmin=None, qmax=None,
[e3f6ef5]	678	update_chisqr=True, weight=None, source='model'):
[ca7a626]	679	"""
[5062bbf]	680	Draw model.
	681
	682	:param model: the model to draw
	683	:param name: the name of the model to draw
	684	:param data: the data on which the model is based to be drawn
	685	:param description: model's description
	686	:param enable1D: if true enable drawing model 1D
	687	:param enable2D: if true enable drawing model 2D
	688	:param qmin: Range's minimum value to draw model
	689	:param qmax: Range's maximum value to draw model
	690	:param qstep: number of step to divide the x and y-axis
[2296316]	691	:param update_chisqr: update chisqr [bool]
[ed2ea6a]	692
[d89f09b]	693	"""
[62f851f]	694	#self.weight = weight
[ad3fa1e]	695	if issubclass(data.__class__, Data1D) or not enable2D:
[f72333f]	696	## draw model 1D with no loaded data
[67e258c]	697	self._draw_model1D(model=model,
	698	data=data,
[66ff250]	699	page_id=page_id,
[67e258c]	700	enable1D=enable1D,
	701	smearer=smearer,
	702	qmin=qmin,
	703	qmax=qmax,
[f64a4b7]	704	fid=fid,
[62f851f]	705	weight=weight,
[fa65e99]	706	toggle_mode_on=toggle_mode_on,
[5ef55d2]	707	state=state,
[e3f6ef5]	708	update_chisqr=update_chisqr,
	709	source=source)
[f72333f]	710	else:
	711	## draw model 2D with no initial data
[ba1f0b2]	712	self._draw_model2D(model=model,
[66ff250]	713	page_id=page_id,
[67e258c]	714	data=data,
	715	enable2D=enable2D,
	716	smearer=smearer,
	717	qmin=qmin,
	718	qmax=qmax,
[f64a4b7]	719	fid=fid,
[d682c92]	720	weight=weight,
[5ef55d2]	721	state=state,
[fa65e99]	722	toggle_mode_on=toggle_mode_on,
[e3f6ef5]	723	update_chisqr=update_chisqr,
	724	source=source)
[2db1d66]	725
[922497f]	726	def onFit(self, uid):
[ca7a626]	727	"""
[2dbffcc]	728	Get series of data, model, associates parameters and range and send then
	729	to series of fit engines. Fit data and model, display result to
	730	corresponding panels.
	731	:param uid: id related to the panel currently calling this fit function.
[ca7a626]	732	"""
[31469d50]	733	flag = True
[bb18ef1]	734	## count the number of fitproblem schedule to fit
[67e258c]	735	fitproblem_count = 0
[66ff250]	736	for value in self.page_finder.values():
[67e258c]	737	if value.get_scheduled() == 1:
[bb18ef1]	738	fitproblem_count += 1
[7db52f1]	739	self._gui_engine = self._return_engine_type()
[c660493]	740	self.fitproblem_count = fitproblem_count
[67e258c]	741	if self._fit_engine == "park":
	742	engineType = "Simultaneous Fit"
[ca7a626]	743	else:
[67e258c]	744	engineType = "Single Fit"
[922497f]	745	fitter_list = []
	746	sim_fitter = None
[284f6fe]	747	is_single_fit = True
[922497f]	748	if self.sim_page is not None and self.sim_page.uid == uid:
[284f6fe]	749	#simulatanous fit only one engine need to be created
	750	## if simultaneous fit change automatically the engine to park
	751	self._on_change_engine(engine='park')
[922497f]	752	sim_fitter = Fit(self._fit_engine)
	753	fitter_list.append(sim_fitter)
[284f6fe]	754	is_single_fit = False
[7db52f1]	755
[284f6fe]	756
	757	self.fitproblem_count = fitproblem_count
	758	if self._fit_engine == "park":
	759	engineType = "Simultaneous Fit"
	760	else:
	761	engineType = "Single Fit"
[922497f]	762
[67e258c]	763	self.current_pg = None
[66ff250]	764	list_page_id = []
[922497f]	765	fit_id = 0
[33dd2e5]	766	batch_inputs = {}
	767	batch_outputs = {}
[66ff250]	768	for page_id, value in self.page_finder.iteritems():
[dc613d6]	769	# For simulfit (uid give with None), do for-loop
	770	# if uid is specified (singlefit), do it only on the page.
	771	if engineType == "Single Fit":
	772	if page_id != uid:
	773	continue
[d89f09b]	774	try:
[67e258c]	775	if value.get_scheduled() == 1:
[f64a4b7]	776	value.nbr_residuals_computed = 0
[f93dfcb]	777	#Get list of parameters name to fit
[d89f09b]	778	pars = []
	779	templist = []
[66ff250]	780	page = self.fit_panel.get_page_by_id(page_id)
[7ee79cb]	781	self.set_fit_weight(uid=page.uid,
	782	flag=page.get_weight_flag(),
	783	is2d = page._is_2D())
[3b19ac9]	784	templist = page.get_param_list()
[31469d50]	785	flag = page._update_paramv_on_fit()
	786	if not flag:
	787	msg = "Fitting range or parameter values are"
	788	msg += " invalid in %s"% \
	789	page.window_caption
	790	wx.PostEvent(page.parent.parent,
	791	StatusEvent(status= msg, info="error",
	792	type="stop"))
	793	return flag
[d89f09b]	794	for element in templist:
[513115c]	795	name = str(element[1])
[ca7a626]	796	pars.append(name)
[7bd6cfae]	797	fitproblem_list = value.values()
	798	for fitproblem in fitproblem_list:
[922497f]	799	if sim_fitter is None:
	800	fitter = Fit(self._fit_engine)
[33dd2e5]	801	self._fit_helper(fitproblem=fitproblem,
	802	pars=pars,
	803	fitter=fitter,
	804	fit_id=fit_id,
	805	batch_inputs=batch_inputs,
	806	batch_outputs=batch_outputs)
[922497f]	807	fitter_list.append(fitter)
	808	else:
	809	fitter = sim_fitter
[33dd2e5]	810	self._fit_helper(fitproblem=fitproblem,
	811	pars=pars,
	812	fitter=fitter,
	813	fit_id=fit_id,
	814	batch_inputs=batch_inputs,
	815	batch_outputs=batch_outputs)
[922497f]	816	fit_id += 1
[66ff250]	817	list_page_id.append(page_id)
	818	current_page_id = page_id
[922497f]	819	value.clear_model_param()
[d89f09b]	820	except:
[31469d50]	821	flag = False
[ba1f0b2]	822	msg= "%s error: %s" % (engineType, sys.exc_value)
	823	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
	824	type="stop"))
[31469d50]	825	return flag
[e54d2c32]	826	## If a thread is already started, stop it
	827	#if self.calc_fit!= None and self.calc_fit.isrunning():
	828	# self.calc_fit.stop()
[a2cb1f9]	829	msg = "Fitting is in progress..."
	830	wx.PostEvent( self.parent, StatusEvent(status=msg, type="progress" ))
	831
	832	#Handler used for park engine displayed message
[66ff250]	833	handler = ConsoleUpdate(parent=self.parent,
	834	manager=self,
	835	improvement_delta=0.1)
[f6aee42]	836	self._mac_sleep(0.2)
[e54d2c32]	837	## perform single fit
[05fb6d12]	838	try:
	839	page = self.fit_panel.get_page_by_id(uid)
	840	batch_on = page.batch_on
	841	except:
	842	batch_on = False
[92a5ac92]	843
[05fb6d12]	844	# batch fit
	845	if batch_on:
[91a43d0]	846	calc_fit = FitThread(handler = handler,
[cc31608]	847	fn=fitter_list,
[2296316]	848	pars=pars,
[33dd2e5]	849	batch_inputs=batch_inputs,
	850	batch_outputs=batch_outputs,
[2296316]	851	page_id=list_page_id,
[92a5ac92]	852	completefn=self._batch_fit_complete,
[7db52f1]	853	ftol=self.ftol,
	854	reset_flag=self.batch_reset_flag)
[e54d2c32]	855	else:
[92a5ac92]	856	# single fit: not batch and not simul fit
	857	if not is_single_fit:
	858	current_page_id = self.sim_page.uid
[e54d2c32]	859	## Perform more than 1 fit at the time
[58e0c83]	860	calc_fit = FitThread(handler=handler,
[cc31608]	861	fn=fitter_list,
[33dd2e5]	862	batch_inputs=batch_inputs,
	863	batch_outputs=batch_outputs,
[66ff250]	864	page_id=list_page_id,
[2296316]	865	updatefn=handler.update_fit,
[6a4002d]	866	completefn=self._fit_completed,
[2296316]	867	ftol=self.ftol)
[66ff250]	868	self.fit_thread_list[current_page_id] = calc_fit
[a2cb1f9]	869	calc_fit.queue()
[cc31608]	870	msg = "Fitting is in progress..."
	871	wx.PostEvent( self.parent, StatusEvent(status=msg, type="progress" ))
	872
	873	self.ready_fit(calc_fit=calc_fit)
[31469d50]	874	return flag
	875
[662da312]	876	def ready_fit(self, calc_fit):
[c660493]	877	"""
	878	Ready for another fit
	879	"""
	880	if self.fitproblem_count != None and self.fitproblem_count > 1:
[662da312]	881	calc_fit.ready(2.5)
[c660493]	882	else:
	883	time.sleep(0.4)
[2f189dc]	884
[2dbffcc]	885	def remove_plot(self, uid, fid=None, theory=False):
[2f189dc]	886	"""
[5062bbf]	887	remove model plot when a fit page is closed
[2dbffcc]	888	:param uid: the id related to the fitpage to close
	889	:param fid: the id of the fitproblem(data, model, range,etc)
[2f189dc]	890	"""
[2dbffcc]	891	if uid not in self.page_finder.keys():
	892	return
	893	fitproblemList = self.page_finder[uid].get_fit_problem(fid)
	894	for fitproblem in fitproblemList:
	895	data = fitproblem.get_fit_data()
	896	model = fitproblem.get_model()
	897	plot_id = None
	898	if model is not None:
	899	plot_id = data.id + name
	900	if theory:
	901	plot_id = data.id
	902	group_id = data.group_id
	903	wx.PostEvent(self.parent, NewPlotEvent(id=plot_id,
	904	group_id=group_id,
	905	action='remove'))
[edcbd467]	906
[2dbffcc]	907	def store_data(self, uid, data_list=None, caption=None):
[31b0c47]	908	"""
[2dbffcc]	909	Recieve a list of data and store them ans well as a caption of
	910	the fit page where they come from.
	911	:param uid: if related to a fit page
	912	:param data_list: list of data to fit
	913	:param caption: caption of the window related to these data
[31b0c47]	914	"""
[cc31608]	915	if data_list is None:
	916	data_list = []
[f7ef313]	917
[2dbffcc]	918	self.page_finder[uid].set_fit_data(data=data_list)
	919	if caption is not None:
	920	self.page_finder[uid].set_fit_tab_caption(caption=caption)
[f7ef313]	921
[6bbeacd4]	922	def on_add_new_page(self, event=None):
[edcbd467]	923	"""
[6bbeacd4]	924	ask fit panel to create a new empty page
[edcbd467]	925	"""
	926	try:
[6bbeacd4]	927	page = self.fit_panel.add_empty_page()
[2dbffcc]	928	page_caption = page.window_caption
[6450d8c]	929	# add data associated to the page created
	930	if page != None:
[f304194]	931	wx.PostEvent(self.parent, StatusEvent(status="Page Created",
[31b0c47]	932	info="info"))
[edcbd467]	933	else:
[f304194]	934	msg = "Page was already Created"
[a0da535]	935	wx.PostEvent(self.parent, StatusEvent(status=msg,
	936	info="warning"))
[1b1bbf9]	937	self.set_top_panel()
[edcbd467]	938	except:
[2dbffcc]	939	msg = "Creating Fit page: %s"%sys.exc_value
	940	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
[6bbeacd4]	941
	942	def add_fit_page(self, data):
	943	"""
	944	given a data, ask to the fitting panel to create a new fitting page,
	945	get this page and store it into the page_finder of this plug-in
[2dbffcc]	946	:param data: is a list of data
[6bbeacd4]	947	"""
	948	page = self.fit_panel.set_data(data)
[7f76f89]	949	# page could be None when loading state files
	950	if page == None:
	951	return page
[2dbffcc]	952	page_caption = page.window_caption
[6bbeacd4]	953	#append Data1D to the panel containing its theory
	954	#if theory already plotted
[66ff250]	955	if page.uid in self.page_finder:
[cc31608]	956	data = page.get_data()
[2dbffcc]	957	theory_data = self.page_finder[page.uid].get_theory_data(data.id)
[6bbeacd4]	958	if issubclass(data.__class__, Data2D):
[e88ebfd]	959	data.group_id = wx.NewId()
[a5701e6]	960	if theory_data is not None:
[66ff250]	961	group_id = str(page.uid) + " Model1D"
[a5701e6]	962	wx.PostEvent(self.parent,
	963	NewPlotEvent(group_id=group_id,
	964	action="delete"))
[0fd2f27]	965	self.parent.update_data(prev_data=theory_data,
	966	new_data=data)
[6bbeacd4]	967	else:
	968	if theory_data is not None:
[66ff250]	969	group_id = str(page.uid) + " Model2D"
[e88ebfd]	970	data.group_id = theory_data.group_id
[a5701e6]	971	wx.PostEvent(self.parent,
	972	NewPlotEvent(group_id=group_id,
	973	action="delete"))
[0fd2f27]	974	self.parent.update_data(prev_data=theory_data,
	975	new_data=data)
[2dbffcc]	976	self.store_data(uid=page.uid, data_list=page.get_data_list(),
	977	caption=page.window_caption)
[33dd2e5]	978	if self.sim_page is not None and not self.batch_on:
[6bbeacd4]	979	self.sim_page.draw_page()
[1b1bbf9]	980	return page
[6bbeacd4]	981
[848a2ef]	982	def _onEVT_SLICER_PANEL(self, event):
	983	"""
[5062bbf]	984	receive and event telling to update a panel with a name starting with
[2e08a9f]	985	event.panel_name. this method update slicer panel
	986	for a given interactor.
[5062bbf]	987
[2e08a9f]	988	:param event: contains type of slicer , paramaters for updating
	989	the panel and panel_name to find the slicer 's panel concerned.
[848a2ef]	990	"""
	991	for item in self.parent.panels:
[0fd2f27]	992	name = event.panel_name
	993	if self.parent.panels[item].window_caption.startswith(name):
[848a2ef]	994	self.parent.panels[item].set_slicer(event.type, event.params)
[df4c3ad]	995
	996	self.parent._mgr.Update()
[b324aa9]	997
[848a2ef]	998	def _closed_fitpage(self, event):
	999	"""
[5062bbf]	1000	request fitpanel to close a given page when its unique data is removed
	1001	from the plot. close fitpage only when the a loaded data is removed
[848a2ef]	1002	"""
[784e2fa]	1003	if event is None or event.data is None:
	1004	return
	1005	if hasattr(event.data,"is_data"):
[a0da535]	1006	if not event.data.is_data or \
[66ff250]	1007	event.data.__class__.__name__ == "Data1D":
[784e2fa]	1008	self.fit_panel.close_page_with_data(event.data)
[2dbffcc]	1009
[dc613d6]	1010	def _reset_schedule_problem(self, value=0, uid=None):
[6f023e8]	1011	"""
[5062bbf]	1012	unschedule or schedule all fitproblem to be fit
[6f023e8]	1013	"""
[dc613d6]	1014	# case that uid is not specified
	1015	if uid == None:
	1016	for page_id in self.page_finder.keys():
	1017	self.page_finder[page_id].schedule_tofit(value)
	1018	# when uid is given
	1019	else:
[2dbffcc]	1020	if uid in self.page_finder.keys():
	1021	self.page_finder[uid].schedule_tofit(value)
[dc613d6]	1022
[33dd2e5]	1023	def _fit_helper(self, fitproblem, pars, fitter, fit_id,
	1024	batch_inputs, batch_outputs):
[2140e68]	1025	"""
[2dbffcc]	1026	Create and set fit engine with series of data and model
	1027	:param pars: list of fittable parameters
	1028	:param fitter_list: list of fit engine
	1029	:param value: structure storing data mapped to their model, range etc..
[2140e68]	1030	"""
[922497f]	1031	data = fitproblem.get_fit_data()
	1032	model = fitproblem.get_model()
	1033	smearer = fitproblem.get_smearer()
	1034	qmin, qmax = fitproblem.get_range()
[29a4024]	1035
[922497f]	1036	#Extra list of parameters and their constraints
	1037	listOfConstraint = []
	1038	param = fitproblem.get_model_param()
	1039	if len(param) > 0:
	1040	for item in param:
	1041	## check if constraint
	1042	if item[0] != None and item[1] != None:
	1043	listOfConstraint.append((item[0],item[1]))
[29a4024]	1044	new_model = model#deepcopy(model)
[41661a0]	1045	fitter.set_model(new_model, fit_id, pars, data=data,
	1046	constraints=listOfConstraint)
[922497f]	1047	fitter.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin,
	1048	qmax=qmax)
	1049	fitter.select_problem_for_fit(id=fit_id, value=1)
[7bd6cfae]	1050
[33dd2e5]	1051
[c77d859]	1052	def _onSelect(self,event):
	1053	"""
[5062bbf]	1054	when Select data to fit a new page is created .Its reference is
	1055	added to self.page_finder
[d89f09b]	1056	"""
[c77d859]	1057	self.panel = event.GetEventObject()
[67e258c]	1058	Plugin.on_perspective(self, event=event)
[5e48acb]	1059	self.select_data(self.panel)
	1060
	1061	def select_data(self, panel):
	1062	"""
	1063	"""
	1064	self.panel = panel
[6ed82c7]	1065	for plottable in self.panel.graph.plottables:
[2fff4db]	1066	if plottable.__class__.__name__ in ["Data1D", "Theory1D"]:
[3831ea1e]	1067	data_id = self.panel.graph.selected_plottable
	1068	if plottable == self.panel.plots[data_id]:
[6bbeacd4]	1069	data = plottable
[cc31608]	1070	self.add_fit_page(data=[data])
[edcbd467]	1071	return
[c77d859]	1072	else:
[6bbeacd4]	1073	data = plottable
[cc31608]	1074	self.add_fit_page(data=[data])
[1b1bbf9]	1075	self.set_top_panel()
[1c1436d]	1076
[66ff250]	1077	def update_fit(self, result=None, msg=""):
	1078	"""
	1079	"""
	1080	print "update_fit result", result
	1081
[41661a0]	1082
[92a5ac92]	1083	def _batch_fit_complete(self, result, pars, page_id,
[33dd2e5]	1084	batch_outputs, batch_inputs, elapsed=None):
[cc31608]	1085	"""
[2dbffcc]	1086	Display fit result in batch
	1087	:param result: list of objects received fromt fit engines
	1088	:param pars: list of fitted parameters names
	1089	:param page_id: list of page ids which called fit function
	1090	:param elapsed: time spent at the fitting level
[cc31608]	1091	"""
[92a5ac92]	1092	self._mac_sleep(0.2)
	1093	uid = page_id[0]
	1094	if uid in self.fit_thread_list.keys():
	1095	del self.fit_thread_list[uid]
	1096
[cc31608]	1097	self._update_fit_button(page_id)
[2bb37c3]	1098	t1 = time.time()
	1099	str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
	1100	msg = "Fit completed on %s \n" % str_time
	1101	msg += "Duration time: %s s.\n" % str(elapsed)
[cc31608]	1102	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
	1103	type="stop"))
[41661a0]	1104	pid = page_id[0]
[91a43d0]	1105	cpage = self.fit_panel.get_page_by_id(pid)
	1106	batch_on = cpage.batch_on
[33dd2e5]	1107	if batch_outputs is None:
	1108	batch_outputs = {}
[91a43d0]	1109	if batch_on:
[33dd2e5]	1110	# format batch_outputs
	1111	batch_outputs["Chi2"] = []
[cc31608]	1112	for index in range(len(pars)):
[33dd2e5]	1113	batch_outputs[pars[index]] = []
[029e4d3]	1114	batch_inputs["error on %s" % pars[index]] = []
[6a4002d]	1115	msg = ""
[92a5ac92]	1116	for list_res in result:
	1117	for res in list_res:
	1118	model, data = res.inputs[0]
[4a52223]	1119	correct_result = False
[92a5ac92]	1120	if model is not None and hasattr(model, "model"):
	1121	model = model.model
	1122	if data is not None and hasattr(data, "sans_data"):
	1123	data = data.sans_data
[4a52223]	1124	is_data2d = issubclass(data.__class__, Data2D)
	1125	#check consistency of arrays
	1126	if not is_data2d:
[15f68ce]	1127	if len(res.theory) == len(res.index[res.index]) and \
[4a52223]	1128	len(res.index) == len(data.y):
	1129	correct_result = True
	1130	else:
[46c4ccb]	1131	copy_data = deepcopy(data)
	1132	new_theory = copy_data.data
	1133	new_theory[res.index] = res.theory
[3b70cc7]	1134	new_theory[res.index == False] = numpy.nan
[46c4ccb]	1135	correct_result = True
[4a52223]	1136	#get all fittable parameters of the current model
	1137	param_list = model.getParamList()
	1138	for param in model.getDispParamList():
	1139	if not model.is_fittable(param) and \
	1140	param in param_list:
	1141	param_list.remove(param)
	1142	if not correct_result or res.fitness is None or \
[92a5ac92]	1143	not numpy.isfinite(res.fitness) or \
	1144	numpy.any(res.pvec == None) or not \
	1145	numpy.all(numpy.isfinite(res.pvec)):
	1146	data_name = str(None)
	1147	if data is not None:
	1148	data_name = str(data.name)
	1149	model_name = str(None)
	1150	if model is not None:
	1151	model_name = str(model.name)
	1152	msg += "Data %s and Model %s did not fit.\n" % (data_name,
	1153	model_name)
[4a52223]	1154	ERROR = numpy.NAN
	1155	cell = BatchCell()
	1156	cell.label = res.fitness
	1157	cell.value = res.fitness
	1158	batch_outputs["Chi2"].append(ERROR)
	1159	for param in param_list:
	1160	# save value of fixed parameters
	1161	if param not in batch_outputs.keys():
	1162	batch_outputs[param] = []
	1163	if param not in res.param_list:
	1164	batch_outputs[str(param)].append(ERROR)
	1165	for index in range(len(res.param_list)):
	1166	#save only fitted values
	1167	batch_outputs[res.param_list[index]].append(ERROR)
	1168	batch_inputs["error on %s" % res.param_list[index]].append(ERROR)
[92a5ac92]	1169	else:
	1170	cell = BatchCell()
	1171	cell.label = res.fitness
	1172	cell.value = res.fitness
	1173	batch_outputs["Chi2"].append(cell)
[47d9be79]	1174	# add parameters to batch_results
	1175	for param in param_list:
	1176	# save value of fixed parameters
	1177	if param not in batch_outputs.keys():
	1178	batch_outputs[param] = []
[26fc866]	1179	if param not in res.param_list:
[47d9be79]	1180	batch_outputs[str(param)].append(model.getParam(param))
[26fc866]	1181	for index in range(len(res.param_list)):
[47d9be79]	1182	#save only fitted values
[26fc866]	1183	batch_outputs[res.param_list[index]].append(res.pvec[index])
[15f68ce]	1184	if res.stderr is not None and len(res.stderr) == len(res.param_list):
	1185	item = res.stderr[index]
	1186	batch_inputs["error on %s" % res.param_list[index]].append(item)
[26fc866]	1187	if res.param_list[index] in model.getParamList():
	1188	model.setParam(res.param_list[index], res.pvec[index])
[92a5ac92]	1189
[6a4002d]	1190	self.page_finder[pid].set_batch_result(batch_inputs=batch_inputs,
[92a5ac92]	1191	batch_outputs=batch_outputs)
	1192	cpage = self.fit_panel.get_page_by_id(pid)
	1193	cpage._on_fit_complete()
	1194	self.page_finder[pid][data.id].set_result(res)
	1195	fitproblem = self.page_finder[pid][data.id]
	1196	qmin, qmax = fitproblem.get_range()
[4a52223]	1197
	1198	if correct_result:
	1199	if not is_data2d:
[7643ba2]	1200	self._complete1D(x=data.x, y=res.theory, page_id=pid,
[92a5ac92]	1201	elapsed=None,
	1202	index=res.index, model=model,
	1203	weight=None, fid=data.id,
	1204	toggle_mode_on=False, state=None,
	1205	data=data, update_chisqr=False,
[7db52f1]	1206	source='fit')
[7643ba2]	1207	else:
[46c4ccb]	1208	self._complete2D(image=new_theory, data=data,
[92a5ac92]	1209	model=model,
	1210	page_id=pid, elapsed=None,
	1211	index=res.index,
	1212	qmin=qmin,
	1213	qmax=qmax, fid=data.id, weight=None,
	1214	toggle_mode_on=False, state=None,
	1215	update_chisqr=False,
[7db52f1]	1216	source='fit')
[4a52223]	1217	self.on_set_batch_result(page_id=pid,
[2de278d9]	1218	fid=data.id,
	1219	batch_outputs=batch_outputs,
	1220	batch_inputs=batch_inputs)
[4a52223]	1221
[7643ba2]	1222	wx.PostEvent(self.parent, StatusEvent(status=msg, error="error",
	1223	type="stop"))
[92a5ac92]	1224	wx.CallAfter(self.parent.on_set_batch_result,batch_outputs,
	1225	batch_inputs,
	1226	self.sub_menu)
	1227
[f64a4b7]	1228	def on_set_batch_result(self, page_id, fid, batch_outputs, batch_inputs):
	1229	"""
	1230	"""
	1231
	1232	pid = page_id
	1233	if fid not in self.page_finder[pid]:
	1234	return
	1235	fitproblem = self.page_finder[pid][fid]
	1236	index = self.page_finder[pid].nbr_residuals_computed - 1
	1237	residuals = fitproblem.get_residuals()
	1238	theory_data = fitproblem.get_theory_data()
	1239	data = fitproblem.get_fit_data()
	1240	model = fitproblem.get_model()
	1241	#fill batch result information
	1242	if "Data" not in batch_outputs.keys():
	1243	batch_outputs["Data"] = []
	1244	from sans.guiframe.data_processor import BatchCell
[ec9a635]	1245	cell = BatchCell()
	1246	cell.label = data.name
	1247	cell.value = index
[6b3edc1]	1248
[ec9a635]	1249	if theory_data != None:
[6b3edc1]	1250	#Suucessful fit
	1251	theory_data.id = wx.NewId()
[b5fe787]	1252	theory_data.name = model.name + "[%s]" % str(data.name)
[e80e704]	1253	if issubclass(theory_data.__class__, Data2D):
	1254	group_id = wx.NewId()
	1255	theory_data.group_id = group_id
	1256	if group_id not in theory_data.list_group_id:
	1257	theory_data.list_group_id.append(group_id)
	1258
[ec9a635]	1259	try:
	1260	# associate residuals plot
[e80e704]	1261	if issubclass(residuals.__class__, Data2D):
	1262	group_id = wx.NewId()
	1263	residuals.group_id = group_id
	1264	if group_id not in residuals.list_group_id:
	1265	residuals.list_group_id.append(group_id)
[ec9a635]	1266	batch_outputs["Chi2"][index].object = [residuals]
	1267	except:
	1268	pass
	1269
	1270	cell.object = [data, theory_data]
	1271	batch_outputs["Data"].append(cell)
	1272	for key, value in data.meta_data.iteritems():
	1273	if key not in batch_inputs.keys():
	1274	batch_inputs[key] = []
	1275	if key.lower().strip() != "loader":
	1276	batch_inputs[key].append(value)
	1277	param = "temperature"
	1278	if hasattr(data.sample, param):
	1279	if param not in batch_inputs.keys():
	1280	batch_inputs[param] = []
	1281	batch_inputs[param].append(data.sample.temperature)
	1282
[6b3edc1]	1283
[6a4002d]	1284	def _fit_completed(self, result, page_id, batch_outputs,
[33dd2e5]	1285	batch_inputs=None,
	1286	pars=None,
[8aa5788]	1287	elapsed=None):
[c77d859]	1288	"""
[2dbffcc]	1289	Display result of the fit on related panel(s).
	1290	:param result: list of object generated when fit ends
	1291	:param pars: list of names of parameters fitted
	1292	:param page_id: list of page ids which called fit function
	1293	:param elapsed: time spent at the fitting level
[c77d859]	1294	"""
[2bb37c3]	1295	t1 = time.time()
	1296	str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
	1297	msg = "Fit completed on %s \n" % str_time
	1298	msg += "Duration time: %s s.\n" % str(elapsed)
	1299	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
	1300	type="stop"))
[7db52f1]	1301	# reset fit_engine if changed by simul_fit
	1302	self._on_change_engine(self._gui_engine)
[2bb37c3]	1303	self._update_fit_button(page_id)
[922497f]	1304	result = result[0]
[dc613d6]	1305	self.fit_thread_list = {}
[66ff250]	1306	if page_id is None:
	1307	page_id = []
[ca7a626]	1308	## fit more than 1 model at the same time
[f6aee42]	1309	self._mac_sleep(0.2)
[ca7a626]	1310	try:
[6a4002d]	1311	index = 0
	1312	for uid in page_id:
	1313	res = result[index]
[7643ba2]	1314	if res.fitness is None or \
[6a4002d]	1315	not numpy.isfinite(res.fitness) or \
	1316	numpy.any(res.pvec == None) or \
	1317	not numpy.all(numpy.isfinite(res.pvec)):
	1318	msg = "Fitting did not converge!!!"
	1319	wx.PostEvent(self.parent,
	1320	StatusEvent(status=msg,
	1321	info="warning",
	1322	type="stop"))
	1323	self._update_fit_button(page_id)
	1324	else:
[2bb37c3]	1325
[7643ba2]	1326	cpage = self.fit_panel.get_page_by_id(uid)
	1327	# Make sure we got all results
	1328	#(CallAfter is important to MAC)
	1329	wx.CallAfter(cpage.onsetValues, res.fitness, res.param_list,
	1330	res.pvec, res.stderr)
	1331	index += 1
	1332	cpage._on_fit_complete()
[6a4002d]	1333	except ValueError:
[d7345b71]	1334	msg = "Fitting did not converge!!!"
[6a4002d]	1335	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
	1336	type="stop"))
	1337	except:
[d7345b71]	1338	msg = "Fit completed but Following"
[6a4002d]	1339	msg += " error occurred:%s" % sys.exc_value
[2296316]	1340	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
	1341	type="stop"))
[6a4002d]	1342
[12cd4ec]	1343	def _update_fit_button(self, page_id):
	1344	"""
	1345	Update Fit button when fit stopped
	1346
	1347	: parameter page_id: fitpage where the button is
	1348	"""
[37290c4]	1349	if page_id.__class__.__name__ != 'list':
	1350	page_id = [page_id]
[12cd4ec]	1351	for uid in page_id:
	1352	page = self.fit_panel.get_page_by_id(uid)
	1353	page._on_fit_complete()
	1354
[c77d859]	1355	def _on_show_panel(self, event):
[5062bbf]	1356	"""
	1357	"""
	1358	pass
[da6fd1a]	1359
	1360	def on_reset_batch_flag(self, event):
	1361	"""
	1362	Set batch_reset_flag
	1363	"""
	1364	event.Skip()
[dafc36f]	1365	if self.menu1 == None:
	1366	return
[da6fd1a]	1367	menu_item = self.menu1.FindItemById(self.id_reset_flag)
	1368	flag = menu_item.IsChecked()
	1369	if not flag:
	1370	menu_item.Check(False)
	1371	self.batch_reset_flag = True
	1372	else:
	1373	menu_item.Check(True)
	1374	self.batch_reset_flag = False
[5062bbf]	1375
[da6fd1a]	1376	## post a message to status bar
	1377	msg = "Set Chain Fitting: %s" % str(not self.batch_reset_flag)
	1378	wx.PostEvent(self.parent,
	1379	StatusEvent(status=msg))
	1380
[c77d859]	1381	def _onset_engine_park(self,event):
	1382	"""
[5062bbf]	1383	set engine to park
[c77d859]	1384	"""
	1385	self._on_change_engine('park')
	1386
	1387	def _onset_engine_scipy(self,event):
	1388	"""
[5062bbf]	1389	set engine to scipy
[c77d859]	1390	"""
	1391	self._on_change_engine('scipy')
	1392
	1393	def _on_slicer_event(self, event):
	1394	"""
[5062bbf]	1395	Receive a panel as event and send it to guiframe
	1396
	1397	:param event: event containing a panel
	1398
[c77d859]	1399	"""
[5062bbf]	1400	if event.panel is not None:
[c77d859]	1401	new_panel = event.panel
[c3435b7f]	1402	self.slicer_panels.append(event.panel)
[c77d859]	1403	# Set group ID if available
	1404	event_id = self.parent.popup_panel(new_panel)
	1405	new_panel.uid = event_id
	1406	self.mypanels.append(new_panel)
[5062bbf]	1407
[848a2ef]	1408	def _onclearslicer(self, event):
	1409	"""
[5062bbf]	1410	Clear the boxslicer when close the panel associate with this slicer
[848a2ef]	1411	"""
[df4c3ad]	1412	name =event.GetPane().caption
[c3435b7f]	1413
	1414	for panel in self.slicer_panels:
	1415	if panel.window_caption==name:
	1416
[df4c3ad]	1417	for item in self.parent.panels:
[2dbffcc]	1418	if hasattr(self.parent.panels[item], "uid"):
[c3435b7f]	1419	if self.parent.panels[item].uid ==panel.base.uid:
[df4c3ad]	1420	self.parent.panels[item].onClearSlicer(event)
	1421	self.parent._mgr.Update()
	1422	break
[c3435b7f]	1423	break
[5062bbf]	1424
[707436d]	1425	def _return_engine_type(self):
	1426	"""
[5062bbf]	1427	return the current type of engine
[707436d]	1428	"""
	1429	return self._fit_engine
	1430
	1431
[c77d859]	1432	def _on_change_engine(self, engine='park'):
	1433	"""
[5062bbf]	1434	Allow to select the type of engine to perform fit
	1435
	1436	:param engine: the key work of the engine
	1437
[c77d859]	1438	"""
[77e23a2]	1439	## saving fit engine name
[c77d859]	1440	self._fit_engine = engine
[707436d]	1441	## change menu item state
[2dbffcc]	1442	if engine == "park":
[0b6ae5f]	1443	self.menu1.FindItemById(self.park_id).Check(True)
	1444	self.menu1.FindItemById(self.scipy_id).Check(False)
[707436d]	1445	else:
[0b6ae5f]	1446	self.menu1.FindItemById(self.park_id).Check(False)
	1447	self.menu1.FindItemById(self.scipy_id).Check(True)
[77e23a2]	1448	## post a message to status bar
[a0da535]	1449	msg = "Engine set to: %s" % self._fit_engine
	1450	wx.PostEvent(self.parent,
	1451	StatusEvent(status=msg))
[66ff250]	1452	## send the current engine type to fitpanel
	1453	self.fit_panel._on_engine_change(name=self._fit_engine)
[dc613d6]	1454
[77e23a2]	1455
[c77d859]	1456	def _on_model_panel(self, evt):
	1457	"""
[5062bbf]	1458	react to model selection on any combo box or model menu.plot the model
	1459
	1460	:param evt: wx.combobox event
	1461
[c77d859]	1462	"""
	1463	model = evt.model
[66ff250]	1464	uid = evt.uid
[6bbeacd4]	1465	qmin = evt.qmin
	1466	qmax = evt.qmax
	1467	smearer = evt.smearer
[2dbffcc]	1468	caption = evt.caption
	1469	enable_smearer = evt.enable_smearer
[9237df4]	1470	if model == None:
[c77d859]	1471	return
[2dbffcc]	1472	if uid not in self.page_finder.keys():
	1473	return
[6bbeacd4]	1474	# save the name containing the data name with the appropriate model
[66ff250]	1475	self.page_finder[uid].set_model(model)
[2dbffcc]	1476	self.page_finder[uid].enable_smearing(enable_smearer)
[66ff250]	1477	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
[2dbffcc]	1478	self.page_finder[uid].set_fit_tab_caption(caption=caption)
[33dd2e5]	1479	if self.sim_page is not None and not self.batch_on:
[6bbeacd4]	1480	self.sim_page.draw_page()
[5062bbf]	1481
[2dbffcc]	1482	def _update1D(self, x, output):
[bb18ef1]	1483	"""
[5062bbf]	1484	Update the output of plotting model 1D
[bb18ef1]	1485	"""
[58e0c83]	1486	msg = "Plot updating ... "
	1487	wx.PostEvent(self.parent, StatusEvent(status=msg,type="update"))
[e575db9]	1488
[ad3fa1e]	1489	def _complete1D(self, x, y, page_id, elapsed, index, model,
[f64a4b7]	1490	weight=None, fid=None,
[ad3fa1e]	1491	toggle_mode_on=False, state=None,
[e3f6ef5]	1492	data=None, update_chisqr=True, source='model'):
[c77d859]	1493	"""
[5062bbf]	1494	Complete plotting 1D data
[c77d859]	1495	"""
	1496	try:
[1ec979d]	1497	numpy.nan_to_num(y)
	1498
[6bbeacd4]	1499	new_plot = Data1D(x=x, y=y)
[dce84c0]	1500	new_plot.is_data = False
[55d2f7e]	1501	new_plot.dy = numpy.zeros(len(y))
[6bbeacd4]	1502	new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
[2dbffcc]	1503	_yaxis, _yunit = data.get_yaxis()
	1504	_xaxis, _xunit = data.get_xaxis()
	1505	new_plot.title = data.name
[5e48acb]	1506
[e288ad0]	1507	new_plot.group_id = data.group_id#self.page_finder[page_id].get_graph_id()
[5e48acb]	1508	if new_plot.group_id == None:
	1509	new_plot.group_id = data.group_id
[2dbffcc]	1510	new_plot.id = str(page_id) + "model"
[a582d28]	1511	#if new_plot.id in self.color_dict:
	1512	# new_plot.custom_color = self.color_dict[new_plot.id]
[6bbeacd4]	1513	#find if this theory was already plotted and replace that plot given
	1514	#the same id
[2dbffcc]	1515	theory_data = self.page_finder[page_id].get_theory_data(fid=data.id)
[71e5c11]	1516
	1517	if data.is_data:
	1518	data_name = str(data.name)
	1519	else:
	1520	data_name = str(model.__class__.__name__)
	1521
	1522	new_plot.name = model.name + " ["+ data_name +"]"
[6bbeacd4]	1523	new_plot.xaxis(_xaxis, _xunit)
	1524	new_plot.yaxis(_yaxis, _yunit)
[2e08a9f]	1525	self.page_finder[page_id].set_theory_data(data=new_plot,
	1526	fid=data.id)
[2dbffcc]	1527	self.parent.update_theory(data_id=data.id, theory=new_plot,
[bdd3739]	1528	state=state)
[66ff250]	1529	current_pg = self.fit_panel.get_page_by_id(page_id)
[ae4ade7]	1530	title = new_plot.title
[eb4f2fd]	1531	batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
	1532	if not batch_on:
	1533	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
[2dbffcc]	1534	title=str(title)))
[90a2358]	1535	else:
	1536	top_data_id = self.fit_panel.get_page_by_id(page_id).data.id
	1537	if data.id == top_data_id:
	1538	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
	1539	title=str(title)))
[2dbffcc]	1540	caption = current_pg.window_caption
	1541	self.page_finder[page_id].set_fit_tab_caption(caption=caption)
[7643ba2]	1542
[2dbffcc]	1543	self.page_finder[page_id].set_theory_data(data=new_plot,
	1544	fid=data.id)
	1545	if toggle_mode_on:
	1546	wx.PostEvent(self.parent,
	1547	NewPlotEvent(group_id=str(page_id) + " Model2D",
	1548	action="Hide"))
[2296316]	1549	else:
[2dbffcc]	1550	if update_chisqr:
	1551	wx.PostEvent(current_pg,
[2e08a9f]	1552	Chi2UpdateEvent(output=self._cal_chisqr(
	1553	data=data,
[f64a4b7]	1554	fid=fid,
[62f851f]	1555	weight=weight,
[2dbffcc]	1556	page_id=page_id,
	1557	index=index)))
	1558	else:
[f64a4b7]	1559	self._plot_residuals(page_id=page_id, data=data, fid=fid,
[62f851f]	1560	index=index, weight=weight)
[cfbd06a]	1561
[d522635]	1562	msg = "Computation completed!"
[a0da535]	1563	wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" ))
[c77d859]	1564	except:
[6bbeacd4]	1565	raise
	1566	#msg = " Error occurred when drawing %s Model 1D: " % new_plot.name
	1567	#msg += " %s" % sys.exc_value
	1568	#wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
[5062bbf]	1569
[c77d859]	1570	def _update2D(self, output,time=None):
	1571	"""
[5062bbf]	1572	Update the output of plotting model
[c77d859]	1573	"""
[58e0c83]	1574	wx.PostEvent(self.parent, StatusEvent(status="Plot \
[a0da535]	1575	#updating ... ", type="update"))
[a2cb1f9]	1576	#self.ready_fit()
[58e0c83]	1577
[66ff250]	1578	def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
[f64a4b7]	1579	qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
[e3f6ef5]	1580	update_chisqr=True, source='model'):
[c77d859]	1581	"""
[5062bbf]	1582	Complete get the result of modelthread and create model 2D
	1583	that can be plot.
[c77d859]	1584	"""
[1ec979d]	1585	numpy.nan_to_num(image)
[2dbffcc]	1586	new_plot= Data2D(image=image, err_image=data.err_data)
[fa65e99]	1587	new_plot.name = model.name
[818589a]	1588	new_plot.title = "Analytical model 2D "
[2dbffcc]	1589	new_plot.id = str(page_id) + "model"
[f3242cf]	1590	new_plot.group_id = str(page_id) + " Model2D"
[2dbffcc]	1591	new_plot.detector = data.detector
	1592	new_plot.source = data.source
	1593	new_plot.is_data = False
	1594	new_plot.qx_data = data.qx_data
	1595	new_plot.qy_data = data.qy_data
	1596	new_plot.q_data = data.q_data
	1597	new_plot.mask = data.mask
	1598	## plot boundaries
	1599	new_plot.ymin = data.ymin
	1600	new_plot.ymax = data.ymax
	1601	new_plot.xmin = data.xmin
	1602	new_plot.xmax = data.xmax
	1603	title = data.title
[71e5c11]	1604
[dce84c0]	1605	new_plot.is_data = False
[71e5c11]	1606	if data.is_data:
	1607	data_name = str(data.name)
	1608	else:
	1609	data_name = str(model.__class__.__name__)
	1610
	1611	if len(title) > 1:
	1612	new_plot.title = "Model2D for " + data_name
[53cf669]	1613	new_plot.name = model.name + " [" + \
[71e5c11]	1614	data_name + "-2D]"
[fa65e99]	1615	theory_data = deepcopy(new_plot)
[5ef55d2]	1616	theory_data.name = "Unknown"
[6bbeacd4]	1617
[2dbffcc]	1618	self.page_finder[page_id].set_theory_data(data=theory_data, fid=data.id)
	1619	self.parent.update_theory(data_id=data.id,
[05319e2]	1620	theory=new_plot,
[e88ebfd]	1621	state=state)
[66ff250]	1622	current_pg = self.fit_panel.get_page_by_id(page_id)
[ae4ade7]	1623	title = new_plot.title
[763bec8]	1624	batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
[e3f6ef5]	1625	if not source == 'fit':
[763bec8]	1626	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
[ae4ade7]	1627	title=title))
[2dbffcc]	1628	self.page_finder[page_id].set_theory_data(data=new_plot, fid=data.id)
	1629	if toggle_mode_on:
	1630	wx.PostEvent(self.parent,
	1631	NewPlotEvent(group_id=str(page_id) + " Model1D",
	1632	action="Hide"))
[2296316]	1633	else:
[2dbffcc]	1634	# Chisqr in fitpage
	1635	if update_chisqr:
	1636	wx.PostEvent(current_pg,
	1637	Chi2UpdateEvent(output=self._cal_chisqr(data=data,
[62f851f]	1638	weight=weight,
[f64a4b7]	1639	fid=fid,
[2dbffcc]	1640	page_id=page_id,
	1641	index=index)))
	1642	else:
[f64a4b7]	1643	self._plot_residuals(page_id=page_id, data=data, fid=fid,
[62f851f]	1644	index=index, weight=weight)
[d522635]	1645	msg = "Computation completed!"
[a0da535]	1646	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
[6bbeacd4]	1647
[2dbffcc]	1648	def _draw_model2D(self, model, page_id, qmin,
	1649	qmax,
	1650	data=None, smearer=None,
[a0da535]	1651	description=None, enable2D=False,
[5ef55d2]	1652	state=None,
[f64a4b7]	1653	fid=None,
[62f851f]	1654	weight=None,
[fa65e99]	1655	toggle_mode_on=False,
[e3f6ef5]	1656	update_chisqr=True, source='model'):
[f93dfcb]	1657	"""
[5062bbf]	1658	draw model in 2D
	1659
	1660	:param model: instance of the model to draw
	1661	:param description: the description of the model
	1662	:param enable2D: when True allows to draw model 2D
	1663	:param qmin: the minimum value to draw model 2D
	1664	:param qmax: the maximum value to draw model 2D
	1665	:param qstep: the number of division of Qx and Qy of the model to draw
[f93dfcb]	1666
	1667	"""
[c77d859]	1668	if not enable2D:
[2dbffcc]	1669	return None
[c77d859]	1670	try:
	1671	from model_thread import Calc2D
	1672	## If a thread is already started, stop it
[a0da535]	1673	if (self.calc_2D is not None) and self.calc_2D.isrunning():
[c77d859]	1674	self.calc_2D.stop()
[2dbffcc]	1675	self.calc_2D = Calc2D(model=model,
[a0da535]	1676	data=data,
[66ff250]	1677	page_id=page_id,
[a0da535]	1678	smearer=smearer,
	1679	qmin=qmin,
	1680	qmax=qmax,
[62f851f]	1681	weight=weight,
[f64a4b7]	1682	fid=fid,
[fa65e99]	1683	toggle_mode_on=toggle_mode_on,
[5ef55d2]	1684	state=state,
[2296316]	1685	completefn=self._complete2D,
[e3f6ef5]	1686	update_chisqr=update_chisqr, source=source)
[c77d859]	1687	self.calc_2D.queue()
[f72333f]	1688
[c77d859]	1689	except:
[6bbeacd4]	1690	raise
	1691	#msg = " Error occurred when drawing %s Model 2D: " % model.name
	1692	#msg += " %s" % sys.exc_value
	1693	#wx.PostEvent(self.parent, StatusEvent(status=msg))
[f72333f]	1694
[2dbffcc]	1695	def _draw_model1D(self, model, page_id, data,
	1696	qmin, qmax, smearer=None,
[5ef55d2]	1697	state=None,
[62f851f]	1698	weight=None,
[f64a4b7]	1699	fid=None,
[e3f6ef5]	1700	toggle_mode_on=False, update_chisqr=True, source='model',
[2296316]	1701	enable1D=True):
[c77d859]	1702	"""
[5062bbf]	1703	Draw model 1D from loaded data1D
	1704
	1705	:param data: loaded data
	1706	:param model: the model to plot
	1707
[c77d859]	1708	"""
	1709	if not enable1D:
[f72333f]	1710	return
[c77d859]	1711	try:
	1712	from model_thread import Calc1D
	1713	## If a thread is already started, stop it
[a0da535]	1714	if (self.calc_1D is not None) and self.calc_1D.isrunning():
[c77d859]	1715	self.calc_1D.stop()
[2dbffcc]	1716	self.calc_1D = Calc1D(data=data,
[6bbeacd4]	1717	model=model,
[66ff250]	1718	page_id=page_id,
[a0da535]	1719	qmin=qmin,
	1720	qmax=qmax,
	1721	smearer=smearer,
[5ef55d2]	1722	state=state,
[62f851f]	1723	weight=weight,
[f64a4b7]	1724	fid=fid,
[fa65e99]	1725	toggle_mode_on=toggle_mode_on,
[2296316]	1726	completefn=self._complete1D,
	1727	#updatefn = self._update1D,
[e3f6ef5]	1728	update_chisqr=update_chisqr,
	1729	source=source)
[c77d859]	1730	self.calc_1D.queue()
	1731	except:
[a0da535]	1732	msg = " Error occurred when drawing %s Model 1D: " % model.name
	1733	msg += " %s" % sys.exc_value
	1734	wx.PostEvent(self.parent, StatusEvent(status=msg))
[2dbffcc]	1735
	1736
	1737
[f64a4b7]	1738	def _cal_chisqr(self, page_id, data, weight, fid=None, index=None):
[f72333f]	1739	"""
[5062bbf]	1740	Get handy Chisqr using the output from draw1D and 2D,
	1741	instead of calling expansive CalcChisqr in guithread
[f72333f]	1742	"""
[df9e0fc]	1743	data_copy = deepcopy(data)
[f72333f]	1744	# default chisqr
	1745	chisqr = None
[2dbffcc]	1746	#to compute chisq make sure data has valid data
[f72333f]	1747	# return None if data == None
[df9e0fc]	1748	if not check_data_validity(data_copy) or data_copy == None:
[2dbffcc]	1749	return chisqr
[df9e0fc]	1750
[f72333f]	1751	# Get data: data I, theory I, and data dI in order
[ca2bdae]	1752	if data_copy.__class__.__name__ == "Data2D":
[a0da535]	1753	if index == None:
[ca2bdae]	1754	index = numpy.ones(len(data_copy.data),ntype=bool)
[62f851f]	1755	if weight != None:
	1756	data_copy.err_data = weight
[a0da535]	1757	# get rid of zero error points
[ca2bdae]	1758	index = index & (data_copy.err_data != 0)
	1759	index = index & (numpy.isfinite(data_copy.data))
	1760	fn = data_copy.data[index]
	1761	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
[df9e0fc]	1762	if theory_data== None:
	1763	return chisqr
[6bbeacd4]	1764	gn = theory_data.data[index]
[ca2bdae]	1765	en = data_copy.err_data[index]
[f72333f]	1766	else:
	1767	# 1 d theory from model_thread is only in the range of index
[2296316]	1768	if index == None:
[ca2bdae]	1769	index = numpy.ones(len(data_copy.y), ntype=bool)
[62f851f]	1770	if weight != None:
	1771	data_copy.dy = weight
[ca2bdae]	1772	if data_copy.dy == None or data_copy.dy == []:
	1773	dy = numpy.ones(len(data_copy.y))
[f151ddf]	1774	else:
[a0da535]	1775	## Set consitently w/AbstractFitengine:
	1776	# But this should be corrected later.
[ca2bdae]	1777	dy = deepcopy(data_copy.dy)
[55d2f7e]	1778	dy[dy==0] = 1
[ca2bdae]	1779	fn = data_copy.y[index]
[eb4f2fd]	1780
[ca2bdae]	1781	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
[df9e0fc]	1782	if theory_data== None:
	1783	return chisqr
[6bbeacd4]	1784	gn = theory_data.y
[4d5fa8c]	1785	en = dy[index]
[df9e0fc]	1786
[f72333f]	1787	# residual
[2296316]	1788	res = (fn - gn) / en
	1789	residuals = res[numpy.isfinite(res)]
[f72333f]	1790	# get chisqr only w/finite
[2296316]	1791	chisqr = numpy.average(residuals * residuals)
[eb4f2fd]	1792
[62f851f]	1793	self._plot_residuals(page_id=page_id, data=data_copy,
[f64a4b7]	1794	fid=fid,
[62f851f]	1795	weight=weight, index=index)
[ca2bdae]	1796
[f72333f]	1797	return chisqr
	1798
[f64a4b7]	1799	def _plot_residuals(self, page_id, weight, fid=None,
	1800	data=None, index=None):
[2296316]	1801	"""
	1802	Plot the residuals
	1803
	1804	:param data: data
	1805	:param index: index array (bool)
	1806	: Note: this is different from the residuals in cal_chisqr()
	1807	"""
[ca2bdae]	1808	data_copy = deepcopy(data)
[2296316]	1809	# Get data: data I, theory I, and data dI in order
[ca2bdae]	1810	if data_copy.__class__.__name__ == "Data2D":
[2296316]	1811	# build residuals
	1812	residuals = Data2D()
	1813	#residuals.copy_from_datainfo(data)
	1814	# Not for trunk the line below, instead use the line above
[ca2bdae]	1815	data_copy.clone_without_data(len(data_copy.data), residuals)
[2296316]	1816	residuals.data = None
[ca2bdae]	1817	fn = data_copy.data#[index]
	1818	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
[2296316]	1819	gn = theory_data.data#[index]
[9fa4a4d]	1820	if weight == None:
	1821	en = data_copy.err_data
	1822	else:
	1823	en = weight
[2296316]	1824	residuals.data = (fn - gn) / en
[ca2bdae]	1825	residuals.qx_data = data_copy.qx_data#[index]
	1826	residuals.qy_data = data_copy.qy_data #[index]
	1827	residuals.q_data = data_copy.q_data#[index]
[2296316]	1828	residuals.err_data = numpy.ones(len(residuals.data))#[index]
	1829	residuals.xmin = min(residuals.qx_data)
	1830	residuals.xmax = max(residuals.qx_data)
	1831	residuals.ymin = min(residuals.qy_data)
	1832	residuals.ymax = max(residuals.qy_data)
[ca2bdae]	1833	residuals.q_data = data_copy.q_data#[index]
	1834	residuals.mask = data_copy.mask
[2296316]	1835	residuals.scale = 'linear'
	1836	# check the lengths
	1837	if len(residuals.data) != len(residuals.q_data):
	1838	return
	1839	else:
	1840	# 1 d theory from model_thread is only in the range of index
[ca2bdae]	1841	if data_copy.dy == None or data_copy.dy == []:
	1842	dy = numpy.ones(len(data_copy.y))
[2296316]	1843	else:
[62f851f]	1844	if weight == None:
[90a1440]	1845	dy = numpy.ones(len(data_copy.y))
[2296316]	1846	## Set consitently w/AbstractFitengine:
	1847	## But this should be corrected later.
[90a1440]	1848	else:
[62f851f]	1849	dy = weight#deepcopy(data_copy.dy)
[2296316]	1850	dy[dy==0] = 1
[ca2bdae]	1851	fn = data_copy.y[index]
	1852	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
[2296316]	1853	gn = theory_data.y
	1854	en = dy[index]
	1855	# build residuals
	1856	residuals = Data1D()
	1857	residuals.y = (fn - gn) / en
[ca2bdae]	1858	residuals.x = data_copy.x[index]
[2296316]	1859	residuals.dy = numpy.ones(len(residuals.y))
	1860	residuals.dx = None
	1861	residuals.dxl = None
	1862	residuals.dxw = None
	1863	residuals.ytransform = 'y'
	1864	# For latter scale changes
	1865	residuals.xaxis('\\rm{Q} ', 'A^{-1}')
	1866	residuals.yaxis('\\rm{Residuals} ', 'normalized')
	1867	new_plot = residuals
[b5fe787]	1868	new_plot.name = "Residuals for " + str(theory_data.name.split()[0]) +"[" + str(data.name) +"]"
[2296316]	1869	## allow to highlight data when plotted
	1870	new_plot.interactive = True
	1871	## when 2 data have the same id override the 1 st plotted
[a2da783]	1872	new_plot.id = "res" + str(data_copy.id)#name + " residuals"
[2296316]	1873	##group_id specify on which panel to plot this data
[5e48acb]	1874	group_id = self.page_finder[page_id].get_graph_id()
	1875	if group_id == None:
	1876	group_id = data.group_id
	1877	new_plot.group_id ="res" + str(group_id)
[2296316]	1878	#new_plot.is_data = True
	1879	##post data to plot
	1880	title = new_plot.name
[62f851f]	1881	self.page_finder[page_id].set_residuals(residuals=new_plot, fid=data.id)
[2de278d9]	1882	self.parent.update_theory(data_id=data.id, theory=new_plot)
[f64a4b7]	1883	batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
[5cf1e5b]	1884	if not batch_on:
	1885	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))
[92a5ac92]	1886
[f64a4b7]	1887
[5062bbf]	1888	#def profile(fn, args, *kw):
	1889	# import cProfile, pstats, os
	1890	# global call_result
	1891	# def call():
	1892	# global call_result
	1893	# call_result = fn(args, *kw)
	1894	# cProfile.runctx('call()', dict(call=call), {}, 'profile.out')
	1895	# stats = pstats.Stats('profile.out')
	1896	# #stats.sort_stats('time')
	1897	# stats.sort_stats('calls')
	1898	# stats.print_stats()
	1899	# os.unlink('profile.out')
	1900	# return call_result
[d89f09b]	1901	if __name__ == "__main__":
	1902	i = Plugin()
	1903
	1904
	1905
	1906

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

SasView

source: sasview/fittingview/src/sans/perspectives/fitting/fitting.py @ cbf01fd

Download in other formats: