fitting.py @ aac161f1

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 aac161f1 was aac161f1, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 8 years ago
Ticket 411: added stop button to simultaneous fits.
Property mode set to `100755`
File size: 84.2 KB

Rev	Line
[f76bf17]	1	"""
	2	Fitting perspective
	3	"""
	4	################################################################################
	5	#This software was developed by the University of Tennessee as part of the
	6	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
	7	#project funded by the US National Science Foundation.
	8	#
	9	#See the license text in license.txt
	10	#
	11	#copyright 2009, University of Tennessee
	12	################################################################################
	13	import re
	14	import sys
	15	import os
	16	import wx
	17	import logging
	18	import numpy
	19	import time
	20	from copy import deepcopy
	21	import models
	22
[b699768]	23	from sas.sascalc.dataloader.loader import Loader
[d85c194]	24	from sas.sasgui.guiframe.dataFitting import Data2D
	25	from sas.sasgui.guiframe.dataFitting import Data1D
	26	from sas.sasgui.guiframe.dataFitting import check_data_validity
	27	from sas.sasgui.guiframe.events import NewPlotEvent
	28	from sas.sasgui.guiframe.events import StatusEvent
	29	from sas.sasgui.guiframe.events import EVT_SLICER_PANEL
	30	from sas.sasgui.guiframe.events import EVT_SLICER_PARS_UPDATE
	31	from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
	32	from sas.sasgui.guiframe.plugin_base import PluginBase
	33	from sas.sasgui.guiframe.data_processor import BatchCell
[b699768]	34	from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
[d85c194]	35	from sas.sasgui.perspectives.fitting.console import ConsoleUpdate
	36	from sas.sasgui.perspectives.fitting.fitproblem import FitProblemDictionary
	37	from sas.sasgui.perspectives.fitting.fitpanel import FitPanel
	38	from sas.sasgui.perspectives.fitting.resultpanel import ResultPanel, PlotResultEvent
	39
	40	from sas.sasgui.perspectives.fitting.fit_thread import FitThread
	41	from sas.sasgui.perspectives.fitting.pagestate import Reader
	42	from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent
	43	from sas.sasgui.perspectives.calculator.model_editor import TextDialog
	44	from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
	45	from sas.sasgui.guiframe.gui_manager import MDIFrame
	46	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
[f76bf17]	47
	48	MAX_NBR_DATA = 4
	49
	50	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
	51
	52
	53	if sys.platform == "win32":
	54	ON_MAC = False
	55	else:
	56	ON_MAC = True
	57
	58
	59
	60	class Plugin(PluginBase):
	61	"""
	62	Fitting plugin is used to perform fit
	63	"""
[f21d496]	64	def __init__(self):
	65	PluginBase.__init__(self, name="Fitting")
[f76bf17]	66
	67	#list of panel to send to guiframe
	68	self.mypanels = []
	69	# reference to the current running thread
	70	self.calc_2D = None
	71	self.calc_1D = None
	72
	73	self.color_dict = {}
	74
	75	self.fit_thread_list = {}
	76	self.residuals = None
	77	self.weight = None
	78	self.fit_panel = None
	79	self.plot_panel = None
	80	# Start with a good default
	81	self.elapsed = 0.022
	82	self.fit_panel = None
	83	## dictionary of page closed and id
	84	self.closed_page_dict = {}
	85	## Relative error desired in the sum of squares (float)
	86	self.batch_reset_flag = True
	87	#List of selected data
	88	self.selected_data_list = []
	89	## list of slicer panel created to display slicer parameters and results
	90	self.slicer_panels = []
	91	# model 2D view
	92	self.model2D_id = None
	93	#keep reference of the simultaneous fit page
	94	self.sim_page = None
	95	self.sim_menu = None
	96	self.batch_page = None
	97	self.batch_menu = None
	98	self.index_model = 0
	99	self.test_model_color = None
	100	#Create a reader for fit page's state
	101	self.state_reader = None
	102	self._extensions = '.fitv'
	103	self.menu1 = None
	104	self.new_model_frame = None
	105
	106	self.temp_state = []
	107	self.state_index = 0
	108	self.sfile_ext = None
	109	# take care of saving data, model and page associated with each other
	110	self.page_finder = {}
	111	# Log startup
	112	logging.info("Fitting plug-in started")
	113	self.batch_capable = self.get_batch_capable()
	114
	115	def get_batch_capable(self):
	116	"""
	117	Check if the plugin has a batch capability
	118	"""
	119	return True
	120
	121	def create_fit_problem(self, page_id):
	122	"""
	123	Given an ID create a fitproblem container
	124	"""
	125	self.page_finder[page_id] = FitProblemDictionary()
	126
	127	def delete_fit_problem(self, page_id):
	128	"""
	129	Given an ID create a fitproblem container
	130	"""
	131	if page_id in self.page_finder.iterkeys():
	132	del self.page_finder[page_id]
	133
	134	def add_color(self, color, id):
	135	"""
	136	adds a color as a key with a plot id as its value to a dictionary
	137	"""
	138	self.color_dict[id] = color
	139
	140	def on_batch_selection(self, flag):
	141	"""
	142	switch the the notebook of batch mode or not
	143	"""
	144	self.batch_on = flag
	145	if self.fit_panel is not None:
	146	self.fit_panel.batch_on = self.batch_on
	147
	148	def populate_menu(self, owner):
	149	"""
	150	Create a menu for the Fitting plug-in
	151
	152	:param id: id to create a menu
	153	:param owner: owner of menu
	154
	155	:return: list of information to populate the main menu
	156
	157	"""
	158	#Menu for fitting
	159	self.menu1 = wx.Menu()
	160	id1 = wx.NewId()
	161	simul_help = "Add new fit panel"
	162	self.menu1.Append(id1, '&New Fit Page', simul_help)
	163	wx.EVT_MENU(owner, id1, self.on_add_new_page)
	164	self.menu1.AppendSeparator()
	165	self.id_simfit = wx.NewId()
	166	simul_help = "Constrained or Simultaneous Fit"
	167	self.menu1.Append(self.id_simfit, '&Constrained or Simultaneous Fit', simul_help)
	168	wx.EVT_MENU(owner, self.id_simfit, self.on_add_sim_page)
	169	self.sim_menu = self.menu1.FindItemById(self.id_simfit)
	170	self.sim_menu.Enable(False)
	171	#combined Batch
	172	self.id_batchfit = wx.NewId()
	173	batch_help = "Combined Batch"
	174	self.menu1.Append(self.id_batchfit, '&Combine Batch Fit', batch_help)
	175	wx.EVT_MENU(owner, self.id_batchfit, self.on_add_sim_page)
	176	self.batch_menu = self.menu1.FindItemById(self.id_batchfit)
	177	self.batch_menu.Enable(False)
	178
	179	self.menu1.AppendSeparator()
	180	self.id_bumps_options = wx.NewId()
	181	bopts_help = "Fitting options"
	182	self.menu1.Append(self.id_bumps_options, 'Fit &Options', bopts_help)
	183	wx.EVT_MENU(owner, self.id_bumps_options, self.on_bumps_options)
	184	self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options)
	185	self.bumps_options_menu.Enable(True)
	186
	187	self.id_result_panel = wx.NewId()
	188	self.menu1.Append(self.id_result_panel, "Fit Results", "Show fit results panel")
[9776c82]	189	wx.EVT_MENU(owner, self.id_result_panel, self.on_fit_results)
[f76bf17]	190	self.menu1.AppendSeparator()
	191
	192	self.id_reset_flag = wx.NewId()
	193	resetf_help = "BatchFit: If checked, the initial param values will be "
	194	resetf_help += "propagated from the previous results. "
	195	resetf_help += "Otherwise, the same initial param values will be used "
	196	resetf_help += "for all fittings."
	197	self.menu1.AppendCheckItem(self.id_reset_flag,
	198	"Chain Fitting [BatchFit Only]",
	199	resetf_help)
	200	wx.EVT_MENU(owner, self.id_reset_flag, self.on_reset_batch_flag)
	201	chain_menu = self.menu1.FindItemById(self.id_reset_flag)
	202	chain_menu.Check(not self.batch_reset_flag)
	203	chain_menu.Enable(self.batch_on)
	204
	205	self.menu1.AppendSeparator()
	206	self.edit_model_menu = wx.Menu()
	207	# Find and put files name in menu
	208	try:
	209	self.set_edit_menu(owner=owner)
	210	except:
	211	raise
	212
	213	self.id_edit = wx.NewId()
	214	editmodel_help = "Edit customized model sample file"
	215	self.menu1.AppendMenu(self.id_edit, "Edit Custom Model",
	216	self.edit_model_menu, editmodel_help)
	217	#create menubar items
	218	return [(self.menu1, self.sub_menu)]
	219
	220	def edit_custom_model(self, event):
	221	"""
	222	Get the python editor panel
	223	"""
[f21d496]	224	event_id = event.GetId()
	225	label = self.edit_menu.GetLabel(event_id)
[d85c194]	226	from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
[f76bf17]	227	filename = os.path.join(models.find_plugins_dir(), label)
	228	frame = PyConsole(parent=self.parent, manager=self,
	229	panel=self.fit_panel,
	230	title='Advanced Custom Model Editor',
	231	filename=filename)
	232	self.put_icon(frame)
	233	frame.Show(True)
	234
	235	def delete_custom_model(self, event):
	236	"""
	237	Delete custom model file
	238	"""
[f21d496]	239	event_id = event.GetId()
	240	label = self.delete_menu.GetLabel(event_id)
[f76bf17]	241	toks = os.path.splitext(label)
	242	path = os.path.join(models.find_plugins_dir(), toks[0])
	243	try:
	244	for ext in ['.py', '.pyc']:
	245	p_path = path + ext
	246	os.remove(p_path)
	247	self.update_custom_combo()
	248	if os.path.isfile(p_path):
	249	msg = "Sorry! Could not be able to delete the default "
	250	msg += "custom model... \n"
	251	msg += "Please manually remove the files (.py, .pyc) "
	252	msg += "in the 'plugin_models' folder \n"
	253	msg += "inside of the SasView application, "
	254	msg += "and try it again."
	255	wx.MessageBox(msg, 'Info')
	256	#wx.PostEvent(self.parent, StatusEvent(status=msg, type='stop',
	257	# info='warning'))
	258	else:
[f21d496]	259	self.delete_menu.Delete(event_id)
[f76bf17]	260	for item in self.edit_menu.GetMenuItems():
	261	if item.GetLabel() == label:
	262	self.edit_menu.DeleteItem(item)
	263	msg = "The custom model, %s, has been deleted." % label
	264	wx.PostEvent(self.parent, StatusEvent(status=msg,
	265	type='stop', info='info'))
	266	break
	267	except:
	268	msg = 'Delete Error: \nCould not delete the file; Check if in use.'
	269	wx.MessageBox(msg, 'Error')
	270
	271	def make_sum_model(self, event):
	272	"""
	273	Edit summodel template and make one
	274	"""
[f21d496]	275	event_id = event.GetId()
[f76bf17]	276	model_manager = models.ModelManager()
	277	model_list = model_manager.get_model_name_list()
	278	plug_dir = models.find_plugins_dir()
[6f16e25]	279	textdial = TextDialog(None, self, wx.ID_ANY, 'Easy Sum/Multi(p1, p2) Editor',
[f76bf17]	280	model_list, plug_dir)
	281	self.put_icon(textdial)
	282	textdial.ShowModal()
	283	textdial.Destroy()
	284
	285	def make_new_model(self, event):
	286	"""
	287	Make new model
	288	"""
	289	if self.new_model_frame != None:
	290	self.new_model_frame.Show(False)
	291	self.new_model_frame.Show(True)
	292	else:
[f21d496]	293	event_id = event.GetId()
[f76bf17]	294	dir_path = models.find_plugins_dir()
	295	title = "New Custom Model Function"
	296	self.new_model_frame = EditorWindow(parent=self, base=self,
	297	path=dir_path, title=title)
	298	self.put_icon(self.new_model_frame)
	299	self.new_model_frame.Show(True)
	300
	301	def update_custom_combo(self):
	302	"""
	303	Update custom model list in the fitpage combo box
	304	"""
	305	custom_model = 'Customized Models'
	306	try:
	307	# Update edit menus
	308	self.set_edit_menu_helper(self.parent, self.edit_custom_model)
	309	self.set_edit_menu_helper(self.parent, self.delete_custom_model)
	310	temp = self.fit_panel.reset_pmodel_list()
	311	if temp:
	312	# Set the new custom model list for all fit pages
	313	for uid, page in self.fit_panel.opened_pages.iteritems():
	314	if hasattr(page, "formfactorbox"):
	315	page.model_list_box = temp
	316	current_val = page.formfactorbox.GetLabel()
	317	#if page.plugin_rbutton.GetValue():
	318	mod_cat = page.categorybox.GetStringSelection()
	319	if mod_cat == custom_model:
	320	#pos = page.formfactorbox.GetSelection()
	321	page._show_combox_helper()
	322	new_val = page.formfactorbox.GetLabel()
	323	if current_val != new_val and new_val != '':
	324	page.formfactorbox.SetLabel(new_val)
	325	else:
	326	page.formfactorbox.SetLabel(current_val)
	327	except:
	328	pass
	329
	330
	331	def set_edit_menu(self, owner):
	332	"""
	333	Set list of the edit model menu labels
	334	"""
[f21d496]	335	wx_id = wx.NewId()
[f76bf17]	336	#new_model_menu = wx.Menu()
[f21d496]	337	self.edit_model_menu.Append(wx_id, 'New',
[f76bf17]	338	'Add a new model function')
[f21d496]	339	wx.EVT_MENU(owner, wx_id, self.make_new_model)
	340	wx_id = wx.NewId()
	341	self.edit_model_menu.Append(wx_id, 'Sum\|Multi(p1, p2)',
[f76bf17]	342	'Sum of two model functions')
[f21d496]	343	wx.EVT_MENU(owner, wx_id, self.make_sum_model)
[f76bf17]	344	e_id = wx.NewId()
	345	self.edit_menu = wx.Menu()
	346	self.edit_model_menu.AppendMenu(e_id,
	347	'Advanced', self.edit_menu)
	348	self.set_edit_menu_helper(owner, self.edit_custom_model)
	349
	350	d_id = wx.NewId()
	351	self.delete_menu = wx.Menu()
	352	self.edit_model_menu.AppendMenu(d_id,
	353	'Delete', self.delete_menu)
	354	self.set_edit_menu_helper(owner, self.delete_custom_model)
	355
	356	def set_edit_menu_helper(self, owner=None, menu=None):
	357	"""
	358	help for setting list of the edit model menu labels
	359	"""
	360	if menu == None:
	361	menu = self.edit_custom_model
	362	list_fnames = os.listdir(models.find_plugins_dir())
	363	list_fnames.sort()
	364	for f_item in list_fnames:
	365	name = os.path.basename(f_item)
	366	toks = os.path.splitext(name)
	367	if toks[-1] == '.py' and not toks[0] == '__init__':
	368	if menu == self.edit_custom_model:
	369	if toks[0] == 'easy_sum_of_p1_p2':
	370	continue
	371	submenu = self.edit_menu
	372	else:
	373	submenu = self.delete_menu
	374	has_file = False
	375	for item in submenu.GetMenuItems():
	376	if name == submenu.GetLabel(item.GetId()):
	377	has_file = True
	378	if not has_file:
[f21d496]	379	wx_id = wx.NewId()
	380	submenu.Append(wx_id, name)
	381	wx.EVT_MENU(owner, wx_id, menu)
[f76bf17]	382	has_file = False
	383
	384	def put_icon(self, frame):
	385	"""
	386	Put icon in the frame title bar
	387	"""
	388	if hasattr(frame, "IsIconized"):
	389	if not frame.IsIconized():
	390	try:
	391	icon = self.parent.GetIcon()
	392	frame.SetIcon(icon)
	393	except:
	394	pass
	395
	396	def on_add_sim_page(self, event):
	397	"""
	398	Create a page to access simultaneous fit option
	399	"""
[f21d496]	400	event_id = event.GetId()
[f76bf17]	401	caption = "Const & Simul Fit"
	402	page = self.sim_page
[f21d496]	403	if event_id == self.id_batchfit:
[f76bf17]	404	caption = "Combined Batch"
	405	page = self.batch_page
	406
	407	def set_focus_page(page):
	408	page.Show(True)
	409	page.Refresh()
	410	page.SetFocus()
	411	#self.parent._mgr.Update()
	412	msg = "%s already opened\n" % str(page.window_caption)
	413	wx.PostEvent(self.parent, StatusEvent(status=msg))
	414
	415	if page != None:
	416	return set_focus_page(page)
	417	if caption == "Const & Simul Fit":
	418	self.sim_page = self.fit_panel.add_sim_page(caption=caption)
	419	else:
	420	self.batch_page = self.fit_panel.add_sim_page(caption=caption)
	421
	422	def get_context_menu(self, plotpanel=None):
	423	"""
	424	Get the context menu items available for P(r).them allow fitting option
	425	for Data2D and Data1D only.
	426
	427	:param graph: the Graph object to which we attach the context menu
	428
	429	:return: a list of menu items with call-back function
	430
	431	:note: if Data1D was generated from Theory1D
	432	the fitting option is not allowed
	433
	434	"""
	435	self.plot_panel = plotpanel
	436	graph = plotpanel.graph
	437	fit_option = "Select data for fitting"
	438	fit_hint = "Dialog with fitting parameters "
	439
	440	if graph.selected_plottable not in plotpanel.plots:
	441	return []
	442	item = plotpanel.plots[graph.selected_plottable]
	443	if item.__class__.__name__ is "Data2D":
	444	if hasattr(item, "is_data"):
	445	if item.is_data:
	446	return [[fit_option, fit_hint, self._onSelect]]
	447	else:
	448	return []
	449	return [[fit_option, fit_hint, self._onSelect]]
	450	else:
	451
	452	# if is_data is true , this in an actual data loaded
	453	#else it is a data created from a theory model
	454	if hasattr(item, "is_data"):
	455	if item.is_data:
	456	return [[fit_option, fit_hint, self._onSelect]]
	457	else:
	458	return []
	459	return [[fit_option, fit_hint, self._onSelect]]
	460	return []
	461
	462	def get_panels(self, parent):
	463	"""
	464	Create and return a list of panel objects
	465	"""
	466	self.parent = parent
	467	#self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
	468	# Creation of the fit panel
	469	self.frame = MDIFrame(self.parent, None, 'None', (100, 200))
	470	self.fit_panel = FitPanel(parent=self.frame, manager=self)
	471	self.frame.set_panel(self.fit_panel)
	472	self._frame_set_helper()
	473	self.on_add_new_page(event=None)
	474	#Set the manager for the main panel
	475	self.fit_panel.set_manager(self)
	476	# List of windows used for the perspective
	477	self.perspective = []
	478	self.perspective.append(self.fit_panel.window_name)
	479
	480	self.result_frame = MDIFrame(self.parent, None, ResultPanel.window_caption, (220, 200))
	481	self.result_panel = ResultPanel(parent=self.result_frame, manager=self)
	482	self.perspective.append(self.result_panel.window_name)
	483
	484	#index number to create random model name
	485	self.index_model = 0
	486	self.index_theory = 0
	487	self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
	488	self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
	489	#self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer)
	490	#Create reader when fitting panel are created
	491	self.state_reader = Reader(self.set_state)
	492	#append that reader to list of available reader
	493	loader = Loader()
	494	loader.associate_file_reader(".fitv", self.state_reader)
	495	#Send the fitting panel to guiframe
	496	self.mypanels.append(self.fit_panel)
	497	self.mypanels.append(self.result_panel)
	498	return self.mypanels
	499
	500	def clear_panel(self):
	501	"""
	502	"""
	503	self.fit_panel.clear_panel()
	504
	505	def delete_data(self, data):
	506	"""
	507	delete the given data from panel
	508	"""
	509	self.fit_panel.delete_data(data)
	510
	511	def set_data(self, data_list=None):
	512	"""
	513	receive a list of data to fit
	514	"""
	515	if data_list is None:
	516	data_list = []
	517	selected_data_list = []
	518	if self.batch_on:
[098f3d2]	519	self.add_fit_page(data=data_list)
[f76bf17]	520	else:
	521	if len(data_list) > MAX_NBR_DATA:
	522	from fitting_widgets import DataDialog
	523	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
	524	if dlg.ShowModal() == wx.ID_OK:
	525	selected_data_list = dlg.get_data()
	526	dlg.Destroy()
	527
	528	else:
	529	selected_data_list = data_list
	530	try:
	531	group_id = wx.NewId()
	532	for data in selected_data_list:
	533	if data is not None:
	534	# 2D has no same group_id
	535	if data.__class__.__name__ == 'Data2D':
	536	group_id = wx.NewId()
	537	data.group_id = group_id
	538	if group_id not in data.list_group_id:
	539	data.list_group_id.append(group_id)
[098f3d2]	540	self.add_fit_page(data=[data])
[f76bf17]	541	except:
[098f3d2]	542	msg = "Fitting set_data: " + str(sys.exc_value)
[f76bf17]	543	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
	544
	545	def set_theory(self, theory_list=None):
	546	"""
	547	"""
	548	#set the model state for a given theory_state:
	549	for item in theory_list:
	550	try:
	551	_, theory_state = item
	552	self.fit_panel.set_model_state(theory_state)
	553	except:
	554	msg = "Fitting: cannot deal with the theory received"
	555	logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
	556	wx.PostEvent(self.parent,
	557	StatusEvent(status=msg, info="error"))
	558
	559	def set_state(self, state=None, datainfo=None, format=None):
	560	"""
	561	Call-back method for the fit page state reader.
	562	This method is called when a .fitv/.svs file is loaded.
	563
	564	: param state: PageState object
	565	: param datainfo: data
	566	"""
	567	#state = self.state_reader.get_state()
	568	if state != None:
	569	state = state.clone()
	570	# store fitting state in temp_state
	571	self.temp_state.append(state)
	572	else:
	573	self.temp_state = []
	574	# index to start with for a new set_state
	575	self.state_index = 0
	576	# state file format
	577	self.sfile_ext = format
	578
	579	self.on_set_state_helper(event=None)
	580
	581	def on_set_state_helper(self, event=None):
	582	"""
	583	Set_state_helper. This actually sets state
	584	after plotting data from state file.
	585
	586	: event: FitStateUpdateEvent called
	587	by dataloader.plot_data from guiframe
	588	"""
	589	if len(self.temp_state) == 0:
	590	if self.state_index == 0 and len(self.mypanels) <= 0 \
	591	and self.sfile_ext == '.svs':
	592	self.temp_state = []
	593	self.state_index = 0
	594	return
	595
	596	try:
	597	# Load fitting state
	598	state = self.temp_state[self.state_index]
	599	#panel state should have model selection to set_state
	600	if state.formfactorcombobox != None:
	601	#set state
	602	data = self.parent.create_gui_data(state.data)
	603	data.group_id = state.data.group_id
	604	self.parent.add_data(data_list={data.id: data})
	605	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
	606	title=data.title))
	607	#need to be fix later make sure we are sendind guiframe.data
	608	#to panel
	609	state.data = data
	610	page = self.fit_panel.set_state(state)
	611	else:
	612	#just set data because set_state won't work
	613	data = self.parent.create_gui_data(state.data)
	614	data.group_id = state.data.group_id
	615	self.parent.add_data(data_list={data.id: data})
	616	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
	617	title=data.title))
	618	page = self.add_fit_page([data])
	619	caption = page.window_caption
	620	self.store_data(uid=page.uid, data_list=page.get_data_list(),
	621	caption=caption)
	622	self.mypanels.append(page)
	623
	624	# get ready for the next set_state
	625	self.state_index += 1
	626
	627	#reset state variables to default when all set_state is finished.
	628	if len(self.temp_state) == self.state_index:
	629
	630	self.temp_state = []
	631	#self.state_index = 0
	632	# Make sure the user sees the fitting panel after loading
	633	#self.parent.set_perspective(self.perspective)
	634	self.on_perspective(event=None)
	635	except:
	636	self.state_index = 0
	637	self.temp_state = []
	638	raise
	639
	640	def set_param2fit(self, uid, param2fit):
	641	"""
	642	Set the list of param names to fit for fitprobelm
	643	"""
	644	self.page_finder[uid].set_param2fit(param2fit)
	645
	646	def set_graph_id(self, uid, graph_id):
	647	"""
	648	Set graph_id for fitprobelm
	649	"""
	650	self.page_finder[uid].set_graph_id(graph_id)
	651
	652	def get_graph_id(self, uid):
	653	"""
	654	Set graph_id for fitprobelm
	655	"""
	656	return self.page_finder[uid].get_graph_id()
	657
	658	def save_fit_state(self, filepath, fitstate):
	659	"""
	660	save fit page state into file
	661	"""
	662	self.state_reader.write(filename=filepath, fitstate=fitstate)
	663
	664	def set_fit_weight(self, uid, flag, is2d=False, fid=None):
	665	"""
	666	Set the fit weights of a given page for all
	667	its data by default. If fid is provide then set the range
	668	only for the data with fid as id
	669	:param uid: id corresponding to a fit page
	670	:param fid: id corresponding to a fit problem (data, model)
	671	:param weight: current dy data
	672	"""
[098f3d2]	673	# If we are not dealing with a specific fit problem, then
	674	# there is no point setting the weights.
	675	if fid is None:
	676	return
[f76bf17]	677	if uid in self.page_finder.keys():
	678	self.page_finder[uid].set_weight(flag=flag, is2d=is2d)
	679
	680	def set_fit_range(self, uid, qmin, qmax, fid=None):
	681	"""
	682	Set the fitting range of a given page for all
	683	its data by default. If fid is provide then set the range
	684	only for the data with fid as id
	685	:param uid: id corresponding to a fit page
	686	:param fid: id corresponding to a fit problem (data, model)
	687	:param qmin: minimum value of the fit range
	688	:param qmax: maximum value of the fit range
	689	"""
	690	if uid in self.page_finder.keys():
	691	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax, fid=fid)
	692
	693	def schedule_for_fit(self, value=0, uid=None):
	694	"""
	695	Set the fit problem field to 0 or 1 to schedule that problem to fit.
	696	Schedule the specified fitproblem or get the fit problem related to
	697	the current page and set value.
	698	:param value: integer 0 or 1
	699	:param uid: the id related to a page contaning fitting information
	700	"""
	701	if uid in self.page_finder.keys():
	702	self.page_finder[uid].schedule_tofit(value)
	703
	704	def get_page_finder(self):
	705	"""
	706	return self.page_finder used also by simfitpage.py
	707	"""
	708	return self.page_finder
	709
	710	def set_page_finder(self, modelname, names, values):
	711	"""
	712	Used by simfitpage.py to reset a parameter given the string constrainst.
	713
	714	:param modelname: the name ot the model for with the parameter
	715	has to reset
	716	:param value: can be a string in this case.
	717	:param names: the paramter name
	718	"""
	719	sim_page_id = self.sim_page.uid
	720	for uid, value in self.page_finder.iteritems():
	721	if uid != sim_page_id and uid != self.batch_page.uid:
[f21d496]	722	model_list = value.get_model()
	723	model = model_list[0]
[f76bf17]	724	if model.name == modelname:
	725	value.set_model_param(names, values)
	726	break
	727
	728	def split_string(self, item):
	729	"""
	730	receive a word containing dot and split it. used to split parameterset
	731	name into model name and parameter name example: ::
	732
	733	paramaterset (item) = M1.A
	734	Will return model_name = M1 , parameter name = A
	735
	736	"""
	737	if item.find(".") >= 0:
	738	param_names = re.split("\.", item)
	739	model_name = param_names[0]
	740	##Assume max len is 3; eg., M0.radius.width
	741	if len(param_names) == 3:
	742	param_name = param_names[1] + "." + param_names[2]
	743	else:
	744	param_name = param_names[1]
	745	return model_name, param_name
	746
	747	def on_bumps_options(self, event=None):
[9776c82]	748	"""
	749	Open the bumps options panel.
	750	"""
[7945367]	751	try:
	752	from bumps.gui.fit_dialog import show_fit_config
	753	show_fit_config(self.parent, help=self.on_help)
	754	except ImportError:
	755	# CRUFT: Bumps 0.7.5.6 and earlier do not have the help button
	756	from bumps.gui.fit_dialog import OpenFitOptions
	757	OpenFitOptions()
	758
	759	def on_help(self, algorithm_id):
	760	_TreeLocation = "user/perspectives/fitting/optimizer.html"
	761	_anchor = "#fit-"+algorithm_id
[6f16e25]	762	DocumentationWindow(self.parent, wx.ID_ANY, _TreeLocation, _anchor, "Optimizer Help")
[7945367]	763
[f76bf17]	764
[9776c82]	765	def on_fit_results(self, event=None):
	766	"""
	767	Make the Fit Results panel visible.
	768	"""
	769	self.result_frame.Show()
	770	self.result_frame.Raise()
	771
[f76bf17]	772	def stop_fit(self, uid):
	773	"""
[acf8e4a5]	774	Stop the fit
[f76bf17]	775	"""
	776	if uid in self.fit_thread_list.keys():
	777	calc_fit = self.fit_thread_list[uid]
	778	if calc_fit is not None and calc_fit.isrunning():
	779	calc_fit.stop()
	780	msg = "Fit stop!"
	781	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
	782	del self.fit_thread_list[uid]
	783	#set the fit button label of page when fit stop is trigger from
	784	#simultaneous fit pane
	785	sim_flag = self.sim_page is not None and uid == self.sim_page.uid
	786	batch_flag = self.batch_page is not None and uid == self.batch_page.uid
	787	if sim_flag or batch_flag:
	788	for uid, value in self.page_finder.iteritems():
	789	if value.get_scheduled() == 1:
	790	if uid in self.fit_panel.opened_pages.keys():
	791	panel = self.fit_panel.opened_pages[uid]
	792	panel._on_fit_complete()
	793
	794	def set_smearer(self, uid, smearer, fid, qmin=None, qmax=None, draw=True,
	795	enable_smearer=False):
	796	"""
	797	Get a smear object and store it to a fit problem of fid as id. If proper
	798	flag is enable , will plot the theory with smearing information.
	799
	800	:param smearer: smear object to allow smearing data of id fid
	801	:param enable_smearer: Define whether or not all (data, model) contained
	802	in the structure of id uid will be smeared before fitting.
	803	:param qmin: the maximum value of the theory plotting range
	804	:param qmax: the maximum value of the theory plotting range
	805	:param draw: Determine if the theory needs to be plot
	806	"""
	807	if uid not in self.page_finder.keys():
	808	return
	809	self.page_finder[uid].enable_smearing(flag=enable_smearer)
	810	self.page_finder[uid].set_smearer(smearer, fid=fid)
	811	if draw:
	812	## draw model 1D with smeared data
	813	data = self.page_finder[uid].get_fit_data(fid=fid)
	814	if data is None:
	815	msg = "set_mearer requires at least data.\n"
	816	msg += "Got data = %s .\n" % str(data)
	817	return
	818	#raise ValueError, msg
	819	model = self.page_finder[uid].get_model(fid=fid)
	820	if model is None:
	821	return
	822	enable1D = issubclass(data.__class__, Data1D)
	823	enable2D = issubclass(data.__class__, Data2D)
	824	## if user has already selected a model to plot
	825	## redraw the model with data smeared
	826	smear = self.page_finder[uid].get_smearer(fid=fid)
	827
	828	# compute weight for the current data
	829	weight = self.page_finder[uid].get_weight(fid=fid)
	830
	831	self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
	832	enable1D=enable1D, enable2D=enable2D,
	833	qmin=qmin, qmax=qmax, weight=weight)
	834	self._mac_sleep(0.2)
	835
	836	def _mac_sleep(self, sec=0.2):
	837	"""
	838	Give sleep to MAC
	839	"""
	840	if ON_MAC:
	841	time.sleep(sec)
	842
	843	def draw_model(self, model, page_id, data=None, smearer=None,
	844	enable1D=True, enable2D=False,
	845	state=None,
	846	fid=None,
	847	toggle_mode_on=False,
	848	qmin=None, qmax=None,
	849	update_chisqr=True, weight=None, source='model'):
	850	"""
	851	Draw model.
	852
	853	:param model: the model to draw
	854	:param name: the name of the model to draw
	855	:param data: the data on which the model is based to be drawn
	856	:param description: model's description
	857	:param enable1D: if true enable drawing model 1D
	858	:param enable2D: if true enable drawing model 2D
	859	:param qmin: Range's minimum value to draw model
	860	:param qmax: Range's maximum value to draw model
	861	:param qstep: number of step to divide the x and y-axis
	862	:param update_chisqr: update chisqr [bool]
	863
	864	"""
	865	#self.weight = weight
	866	if issubclass(data.__class__, Data1D) or not enable2D:
	867	## draw model 1D with no loaded data
	868	self._draw_model1D(model=model,
	869	data=data,
	870	page_id=page_id,
	871	enable1D=enable1D,
	872	smearer=smearer,
	873	qmin=qmin,
	874	qmax=qmax,
	875	fid=fid,
	876	weight=weight,
	877	toggle_mode_on=toggle_mode_on,
	878	state=state,
	879	update_chisqr=update_chisqr,
	880	source=source)
	881	else:
	882	## draw model 2D with no initial data
	883	self._draw_model2D(model=model,
	884	page_id=page_id,
	885	data=data,
	886	enable2D=enable2D,
	887	smearer=smearer,
	888	qmin=qmin,
	889	qmax=qmax,
	890	fid=fid,
	891	weight=weight,
	892	state=state,
	893	toggle_mode_on=toggle_mode_on,
	894	update_chisqr=update_chisqr,
	895	source=source)
	896
	897	def onFit(self, uid):
	898	"""
	899	Get series of data, model, associates parameters and range and send then
[acf8e4a5]	900	to series of fitters. Fit data and model, display result to
[f76bf17]	901	corresponding panels.
	902	:param uid: id related to the panel currently calling this fit function.
	903	"""
	904	if uid is None: raise RuntimeError("no page to fit") # Should never happen
	905
	906	sim_page_uid = getattr(self.sim_page, 'uid', None)
	907	batch_page_uid = getattr(self.batch_page, 'uid', None)
	908
	909	if uid == sim_page_uid:
	910	fit_type = 'simultaneous'
	911	elif uid == batch_page_uid:
	912	fit_type = 'combined_batch'
	913	else:
	914	fit_type = 'single'
	915
	916	fitter_list = []
	917	sim_fitter = None
	918	if fit_type == 'simultaneous':
[acf8e4a5]	919	# for simultaneous fitting only one fitter is needed
	920	sim_fitter = Fit()
[f76bf17]	921	sim_fitter.fitter_id = self.sim_page.uid
	922	fitter_list.append(sim_fitter)
	923
	924	self.current_pg = None
	925	list_page_id = []
	926	fit_id = 0
	927	for page_id, page_info in self.page_finder.iteritems():
	928	# For simulfit (uid give with None), do for-loop
	929	# if uid is specified (singlefit), do it only on the page.
	930	if page_id in (sim_page_uid, batch_page_uid): continue
	931	if fit_type == "single" and page_id != uid: continue
	932
	933	try:
	934	if page_info.get_scheduled() == 1:
	935	page_info.nbr_residuals_computed = 0
	936	page = self.fit_panel.get_page_by_id(page_id)
	937	self.set_fit_weight(uid=page.uid,
	938	flag=page.get_weight_flag(),
	939	is2d=page._is_2D())
	940	if not page.param_toFit:
	941	msg = "No fitting parameters for %s" % page.window_caption
	942	wx.PostEvent(page.parent.parent,
	943	StatusEvent(status=msg, info="error",
	944	type="stop"))
	945	return False
	946	if not page._update_paramv_on_fit():
	947	msg = "Fitting range or parameter values are"
	948	msg += " invalid in %s" % \
	949	page.window_caption
	950	wx.PostEvent(page.parent.parent,
	951	StatusEvent(status=msg, info="error",
	952	type="stop"))
	953	return False
	954
	955	pars = [str(element[1]) for element in page.param_toFit]
	956	fitproblem_list = page_info.values()
	957	for fitproblem in fitproblem_list:
	958	if sim_fitter is None:
[acf8e4a5]	959	fitter = Fit()
[f76bf17]	960	fitter.fitter_id = page_id
	961	fitter_list.append(fitter)
	962	else:
	963	fitter = sim_fitter
	964	self._add_problem_to_fit(fitproblem=fitproblem,
	965	pars=pars,
	966	fitter=fitter,
	967	fit_id=fit_id)
	968	fit_id += 1
	969	list_page_id.append(page_id)
	970	page_info.clear_model_param()
	971	except KeyboardInterrupt:
	972	msg = "Fitting terminated"
	973	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
	974	type="stop"))
	975	return True
	976	except:
[a3f125f0]	977	raise
[f76bf17]	978	msg = "Fitting error: %s" % str(sys.exc_value)
	979	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
	980	type="stop"))
	981	return False
	982	## If a thread is already started, stop it
	983	#if self.calc_fit!= None and self.calc_fit.isrunning():
	984	# self.calc_fit.stop()
	985	msg = "Fitting is in progress..."
	986	wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress"))
	987
[acf8e4a5]	988	#Handler used to display fit message
[f76bf17]	989	handler = ConsoleUpdate(parent=self.parent,
	990	manager=self,
	991	improvement_delta=0.1)
	992	self._mac_sleep(0.2)
	993
	994	# batch fit
	995	batch_inputs = {}
	996	batch_outputs = {}
	997	if fit_type == "simultaneous":
	998	page = self.sim_page
	999	elif fit_type == "combined_batch":
	1000	page = self.batch_page
	1001	else:
	1002	page = self.fit_panel.get_page_by_id(uid)
	1003	if page.batch_on:
	1004	calc_fit = FitThread(handler=handler,
	1005	fn=fitter_list,
	1006	pars=pars,
	1007	batch_inputs=batch_inputs,
	1008	batch_outputs=batch_outputs,
	1009	page_id=list_page_id,
	1010	completefn=self._batch_fit_complete,
	1011	reset_flag=self.batch_reset_flag)
	1012	else:
	1013	## Perform more than 1 fit at the time
	1014	calc_fit = FitThread(handler=handler,
	1015	fn=fitter_list,
	1016	batch_inputs=batch_inputs,
	1017	batch_outputs=batch_outputs,
	1018	page_id=list_page_id,
	1019	updatefn=handler.update_fit,
	1020	completefn=self._fit_completed)
	1021	#self.fit_thread_list[current_page_id] = calc_fit
	1022	self.fit_thread_list[uid] = calc_fit
	1023	calc_fit.queue()
	1024	calc_fit.ready(2.5)
	1025	msg = "Fitting is in progress..."
	1026	wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress"))
	1027
	1028	return True
	1029
	1030	def remove_plot(self, uid, fid=None, theory=False):
	1031	"""
	1032	remove model plot when a fit page is closed
	1033	:param uid: the id related to the fitpage to close
	1034	:param fid: the id of the fitproblem(data, model, range,etc)
	1035	"""
	1036	if uid not in self.page_finder.keys():
	1037	return
	1038	fitproblemList = self.page_finder[uid].get_fit_problem(fid)
	1039	for fitproblem in fitproblemList:
	1040	data = fitproblem.get_fit_data()
	1041	model = fitproblem.get_model()
	1042	plot_id = None
	1043	if model is not None:
	1044	plot_id = data.id + model.name
	1045	if theory:
	1046	plot_id = data.id + model.name
	1047	group_id = data.group_id
	1048	wx.PostEvent(self.parent, NewPlotEvent(id=plot_id,
	1049	group_id=group_id,
	1050	action='remove'))
	1051
	1052	def store_data(self, uid, data_list=None, caption=None):
	1053	"""
	1054	Recieve a list of data and store them ans well as a caption of
	1055	the fit page where they come from.
	1056	:param uid: if related to a fit page
	1057	:param data_list: list of data to fit
	1058	:param caption: caption of the window related to these data
	1059	"""
	1060	if data_list is None:
	1061	data_list = []
	1062
	1063	self.page_finder[uid].set_fit_data(data=data_list)
	1064	if caption is not None:
	1065	self.page_finder[uid].set_fit_tab_caption(caption=caption)
	1066
	1067	def on_add_new_page(self, event=None):
	1068	"""
	1069	ask fit panel to create a new empty page
	1070	"""
	1071	try:
	1072	page = self.fit_panel.add_empty_page()
	1073	# add data associated to the page created
	1074	if page != None:
	1075	wx.PostEvent(self.parent, StatusEvent(status="Page Created",
	1076	info="info"))
	1077	else:
	1078	msg = "Page was already Created"
	1079	wx.PostEvent(self.parent, StatusEvent(status=msg,
	1080	info="warning"))
	1081	except:
	1082	msg = "Creating Fit page: %s" % sys.exc_value
	1083	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
	1084
	1085	def add_fit_page(self, data):
	1086	"""
	1087	given a data, ask to the fitting panel to create a new fitting page,
	1088	get this page and store it into the page_finder of this plug-in
	1089	:param data: is a list of data
	1090	"""
	1091	page = self.fit_panel.set_data(data)
	1092	# page could be None when loading state files
	1093	if page == None:
	1094	return page
	1095	#append Data1D to the panel containing its theory
	1096	#if theory already plotted
	1097	if page.uid in self.page_finder:
	1098	data = page.get_data()
	1099	theory_data = self.page_finder[page.uid].get_theory_data(data.id)
	1100	if issubclass(data.__class__, Data2D):
	1101	data.group_id = wx.NewId()
	1102	if theory_data is not None:
	1103	group_id = str(page.uid) + " Model1D"
	1104	wx.PostEvent(self.parent,
	1105	NewPlotEvent(group_id=group_id,
	1106	action="delete"))
	1107	self.parent.update_data(prev_data=theory_data,
	1108	new_data=data)
	1109	else:
	1110	if theory_data is not None:
	1111	group_id = str(page.uid) + " Model2D"
	1112	data.group_id = theory_data.group_id
	1113	wx.PostEvent(self.parent,
	1114	NewPlotEvent(group_id=group_id,
	1115	action="delete"))
	1116	self.parent.update_data(prev_data=theory_data,
	1117	new_data=data)
	1118	self.store_data(uid=page.uid, data_list=page.get_data_list(),
	1119	caption=page.window_caption)
	1120	if self.sim_page is not None and not self.batch_on:
	1121	self.sim_page.draw_page()
	1122	if self.batch_page is not None and self.batch_on:
	1123	self.batch_page.draw_page()
	1124
	1125	return page
	1126
	1127	def _onEVT_SLICER_PANEL(self, event):
	1128	"""
	1129	receive and event telling to update a panel with a name starting with
	1130	event.panel_name. this method update slicer panel
	1131	for a given interactor.
	1132
	1133	:param event: contains type of slicer , paramaters for updating
	1134	the panel and panel_name to find the slicer 's panel concerned.
	1135	"""
	1136	event.panel_name
	1137	for item in self.parent.panels:
	1138	name = event.panel_name
	1139	if self.parent.panels[item].window_caption.startswith(name):
	1140	self.parent.panels[item].set_slicer(event.type, event.params)
	1141
	1142	#self.parent._mgr.Update()
	1143
	1144	def _closed_fitpage(self, event):
	1145	"""
	1146	request fitpanel to close a given page when its unique data is removed
	1147	from the plot. close fitpage only when the a loaded data is removed
	1148	"""
	1149	if event is None or event.data is None:
	1150	return
	1151	if hasattr(event.data, "is_data"):
	1152	if not event.data.is_data or \
	1153	event.data.__class__.__name__ == "Data1D":
	1154	self.fit_panel.close_page_with_data(event.data)
	1155
	1156	def _reset_schedule_problem(self, value=0, uid=None):
	1157	"""
	1158	unschedule or schedule all fitproblem to be fit
	1159	"""
	1160	# case that uid is not specified
	1161	if uid == None:
	1162	for page_id in self.page_finder.keys():
	1163	self.page_finder[page_id].schedule_tofit(value)
	1164	# when uid is given
	1165	else:
	1166	if uid in self.page_finder.keys():
	1167	self.page_finder[uid].schedule_tofit(value)
	1168
	1169	def _add_problem_to_fit(self, fitproblem, pars, fitter, fit_id):
	1170	"""
[acf8e4a5]	1171	Create and set fitter with series of data and model
[f76bf17]	1172	"""
	1173	data = fitproblem.get_fit_data()
	1174	model = fitproblem.get_model()
	1175	smearer = fitproblem.get_smearer()
	1176	qmin, qmax = fitproblem.get_range()
	1177
	1178	#Extra list of parameters and their constraints
	1179	listOfConstraint = []
	1180	param = fitproblem.get_model_param()
	1181	if len(param) > 0:
	1182	for item in param:
	1183	## check if constraint
	1184	if item[0] != None and item[1] != None:
	1185	listOfConstraint.append((item[0], item[1]))
	1186	new_model = model
	1187	fitter.set_model(new_model, fit_id, pars, data=data,
	1188	constraints=listOfConstraint)
	1189	fitter.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin,
	1190	qmax=qmax)
	1191	fitter.select_problem_for_fit(id=fit_id, value=1)
	1192
	1193	def _onSelect(self, event):
	1194	"""
	1195	when Select data to fit a new page is created .Its reference is
	1196	added to self.page_finder
	1197	"""
	1198	panel = self.plot_panel
	1199	if panel == None:
	1200	raise ValueError, "Fitting:_onSelect: NonType panel"
	1201	Plugin.on_perspective(self, event=event)
	1202	self.select_data(panel)
	1203
	1204	def select_data(self, panel):
	1205	"""
	1206	"""
	1207	for plottable in panel.graph.plottables:
	1208	if plottable.__class__.__name__ in ["Data1D", "Theory1D"]:
	1209	data_id = panel.graph.selected_plottable
	1210	if plottable == panel.plots[data_id]:
	1211	data = plottable
	1212	self.add_fit_page(data=[data])
	1213	return
	1214	else:
	1215	data = plottable
	1216	self.add_fit_page(data=[data])
	1217
	1218	def update_fit(self, result=None, msg=""):
	1219	"""
	1220	"""
	1221	print "update_fit result", result
	1222
	1223	def _batch_fit_complete(self, result, pars, page_id,
	1224	batch_outputs, batch_inputs, elapsed=None):
	1225	"""
	1226	Display fit result in batch
[acf8e4a5]	1227	:param result: list of objects received from fitters
[f76bf17]	1228	:param pars: list of fitted parameters names
	1229	:param page_id: list of page ids which called fit function
	1230	:param elapsed: time spent at the fitting level
	1231	"""
	1232	self._mac_sleep(0.2)
	1233	uid = page_id[0]
	1234	if uid in self.fit_thread_list.keys():
	1235	del self.fit_thread_list[uid]
	1236
[373d4ee]	1237	wx.CallAfter(self._update_fit_button, page_id)
[f76bf17]	1238	t1 = time.time()
	1239	str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
	1240	msg = "Fit completed on %s \n" % str_time
	1241	msg += "Duration time: %s s.\n" % str(elapsed)
	1242	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
	1243	type="stop"))
	1244
	1245	if batch_outputs is None:
	1246	batch_outputs = {}
	1247
	1248	# format batch_outputs
	1249	batch_outputs["Chi2"] = []
	1250	#Don't like these loops
	1251	# Need to create dictionary of all fitted parameters
	1252	# since the number of parameters can differ between each fit result
	1253	for list_res in result:
	1254	for res in list_res:
	1255	model, data = res.inputs[0]
	1256	if model is not None and hasattr(model, "model"):
	1257	model = model.model
	1258	#get all fittable parameters of the current model
	1259	for param in model.getParamList():
	1260	if param not in batch_outputs.keys():
	1261	batch_outputs[param] = []
	1262	for param in model.getDispParamList():
	1263	if not model.is_fittable(param) and \
	1264	param in batch_outputs.keys():
	1265	del batch_outputs[param]
	1266	# Add fitted parameters and their error
	1267	for param in res.param_list:
	1268	if param not in batch_outputs.keys():
	1269	batch_outputs[param] = []
	1270	err_param = "error on %s" % str(param)
	1271	if err_param not in batch_inputs.keys():
	1272	batch_inputs[err_param] = []
	1273	msg = ""
	1274	for list_res in result:
	1275	for res in list_res:
	1276	pid = res.fitter_id
	1277	model, data = res.inputs[0]
	1278	correct_result = False
	1279	if model is not None and hasattr(model, "model"):
	1280	model = model.model
	1281	if data is not None and hasattr(data, "sas_data"):
	1282	data = data.sas_data
	1283
	1284	is_data2d = issubclass(data.__class__, Data2D)
	1285	#check consistency of arrays
	1286	if not is_data2d:
	1287	if len(res.theory) == len(res.index[res.index]) and \
	1288	len(res.index) == len(data.y):
	1289	correct_result = True
	1290	else:
	1291	copy_data = deepcopy(data)
	1292	new_theory = copy_data.data
	1293	new_theory[res.index] = res.theory
	1294	new_theory[res.index == False] = numpy.nan
	1295	correct_result = True
	1296	#get all fittable parameters of the current model
	1297	param_list = model.getParamList()
	1298	for param in model.getDispParamList():
	1299	if not model.is_fittable(param) and \
	1300	param in param_list:
	1301	param_list.remove(param)
	1302	if not correct_result or res.fitness is None or \
	1303	not numpy.isfinite(res.fitness) or \
	1304	numpy.any(res.pvec == None) or not \
	1305	numpy.all(numpy.isfinite(res.pvec)):
	1306	data_name = str(None)
	1307	if data is not None:
	1308	data_name = str(data.name)
	1309	model_name = str(None)
	1310	if model is not None:
	1311	model_name = str(model.name)
	1312	msg += "Data %s and Model %s did not fit.\n" % (data_name,
	1313	model_name)
	1314	ERROR = numpy.NAN
	1315	cell = BatchCell()
	1316	cell.label = res.fitness
	1317	cell.value = res.fitness
	1318	batch_outputs["Chi2"].append(ERROR)
	1319	for param in param_list:
	1320	# save value of fixed parameters
	1321	if param not in res.param_list:
	1322	batch_outputs[str(param)].append(ERROR)
	1323	else:
	1324	#save only fitted values
	1325	batch_outputs[param].append(ERROR)
	1326	batch_inputs["error on %s" % str(param)].append(ERROR)
	1327	else:
[acf8e4a5]	1328	# TODO: Why sometimes res.pvec comes with numpy.float64?
	1329	# probably from scipy lmfit
[f76bf17]	1330	if res.pvec.__class__ == numpy.float64:
	1331	res.pvec = [res.pvec]
	1332
	1333	cell = BatchCell()
	1334	cell.label = res.fitness
	1335	cell.value = res.fitness
	1336	batch_outputs["Chi2"].append(cell)
	1337	# add parameters to batch_results
	1338	for param in param_list:
	1339	# save value of fixed parameters
	1340	if param not in res.param_list:
	1341	batch_outputs[str(param)].append(model.getParam(param))
	1342	else:
	1343	index = res.param_list.index(param)
	1344	#save only fitted values
	1345	batch_outputs[param].append(res.pvec[index])
	1346	if res.stderr is not None and \
	1347	len(res.stderr) == len(res.param_list):
	1348	item = res.stderr[index]
	1349	batch_inputs["error on %s" % param].append(item)
	1350	else:
	1351	batch_inputs["error on %s" % param].append('-')
	1352	model.setParam(param, res.pvec[index])
	1353	#fill the batch result with emtpy value if not in the current
	1354	#model
	1355	EMPTY = "-"
	1356	for key in batch_outputs.keys():
	1357	if key not in param_list and key not in ["Chi2", "Data"]:
	1358	batch_outputs[key].append(EMPTY)
	1359
	1360	self.page_finder[pid].set_batch_result(batch_inputs=batch_inputs,
	1361	batch_outputs=batch_outputs)
	1362
	1363	cpage = self.fit_panel.get_page_by_id(pid)
	1364	cpage._on_fit_complete()
	1365	self.page_finder[pid][data.id].set_result(res)
	1366	fitproblem = self.page_finder[pid][data.id]
	1367	qmin, qmax = fitproblem.get_range()
	1368	plot_result = False
	1369	if correct_result:
	1370	if not is_data2d:
	1371	self._complete1D(x=data.x[res.index], y=res.theory, page_id=pid,
	1372	elapsed=None,
	1373	index=res.index, model=model,
	1374	weight=None, fid=data.id,
	1375	toggle_mode_on=False, state=None,
	1376	data=data, update_chisqr=False,
	1377	source='fit', plot_result=plot_result)
	1378	else:
	1379	self._complete2D(image=new_theory, data=data,
	1380	model=model,
	1381	page_id=pid, elapsed=None,
	1382	index=res.index,
	1383	qmin=qmin,
	1384	qmax=qmax, fid=data.id, weight=None,
	1385	toggle_mode_on=False, state=None,
	1386	update_chisqr=False,
	1387	source='fit', plot_result=plot_result)
	1388	self.on_set_batch_result(page_id=pid,
	1389	fid=data.id,
	1390	batch_outputs=batch_outputs,
	1391	batch_inputs=batch_inputs)
	1392
	1393	wx.PostEvent(self.parent, StatusEvent(status=msg, error="info",
	1394	type="stop"))
	1395	# Remove parameters that are not shown
	1396	cpage = self.fit_panel.get_page_by_id(uid)
	1397	tbatch_outputs = {}
	1398	shownkeystr = cpage.get_copy_params()
	1399	for key in batch_outputs.keys():
	1400	if key in ["Chi2", "Data"] or shownkeystr.count(key) > 0:
	1401	tbatch_outputs[key] = batch_outputs[key]
	1402
	1403	wx.CallAfter(self.parent.on_set_batch_result, tbatch_outputs,
	1404	batch_inputs, self.sub_menu)
	1405
	1406	def on_set_batch_result(self, page_id, fid, batch_outputs, batch_inputs):
	1407	"""
	1408	"""
	1409	pid = page_id
	1410	if fid not in self.page_finder[pid]:
	1411	return
	1412	fitproblem = self.page_finder[pid][fid]
	1413	index = self.page_finder[pid].nbr_residuals_computed - 1
	1414	residuals = fitproblem.get_residuals()
	1415	theory_data = fitproblem.get_theory_data()
	1416	data = fitproblem.get_fit_data()
	1417	model = fitproblem.get_model()
	1418	#fill batch result information
	1419	if "Data" not in batch_outputs.keys():
	1420	batch_outputs["Data"] = []
[d85c194]	1421	from sas.sasgui.guiframe.data_processor import BatchCell
[f76bf17]	1422	cell = BatchCell()
	1423	cell.label = data.name
	1424	cell.value = index
	1425
	1426	if theory_data != None:
	1427	#Suucessful fit
	1428	theory_data.id = wx.NewId()
	1429	theory_data.name = model.name + "[%s]" % str(data.name)
	1430	if issubclass(theory_data.__class__, Data2D):
	1431	group_id = wx.NewId()
	1432	theory_data.group_id = group_id
	1433	if group_id not in theory_data.list_group_id:
	1434	theory_data.list_group_id.append(group_id)
	1435
	1436	try:
	1437	# associate residuals plot
	1438	if issubclass(residuals.__class__, Data2D):
	1439	group_id = wx.NewId()
	1440	residuals.group_id = group_id
	1441	if group_id not in residuals.list_group_id:
	1442	residuals.list_group_id.append(group_id)
	1443	batch_outputs["Chi2"][index].object = [residuals]
	1444	except:
	1445	pass
	1446
	1447	cell.object = [data, theory_data]
	1448	batch_outputs["Data"].append(cell)
	1449	for key, value in data.meta_data.iteritems():
	1450	if key not in batch_inputs.keys():
	1451	batch_inputs[key] = []
	1452	#if key.lower().strip() != "loader":
	1453	batch_inputs[key].append(value)
	1454	param = "temperature"
	1455	if hasattr(data.sample, param):
	1456	if param not in batch_inputs.keys():
	1457	batch_inputs[param] = []
	1458	batch_inputs[param].append(data.sample.temperature)
	1459
	1460	def _fit_completed(self, result, page_id, batch_outputs,
	1461	batch_inputs=None, pars=None, elapsed=None):
	1462	"""
	1463	Display result of the fit on related panel(s).
	1464	:param result: list of object generated when fit ends
	1465	:param pars: list of names of parameters fitted
	1466	:param page_id: list of page ids which called fit function
	1467	:param elapsed: time spent at the fitting level
	1468	"""
	1469	t1 = time.time()
	1470	str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
	1471	msg = "Fit completed on %s \n" % str_time
	1472	msg += "Duration time: %s s.\n" % str(elapsed)
	1473	wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
	1474	type="stop"))
	1475	wx.PostEvent(self.result_panel, PlotResultEvent(result=result))
[373d4ee]	1476	wx.CallAfter(self._update_fit_button, page_id)
[f76bf17]	1477	result = result[0]
	1478	self.fit_thread_list = {}
	1479	if page_id is None:
	1480	page_id = []
	1481	## fit more than 1 model at the same time
	1482	self._mac_sleep(0.2)
	1483	try:
	1484	index = 0
[aac161f1]	1485	# Update potential simfit page(s)
	1486	if self.sim_page is not None:
	1487	self.sim_page._on_fit_complete()
	1488	if self.batch_page:
	1489	self.batch_page._on_fit_complete()
	1490	# Update all fit pages
[f76bf17]	1491	for uid in page_id:
	1492	res = result[index]
	1493	if res.fitness is None or \
	1494	not numpy.isfinite(res.fitness) or \
	1495	numpy.any(res.pvec == None) or \
	1496	not numpy.all(numpy.isfinite(res.pvec)):
	1497	msg = "Fitting did not converge!!!"
	1498	wx.PostEvent(self.parent,
	1499	StatusEvent(status=msg,
	1500	info="warning",
	1501	type="stop"))
[373d4ee]	1502	wx.CallAfter(self._update_fit_button, page_id)
[f76bf17]	1503	else:
	1504	#set the panel when fit result are float not list
	1505	if res.pvec.__class__ == numpy.float64:
	1506	pvec = [res.pvec]
	1507	else:
	1508	pvec = res.pvec
	1509	if res.stderr.__class__ == numpy.float64:
	1510	stderr = [res.stderr]
	1511	else:
	1512	stderr = res.stderr
	1513	cpage = self.fit_panel.get_page_by_id(uid)
	1514	# Make sure we got all results
	1515	#(CallAfter is important to MAC)
	1516	try:
	1517	#if res != None:
	1518	wx.CallAfter(cpage.onsetValues, res.fitness,
	1519	res.param_list,
	1520	pvec, stderr)
	1521	index += 1
	1522	wx.CallAfter(cpage._on_fit_complete)
	1523	except KeyboardInterrupt:
	1524	msg = "Singular point: Fitting Stoped."
	1525	wx.PostEvent(self.parent, StatusEvent(status=msg,
	1526	info="info",
	1527	type="stop"))
	1528	except:
	1529	msg = "Singular point: Fitting Error occurred."
	1530	wx.PostEvent(self.parent, StatusEvent(status=msg,
	1531	info="error",
	1532	type="stop"))
	1533
	1534	except:
[e1442d4]	1535	msg = ("Fit completed but the following error occurred: %s"
	1536	% sys.exc_value)
	1537	#import traceback; msg = "\n".join((traceback.format_exc(), msg))
[f76bf17]	1538	wx.PostEvent(self.parent, StatusEvent(status=msg, info="warning",
	1539	type="stop"))
	1540
	1541	def _update_fit_button(self, page_id):
	1542	"""
	1543	Update Fit button when fit stopped
	1544
	1545	: parameter page_id: fitpage where the button is
	1546	"""
	1547	if page_id.__class__.__name__ != 'list':
	1548	page_id = [page_id]
	1549	for uid in page_id:
	1550	page = self.fit_panel.get_page_by_id(uid)
	1551	page._on_fit_complete()
	1552
	1553	def _on_show_panel(self, event):
	1554	"""
	1555	"""
	1556	pass
	1557
	1558	def on_reset_batch_flag(self, event):
	1559	"""
	1560	Set batch_reset_flag
	1561	"""
	1562	event.Skip()
	1563	if self.menu1 == None:
	1564	return
	1565	menu_item = self.menu1.FindItemById(self.id_reset_flag)
	1566	flag = menu_item.IsChecked()
	1567	if not flag:
	1568	menu_item.Check(False)
	1569	self.batch_reset_flag = True
	1570	else:
	1571	menu_item.Check(True)
	1572	self.batch_reset_flag = False
	1573
	1574	## post a message to status bar
	1575	msg = "Set Chain Fitting: %s" % str(not self.batch_reset_flag)
	1576	wx.PostEvent(self.parent,
	1577	StatusEvent(status=msg))
	1578
	1579
	1580	def _on_slicer_event(self, event):
	1581	"""
	1582	Receive a panel as event and send it to guiframe
	1583
	1584	:param event: event containing a panel
	1585
	1586	"""
	1587	if event.panel is not None:
	1588	self.slicer_panels.append(event.panel)
	1589	# Set group ID if available
	1590	event_id = self.parent.popup_panel(event.panel)
	1591	event.panel.uid = event_id
	1592	self.mypanels.append(event.panel)
	1593
	1594	def _onclearslicer(self, event):
	1595	"""
	1596	Clear the boxslicer when close the panel associate with this slicer
	1597	"""
	1598	name = event.GetEventObject().frame.GetTitle()
	1599	for panel in self.slicer_panels:
	1600	if panel.window_caption == name:
	1601
	1602	for item in self.parent.panels:
	1603	if hasattr(self.parent.panels[item], "uid"):
	1604	if self.parent.panels[item].uid == panel.base.uid:
	1605	self.parent.panels[item].onClearSlicer(event)
	1606	#self.parent._mgr.Update()
	1607	break
	1608	break
	1609
	1610	def _on_model_panel(self, evt):
	1611	"""
	1612	react to model selection on any combo box or model menu.plot the model
	1613
	1614	:param evt: wx.combobox event
	1615
	1616	"""
	1617	model = evt.model
	1618	uid = evt.uid
	1619	qmin = evt.qmin
	1620	qmax = evt.qmax
	1621	caption = evt.caption
	1622	enable_smearer = evt.enable_smearer
	1623	if model == None:
	1624	return
	1625	if uid not in self.page_finder.keys():
	1626	return
	1627	# save the name containing the data name with the appropriate model
	1628	self.page_finder[uid].set_model(model)
	1629	self.page_finder[uid].enable_smearing(enable_smearer)
	1630	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
	1631	self.page_finder[uid].set_fit_tab_caption(caption=caption)
	1632	if self.sim_page is not None and not self.batch_on:
	1633	self.sim_page.draw_page()
	1634	if self.batch_page is not None and self.batch_on:
	1635	self.batch_page.draw_page()
	1636
	1637	def _update1D(self, x, output):
	1638	"""
	1639	Update the output of plotting model 1D
	1640	"""
	1641	msg = "Plot updating ... "
	1642	wx.PostEvent(self.parent, StatusEvent(status=msg, type="update"))
	1643
	1644	def _complete1D(self, x, y, page_id, elapsed, index, model,
	1645	weight=None, fid=None,
	1646	toggle_mode_on=False, state=None,
	1647	data=None, update_chisqr=True,
	1648	source='model', plot_result=True):
	1649	"""
	1650	Complete plotting 1D data
	1651	"""
	1652	try:
	1653	numpy.nan_to_num(y)
	1654
	1655	new_plot = Data1D(x=x, y=y)
	1656	new_plot.is_data = False
	1657	new_plot.dy = numpy.zeros(len(y))
	1658	new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
	1659	_yaxis, _yunit = data.get_yaxis()
	1660	_xaxis, _xunit = data.get_xaxis()
	1661	new_plot.title = data.name
	1662
	1663	new_plot.group_id = data.group_id
	1664	if new_plot.group_id == None:
	1665	new_plot.group_id = data.group_id
	1666	new_plot.id = str(page_id) + " " + data.name
	1667	#if new_plot.id in self.color_dict:
	1668	# new_plot.custom_color = self.color_dict[new_plot.id]
	1669	#find if this theory was already plotted and replace that plot given
	1670	#the same id
[f21d496]	1671	self.page_finder[page_id].get_theory_data(fid=data.id)
[f76bf17]	1672
	1673	if data.is_data:
	1674	data_name = str(data.name)
	1675	else:
	1676	data_name = str(model.__class__.__name__)
	1677
	1678	new_plot.name = model.name + " [" + data_name + "]"
	1679	new_plot.xaxis(_xaxis, _xunit)
	1680	new_plot.yaxis(_yaxis, _yunit)
	1681	self.page_finder[page_id].set_theory_data(data=new_plot,
	1682	fid=data.id)
	1683	self.parent.update_theory(data_id=data.id, theory=new_plot,
	1684	state=state)
	1685	current_pg = self.fit_panel.get_page_by_id(page_id)
	1686	title = new_plot.title
	1687	batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
	1688	if not batch_on:
	1689	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
	1690	title=str(title)))
	1691	elif plot_result:
	1692	top_data_id = self.fit_panel.get_page_by_id(page_id).data.id
	1693	if data.id == top_data_id:
	1694	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
	1695	title=str(title)))
	1696	caption = current_pg.window_caption
	1697	self.page_finder[page_id].set_fit_tab_caption(caption=caption)
	1698
	1699	self.page_finder[page_id].set_theory_data(data=new_plot,
	1700	fid=data.id)
	1701	if toggle_mode_on:
	1702	wx.PostEvent(self.parent,
	1703	NewPlotEvent(group_id=str(page_id) + " Model2D",
	1704	action="Hide"))
	1705	else:
	1706	if update_chisqr:
	1707	wx.PostEvent(current_pg,
	1708	Chi2UpdateEvent(output=self._cal_chisqr(
	1709	data=data,
	1710	fid=fid,
	1711	weight=weight,
	1712	page_id=page_id,
	1713	index=index)))
	1714	else:
	1715	self._plot_residuals(page_id=page_id, data=data, fid=fid,
	1716	index=index, weight=weight)
	1717
	1718	msg = "Computation completed!"
	1719	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
	1720	except:
	1721	raise
	1722
	1723	def _update2D(self, output, time=None):
	1724	"""
	1725	Update the output of plotting model
	1726	"""
	1727	wx.PostEvent(self.parent, StatusEvent(status="Plot \
	1728	#updating ... ", type="update"))
	1729	#self.ready_fit()
	1730
	1731	def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
	1732	qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
	1733	update_chisqr=True, source='model', plot_result=True):
	1734	"""
	1735	Complete get the result of modelthread and create model 2D
	1736	that can be plot.
	1737	"""
	1738	numpy.nan_to_num(image)
	1739	new_plot = Data2D(image=image, err_image=data.err_data)
	1740	new_plot.name = model.name + '2d'
	1741	new_plot.title = "Analytical model 2D "
	1742	new_plot.id = str(page_id) + " " + data.name
	1743	new_plot.group_id = str(page_id) + " Model2D"
	1744	new_plot.detector = data.detector
	1745	new_plot.source = data.source
	1746	new_plot.is_data = False
	1747	new_plot.qx_data = data.qx_data
	1748	new_plot.qy_data = data.qy_data
	1749	new_plot.q_data = data.q_data
	1750	new_plot.mask = data.mask
	1751	## plot boundaries
	1752	new_plot.ymin = data.ymin
	1753	new_plot.ymax = data.ymax
	1754	new_plot.xmin = data.xmin
	1755	new_plot.xmax = data.xmax
	1756	title = data.title
	1757
	1758	new_plot.is_data = False
	1759	if data.is_data:
	1760	data_name = str(data.name)
	1761	else:
	1762	data_name = str(model.__class__.__name__) + '2d'
	1763
	1764	if len(title) > 1:
	1765	new_plot.title = "Model2D for %s " % model.name + data_name
	1766	new_plot.name = model.name + " [" + \
	1767	data_name + "]"
	1768	theory_data = deepcopy(new_plot)
	1769
	1770	self.page_finder[page_id].set_theory_data(data=theory_data,
	1771	fid=data.id)
	1772	self.parent.update_theory(data_id=data.id,
	1773	theory=new_plot,
	1774	state=state)
	1775	current_pg = self.fit_panel.get_page_by_id(page_id)
	1776	title = new_plot.title
	1777	if not source == 'fit' and plot_result:
	1778	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
	1779	title=title))
	1780	if toggle_mode_on:
	1781	wx.PostEvent(self.parent,
	1782	NewPlotEvent(group_id=str(page_id) + " Model1D",
	1783	action="Hide"))
	1784	else:
	1785	# Chisqr in fitpage
	1786	if update_chisqr:
	1787	wx.PostEvent(current_pg,
	1788	Chi2UpdateEvent(output=self._cal_chisqr(data=data,
	1789	weight=weight,
	1790	fid=fid,
	1791	page_id=page_id,
	1792	index=index)))
	1793	else:
	1794	self._plot_residuals(page_id=page_id, data=data, fid=fid,
	1795	index=index, weight=weight)
	1796	msg = "Computation completed!"
	1797	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
	1798
	1799	def _draw_model2D(self, model, page_id, qmin,
	1800	qmax,
	1801	data=None, smearer=None,
	1802	description=None, enable2D=False,
	1803	state=None,
	1804	fid=None,
	1805	weight=None,
	1806	toggle_mode_on=False,
	1807	update_chisqr=True, source='model'):
	1808	"""
	1809	draw model in 2D
	1810
	1811	:param model: instance of the model to draw
	1812	:param description: the description of the model
	1813	:param enable2D: when True allows to draw model 2D
	1814	:param qmin: the minimum value to draw model 2D
	1815	:param qmax: the maximum value to draw model 2D
	1816	:param qstep: the number of division of Qx and Qy of the model to draw
	1817
	1818	"""
	1819	if not enable2D:
	1820	return None
	1821	try:
	1822	from model_thread import Calc2D
	1823	## If a thread is already started, stop it
	1824	if (self.calc_2D is not None) and self.calc_2D.isrunning():
	1825	self.calc_2D.stop()
	1826	## stop just raises a flag to tell the thread to kill
	1827	## itself -- see the fix in Calc1D implemented to fix
	1828	## an actual problem. Seems the fix should also go here
	1829	## and may be the cause of other noted instabilities
	1830	##
	1831	## -PDB August 12, 2014
	1832	while self.calc_2D.isrunning():
	1833	time.sleep(0.1)
	1834	self.calc_2D = Calc2D(model=model,
	1835	data=data,
	1836	page_id=page_id,
	1837	smearer=smearer,
	1838	qmin=qmin,
	1839	qmax=qmax,
	1840	weight=weight,
	1841	fid=fid,
	1842	toggle_mode_on=toggle_mode_on,
	1843	state=state,
	1844	completefn=self._complete2D,
	1845	update_chisqr=update_chisqr, source=source)
	1846	self.calc_2D.queue()
	1847	except:
	1848	raise
	1849
	1850	def _draw_model1D(self, model, page_id, data,
	1851	qmin, qmax, smearer=None,
	1852	state=None,
	1853	weight=None,
	1854	fid=None,
	1855	toggle_mode_on=False, update_chisqr=True, source='model',
	1856	enable1D=True):
	1857	"""
	1858	Draw model 1D from loaded data1D
	1859
	1860	:param data: loaded data
	1861	:param model: the model to plot
	1862
	1863	"""
	1864	if not enable1D:
	1865	return
	1866	try:
	1867	from model_thread import Calc1D
	1868	## If a thread is already started, stop it
	1869	if (self.calc_1D is not None) and self.calc_1D.isrunning():
	1870	self.calc_1D.stop()
	1871	## stop just raises the flag -- the thread is supposed to
	1872	## then kill itself but cannot. Paul Kienzle came up with
	1873	## this fix to prevent threads from stepping on each other
	1874	## which was causing a simple custom model to crash Sasview.
	1875	## We still don't know why the fit sometimes lauched a second
	1876	## thread -- something which should also be investigated.
	1877	## The thread approach was implemented in order to be able
	1878	## to lauch a computation in a separate thread from the GUI so
	1879	## that the GUI can still respond to user input including
	1880	## a request to stop the computation.
	1881	## It seems thus that the whole thread approach used here
	1882	## May need rethinking
	1883	##
	1884	## -PDB August 12, 2014
	1885	while self.calc_1D.isrunning():
	1886	time.sleep(0.1)
	1887	self.calc_1D = Calc1D(data=data,
	1888	model=model,
	1889	page_id=page_id,
	1890	qmin=qmin,
	1891	qmax=qmax,
	1892	smearer=smearer,
	1893	state=state,
	1894	weight=weight,
	1895	fid=fid,
	1896	toggle_mode_on=toggle_mode_on,
	1897	completefn=self._complete1D,
	1898	#updatefn = self._update1D,
	1899	update_chisqr=update_chisqr,
	1900	source=source)
	1901	self.calc_1D.queue()
	1902	except:
	1903	msg = " Error occurred when drawing %s Model 1D: " % model.name
	1904	msg += " %s" % sys.exc_value
	1905	wx.PostEvent(self.parent, StatusEvent(status=msg))
	1906
	1907	def _cal_chisqr(self, page_id, data, weight, fid=None, index=None):
	1908	"""
	1909	Get handy Chisqr using the output from draw1D and 2D,
	1910	instead of calling expansive CalcChisqr in guithread
	1911	"""
	1912	try:
	1913	data_copy = deepcopy(data)
	1914	except:
	1915	return
	1916	# default chisqr
	1917	chisqr = None
	1918	#to compute chisq make sure data has valid data
	1919	# return None if data == None
	1920	if not check_data_validity(data_copy) or data_copy == None:
	1921	return chisqr
	1922
	1923	# Get data: data I, theory I, and data dI in order
	1924	if data_copy.__class__.__name__ == "Data2D":
	1925	if index == None:
	1926	index = numpy.ones(len(data_copy.data), dtype=bool)
	1927	if weight != None:
	1928	data_copy.err_data = weight
	1929	# get rid of zero error points
	1930	index = index & (data_copy.err_data != 0)
	1931	index = index & (numpy.isfinite(data_copy.data))
	1932	fn = data_copy.data[index]
	1933	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
	1934	if theory_data == None:
	1935	return chisqr
	1936	gn = theory_data.data[index]
	1937	en = data_copy.err_data[index]
	1938	else:
	1939	# 1 d theory from model_thread is only in the range of index
	1940	if index == None:
	1941	index = numpy.ones(len(data_copy.y), dtype=bool)
	1942	if weight != None:
	1943	data_copy.dy = weight
	1944	if data_copy.dy == None or data_copy.dy == []:
	1945	dy = numpy.ones(len(data_copy.y))
	1946	else:
[acf8e4a5]	1947	## Set consistently w/AbstractFitengine:
[f76bf17]	1948	# But this should be corrected later.
	1949	dy = deepcopy(data_copy.dy)
	1950	dy[dy == 0] = 1
	1951	fn = data_copy.y[index]
	1952
	1953	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
	1954	if theory_data == None:
	1955	return chisqr
	1956	gn = theory_data.y
	1957	en = dy[index]
	1958
	1959	# residual
	1960	try:
	1961	res = (fn - gn) / en
	1962	except ValueError:
	1963	print "Unmatch lengths %s, %s, %s" % (len(fn), len(gn), len(en))
	1964	return
	1965
	1966	residuals = res[numpy.isfinite(res)]
	1967	# get chisqr only w/finite
	1968	chisqr = numpy.average(residuals * residuals)
	1969
	1970	self._plot_residuals(page_id=page_id, data=data_copy,
	1971	fid=fid,
	1972	weight=weight, index=index)
	1973
	1974	return chisqr
	1975
	1976	def _plot_residuals(self, page_id, weight, fid=None,
	1977	data=None, index=None):
	1978	"""
	1979	Plot the residuals
	1980
	1981	:param data: data
	1982	:param index: index array (bool)
	1983	: Note: this is different from the residuals in cal_chisqr()
	1984	"""
	1985	data_copy = deepcopy(data)
	1986	# Get data: data I, theory I, and data dI in order
	1987	if data_copy.__class__.__name__ == "Data2D":
	1988	# build residuals
	1989	residuals = Data2D()
	1990	#residuals.copy_from_datainfo(data)
	1991	# Not for trunk the line below, instead use the line above
	1992	data_copy.clone_without_data(len(data_copy.data), residuals)
	1993	residuals.data = None
	1994	fn = data_copy.data
	1995	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
	1996	gn = theory_data.data
	1997	if weight == None:
	1998	en = data_copy.err_data
	1999	else:
	2000	en = weight
	2001	residuals.data = (fn - gn) / en
	2002	residuals.qx_data = data_copy.qx_data
	2003	residuals.qy_data = data_copy.qy_data
	2004	residuals.q_data = data_copy.q_data
	2005	residuals.err_data = numpy.ones(len(residuals.data))
	2006	residuals.xmin = min(residuals.qx_data)
	2007	residuals.xmax = max(residuals.qx_data)
	2008	residuals.ymin = min(residuals.qy_data)
	2009	residuals.ymax = max(residuals.qy_data)
	2010	residuals.q_data = data_copy.q_data
	2011	residuals.mask = data_copy.mask
	2012	residuals.scale = 'linear'
	2013	# check the lengths
	2014	if len(residuals.data) != len(residuals.q_data):
	2015	return
	2016	else:
	2017	# 1 d theory from model_thread is only in the range of index
	2018	if data_copy.dy == None or data_copy.dy == []:
	2019	dy = numpy.ones(len(data_copy.y))
	2020	else:
	2021	if weight == None:
	2022	dy = numpy.ones(len(data_copy.y))
	2023	## Set consitently w/AbstractFitengine:
	2024	## But this should be corrected later.
	2025	else:
	2026	dy = weight
	2027	dy[dy == 0] = 1
	2028	fn = data_copy.y[index]
	2029	theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
	2030	gn = theory_data.y
	2031	en = dy[index]
	2032	# build residuals
	2033	residuals = Data1D()
	2034	try:
	2035	residuals.y = (fn - gn) / en
	2036	except:
	2037	msg = "ResidualPlot Error: different # of data points in theory"
	2038	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
	2039	residuals.y = (fn - gn[index]) / en
	2040	residuals.x = data_copy.x[index]
	2041	residuals.dy = numpy.ones(len(residuals.y))
	2042	residuals.dx = None
	2043	residuals.dxl = None
	2044	residuals.dxw = None
	2045	residuals.ytransform = 'y'
	2046	# For latter scale changes
	2047	residuals.xaxis('\\rm{Q} ', 'A^{-1}')
	2048	residuals.yaxis('\\rm{Residuals} ', 'normalized')
	2049	theory_name = str(theory_data.name.split()[0])
	2050	new_plot = residuals
	2051	new_plot.name = "Residuals for " + str(theory_name) + "[" + \
	2052	str(data.name) + "]"
	2053	## allow to highlight data when plotted
	2054	new_plot.interactive = True
	2055	## when 2 data have the same id override the 1 st plotted
	2056	new_plot.id = "res" + str(data_copy.id) + str(theory_name)
	2057	##group_id specify on which panel to plot this data
	2058	group_id = self.page_finder[page_id].get_graph_id()
	2059	if group_id == None:
	2060	group_id = data.group_id
	2061	new_plot.group_id = "res" + str(group_id)
	2062	#new_plot.is_data = True
	2063	##post data to plot
	2064	title = new_plot.name
	2065	self.page_finder[page_id].set_residuals(residuals=new_plot,
	2066	fid=data.id)
	2067	self.parent.update_theory(data_id=data.id, theory=new_plot)
	2068	batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
	2069	if not batch_on:
	2070	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/fitting.py @ aac161f1

Download in other formats: