fitting.py @ 6246e00

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

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

SasView

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

Download in other formats: