fitting.py @ 2a0f33f

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 2a0f33f was 2a0f33f, checked in by Paul Kienzle <pkienzle@…>, 7 years ago
move fit pagestate from gui to calc
Property mode set to `100755`
File size: 88.9 KB

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

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

SasView

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

Download in other formats: