fitting.py @ 8f02f7f

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

Download in other formats: