fitting.py @ b7e6bd3

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 b7e6bd3 was 2296316, checked in by Jae Cho <jhjcho@…>, 14 years ago
moving features from the branch
Property mode set to `100644`
File size: 62.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 wx
17	import logging
18	import numpy
19	import string
20	import time
21	from copy import deepcopy
22	import models
23	import fitpage
24
25
26	from DataLoader.loader import Loader
27	from sans.guiframe.dataFitting import Data2D
28	from sans.guiframe.dataFitting import Data1D
29	from sans.guiframe.events import NewPlotEvent
30	from sans.guiframe.events import StatusEvent
31	from sans.guiframe.events import EVT_SLICER_PANEL
32	from sans.guiframe.events import EVT_REMOVE_DATA
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
37	from .console import ConsoleUpdate
38	from .fitproblem import FitProblem
39	from .fitpanel import FitPanel
40	from .fit_thread import FitThread
41	from .pagestate import Reader
42	from .fitpage import Chi2UpdateEvent
43
44	DEFAULT_BEAM = 0.005
45	DEFAULT_QMIN = 0.001
46	DEFAULT_QMAX = 0.13
47	DEFAULT_NPTS = 50
48	MAX_NBR_DATA = 4
49
50
51	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
52
53
54
55	class Plugin(PluginBase):
56	"""
57	Fitting plugin is used to perform fit
58	"""
59	def __init__(self, standalone=False):
60	PluginBase.__init__(self, name="Fitting", standalone=standalone)
61
62	#Provide list of models existing in the application
63	self.menu_mng = models.ModelManager()
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	self.fit_thread_list = {}
71	self.residuals = None
72	self.fit_panel = None
73	# Start with a good default
74	self.elapsed = 0.022
75	# the type of optimizer selected, park or scipy
76	self.fitter = None
77	self.fit_panel = None
78	#let fit ready
79	self.fitproblem_count = None
80	#Flag to let the plug-in know that it is running stand alone
81	self.standalone = True
82	## dictionary of page closed and id
83	self.closed_page_dict = {}
84	## Fit engine
85	self._fit_engine = 'scipy'
86	## Relative error desired in the sum of squares (float); scipy only
87	self.ftol=1.49012e-08
88	#List of selected data
89	self.selected_data_list = []
90	## list of slicer panel created to display slicer parameters and results
91	self.slicer_panels = []
92	# model 2D view
93	self.model2D_id = None
94	#keep reference of the simultaneous fit page
95	self.sim_page = None
96	self.index_model = 0
97	#Create a reader for fit page's state
98	self.state_reader = None
99	self._extensions = '.fitv'
100	self.temp_state = []
101	self.state_index = 0
102	self.sfile_ext = None
103	# take care of saving data, model and page associated with each other
104	self.page_finder = {}
105	# Log startup
106	logging.info("Fitting plug-in started")
107
108	def populate_menu(self, owner):
109	"""
110	Create a menu for the Fitting plug-in
111
112	:param id: id to create a menu
113	:param owner: owner of menu
114
115	:return: list of information to populate the main menu
116
117	"""
118	#Menu for fitting
119	self.menu1 = wx.Menu()
120
121	#Set park engine
122	id3 = wx.NewId()
123	scipy_help= "Scipy Engine: Perform Simple fit. More in Help window...."
124	self.menu1.AppendCheckItem(id3, "Simple Fit [Scipy]",scipy_help)
125	wx.EVT_MENU(owner, id3, self._onset_engine_scipy)
126
127	id3 = wx.NewId()
128	park_help = "Park Engine: Perform Complex fit. More in Help window...."
129	self.menu1.AppendCheckItem(id3, "Complex Fit [Park]",park_help)
130	wx.EVT_MENU(owner, id3, self._onset_engine_park)
131
132	self.menu1.FindItemByPosition(0).Check(True)
133	self.menu1.FindItemByPosition(1).Check(False)
134
135	self.menu1.AppendSeparator()
136	id1 = wx.NewId()
137	simul_help = "Simultaneous Fit"
138	self.menu1.Append(id1, '&Simultaneous Fit',simul_help)
139	wx.EVT_MENU(owner, id1, self.on_add_sim_page)
140
141	id1 = wx.NewId()
142	simul_help = "Add new fit page"
143	self.menu1.Append(id1, '&Create New Page',simul_help)
144	wx.EVT_MENU(owner, id1, self.on_add_new_page)
145
146	#self.fit_panel.set_model_list(self.menu_mng.get_model_list())
147
148	#create menubar items
149	return [(self.menu1, "FitEngine")]
150
151	def on_add_sim_page(self, event):
152	"""
153	Create a page to access simultaneous fit option
154	"""
155	if self.sim_page != None:
156	msg= "Simultaneous Fit page already opened"
157	wx.PostEvent(self.parent, StatusEvent(status= msg))
158	return
159
160	self.sim_page= self.fit_panel.add_sim_page()
161
162	def help(self, evt):
163	"""
164	Show a general help dialog.
165	"""
166	from help_panel import HelpWindow
167	frame = HelpWindow(None, -1, 'HelpWindow')
168	frame.Show(True)
169
170	def get_context_menu(self, plotpanel=None):
171	"""
172	Get the context menu items available for P(r).them allow fitting option
173	for Data2D and Data1D only.
174
175	:param graph: the Graph object to which we attach the context menu
176
177	:return: a list of menu items with call-back function
178
179	:note: if Data1D was generated from Theory1D
180	the fitting option is not allowed
181
182	"""
183	graph = plotpanel.graph
184	fit_option = "Select data for fitting"
185	fit_hint = "Dialog with fitting parameters "
186
187	if graph.selected_plottable not in plotpanel.plots:
188	return []
189	item = plotpanel.plots[graph.selected_plottable]
190	if item.__class__.__name__ is "Data2D":
191	if hasattr(item,"is_data"):
192	if item.is_data:
193	return [[fit_option, fit_hint, self._onSelect]]
194	else:
195	return []
196	return [[fit_option, fit_hint, self._onSelect]]
197	else:
198
199	# if is_data is true , this in an actual data loaded
200	#else it is a data created from a theory model
201	if hasattr(item,"is_data"):
202	if item.is_data:
203	return [[fit_option, fit_hint,
204	self._onSelect]]
205	else:
206	return []
207	return []
208
209
210	def get_panels(self, parent):
211	"""
212	Create and return a list of panel objects
213	"""
214	self.parent = parent
215	#self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
216	# Creation of the fit panel
217	self.fit_panel = FitPanel(parent=self.parent, manager=self)
218	self.on_add_new_page(event=None)
219	#Set the manager for the main panel
220	self.fit_panel.set_manager(self)
221	# List of windows used for the perspective
222	self.perspective = []
223	self.perspective.append(self.fit_panel.window_name)
224
225	#index number to create random model name
226	self.index_model = 0
227	self.index_theory= 0
228	self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
229
230	self.parent.Bind(EVT_REMOVE_DATA, self._closed_fitpage)
231	self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
232	self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer)
233	#Create reader when fitting panel are created
234	self.state_reader = Reader(self.set_state)
235	#append that reader to list of available reader
236	loader = Loader()
237	loader.associate_file_reader(".fitv", self.state_reader)
238	loader.associate_file_reader(".svs", self.state_reader)
239	from sans.perspectives.calculator.sld_panel import SldPanel
240	#Send the fitting panel to guiframe
241	self.mypanels.append(self.fit_panel)
242	self.mypanels.append(SldPanel(parent=self.parent, base=self.parent))
243	return self.mypanels
244
245	def clear_panel(self):
246	"""
247	"""
248	self.fit_panel.clear_panel()
249
250	def set_default_perspective(self):
251	"""
252	Call back method that True to notify the parent that the current plug-in
253	can be set as default perspective.
254	when returning False, the plug-in is not candidate for an automatic
255	default perspective setting
256	"""
257	return True
258
259	def delete_data(self, data):
260	"""
261	delete the given data from panel
262	"""
263	self.fit_panel.delete_data(data)
264
265	def set_data(self, data_list=None):
266	"""
267	receive a list of data to fit
268	"""
269	if data_list is None:
270	data_list = []
271	selected_data_list = []
272	if len(data_list) > MAX_NBR_DATA :
273	from fitting_widgets import DataDialog
274	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
275	if dlg.ShowModal() == wx.ID_OK:
276	selected_data_list = dlg.get_data()
277	else:
278	selected_data_list = data_list
279	try:
280	for data in selected_data_list:
281	self.add_fit_page(data=data)
282	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
283	title=str(data.title)))
284	except:
285	raise
286	#msg = "Fitting Set_data: " + str(sys.exc_value)
287	#wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
288
289	def set_theory(self, theory_list=None):
290	"""
291	"""
292	#set the model state for a given theory_state:
293	for item in theory_list:
294	try:
295	_, theory_state = item
296	self.fit_panel.set_model_state(theory_state)
297	except:
298	msg = "Fitting: cannot deal with the theory received"
299	logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
300	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
301
302	def set_state(self, state=None, datainfo=None, format=None):
303	"""
304	Call-back method for the fit page state reader.
305	This method is called when a .fitv/.svs file is loaded.
306
307	: param state: PageState object
308	: param datainfo: data
309	"""
310	#state = self.state_reader.get_state()
311	if state != None:
312	# store fitting state in temp_state
313	self.temp_state.append(state)
314	else:
315	self.temp_state = []
316	# index to start with for a new set_state
317	self.state_index = 0
318	# state file format
319	self.sfile_ext = format
320
321	self.on_set_state_helper(event=None)
322
323	def on_set_state_helper(self,event=None):
324	"""
325	Set_state_helper. This actually sets state after plotting data from state file.
326
327	: event: FitStateUpdateEvent called by dataloader.plot_data from guiframe
328	"""
329	if len(self.temp_state) == 0:
330	if self.state_index==0 and len(self.mypanels) <= 0 and self.sfile_ext =='.svs':
331	self.fit_panel.add_default_pages()
332	self.temp_state = []
333	self.state_index = 0
334	return
335
336	try:
337	# Load fitting state
338	state = self.temp_state[self.state_index]
339	#panel state should have model selection to set_state
340	if state.formfactorcombobox != None:
341	#set state
342	data = self.parent.create_gui_data(state.data)
343
344	data.group_id = state.data.group_id
345	self.parent.add_data(data_list={data.id:data})
346	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
347	title=data.title))
348	#need to be fix later make sure we are sendind guiframe.data
349	#to panel
350	state.data = data
351	page = self.fit_panel.set_state(state)
352	else:
353	#just set data because set_state won't work
354	data = self.parent.create_gui_data(state.data)
355	data.group_id = state.data.group_id
356	self.parent.add_data(data_list={data.id:data})
357	wx.PostEvent(self.parent, NewPlotEvent(plot=data,
358	title=data.title))
359	self.add_fit_page(data)
360	caption = panel.window_name
361	self.store_data(page=panel.id, data=data, caption=caption)
362	self.mypanels.append(panel)
363
364	# get ready for the next set_state
365	self.state_index += 1
366
367	#reset state variables to default when all set_state is finished.
368	if len(self.temp_state) == self.state_index:
369
370	self.temp_state = []
371	#self.state_index = 0
372	# Make sure the user sees the fitting panel after loading
373	#self.parent.set_perspective(self.perspective)
374	self.on_perspective(event=None)
375	except:
376	self.state_index==0
377	self.temp_state = []
378	raise
379
380	def save_fit_state(self, filepath, fitstate):
381	"""
382	save fit page state into file
383	"""
384	self.state_reader.write(filename=filepath, fitstate=fitstate)
385
386	def set_fit_range(self, uid, qmin, qmax):
387	"""
388	Set the fitting range of a given page
389	"""
390	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
391
392	def schedule_for_fit(self,value=0, uid=None,fitproblem =None):
393	"""
394	Set the fit problem field to 0 or 1 to schedule that problem to fit.
395	Schedule the specified fitproblem or get the fit problem related to
396	the current page and set value.
397
398	:param value: integer 0 or 1
399	:param fitproblem: fitproblem to schedule or not to fit
400
401	"""
402	if fitproblem !=None:
403	fitproblem.schedule_tofit(value)
404	else:
405	self.page_finder[uid].schedule_tofit(value)
406
407	def get_page_finder(self):
408	"""
409	return self.page_finder used also by simfitpage.py
410	"""
411	return self.page_finder
412
413	def set_page_finder(self,modelname,names,values):
414	"""
415	Used by simfitpage.py to reset a parameter given the string constrainst.
416
417	:param modelname: the name ot the model for with the parameter has to reset
418	:param value: can be a string in this case.
419	:param names: the paramter name
420
421	:note: expecting park used for fit.
422
423	"""
424	sim_page_id = self.sim_page.uid
425	for uid, value in self.page_finder.iteritems():
426	if uid != sim_page_id:
427	list = value.get_model()
428	model = list[0]
429	if model.name == modelname:
430	value.set_model_param(names, values)
431	break
432
433	def split_string(self,item):
434	"""
435	receive a word containing dot and split it. used to split parameterset
436	name into model name and parameter name example: ::
437
438	paramaterset (item) = M1.A
439	Will return model_name = M1 , parameter name = A
440
441	"""
442	if string.find(item,".")!=-1:
443	param_names= re.split("\.",item)
444	model_name=param_names[0]
445	##Assume max len is 3; eg., M0.radius.width
446	if len(param_names) == 3:
447	param_name=param_names[1]+"."+param_names[2]
448	else:
449	param_name=param_names[1]
450	return model_name,param_name
451
452	def set_ftol(self, ftol=None):
453	"""
454	Set ftol: Relative error desired in the sum of chi squares.
455	"""
456	# check if it is flaot
457	try:
458	f_tol = float(ftol)
459	except:
460	# default
461	f_tol = 1.49012e-08
462
463	self.ftol = f_tol
464
465	def stop_fit(self, uid):
466	"""
467	Stop the fit engine
468	"""
469	if uid in self.fit_thread_list.keys():
470	calc_fit = self.fit_thread_list[uid]
471	if calc_fit is not None and calc_fit.isrunning():
472	calc_fit.stop()
473	msg = "Fit stop!"
474	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
475	#set the fit button label of page when fit stop is trigger from
476	#simultaneous fit pane
477	if self.sim_page is not None and uid == self.sim_page.uid:
478	for uid, value in self.page_finder.iteritems():
479	if value.get_scheduled() == 1:
480	if uid in self.fit_panel.opened_pages.keys():
481	panel = self.fit_panel.opened_pages[uid]
482	panel. _on_fit_complete()
483
484	def set_smearer(self, uid, smearer, qmin=None, qmax=None, draw=True):
485	"""
486	Get a smear object and store it to a fit problem
487
488	:param smearer: smear object to allow smearing data
489
490	"""
491	if uid not in self.page_finder.keys():
492	msg = "Cannot find ID: %s in page_finder" % str(uid)
493	raise ValueError, msg
494	self.page_finder[uid].set_smearer(smearer)
495	if draw:
496	## draw model 1D with smeared data
497	data = self.page_finder[uid].get_fit_data()
498	model = self.page_finder[uid].get_model()
499	if model is None:
500	return
501	## if user has already selected a model to plot
502	## redraw the model with data smeared
503	smear = self.page_finder[uid].get_smearer()
504	self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
505	qmin=qmin, qmax=qmax)
506
507	def draw_model(self, model, page_id, data=None, smearer=None,
508	enable1D=True, enable2D=False,
509	state=None,
510	toggle_mode_on=False,
511	qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,
512	qstep=DEFAULT_NPTS,
513	update_chisqr=True):
514	"""
515	Draw model.
516
517	:param model: the model to draw
518	:param name: the name of the model to draw
519	:param data: the data on which the model is based to be drawn
520	:param description: model's description
521	:param enable1D: if true enable drawing model 1D
522	:param enable2D: if true enable drawing model 2D
523	:param qmin: Range's minimum value to draw model
524	:param qmax: Range's maximum value to draw model
525	:param qstep: number of step to divide the x and y-axis
526	:param update_chisqr: update chisqr [bool]
527
528	"""
529	if data.__class__.__name__ == "Data1D" or not enable2D:
530	## draw model 1D with no loaded data
531
532	self._draw_model1D(model=model,
533	data=data,
534	page_id=page_id,
535	enable1D=enable1D,
536	smearer=smearer,
537	qmin=qmin,
538	qmax=qmax,
539	toggle_mode_on=toggle_mode_on,
540	state=state,
541	qstep=qstep,
542	update_chisqr=update_chisqr)
543	else:
544	## draw model 2D with no initial data
545	self._draw_model2D(model=model,
546	page_id=page_id,
547	data=data,
548	enable2D=enable2D,
549	smearer=smearer,
550	qmin=qmin,
551	qmax=qmax,
552	state=state,
553	toggle_mode_on=toggle_mode_on,
554	qstep=qstep,
555	update_chisqr=update_chisqr)
556
557	def onFit(self):
558	"""
559	perform fit
560	"""
561	## count the number of fitproblem schedule to fit
562	fitproblem_count = 0
563	for value in self.page_finder.values():
564	if value.get_scheduled() == 1:
565	fitproblem_count += 1
566
567	## if simultaneous fit change automatically the engine to park
568	if fitproblem_count > 1:
569	self._on_change_engine(engine='park')
570
571	self.fitproblem_count = fitproblem_count
572
573	from sans.fit.Fitting import Fit
574	fitter = Fit(self._fit_engine)
575
576	if self._fit_engine == "park":
577	engineType = "Simultaneous Fit"
578	else:
579	engineType = "Single Fit"
580
581	fproblemId = 0
582	self.current_pg = None
583	list_page_id = []
584	for page_id, value in self.page_finder.iteritems():
585	try:
586	if value.get_scheduled() == 1:
587	#Get list of parameters name to fit
588	pars = []
589	templist = []
590
591	page = self.fit_panel.get_page_by_id(page_id)
592	templist = page.get_param_list()
593	for element in templist:
594	name = str(element[1])
595	pars.append(name)
596	#Set Engine (model , data) related to the page on
597	self._fit_helper(value=value, pars=pars,
598	fitter=fitter,
599	fitproblem_id=fproblemId,
600	title=engineType)
601	list_page_id.append(page_id)
602	fproblemId += 1
603	current_page_id = page_id
604	except:
605	raise
606	#msg= "%s error: %s" % (engineType, sys.exc_value)
607	#wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
608	# type="stop"))
609	#return
610	## If a thread is already started, stop it
611	#if self.calc_fit!= None and self.calc_fit.isrunning():
612	# self.calc_fit.stop()
613	#Handler used for park engine displayed message
614	handler = ConsoleUpdate(parent=self.parent,
615	manager=self,
616	improvement_delta=0.1)
617
618	## perform single fit
619	if fitproblem_count == 1:
620	calc_fit = FitThread(handler = handler,
621	fn=fitter,
622	pars=pars,
623	page_id=list_page_id,
624	completefn=self._single_fit_completed,
625	ftol=self.ftol)
626	else:
627	current_page_id = self.sim_page.uid
628	## Perform more than 1 fit at the time
629	calc_fit = FitThread(handler=handler,
630	fn=fitter,
631	page_id=list_page_id,
632	updatefn=handler.update_fit,
633	ftol=self.ftol)
634	self.fit_thread_list[current_page_id] = calc_fit
635	calc_fit.queue()
636	self.ready_fit(calc_fit=calc_fit)
637
638
639	def ready_fit(self, calc_fit):
640	"""
641	Ready for another fit
642	"""
643	if self.fitproblem_count != None and self.fitproblem_count > 1:
644	calc_fit.ready(2.5)
645
646	else:
647	time.sleep(0.4)
648
649	def remove_plot(self, uid, theory=False):
650	"""
651	remove model plot when a fit page is closed
652	"""
653	fitproblem = self.page_finder[uid]
654	data = fitproblem.get_fit_data()
655	model = fitproblem.get_model()
656	plot_id = None
657	if model is not None:
658	plot_id = data.id + name
659	if theory:
660	plot_id = data.id
661	group_id = data.group_id
662	wx.PostEvent(self.parent, NewPlotEvent(id=plot_id,
663	group_id=group_id,
664	action='remove'))
665
666	def store_data(self, uid, data=None, caption=None):
667	"""
668	Helper to save page reference into the plug-in
669
670	:param page: page to store
671
672	"""
673	#create a fitproblem storing all link to data,model,page creation
674	if not uid in self.page_finder.keys():
675	self.page_finder[uid] = FitProblem()
676	self.page_finder[uid].set_fit_data(data)
677	self.page_finder[uid].set_fit_tab_caption(caption)
678
679	def on_add_new_page(self, event=None):
680	"""
681	ask fit panel to create a new empty page
682	"""
683	try:
684	page = self.fit_panel.add_empty_page()
685	page_caption = page.window_name
686	# add data associated to the page created
687	if page != None:
688	self.store_data(uid=page.uid, caption=page_caption,
689	data=page.get_data())
690	wx.PostEvent(self.parent, StatusEvent(status="Page Created",
691	info="info"))
692	else:
693	msg = "Page was already Created"
694	wx.PostEvent(self.parent, StatusEvent(status=msg,
695	info="warning"))
696	except:
697	raise
698	#msg = "Creating Fit page: %s"%sys.exc_value
699	#wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
700
701
702	def add_fit_page(self, data):
703	"""
704	given a data, ask to the fitting panel to create a new fitting page,
705	get this page and store it into the page_finder of this plug-in
706	"""
707	page = self.fit_panel.set_data(data)
708	page_caption = page.window_name
709	#append Data1D to the panel containing its theory
710	#if theory already plotted
711	if page.uid in self.page_finder:
712	theory_data = self.page_finder[page.uid].get_theory_data()
713	if issubclass(data.__class__, Data2D):
714	data.group_id = wx.NewId()
715	if theory_data is not None:
716	group_id = str(page.uid) + " Model1D"
717	wx.PostEvent(self.parent,
718	NewPlotEvent(group_id=group_id,
719	action="delete"))
720	self.parent.update_data(prev_data=theory_data, new_data=data)
721	else:
722	if theory_data is not None:
723	group_id = str(page.uid) + " Model2D"
724	data.group_id = theory_data.group_id
725	wx.PostEvent(self.parent,
726	NewPlotEvent(group_id=group_id,
727	action="delete"))
728	self.parent.update_data(prev_data=theory_data, new_data=data)
729
730	self.store_data(uid=page.uid, data=data, caption=page.window_name)
731	if self.sim_page is not None:
732	self.sim_page.draw_page()
733
734	def _onEVT_SLICER_PANEL(self, event):
735	"""
736	receive and event telling to update a panel with a name starting with
737	event.panel_name. this method update slicer panel for a given interactor.
738
739	:param event: contains type of slicer , paramaters for updating the panel
740	and panel_name to find the slicer 's panel concerned.
741	"""
742	for item in self.parent.panels:
743	if self.parent.panels[item].window_caption.startswith(event.panel_name):
744	self.parent.panels[item].set_slicer(event.type, event.params)
745
746	self.parent._mgr.Update()
747
748	def _closed_fitpage(self, event):
749	"""
750	request fitpanel to close a given page when its unique data is removed
751	from the plot. close fitpage only when the a loaded data is removed
752	"""
753	if event is None or event.data is None:
754	return
755	if hasattr(event.data,"is_data"):
756	if not event.data.is_data or \
757	event.data.__class__.__name__ == "Data1D":
758	self.fit_panel.close_page_with_data(event.data)
759
760	def _add_page_onmenu(self, name, fitproblem=None):
761	"""
762	Add name of a closed page of fitpanel in a menu
763	"""
764	list = self.menu1.GetMenuItems()
765	for item in list:
766	if name == item.GetItemLabel():
767	self.closed_page_dict[name][1] = fitproblem
768
769	if not name in self.closed_page_dict.keys():
770	# Post paramters
771	event_id = wx.NewId()
772	self.menu1.Append(event_id, name, "Show %s fit panel" % name)
773	self.closed_page_dict[name]= [event_id, fitproblem]
774	wx.EVT_MENU(self.parent, event_id, self._open_closed_page)
775
776	def _open_closed_page(self, event):
777	"""
778	reopen a closed page
779	"""
780	for name, value in self.closed_page_dict.iteritems():
781	if event.GetId() in value:
782	uid,fitproblem = value
783	if name !="Model":
784	data= fitproblem.get_fit_data()
785	page = self.fit_panel.add_fit_page(data=data, reset=True)
786	if fitproblem != None:
787	self.page_finder[uid] = fitproblem
788	if self.sim_page != None:
789	self.sim_page.draw_page()
790
791	else:
792	model = fitproblem
793	self.fit_panel.add_model_page(model=model, topmenu=True,
794	reset= True)
795	break
796
797	def _reset_schedule_problem(self, value=0):
798	"""
799	unschedule or schedule all fitproblem to be fit
800	"""
801	for page_id in self.page_finder.keys():
802	self.page_finder[page_id].schedule_tofit(value)
803
804	def _fit_helper(self, pars, value, fitproblem_id,fitter, title="Single Fit " ):
805	"""
806	helper for fitting
807	"""
808	metadata = value.get_fit_data()
809	model = value.get_model()
810	smearer = value.get_smearer()
811	qmin, qmax = value.get_range()
812	self.fit_id = fitproblem_id
813	#Create list of parameters for fitting used
814	templist = []
815
816	try:
817	#Extra list of parameters and their constraints
818	listOfConstraint = []
819
820	param = value.get_model_param()
821	if len(param) > 0:
822	for item in param:
823	## check if constraint
824	if item[0] != None and item[1] != None:
825	listOfConstraint.append((item[0],item[1]))
826
827	#Do the single fit
828	fitter.set_model(model, self.fit_id,
829	pars, constraints=listOfConstraint)
830
831	fitter.set_data(data=metadata, id=self.fit_id,
832	smearer=smearer, qmin=qmin, qmax=qmax)
833
834	fitter.select_problem_for_fit(id=self.fit_id,
835	value=value.get_scheduled())
836	value.clear_model_param()
837	except:
838	raise
839	#msg = title + " error: %s" % sys.exc_value
840	#wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
841
842	def _onSelect(self,event):
843	"""
844	when Select data to fit a new page is created .Its reference is
845	added to self.page_finder
846	"""
847	self.panel = event.GetEventObject()
848	Plugin.on_perspective(self, event=event)
849	for plottable in self.panel.graph.plottables:
850	if plottable.__class__.__name__ in ["Data1D", "Theory1D"]:
851	if plottable.name == self.panel.graph.selected_plottable:
852	data = plottable
853	self.add_fit_page(data=data)
854	return
855	else:
856	data = plottable
857	self.add_fit_page(data=data)
858
859	def update_fit(self, result=None, msg=""):
860	"""
861	"""
862	print "update_fit result", result
863
864	def _single_fit_completed(self, result, pars, page_id, elapsed=None):
865	"""
866	Display fit result on one page of the notebook.
867
868	:param result: result of fit
869	:param pars: list of names of parameters fitted
870	:param current_pg: the page where information will be displayed
871	:param qmin: the minimum value of x to replot the model
872	:param qmax: the maximum value of x to replot model
873
874	"""
875	try:
876	if result == None:
877	msg= "Single Fitting did not converge!!!"
878	wx.PostEvent(self.parent,
879	StatusEvent(status=msg,
880	info="warning",
881	type="stop"))
882	return
883	if not numpy.isfinite(result.fitness) or \
884	numpy.any(result.pvec == None) or \
885	not numpy.all(numpy.isfinite(result.pvec)):
886	msg = "Single Fitting did not converge!!!"
887	wx.PostEvent(self.parent,
888	StatusEvent(status=msg,
889	info="warning",
890	type="stop"))
891	return
892	for uid in page_id:
893	value = self.page_finder[uid]
894	model = value.get_model()
895	page_id = uid
896
897	param_name = []
898	for name in pars:
899	param_name.append(name)
900
901	cpage = self.fit_panel.get_page_by_id(uid)
902	cpage.onsetValues(result.fitness,
903	param_name, result.pvec,result.stderr)
904	cpage._on_fit_complete()
905
906	except ValueError:
907	msg = "Single Fitting did not converge!!!"
908	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
909	type="stop"))
910	return
911	except:
912	raise
913	#msg = "Single Fit completed but Following"
914	#msg += " error occurred:%s" % sys.exc_value
915	#wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
916	# type="stop"))
917	return
918
919	def _simul_fit_completed(self, result, page_id,pars=None, elapsed=None):
920	"""
921	Parameter estimation completed,
922	display the results to the user
923
924	:param alpha: estimated best alpha
925	:param elapsed: computation time
926
927	"""
928	if page_id is None:
929	page_id = []
930	## fit more than 1 model at the same time
931	try:
932	msg = ""
933	if result == None:
934	msg= "Complex Fitting did not converge!!!"
935	wx.PostEvent(self.parent, StatusEvent(status=msg,
936	type="stop"))
937	return
938	if not numpy.isfinite(result.fitness) or \
939	numpy.any(result.pvec == None) or not \
940	numpy.all(numpy.isfinite(result.pvec)):
941	msg= "Simultaneous Fitting did not converge!!!"
942	wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
943	return
944
945	for uid in page_id:
946	value = self.page_finder[uid]
947	model = value.get_model()
948	data = value.get_fit_data()
949	small_param_name = []
950	small_out = []
951	small_cov = []
952	#Separate result in to data corresponding to each page
953	for p in result.parameters:
954	model_name, param_name = self.split_string(p.name)
955	if model.name == model_name:
956	p_name= model.name+"."+param_name
957	if p.name == p_name:
958	if p.value != None and numpy.isfinite(p.value):
959	small_out.append(p.value)
960	small_param_name.append(param_name)
961	small_cov.append(p.stderr)
962	# Display result on each page
963	cpage = self.fit_panel.get_page_by_id(uid)
964	cpage.onsetValues(result.fitness,
965	small_param_name,
966	small_out,small_cov)
967	cpage._on_fit_complete()
968
969	except Exception:
970	msg = "Complex Fitting did not converge!!!"
971	wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
972	type="stop"))
973	return
974
975	except:
976	msg = "Simultaneous Fit completed"
977	msg += " but Following error occurred:%s" % sys.exc_value
978	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
979
980	def _on_show_panel(self, event):
981	"""
982	"""
983	pass
984
985	def _onset_engine_park(self,event):
986	"""
987	set engine to park
988	"""
989	self._on_change_engine('park')
990
991	def _onset_engine_scipy(self,event):
992	"""
993	set engine to scipy
994	"""
995	self._on_change_engine('scipy')
996
997	def _on_slicer_event(self, event):
998	"""
999	Receive a panel as event and send it to guiframe
1000
1001	:param event: event containing a panel
1002
1003	"""
1004	if event.panel is not None:
1005	new_panel = event.panel
1006	self.slicer_panels.append(event.panel)
1007	# Set group ID if available
1008	event_id = self.parent.popup_panel(new_panel)
1009	#self.menu3.Append(event_id, new_panel.window_caption,
1010	# "Show %s plot panel" % new_panel.window_caption)
1011	# Set id to allow us to reference the panel later
1012
1013	new_panel.uid = event_id
1014	self.mypanels.append(new_panel)
1015
1016	def _onclearslicer(self, event):
1017	"""
1018	Clear the boxslicer when close the panel associate with this slicer
1019	"""
1020	name =event.GetPane().caption
1021
1022	for panel in self.slicer_panels:
1023	if panel.window_caption==name:
1024
1025	for item in self.parent.panels:
1026	if hasattr(self.parent.panels[item],"uid"):
1027	if self.parent.panels[item].uid ==panel.base.uid:
1028	self.parent.panels[item].onClearSlicer(event)
1029	self.parent._mgr.Update()
1030	break
1031	break
1032
1033	def _return_engine_type(self):
1034	"""
1035	return the current type of engine
1036	"""
1037	return self._fit_engine
1038
1039
1040	def _on_change_engine(self, engine='park'):
1041	"""
1042	Allow to select the type of engine to perform fit
1043
1044	:param engine: the key work of the engine
1045
1046	"""
1047	## saving fit engine name
1048	self._fit_engine = engine
1049	## change menu item state
1050	if engine=="park":
1051	self.menu1.FindItemByPosition(0).Check(False)
1052	self.menu1.FindItemByPosition(1).Check(True)
1053	else:
1054	self.menu1.FindItemByPosition(0).Check(True)
1055	self.menu1.FindItemByPosition(1).Check(False)
1056	## post a message to status bar
1057	msg = "Engine set to: %s" % self._fit_engine
1058	wx.PostEvent(self.parent,
1059	StatusEvent(status=msg))
1060	## send the current engine type to fitpanel
1061	self.fit_panel._on_engine_change(name=self._fit_engine)
1062
1063	def _on_model_panel(self, evt):
1064	"""
1065	react to model selection on any combo box or model menu.plot the model
1066
1067	:param evt: wx.combobox event
1068
1069	"""
1070	model = evt.model
1071	uid = evt.uid
1072	qmin = evt.qmin
1073	qmax = evt.qmax
1074	smearer = evt.smearer
1075
1076	if model == None:
1077	return
1078
1079	if self.page_finder[uid].get_model() is None:
1080	model.name = "M" + str(self.index_model)
1081	self.index_model += 1
1082	else:
1083	model.name = self.page_finder[uid].get_model().name
1084	# save the name containing the data name with the appropriate model
1085	self.page_finder[uid].set_model(model)
1086	self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
1087	if self.sim_page is not None:
1088	self.sim_page.draw_page()
1089
1090	def _update1D(self,x, output):
1091	"""
1092	Update the output of plotting model 1D
1093	"""
1094	msg = "Plot updating ... "
1095	wx.PostEvent(self.parent, StatusEvent(status=msg,type="update"))
1096	self.ready_fit()
1097
1098
1099	def _fill_default_model2D(self, theory, page_id, qmax,qstep, qmin=None):
1100	"""
1101	fill Data2D with default value
1102
1103	:param theory: Data2D to fill
1104
1105	"""
1106	from DataLoader.data_info import Detector, Source
1107
1108	detector = Detector()
1109	theory.detector.append(detector)
1110	theory.source= Source()
1111
1112	## Default values
1113	theory.detector[0].distance= 8000 # mm
1114	theory.source.wavelength= 6 # A
1115	theory.detector[0].pixel_size.x= 5 # mm
1116	theory.detector[0].pixel_size.y= 5 # mm
1117
1118	theory.detector[0].beam_center.x= qmax
1119	theory.detector[0].beam_center.y= qmax
1120
1121	## create x_bins and y_bins of the model 2D
1122	pixel_width_x = theory.detector[0].pixel_size.x
1123	pixel_width_y = theory.detector[0].pixel_size.y
1124	center_x = theory.detector[0].beam_center.x/pixel_width_x
1125	center_y = theory.detector[0].beam_center.y/pixel_width_y
1126
1127	# theory default: assume the beam
1128	#center is located at the center of sqr detector
1129	xmax = qmax
1130	xmin = -qmax
1131	ymax = qmax
1132	ymin = -qmax
1133
1134	x= numpy.linspace(start= -1*qmax,
1135	stop=qmax,
1136	num=qstep,
1137	endpoint=True)
1138	y = numpy.linspace(start=-1*qmax,
1139	stop= qmax,
1140	num= qstep,
1141	endpoint=True)
1142
1143	## use data info instead
1144	new_x = numpy.tile(x, (len(y),1))
1145	new_y = numpy.tile(y, (len(x),1))
1146	new_y = new_y.swapaxes(0,1)
1147
1148	# all data reuire now in 1d array
1149	qx_data = new_x.flatten()
1150	qy_data = new_y.flatten()
1151
1152	q_data = numpy.sqrt(qx_dataqx_data+qy_dataqy_data)
1153	# set all True (standing for unmasked) as default
1154	mask = numpy.ones(len(qx_data), dtype = bool)
1155
1156	# calculate the range of qx and qy: this way,
1157	# it is a little more independent
1158	x_size = xmax- xmin
1159	y_size = ymax -ymin
1160
1161	# store x and y bin centers in q space
1162	x_bins = x
1163	y_bins = y
1164	# bin size: x- & y-directions
1165	xstep = x_size/len(x_bins-1)
1166	ystep = y_size/len(y_bins-1)
1167
1168	#theory.data = numpy.zeros(len(mask))
1169	theory.err_data = numpy.ones(len(mask))
1170	theory.qx_data = qx_data
1171	theory.qy_data = qy_data
1172	theory.q_data = q_data
1173	theory.mask = mask
1174	theory.x_bins = x_bins
1175	theory.y_bins = y_bins
1176
1177	# max and min taking account of the bin sizes
1178	theory.xmin = xmin
1179	theory.xmax = xmax
1180	theory.ymin = ymin
1181	theory.ymax = ymax
1182	theory.group_id = str(page_id) + " Model2D"
1183	theory.id = str(page_id) + " Model2D"
1184
1185	def _complete1D(self, x,y, page_id, elapsed,index,model,
1186	toggle_mode_on=False,state=None,
1187	data=None, update_chisqr=True):
1188	"""
1189	Complete plotting 1D data
1190	"""
1191	try:
1192	new_plot = Data1D(x=x, y=y)
1193	new_plot.is_data = False
1194	new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
1195	if data != None:
1196	_xaxis, _xunit = data.get_xaxis()
1197	_yaxis, _yunit = data.get_yaxis()
1198	new_plot.title = data.name
1199	#if the theory is already plotted use the same group id
1200	#to replot
1201	if page_id in self.page_finder:
1202	theory_data = self.page_finder[page_id].get_theory_data()
1203	if theory_data is not None:
1204	data.group_id = theory_data.group_id
1205	#data is plotted before the theory, then take its group_id
1206	#assign to the new theory
1207	new_plot.group_id = data.group_id
1208
1209	else:
1210	_xaxis, _xunit = "\\rm{Q}", 'A^{-1}'
1211	_yaxis, _yunit = "\\rm{Intensity} ", "cm^{-1}"
1212	new_plot.title = "Analytical model 1D "
1213	#find a group id to plot theory without data
1214	new_plot.group_id = str(page_id) + " Model1D"
1215	new_plot.id = str(page_id) + " Model1D"
1216
1217	#find if this theory was already plotted and replace that plot given
1218	#the same id
1219
1220	theory_data = self.page_finder[page_id].get_theory_data()
1221	if theory_data is not None:
1222	new_plot.id = theory_data.id
1223
1224	new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]"
1225	new_plot.xaxis(_xaxis, _xunit)
1226	new_plot.yaxis(_yaxis, _yunit)
1227	if toggle_mode_on:
1228	new_plot.id = str(page_id) + " Model"
1229	wx.PostEvent(self.parent,
1230	NewPlotEvent(group_id=str(page_id) + " Model2D",
1231	action="Hide"))
1232
1233	self.page_finder[page_id].set_theory_data(new_plot)
1234	if data is None:
1235	data_id = None
1236	else:
1237	data_id = data.id
1238	self.parent.update_theory(data_id=data_id,
1239	theory=new_plot,
1240	state=state)
1241	current_pg = self.fit_panel.get_page_by_id(page_id)
1242	title = new_plot.title
1243	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1244	title= str(title)))
1245	if update_chisqr:
1246	wx.PostEvent(current_pg,
1247	Chi2UpdateEvent(output=self._cal_chisqr(data=data,
1248	page_id=page_id,
1249	index=index)))
1250	else:
1251	self._plot_residuals(page_id, data, index)
1252
1253	msg = "Plot 1D complete !"
1254	wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" ))
1255	#self.current_pg.state.theory_data = deepcopy(self.theory_data)
1256	except:
1257	raise
1258	#msg = " Error occurred when drawing %s Model 1D: " % new_plot.name
1259	#msg += " %s" % sys.exc_value
1260	#wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
1261
1262	def _update2D(self, output,time=None):
1263	"""
1264	Update the output of plotting model
1265	"""
1266	wx.PostEvent(self.parent, StatusEvent(status="Plot \
1267	#updating ... ", type="update"))
1268	self.ready_fit()
1269
1270	def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
1271	qmax, toggle_mode_on=False,state=None,qstep=DEFAULT_NPTS,
1272	update_chisqr=True):
1273	"""
1274	Complete get the result of modelthread and create model 2D
1275	that can be plot.
1276	"""
1277	err_image = numpy.zeros(numpy.shape(image))
1278
1279	new_plot= Data2D(image=image, err_image=err_image)
1280	new_plot.name = model.name
1281
1282	if data is None:
1283	self._fill_default_model2D(theory=new_plot,
1284	qmax=qmax,
1285	page_id=page_id,
1286	qstep=qstep,
1287	qmin= qmin)
1288
1289	else:
1290	new_plot.id = str(page_id) + " Model2D"
1291	new_plot.group_id = str(page_id) + " Model2D"
1292	new_plot.x_bins = data.x_bins
1293	new_plot.y_bins = data.y_bins
1294	new_plot.detector = data.detector
1295	new_plot.source = data.source
1296	new_plot.is_data = False
1297	new_plot.qx_data = data.qx_data
1298	new_plot.qy_data = data.qy_data
1299	new_plot.q_data = data.q_data
1300	#numpy.zeros(len(data.err_data))#data.err_data
1301	new_plot.err_data = err_image
1302	new_plot.mask = data.mask
1303	## plot boundaries
1304	new_plot.ymin = data.ymin
1305	new_plot.ymax = data.ymax
1306	new_plot.xmin = data.xmin
1307	new_plot.xmax = data.xmax
1308	new_plot.is_data = False
1309	new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]"
1310	new_plot.title = "Analytical model 2D "
1311	theory_data = deepcopy(new_plot)
1312	theory_data.name = "Unknown"
1313	if toggle_mode_on:
1314	new_plot.id = str(page_id) + " Model"
1315	wx.PostEvent(self.parent,
1316	NewPlotEvent(group_id=str(page_id) + " Model1D",
1317	action="Hide"))
1318
1319	self.page_finder[page_id].set_theory_data(new_plot)
1320	if data is None:
1321	data_id = None
1322	else:
1323	data_id = data.id
1324	self.parent.update_theory(data_id=data_id,
1325	theory=new_plot,
1326	state=state)
1327	current_pg = self.fit_panel.get_page_by_id(page_id)
1328	title = new_plot.title
1329	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1330	title=title))
1331	# Chisqr in fitpage
1332	if update_chisqr:
1333	wx.PostEvent(current_pg,
1334	Chi2UpdateEvent(output=\
1335	self._cal_chisqr(data=data,
1336	page_id=page_id,
1337	index=index)))
1338	else:
1339	self._plot_residuals(page_id, data, index)
1340	msg = "Plot 2D complete !"
1341	wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
1342
1343	def _draw_model2D(self, model, page_id, data=None, smearer=None,
1344	description=None, enable2D=False,
1345	state=None,
1346	toggle_mode_on=False,
1347	qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,
1348	qstep=DEFAULT_NPTS,
1349	update_chisqr=True):
1350	"""
1351	draw model in 2D
1352
1353	:param model: instance of the model to draw
1354	:param description: the description of the model
1355	:param enable2D: when True allows to draw model 2D
1356	:param qmin: the minimum value to draw model 2D
1357	:param qmax: the maximum value to draw model 2D
1358	:param qstep: the number of division of Qx and Qy of the model to draw
1359
1360	"""
1361	x= numpy.linspace(start=-1*qmax,
1362	stop=qmax,
1363	num=qstep,
1364	endpoint=True)
1365	y = numpy.linspace(start= -1*qmax,
1366	stop=qmax,
1367	num=qstep,
1368	endpoint=True)
1369	if model is None:
1370	msg = "Panel with ID: %s does not contained model" % str(page_id)
1371	raise ValueError, msg
1372	## use data info instead
1373	if data is not None:
1374	## check if data2D to plot
1375	if hasattr(data, "x_bins"):
1376	enable2D = True
1377	x = data.x_bins
1378	y = data.y_bins
1379
1380	if not enable2D:
1381	return None, None
1382	try:
1383	from model_thread import Calc2D
1384	## If a thread is already started, stop it
1385	if (self.calc_2D is not None) and self.calc_2D.isrunning():
1386	self.calc_2D.stop()
1387
1388	self.calc_2D = Calc2D(x=x,
1389	y=y,
1390	model=model,
1391	data=data,
1392	page_id=page_id,
1393	smearer=smearer,
1394	qmin=qmin,
1395	qmax=qmax,
1396	qstep=qstep,
1397	toggle_mode_on=toggle_mode_on,
1398	state=state,
1399	completefn=self._complete2D,
1400	#updatefn= self._update2D,
1401	update_chisqr=update_chisqr)
1402
1403	self.calc_2D.queue()
1404
1405	except:
1406	raise
1407	#msg = " Error occurred when drawing %s Model 2D: " % model.name
1408	#msg += " %s" % sys.exc_value
1409	#wx.PostEvent(self.parent, StatusEvent(status=msg))
1410
1411	def _draw_model1D(self, model, page_id, data=None, smearer=None,
1412	qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,
1413	state=None,
1414	toggle_mode_on=False,
1415	qstep=DEFAULT_NPTS, update_chisqr=True,
1416	enable1D=True):
1417	"""
1418	Draw model 1D from loaded data1D
1419
1420	:param data: loaded data
1421	:param model: the model to plot
1422
1423	"""
1424	x= numpy.linspace(start=qmin,
1425	stop=qmax,
1426	num=qstep,
1427	endpoint=True
1428	)
1429	if data is not None:
1430	## check for data2D
1431	if hasattr(data,"x_bins"):
1432	return
1433	x = data.x
1434	if qmin == None :
1435	qmin == DEFAULT_QMIN
1436
1437	if qmax == None:
1438	qmax == DEFAULT_QMAX
1439	if not enable1D:
1440	return
1441	try:
1442	from model_thread import Calc1D
1443	## If a thread is already started, stop it
1444	if (self.calc_1D is not None) and self.calc_1D.isrunning():
1445	self.calc_1D.stop()
1446	self.calc_1D = Calc1D(x=x,
1447	data=data,
1448	model=model,
1449	page_id=page_id,
1450	qmin=qmin,
1451	qmax=qmax,
1452	smearer=smearer,
1453	state=state,
1454	toggle_mode_on=toggle_mode_on,
1455	completefn=self._complete1D,
1456	#updatefn = self._update1D,
1457	update_chisqr=update_chisqr)
1458
1459	self.calc_1D.queue()
1460
1461	except:
1462	msg = " Error occurred when drawing %s Model 1D: " % model.name
1463	msg += " %s" % sys.exc_value
1464	wx.PostEvent(self.parent, StatusEvent(status=msg))
1465
1466	def _cal_chisqr(self, page_id, data=None, index=None):
1467	"""
1468	Get handy Chisqr using the output from draw1D and 2D,
1469	instead of calling expansive CalcChisqr in guithread
1470	"""
1471	# default chisqr
1472	chisqr = None
1473
1474	# return None if data == None
1475	if data == None: return chisqr
1476
1477	# Get data: data I, theory I, and data dI in order
1478	if data.__class__.__name__ == "Data2D":
1479	if index == None:
1480	index = numpy.ones(len(data.data),ntype=bool)
1481	# get rid of zero error points
1482	index = index & (data.err_data != 0 )
1483	index = index & (numpy.isfinite(data.data))
1484	fn = data.data[index]
1485	theory_data = self.page_finder[page_id].get_theory_data()
1486	gn = theory_data.data[index]
1487	en = data.err_data[index]
1488	else:
1489	# 1 d theory from model_thread is only in the range of index
1490	if index == None:
1491	index = numpy.ones(len(data.y), ntype=bool)
1492	if data.dy == None or data.dy == []:
1493	dy = numpy.ones(len(data.y))
1494	else:
1495	## Set consitently w/AbstractFitengine:
1496	# But this should be corrected later.
1497	dy = deepcopy(data.dy)
1498	dy[dy==0] = 1
1499	fn = data.y[index]
1500	theory_data = self.page_finder[page_id].get_theory_data()
1501	gn = theory_data.y
1502	en = dy[index]
1503	# residual
1504	res = (fn - gn) / en
1505	residuals = res[numpy.isfinite(res)]
1506	# get chisqr only w/finite
1507	chisqr = numpy.average(residuals * residuals)
1508
1509	self._plot_residuals(page_id, data, index)
1510	return chisqr
1511
1512
1513
1514	def _plot_residuals(self, page_id, data=None, index=None):
1515	"""
1516	Plot the residuals
1517
1518	:param data: data
1519	:param index: index array (bool)
1520	: Note: this is different from the residuals in cal_chisqr()
1521	"""
1522	if data == None:
1523	return
1524
1525	# Get data: data I, theory I, and data dI in order
1526	if data.__class__.__name__ == "Data2D":
1527	# build residuals
1528	#print data
1529	residuals = Data2D()
1530	#residuals.copy_from_datainfo(data)
1531	# Not for trunk the line below, instead use the line above
1532	data.clone_without_data(len(data.data), residuals)
1533	residuals.data = None
1534	fn = data.data#[index]
1535	theory_data = self.page_finder[page_id].get_theory_data()
1536	gn = theory_data.data#[index]
1537	en = data.err_data#[index]
1538	residuals.data = (fn - gn) / en
1539	residuals.qx_data = data.qx_data#[index]
1540	residuals.qy_data = data.qy_data #[index]
1541	residuals.q_data = data.q_data#[index]
1542	residuals.err_data = numpy.ones(len(residuals.data))#[index]
1543	residuals.xmin = min(residuals.qx_data)
1544	residuals.xmax = max(residuals.qx_data)
1545	residuals.ymin = min(residuals.qy_data)
1546	residuals.ymax = max(residuals.qy_data)
1547	residuals.q_data = data.q_data#[index]
1548	residuals.mask = data.mask
1549	residuals.scale = 'linear'
1550	#print "print data",residuals
1551	# check the lengths
1552	if len(residuals.data) != len(residuals.q_data):
1553	return
1554
1555	else:
1556	# 1 d theory from model_thread is only in the range of index
1557	if data.dy == None or data.dy == []:
1558	dy = numpy.ones(len(data.y))
1559	else:
1560	## Set consitently w/AbstractFitengine:
1561	## But this should be corrected later.
1562	dy = deepcopy(data.dy)
1563	dy[dy==0] = 1
1564	fn = data.y[index]
1565	theory_data = self.page_finder[page_id].get_theory_data()
1566	gn = theory_data.y
1567	en = dy[index]
1568	# build residuals
1569	residuals = Data1D()
1570	residuals.y = (fn - gn) / en
1571	residuals.x = data.x[index]
1572	residuals.dy = numpy.ones(len(residuals.y))
1573	residuals.dx = None
1574	residuals.dxl = None
1575	residuals.dxw = None
1576	residuals.ytransform = 'y'
1577	# For latter scale changes
1578	residuals.xaxis('\\rm{Q} ', 'A^{-1}')
1579	residuals.yaxis('\\rm{Residuals} ', 'normalized')
1580
1581	new_plot = residuals
1582	if data.id == None:
1583	data.id = data.name
1584	name = data.id
1585	new_plot.name = "Residuals for " + str(data.name)
1586	## allow to highlight data when plotted
1587	new_plot.interactive = True
1588	## when 2 data have the same id override the 1 st plotted
1589	new_plot.id = new_plot.name#name + " residuals"
1590	##group_id specify on which panel to plot this data
1591	new_plot.group_id = new_plot.id
1592	#new_plot.is_data = True
1593	##post data to plot
1594	title = new_plot.name
1595
1596	# plot data
1597	wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))
1598
1599	#def profile(fn, args, *kw):
1600	# import cProfile, pstats, os
1601	# global call_result
1602	# def call():
1603	# global call_result
1604	# call_result = fn(args, *kw)
1605	# cProfile.runctx('call()', dict(call=call), {}, 'profile.out')
1606	# stats = pstats.Stats('profile.out')
1607	# #stats.sort_stats('time')
1608	# stats.sort_stats('calls')
1609	# stats.print_stats()
1610	# os.unlink('profile.out')
1611	# return call_result
1612	if __name__ == "__main__":
1613	i = Plugin()
1614
1615
1616
1617

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

SasView

source: sasview/sansview/perspectives/fitting/fitting.py @ b7e6bd3

Download in other formats: