fitting.py @ b2964ef

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

Download in other formats: