fitting.py @ 767514a

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

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

SasView

source: sasview/src/sans/perspectives/fitting/fitting.py @ 767514a

Download in other formats: