fitting.py @ b4da6df

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 b4da6df was d2843a9, checked in by Jae Cho <jhjcho@…>, 13 years ago
ordered edit model menu
Property mode set to `100644`
File size: 89.7 KB

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

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

SasView

source: sasview/fittingview/src/sans/perspectives/fitting/fitting.py @ b4da6df

Download in other formats: