fitting.py @ 7d64b0e

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 7d64b0e was 824e488, checked in by Mathieu Doucet <doucetm@…>, 10 years ago
pylint fixes and remove old code
Property mode set to `100644`
File size: 85.2 KB

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

Download in other formats: