fitting.py @ e1442d4

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

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

Download in other formats: