fitting.py @ b768e92

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

Last change on this file since b768e92 was 934ce649, checked in by Paul Kienzle <pkienzle@…>, 9 years ago
make sure errors in compute get reported to user
Property mode set to `100755`
File size: 85.1 KB

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

Download in other formats: