basepage.py @ e80e704

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 e80e704 was 3b70cc7, checked in by Jae Cho <jhjcho@…>, 13 years ago
fixed 2d batch plot
Property mode set to `100644`
File size: 126.0 KB

Line
1
2	import sys
3	import os
4	import wx
5	import numpy
6	import time
7	import copy
8	import math
9	import string
10	from wx.lib.scrolledpanel import ScrolledPanel
11	from sans.guiframe.panel_base import PanelBase
12	from sans.guiframe.utils import format_number,check_float
13	from sans.guiframe.events import PanelOnFocusEvent
14	from sans.guiframe.events import StatusEvent
15	from sans.guiframe.events import AppendBookmarkEvent
16	from sans.guiframe.dataFitting import Data2D
17	from sans.guiframe.dataFitting import Data1D
18	from sans.guiframe.dataFitting import check_data_validity
19	from sans.dataloader.data_info import Detector
20	from sans.dataloader.data_info import Source
21	import pagestate
22	from pagestate import PageState
23
24	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
25	(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent()
26	(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent()
27
28	_BOX_WIDTH = 76
29	_QMIN_DEFAULT = 0.0005
30	_QMAX_DEFAULT = 0.5
31	_NPTS_DEFAULT = 50
32	#Control panel width
33	if sys.platform.count("win32")> 0:
34	PANEL_WIDTH = 450
35	FONT_VARIANT = 0
36	ON_MAC = False
37	else:
38	PANEL_WIDTH = 500
39	FONT_VARIANT = 1
40	ON_MAC = True
41
42
43
44	class BasicPage(ScrolledPanel, PanelBase):
45	"""
46	This class provide general structure of fitpanel page
47	"""
48	## Internal name for the AUI manager
49	window_name = "Fit Page"
50	## Title to appear on top of the window
51	window_caption = "Fit Page "
52
53	def __init__(self, parent,color='blue', **kwargs):
54	"""
55	"""
56	ScrolledPanel.__init__(self, parent, **kwargs)
57	PanelBase.__init__(self, parent)
58	self.SetupScrolling()
59	#Set window's font size
60	self.SetWindowVariant(variant=FONT_VARIANT)
61
62	self.SetBackgroundColour(color)
63	## parent of the page
64	self.parent = parent
65	## manager is the fitting plugin
66	## owner of the page (fitting plugin)
67	self.event_owner = None
68	## current model
69	self.model = None
70	self.index_model = None
71	## data
72	self.data = None
73	#list of available data
74	self.data_list = []
75	self.mask = None
76	self.uid = wx.NewId()
77	self.graph_id = None
78	#Q range for data set
79	self.qmin_data_set = numpy.inf
80	self.qmax_data_set = None
81	self.npts_data_set = 0
82	## Q range
83	self.qmin = None
84	self.qmax = None
85	self.qmax_x = _QMAX_DEFAULT
86	self.qmin_x = _QMIN_DEFAULT
87	self.npts_x = _NPTS_DEFAULT
88	## total number of point: float
89	self.npts = None
90	## default fitengine type
91	self.engine_type = 'scipy'
92	## smear default
93	self.current_smearer = None
94	## 2D smear accuracy default
95	self.smear2d_accuracy = 'Low'
96	## slit smear:
97	self.dxl = None
98	self.dxw = None
99	## pinhole smear
100	self.dx_min = None
101	self.dx_max = None
102
103	self.disp_cb_dict = {}
104
105	self.state = PageState(parent=parent)
106	## dictionary containing list of models
107	self.model_list_box = {}
108
109	## Data member to store the dispersion object created
110	self._disp_obj_dict = {}
111	## selected parameters to apply dispersion
112	self.disp_cb_dict ={}
113	## smearer object
114	self.enable2D = False
115	self.is_mac = ON_MAC
116
117	##list of model parameters. each item must have same length
118	## each item related to a given parameters
119	##[cb state, name, value, "+/-", error of fit, min, max , units]
120	self.parameters = []
121	# non-fittable parameter whose value is astring
122	self.str_parameters = []
123	## list of parameters to fit , must be like self.parameters
124	self.param_toFit = []
125	## list of looking like parameters but with non fittable parameters info
126	self.fixed_param = []
127	## list of looking like parameters but with fittable parameters info
128	self.fittable_param = []
129	##list of dispersion parameters
130	self.disp_list = []
131	self.disp_name = ""
132
133	## list of orientation parameters
134	self.orientation_params = []
135	self.orientation_params_disp = []
136	if self.model != None:
137	self.disp_list = self.model.getDispParamList()
138	self.temp_multi_functional = False
139	##enable model 2D draw
140	self.enable2D = False
141	## check that the fit range is correct to plot the model again
142	self.fitrange = True
143	## Create memento to save the current state
144	self.state = PageState(parent=self.parent,
145	model=self.model, data=self.data)
146	## flag to determine if state has change
147	self.state_change = False
148	## save customized array
149	self.values = []
150	self.weights = []
151	## retrieve saved state
152	self.number_saved_state = 0
153	## dictionary of saved state
154	self.saved_states = {}
155	## Create context menu for page
156	self.popUpMenu = wx.Menu()
157
158	id = wx.NewId()
159	self._keep = wx.MenuItem(self.popUpMenu,id,"Add bookmark",
160	" Keep the panel status to recall it later")
161	self.popUpMenu.AppendItem(self._keep)
162	self._keep.Enable(False)
163	self._set_bookmark_flag(False)
164	self._set_save_flag(False)
165	wx.EVT_MENU(self, id, self.on_bookmark)
166	self.popUpMenu.AppendSeparator()
167
168	## Default locations
169	self._default_save_location = os.getcwd()
170	## save initial state on context menu
171	#self.onSave(event=None)
172	self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
173
174	# bind key event
175	self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
176
177	## create the basic structure of the panel with empty sizer
178	self.define_page_structure()
179	## drawing Initial dispersion parameters sizer
180	self.set_dispers_sizer()
181
182	## layout
183	self.set_layout()
184
185	def set_index_model(self, index):
186	"""
187	Index related to this page
188	"""
189	self.index_model = index
190
191	def create_default_data(self):
192	"""
193	Given the user selection, creates a 1D or 2D data
194	Only when the page is on theory mode.
195	"""
196	if not hasattr(self, "model_view"):
197	return
198	toggle_mode_on = self.model_view.IsEnabled()
199	if toggle_mode_on:
200	if self.enable2D and not check_data_validity(self.data):
201	self._create_default_2d_data()
202	else:
203	self._create_default_1d_data()
204
205	def _create_default_1d_data(self):
206	"""
207	Create default data for fitting perspective
208	Only when the page is on theory mode.
209	:warning: This data is never plotted.
210
211	"""
212	x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
213	num=self.npts_x, endpoint=True)
214	self.data = Data1D(x=x)
215	self.data.xaxis('\\rm{Q}',"A^{-1}")
216	self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
217	self.data.is_data = False
218	self.data.id = str(self.uid) + " data"
219	self.data.group_id = str(self.uid) + " Model1D"
220
221	def _create_default_2d_data(self):
222	"""
223	Create 2D data by default
224	Only when the page is on theory mode.
225	:warning: This data is never plotted.
226	"""
227	self.data = Data2D()
228	qmax = self.qmax_x / math.sqrt(2)
229	self.data.xaxis('\\rm{Q_{x}}', 'A^{-1}')
230	self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}')
231	self.data.is_data = False
232	self.data.id = str(self.uid) + " data"
233	self.data.group_id = str(self.uid) + " Model2D"
234	## Default values
235	self.data.detector.append(Detector())
236	index = len(self.data.detector) - 1
237	self.data.detector[index].distance = 8000 # mm
238	self.data.source.wavelength= 6 # A
239	self.data.detector[index].pixel_size.x = 5 # mm
240	self.data.detector[index].pixel_size.y = 5 # mm
241	self.data.detector[index].beam_center.x = qmax
242	self.data.detector[index].beam_center.y = qmax
243	## create x_bins and y_bins of the model 2D
244	pixel_width_x = self.data.detector[index].pixel_size.x
245	pixel_width_y = self.data.detector[index].pixel_size.y
246	center_x = self.data.detector[index].beam_center.x/pixel_width_x
247	center_y = self.data.detector[index].beam_center.y/pixel_width_y
248	# theory default: assume the beam
249	#center is located at the center of sqr detector
250	xmax = qmax
251	xmin = -qmax
252	ymax = qmax
253	ymin = -qmax
254	qstep = self.npts_x
255
256	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
257	y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
258	## use data info instead
259	new_x = numpy.tile(x, (len(y), 1))
260	new_y = numpy.tile(y, (len(x), 1))
261	new_y = new_y.swapaxes(0,1)
262	# all data reuire now in 1d array
263	qx_data = new_x.flatten()
264	qy_data = new_y.flatten()
265	q_data = numpy.sqrt(qx_dataqx_data + qy_dataqy_data)
266	# set all True (standing for unmasked) as default
267	mask = numpy.ones(len(qx_data), dtype=bool)
268	# calculate the range of qx and qy: this way,
269	# it is a little more independent
270	x_size = xmax - xmin
271	y_size = ymax - ymin
272	# store x and y bin centers in q space
273	x_bins = x
274	y_bins = y
275	# bin size: x- & y-directions
276	xstep = x_size/len(x_bins-1)
277	ystep = y_size/len(y_bins-1)
278
279	self.data.source = Source()
280	self.data.data = numpy.ones(len(mask))
281	self.data.err_data = numpy.ones(len(mask))
282	self.data.qx_data = qx_data
283	self.data.qy_data = qy_data
284	self.data.q_data = q_data
285	self.data.mask = mask
286	self.data.x_bins = x_bins
287	self.data.y_bins = y_bins
288	# max and min taking account of the bin sizes
289	self.data.xmin = xmin
290	self.data.xmax = xmax
291	self.data.ymin = ymin
292	self.data.ymax = ymax
293
294	def on_set_focus(self, event):
295	"""
296	On Set Focus, update guimanger and menu
297	"""
298	if self._manager is not None:
299	wx.PostEvent(self._manager.parent, PanelOnFocusEvent(panel=self))
300	self.on_tap_focus()
301
302	def on_tap_focus(self):
303	"""
304	Update menu1 on cliking the page tap
305	"""
306	if self._manager.menu1 != None:
307	chain_menu = self._manager.menu1.FindItemById(\
308	self._manager.id_reset_flag)
309	chain_menu.Enable(self.batch_on)
310	sim_menu = self._manager.menu1.FindItemById(self._manager.id_simfit)
311	sim_menu.Enable(not self.batch_on and self.data.is_data\
312	and (self.model!=None))
313
314	class ModelTextCtrl(wx.TextCtrl):
315	"""
316	Text control for model and fit parameters.
317	Binds the appropriate events for user interactions.
318	Default callback methods can be overwritten on initialization
319
320	:param kill_focus_callback: callback method for EVT_KILL_FOCUS event
321	:param set_focus_callback: callback method for EVT_SET_FOCUS event
322	:param mouse_up_callback: callback method for EVT_LEFT_UP event
323	:param text_enter_callback: callback method for EVT_TEXT_ENTER event
324
325	"""
326	## Set to True when the mouse is clicked while the whole string is selected
327	full_selection = False
328	## Call back for EVT_SET_FOCUS events
329	_on_set_focus_callback = None
330
331	def __init__(self, parent, id=-1,
332	value=wx.EmptyString,
333	pos=wx.DefaultPosition,
334	size=wx.DefaultSize,
335	style=0,
336	validator=wx.DefaultValidator,
337	name=wx.TextCtrlNameStr,
338	kill_focus_callback=None,
339	set_focus_callback=None,
340	mouse_up_callback=None,
341	text_enter_callback = None):
342
343	wx.TextCtrl.__init__(self, parent, id, value, pos,
344	size, style, validator, name)
345
346	# Bind appropriate events
347	self._on_set_focus_callback = parent.onSetFocus \
348	if set_focus_callback is None else set_focus_callback
349	self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
350	self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus \
351	if kill_focus_callback is None else kill_focus_callback)
352	self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter \
353	if text_enter_callback is None else text_enter_callback)
354	if not ON_MAC :
355	self.Bind(wx.EVT_LEFT_UP, self._highlight_text \
356	if mouse_up_callback is None else mouse_up_callback)
357
358	def _on_set_focus(self, event):
359	"""
360	Catch when the text control is set in focus to highlight the whole
361	text if necessary
362
363	:param event: mouse event
364
365	"""
366	event.Skip()
367	self.full_selection = True
368	return self._on_set_focus_callback(event)
369
370
371
372	def _highlight_text(self, event):
373	"""
374	Highlight text of a TextCtrl only of no text has be selected
375
376	:param event: mouse event
377
378	"""
379	# Make sure the mouse event is available to other listeners
380	event.Skip()
381	control = event.GetEventObject()
382	if self.full_selection:
383	self.full_selection = False
384	# Check that we have a TextCtrl
385	if issubclass(control.__class__, wx.TextCtrl):
386	# Check whether text has been selected,
387	# if not, select the whole string
388	(start, end) = control.GetSelection()
389	if start==end:
390	control.SetSelection(-1,-1)
391
392	def _silent_kill_focus(self,event):
393	"""
394	Save the state of the page
395	"""
396
397	event.Skip()
398	pass
399
400	def set_page_info(self, page_info):
401	"""
402	set some page important information at once
403	"""
404	##window_name
405	self.window_name = page_info.window_name
406	##window_caption
407	self.window_caption = page_info.window_caption
408	## manager is the fitting plugin
409	self._manager= page_info.manager
410	## owner of the page (fitting plugin)
411	self.event_owner= page_info.event_owner
412	## current model
413	self.model = page_info.model
414	## data
415	self.data = page_info.data
416	## dictionary containing list of models
417	self.model_list_box = page_info.model_list_box
418	## Data member to store the dispersion object created
419	self.populate_box(dict=self.model_list_box)
420
421	def onContextMenu(self, event):
422	"""
423	Retrieve the state selected state
424	"""
425	# Skipping the save state functionality for release 0.9.0
426	#return
427
428	pos = event.GetPosition()
429	pos = self.ScreenToClient(pos)
430
431	self.PopupMenu(self.popUpMenu, pos)
432
433
434	def onUndo(self, event):
435	"""
436	Cancel the previous action
437	"""
438	event = PreviousStateEvent(page = self)
439	wx.PostEvent(self.parent, event)
440
441	def onRedo(self, event):
442	"""
443	Restore the previous action cancelled
444	"""
445	event = NextStateEvent(page= self)
446	wx.PostEvent(self.parent, event)
447
448	def define_page_structure(self):
449	"""
450	Create empty sizer for a panel
451	"""
452	self.vbox = wx.BoxSizer(wx.VERTICAL)
453	self.sizer0 = wx.BoxSizer(wx.VERTICAL)
454	self.sizer1 = wx.BoxSizer(wx.VERTICAL)
455	self.sizer2 = wx.BoxSizer(wx.VERTICAL)
456	self.sizer3 = wx.BoxSizer(wx.VERTICAL)
457	self.sizer4 = wx.BoxSizer(wx.VERTICAL)
458	self.sizer5 = wx.BoxSizer(wx.VERTICAL)
459	self.sizer6 = wx.BoxSizer(wx.VERTICAL)
460
461	self.sizer0.SetMinSize((PANEL_WIDTH,-1))
462	self.sizer1.SetMinSize((PANEL_WIDTH,-1))
463	self.sizer2.SetMinSize((PANEL_WIDTH,-1))
464	self.sizer3.SetMinSize((PANEL_WIDTH,-1))
465	self.sizer4.SetMinSize((PANEL_WIDTH,-1))
466	self.sizer5.SetMinSize((PANEL_WIDTH,-1))
467	self.sizer6.SetMinSize((PANEL_WIDTH,-1))
468
469	self.vbox.Add(self.sizer0)
470	self.vbox.Add(self.sizer1)
471	self.vbox.Add(self.sizer2)
472	self.vbox.Add(self.sizer3)
473	self.vbox.Add(self.sizer4)
474	self.vbox.Add(self.sizer5)
475	self.vbox.Add(self.sizer6)
476
477	def set_layout(self):
478	"""
479	layout
480	"""
481	self.vbox.Layout()
482	self.vbox.Fit(self)
483	self.SetSizer(self.vbox)
484	self.Centre()
485
486	def set_owner(self,owner):
487	"""
488	set owner of fitpage
489
490	:param owner: the class responsible of plotting
491
492	"""
493	self.event_owner = owner
494	self.state.event_owner = owner
495
496	def get_state(self):
497	"""
498	"""
499	return self.state
500
501	def get_data(self):
502	"""
503	return the current data
504	"""
505	return self.data
506
507	def get_data_list(self):
508	"""
509	return the current data
510	"""
511	return self.data_list
512
513	def set_manager(self, manager):
514	"""
515	set panel manager
516
517	:param manager: instance of plugin fitting
518
519	"""
520	self._manager = manager
521	self.state.manager = manager
522
523	def populate_box(self, dict):
524	"""
525	Store list of model
526
527	:param dict: dictionary containing list of models
528
529	"""
530	self.model_list_box = dict
531	self.state.model_list_box = self.model_list_box
532	self.initialize_combox()
533
534	def initialize_combox(self):
535	"""
536	put default value in the combobox
537	"""
538	## fill combox box
539	if self.model_list_box is None:
540	return
541	if len(self.model_list_box) > 0:
542	self._populate_box(self.formfactorbox,
543	self.model_list_box["Shapes"])
544
545	if len(self.model_list_box) > 0:
546	self._populate_box(self.structurebox,
547	self.model_list_box["Structure Factors"])
548	self.structurebox.Insert("None", 0, None)
549	self.structurebox.SetSelection(0)
550	self.structurebox.Hide()
551	self.text2.Hide()
552	self.structurebox.Disable()
553	self.text2.Disable()
554
555	if self.model.__class__ in self.model_list_box["P(Q)*S(Q)"]:
556	self.structurebox.Show()
557	self.text2.Show()
558	self.structurebox.Enable()
559	self.text2.Enable()
560
561	def set_dispers_sizer(self):
562	"""
563	fill sizer containing dispersity info
564	"""
565	self.sizer4.Clear(True)
566	name="Polydispersity and Orientational Distribution"
567	box_description= wx.StaticBox(self, -1,name)
568	box_description.SetForegroundColour(wx.BLUE)
569	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
570	#----------------------------------------------------
571	self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10),
572	style=wx.RB_GROUP)
573	self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30))
574	# best size for MAC and PC
575	if ON_MAC:
576	size_q = (30, 20)
577	else:
578	size_q = (20, 15)
579	self.disp_help_bt = wx.Button(self,wx.NewId(),'?',
580	style = wx.BU_EXACTFIT,
581	size=size_q)
582	self.disp_help_bt.Bind(wx.EVT_BUTTON,
583	self.on_pd_help_clicked,id= self.disp_help_bt.GetId())
584	self.disp_help_bt.SetToolTipString("Helps for Polydispersion.")
585
586	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
587	id=self.disable_disp.GetId())
588	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
589	id=self.enable_disp.GetId())
590	#MAC needs SetValue
591	self.disable_disp.SetValue(True)
592	sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
593	sizer_dispersion.Add((20,20))
594	name=""#Polydispersity and \nOrientational Distribution "
595	sizer_dispersion.Add(wx.StaticText(self,-1,name))
596	sizer_dispersion.Add(self.enable_disp )
597	sizer_dispersion.Add((20,20))
598	sizer_dispersion.Add(self.disable_disp )
599	sizer_dispersion.Add((25,20))
600	sizer_dispersion.Add(self.disp_help_bt)
601
602	## fill a sizer for dispersion
603	boxsizer1.Add( sizer_dispersion,0,
604	wx.TOP\|wx.BOTTOM\|wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE,border=5)
605	#boxsizer1.Add( (10,10) )
606	#boxsizer1.Add( sizer_select_dispers )
607	self.sizer4_4 = wx.GridBagSizer(6,5)
608
609	boxsizer1.Add( self.sizer4_4 )
610	#-----------------------------------------------------
611	self.sizer4.Add(boxsizer1,0, wx.EXPAND \| wx.ALL, 10)
612	self.sizer4_4.Layout()
613	self.sizer4.Layout()
614	self.Layout()
615
616	self.Refresh()
617	## saving the state of enable dispersity button
618	self.state.enable_disp= self.enable_disp.GetValue()
619	self.state.disable_disp= self.disable_disp.GetValue()
620	self.SetupScrolling()
621
622
623	def onResetModel(self, event):
624	"""
625	Reset model state
626	"""
627	menu = event.GetEventObject()
628	## post help message for the selected model
629	msg = menu.GetHelpString(event.GetId())
630	msg +=" reloaded"
631	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
632	self.Show(False)
633	name = menu.GetLabel(event.GetId())
634	self._on_select_model_helper()
635	if name in self.saved_states.keys():
636	previous_state = self.saved_states[name]
637	## reset state of checkbox,textcrtl and regular parameters value
638
639	self.reset_page(previous_state)
640	self.Show(True)
641
642	def on_preview(self, event):
643	"""
644	Report the current fit results
645	"""
646	# Get plot image from plotpanel
647	images, canvases = self.get_images()
648	# get the report dialog
649	self.state.report(images, canvases)
650
651
652	def on_save(self, event):
653	"""
654	Save the current state into file
655	"""
656	self.save_current_state()
657	new_state = self.state.clone()
658	# Ask the user the location of the file to write to.
659	path = None
660	if self.parent != None:
661	self._default_save_location = \
662	self.parent.parent._default_save_location
663	dlg = wx.FileDialog(self, "Choose a file", self._default_save_location,
664	self.window_caption, "*.fitv", wx.SAVE)
665
666	if dlg.ShowModal() == wx.ID_OK:
667	path = dlg.GetPath()
668	self._default_save_location = os.path.dirname(path)
669	self.parent.parent._default_save_location =\
670	self._default_save_location
671	else:
672	return None
673	# MAC always needs the extension for saving
674	extens = ".fitv"
675	# Make sure the ext included in the file name
676	fName = os.path.splitext(path)[0] + extens
677	#the manager write the state into file
678	self._manager.save_fit_state(filepath=fName, fitstate=new_state)
679	return new_state
680
681	def on_copy(self, event):
682	"""
683	Copy Parameter values to the clipboad
684	"""
685	if event != None:
686	event.Skip()
687	# It seems MAC needs wxCallAfter
688	wx.CallAfter(self.get_copy)
689
690	# messages depending on the flag
691	#self._copy_info(None)
692
693	def on_paste(self, event):
694	"""
695	Paste Parameter values to the panel if possible
696	"""
697	if event != None:
698	event.Skip()
699	# It seems MAC needs wxCallAfter for the setvalues
700	# for multiple textctrl items, otherwise it tends to crash once a while.
701	wx.CallAfter(self.get_paste)
702	# messages depending on the flag
703	#self._copy_info(True)
704
705	def _copy_info(self, flag):
706	"""
707	Send event dpemding on flag
708
709	: Param flag: flag that distinguish event
710	"""
711	# messages depending on the flag
712	if flag == None:
713	msg = " Parameter values are copied to the clipboard..."
714	infor = 'warning'
715	elif flag:
716	msg = " Parameter values are pasted from the clipboad..."
717	infor = "warning"
718	else:
719	msg = "Error was occured "
720	msg += ": No valid parameter values to paste from the clipboard..."
721	infor = "error"
722	# inform msg to wx
723	wx.PostEvent( self.parent.parent,
724	StatusEvent(status= msg, info=infor))
725
726	def _get_time_stamp(self):
727	"""
728	return time and date stings
729	"""
730	# date and time
731	year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime()
732	current_time= str(hour)+":"+str(minute)+":"+str(second)
733	current_date= str( month)+"/"+str(day)+"/"+str(year)
734	return current_time, current_date
735
736	def on_bookmark(self, event):
737	"""
738	save history of the data and model
739	"""
740	if self.model==None:
741	msg="Can not bookmark; Please select Data and Model first..."
742	wx.MessageBox(msg, 'Info')
743	return
744	self.save_current_state()
745	new_state = self.state.clone()
746	##Add model state on context menu
747	self.number_saved_state += 1
748	current_time, current_date = self._get_time_stamp()
749	#name= self.model.name+"[%g]"%self.number_saved_state
750	name = "Fitting: %g]" % self.number_saved_state
751	name += self.model.__class__.__name__
752	name += "bookmarked at %s on %s" % (current_time, current_date)
753	self.saved_states[name]= new_state
754
755	## Add item in the context menu
756	msg = "Model saved at %s on %s"%(current_time, current_date)
757	## post help message for the selected model
758	msg +=" Saved! right click on this page to retrieve this model"
759	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
760
761	id = wx.NewId()
762	self.popUpMenu.Append(id,name,str(msg))
763	wx.EVT_MENU(self, id, self.onResetModel)
764	wx.PostEvent(self.parent.parent,
765	AppendBookmarkEvent(title=name,
766	hint=str(msg), handler=self._back_to_bookmark))
767	def _back_to_bookmark(self, event):
768	"""
769	Back to bookmark
770	"""
771	self._manager.on_perspective(event)
772	self.onResetModel(event)
773	def old_on_bookmark(self, event):
774	"""
775	save history of the data and model
776	"""
777	if self.model==None:
778	msg="Can not bookmark; Please select Data and Model first..."
779	wx.MessageBox(msg, 'Info')
780	return
781	if hasattr(self,"enable_disp"):
782	self.state.enable_disp = copy.deepcopy(self.enable_disp.GetValue())
783	if hasattr(self, "disp_box"):
784	self.state.disp_box = copy.deepcopy(self.disp_box.GetSelection())
785
786	self.state.model.name= self.model.name
787
788	#Remember fit engine_type for fit panel
789	if self.engine_type == None:
790	self.engine_type = "scipy"
791	if self._manager !=None:
792	self._manager._on_change_engine(engine=self.engine_type)
793
794	self.state.engine_type = self.engine_type
795
796	new_state = self.state.clone()
797	new_state.model.name = self.state.model.name
798
799	new_state.enable2D = copy.deepcopy(self.enable2D)
800	##Add model state on context menu
801	self.number_saved_state += 1
802	#name= self.model.name+"[%g]"%self.number_saved_state
803	name= self.model.__class__.__name__+"[%g]"%self.number_saved_state
804	self.saved_states[name]= new_state
805
806	## Add item in the context menu
807
808	year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime()
809	my_time= str(hour)+" : "+str(minute)+" : "+str(second)+" "
810	date= str( month)+"\|"+str(day)+"\|"+str(year)
811	msg= "Model saved at %s on %s"%(my_time, date)
812	## post help message for the selected model
813	msg +=" Saved! right click on this page to retrieve this model"
814	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
815
816	id = wx.NewId()
817	self.popUpMenu.Append(id,name,str(msg))
818	wx.EVT_MENU(self, id, self.onResetModel)
819
820	def onSetFocus(self, evt):
821	"""
822	highlight the current textcrtl and hide the error text control shown
823	after fitting
824	"""
825	return
826
827	def read_file(self, path):
828	"""
829	Read two columns file
830
831	:param path: the path to the file to read
832
833	"""
834	try:
835	if path==None:
836	wx.PostEvent(self.parent.parent, StatusEvent(status=\
837	" Selected Distribution was not loaded: %s"%path))
838	return None, None
839	input_f = open(path, 'r')
840	buff = input_f.read()
841	lines = buff.split('\n')
842
843	angles = []
844	weights=[]
845	for line in lines:
846	toks = line.split()
847	try:
848	angle = float(toks[0])
849	weight = float(toks[1])
850	except:
851	# Skip non-data lines
852	pass
853	angles.append(angle)
854	weights.append(weight)
855	return numpy.array(angles), numpy.array(weights)
856	except:
857	raise
858
859	def createMemento(self):
860	"""
861	return the current state of the page
862	"""
863	return self.state.clone()
864
865
866	def save_current_state(self):
867	"""
868	Store current state
869	"""
870	self.state.engine_type = copy.deepcopy(self.engine_type)
871	## save model option
872	if self.model!= None:
873	self.disp_list= self.model.getDispParamList()
874	self.state.disp_list= copy.deepcopy(self.disp_list)
875	self.state.model = self.model.clone()
876	#save radiobutton state for model selection
877	self.state.shape_rbutton = self.shape_rbutton.GetValue()
878	self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
879	self.state.struct_rbutton = self.struct_rbutton.GetValue()
880	self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
881	#model combobox
882	self.state.structurebox = self.structurebox.GetSelection()
883	self.state.formfactorbox = self.formfactorbox.GetSelection()
884
885	self.state.enable2D = copy.deepcopy(self.enable2D)
886	self.state.values= copy.deepcopy(self.values)
887	self.state.weights = copy.deepcopy( self.weights)
888	## save data
889	self.state.data= copy.deepcopy(self.data)
890	self.state.qmax_x = self.qmax_x
891	self.state.qmin_x = self.qmin_x
892	self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
893	self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
894	self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
895	self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
896	if hasattr(self,"enable_disp"):
897	self.state.enable_disp= self.enable_disp.GetValue()
898	self.state.disable_disp = self.disable_disp.GetValue()
899
900	self.state.smearer = copy.deepcopy(self.current_smearer)
901	if hasattr(self,"enable_smearer"):
902	self.state.enable_smearer = \
903	copy.deepcopy(self.enable_smearer.GetValue())
904	self.state.disable_smearer = \
905	copy.deepcopy(self.disable_smearer.GetValue())
906
907	self.state.pinhole_smearer = \
908	copy.deepcopy(self.pinhole_smearer.GetValue())
909	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
910
911	if len(self._disp_obj_dict)>0:
912	for k , v in self._disp_obj_dict.iteritems():
913	self.state._disp_obj_dict[k]= v
914
915
916	self.state.values = copy.deepcopy(self.values)
917	self.state.weights = copy.deepcopy(self.weights)
918	## save plotting range
919	self._save_plotting_range()
920
921	self.state.orientation_params = []
922	self.state.orientation_params_disp = []
923	self.state.parameters = []
924	self.state.fittable_param = []
925	self.state.fixed_param = []
926	self.state.str_parameters = []
927
928
929	## save checkbutton state and txtcrtl values
930	self._copy_parameters_state(self.str_parameters,
931	self.state.str_parameters)
932	self._copy_parameters_state(self.orientation_params,
933	self.state.orientation_params)
934	self._copy_parameters_state(self.orientation_params_disp,
935	self.state.orientation_params_disp)
936
937	self._copy_parameters_state(self.parameters, self.state.parameters)
938	self._copy_parameters_state(self.fittable_param,
939	self.state.fittable_param)
940	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
941	#save chisqr
942	self.state.tcChi = self.tcChi.GetValue()
943
944	def save_current_state_fit(self):
945	"""
946	Store current state for fit_page
947	"""
948	## save model option
949	if self.model!= None:
950	self.disp_list= self.model.getDispParamList()
951	self.state.disp_list= copy.deepcopy(self.disp_list)
952	self.state.model = self.model.clone()
953	if hasattr(self, "engine_type"):
954	self.state.engine_type = copy.deepcopy(self.engine_type)
955
956	self.state.enable2D = copy.deepcopy(self.enable2D)
957	self.state.values= copy.deepcopy(self.values)
958	self.state.weights = copy.deepcopy( self.weights)
959	## save data
960	self.state.data= copy.deepcopy(self.data)
961
962	if hasattr(self,"enable_disp"):
963	self.state.enable_disp= self.enable_disp.GetValue()
964	self.state.disable_disp = self.disable_disp.GetValue()
965
966	self.state.smearer = copy.deepcopy(self.current_smearer)
967	if hasattr(self,"enable_smearer"):
968	self.state.enable_smearer = \
969	copy.deepcopy(self.enable_smearer.GetValue())
970	self.state.disable_smearer = \
971	copy.deepcopy(self.disable_smearer.GetValue())
972
973	self.state.pinhole_smearer = \
974	copy.deepcopy(self.pinhole_smearer.GetValue())
975	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
976	self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
977	self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
978	self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
979	self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
980	if hasattr(self,"disp_box"):
981	self.state.disp_box = self.disp_box.GetCurrentSelection()
982
983	if len(self.disp_cb_dict) > 0:
984	for k, v in self.disp_cb_dict.iteritems():
985
986	if v == None :
987	self.state.disp_cb_dict[k] = v
988	else:
989	try:
990	self.state.disp_cb_dict[k] = v.GetValue()
991	except:
992	self.state.disp_cb_dict[k] = None
993
994	if len(self._disp_obj_dict) > 0:
995	for k , v in self._disp_obj_dict.iteritems():
996
997	self.state._disp_obj_dict[k] = v
998
999
1000	self.state.values = copy.deepcopy(self.values)
1001	self.state.weights = copy.deepcopy(self.weights)
1002
1003	## save plotting range
1004	self._save_plotting_range()
1005
1006	## save checkbutton state and txtcrtl values
1007	self._copy_parameters_state(self.orientation_params,
1008	self.state.orientation_params)
1009	self._copy_parameters_state(self.orientation_params_disp,
1010	self.state.orientation_params_disp)
1011	self._copy_parameters_state(self.parameters, self.state.parameters)
1012	self._copy_parameters_state(self.fittable_param,
1013	self.state.fittable_param)
1014	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
1015
1016
1017	def check_invalid_panel(self):
1018	"""
1019	check if the user can already perform some action with this panel
1020	"""
1021	flag = False
1022	if self.data is None:
1023	self.disable_smearer.SetValue(True)
1024	self.disable_disp.SetValue(True)
1025	msg = "Please load Data and select Model to start..."
1026	wx.MessageBox(msg, 'Info')
1027	return True
1028
1029	def set_model_state(self, state):
1030	"""
1031	reset page given a model state
1032	"""
1033	self.disp_cb_dict = state.disp_cb_dict
1034	self.disp_list = state.disp_list
1035
1036	## set the state of the radio box
1037	self.shape_rbutton.SetValue(state.shape_rbutton )
1038	self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton)
1039	self.struct_rbutton.SetValue(state.struct_rbutton)
1040	self.plugin_rbutton.SetValue(state.plugin_rbutton)
1041
1042	## fill model combobox
1043	self._show_combox_helper()
1044	#select the current model
1045	self.formfactorbox.Select(int(state.formfactorcombobox))
1046	self.structurebox.SetSelection(state.structurecombobox )
1047	if state.multi_factor != None:
1048	self.multifactorbox.SetSelection(state.multi_factor)
1049
1050	## reset state of checkbox,textcrtl and regular parameters value
1051	self._reset_parameters_state(self.orientation_params_disp,
1052	state.orientation_params_disp)
1053	self._reset_parameters_state(self.orientation_params,
1054	state.orientation_params)
1055	self._reset_parameters_state(self.str_parameters,
1056	state.str_parameters)
1057	self._reset_parameters_state(self.parameters,state.parameters)
1058	## display dispersion info layer
1059	self.enable_disp.SetValue(state.enable_disp)
1060	self.disable_disp.SetValue(state.disable_disp)
1061
1062	if hasattr(self, "disp_box"):
1063
1064	self.disp_box.SetSelection(state.disp_box)
1065	n= self.disp_box.GetCurrentSelection()
1066	dispersity= self.disp_box.GetClientData(n)
1067	name = dispersity.__name__
1068
1069	self._set_dipers_Param(event=None)
1070
1071	if name == "ArrayDispersion":
1072
1073	for item in self.disp_cb_dict.keys():
1074
1075	if hasattr(self.disp_cb_dict[item], "SetValue") :
1076	self.disp_cb_dict[item].SetValue(\
1077	state.disp_cb_dict[item])
1078	# Create the dispersion objects
1079	from sans.models.dispersion_models import ArrayDispersion
1080	disp_model = ArrayDispersion()
1081	if hasattr(state,"values")and\
1082	self.disp_cb_dict[item].GetValue() == True:
1083	if len(state.values)>0:
1084	self.values=state.values
1085	self.weights=state.weights
1086	disp_model.set_weights(self.values,
1087	state.weights)
1088	else:
1089	self._reset_dispersity()
1090
1091	self._disp_obj_dict[item] = disp_model
1092	# Set the new model as the dispersion object
1093	#for the selected parameter
1094	self.model.set_dispersion(item, disp_model)
1095
1096	self.model._persistency_dict[item] = \
1097	[state.values, state.weights]
1098
1099	else:
1100	keys = self.model.getParamList()
1101	for item in keys:
1102	if item in self.disp_list and \
1103	not self.model.details.has_key(item):
1104	self.model.details[item] = ["", None, None]
1105	for k,v in self.state.disp_cb_dict.iteritems():
1106	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1107	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1108	## smearing info restore
1109	if hasattr(self, "enable_smearer"):
1110	## set smearing value whether or not the data
1111	#contain the smearing info
1112	self.enable_smearer.SetValue(state.enable_smearer)
1113	self.disable_smearer.SetValue(state.disable_smearer)
1114	self.onSmear(event=None)
1115	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1116	self.slit_smearer.SetValue(state.slit_smearer)
1117
1118	self.dI_noweight.SetValue(state.dI_noweight)
1119	self.dI_didata.SetValue(state.dI_didata)
1120	self.dI_sqrdata.SetValue(state.dI_sqrdata)
1121	self.dI_idata.SetValue(state.dI_idata)
1122
1123	## we have two more options for smearing
1124	if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None)
1125	elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None)
1126
1127	## reset state of checkbox,textcrtl and dispersity parameters value
1128	self._reset_parameters_state(self.fittable_param,state.fittable_param)
1129	self._reset_parameters_state(self.fixed_param,state.fixed_param)
1130
1131	## draw the model with previous parameters value
1132	self._onparamEnter_helper()
1133	self.select_param(event=None)
1134	#Save state_fit
1135	self.save_current_state_fit()
1136	self._lay_out()
1137	self.Refresh()
1138
1139	def reset_page_helper(self, state):
1140	"""
1141	Use page_state and change the state of existing page
1142
1143	:precondition: the page is already drawn or created
1144
1145	:postcondition: the state of the underlying data change as well as the
1146	state of the graphic interface
1147	"""
1148	if state == None:
1149	#self._undo.Enable(False)
1150	return
1151	# set data, etc. from the state
1152	# reset page between theory and fitting from bookmarking
1153	#if state.data == None:
1154	# data = None
1155	#else:
1156	data = state.data
1157
1158	#if data != None:
1159
1160	if data == None:
1161	data_min = state.qmin
1162	data_max = state.qmax
1163	self.qmin_x = data_min
1164	self.qmax_x = data_max
1165	#self.minimum_q.SetValue(str(data_min))
1166	#self.maximum_q.SetValue(str(data_max))
1167	self.qmin.SetValue(str(data_min))
1168	self.qmax.SetValue(str(data_max))
1169
1170	self.state.data = data
1171	self.state.qmin = self.qmin_x
1172	self.state.qmax = self.qmax_x
1173	else:
1174	self.set_data(data)
1175
1176	self.enable2D= state.enable2D
1177	self.engine_type = state.engine_type
1178
1179	self.disp_cb_dict = state.disp_cb_dict
1180	self.disp_list = state.disp_list
1181
1182	## set the state of the radio box
1183	self.shape_rbutton.SetValue(state.shape_rbutton )
1184	self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton)
1185	self.struct_rbutton.SetValue(state.struct_rbutton)
1186	self.plugin_rbutton.SetValue(state.plugin_rbutton)
1187
1188	## fill model combobox
1189	self._show_combox_helper()
1190	#select the current model
1191	self.formfactorbox.Select(int(state.formfactorcombobox))
1192	self.structurebox.SetSelection(state.structurecombobox )
1193	if state.multi_factor != None:
1194	self.multifactorbox.SetSelection(state.multi_factor)
1195
1196	#reset the fitting engine type
1197	self.engine_type = state.engine_type
1198	#draw the pnael according to the new model parameter
1199	self._on_select_model(event=None)
1200	# take care of 2D button
1201	if data == None and self.model_view.IsEnabled():
1202	if self.enable2D:
1203	self.model_view.SetLabel("2D Mode")
1204	else:
1205	self.model_view.SetLabel("1D Mode")
1206	# else:
1207
1208	if self._manager !=None:
1209	self._manager._on_change_engine(engine=self.engine_type)
1210	## set the select all check box to the a given state
1211	self.cb1.SetValue(state.cb1)
1212
1213	## reset state of checkbox,textcrtl and regular parameters value
1214	self._reset_parameters_state(self.orientation_params_disp,
1215	state.orientation_params_disp)
1216	self._reset_parameters_state(self.orientation_params,
1217	state.orientation_params)
1218	self._reset_parameters_state(self.str_parameters,
1219	state.str_parameters)
1220	self._reset_parameters_state(self.parameters,state.parameters)
1221	## display dispersion info layer
1222	self.enable_disp.SetValue(state.enable_disp)
1223	self.disable_disp.SetValue(state.disable_disp)
1224	# If the polydispersion is ON
1225	if state.enable_disp:
1226	# reset dispersion according the state
1227	self._set_dipers_Param(event=None)
1228	self._reset_page_disp_helper(state)
1229	##plotting range restore
1230	self._reset_plotting_range(state)
1231	## smearing info restore
1232	if hasattr(self, "enable_smearer"):
1233	## set smearing value whether or not the data
1234	#contain the smearing info
1235	self.enable_smearer.SetValue(state.enable_smearer)
1236	self.disable_smearer.SetValue(state.disable_smearer)
1237	self.onSmear(event=None)
1238	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1239	self.slit_smearer.SetValue(state.slit_smearer)
1240	try:
1241	self.dI_noweight.SetValue(state.dI_noweight)
1242	self.dI_didata.SetValue(state.dI_didata)
1243	self.dI_sqrdata.SetValue(state.dI_sqrdata)
1244	self.dI_idata.SetValue(state.dI_idata)
1245	except:
1246	# to support older state file formats
1247	self.dI_noweight.SetValue(False)
1248	self.dI_didata.SetValue(True)
1249	self.dI_sqrdata.SetValue(False)
1250	self.dI_idata.SetValue(False)
1251
1252	## we have two more options for smearing
1253	if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None)
1254	elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None)
1255
1256	## reset state of checkbox,textcrtl and dispersity parameters value
1257	self._reset_parameters_state(self.fittable_param,state.fittable_param)
1258	self._reset_parameters_state(self.fixed_param,state.fixed_param)
1259
1260	## draw the model with previous parameters value
1261	self._onparamEnter_helper()
1262	#reset the value of chisqr when not consistent with the value computed
1263	self.tcChi.SetValue(str(self.state.tcChi))
1264	## reset context menu items
1265	self._reset_context_menu()
1266
1267	## set the value of the current state to the state given as parameter
1268	self.state = state.clone()
1269
1270	def _reset_page_disp_helper(self, state):
1271	"""
1272	Help to rest page for dispersions
1273	"""
1274	keys = self.model.getParamList()
1275	for item in keys:
1276	if item in self.disp_list and \
1277	not self.model.details.has_key(item):
1278	self.model.details[item] = ["", None, None]
1279	#for k,v in self.state.disp_cb_dict.iteritems():
1280	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1281	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1282	self.values = copy.deepcopy(state.values)
1283	self.weights = copy.deepcopy(state.weights)
1284
1285	for key, disp in state._disp_obj_dict.iteritems():
1286	# From saved file, disp_model can not be sent in model obj.
1287	# it will be sent as a string here, then converted to model object.
1288	if disp.__class__.__name__ == 'str':
1289	com_str = "from sans.models.dispersion_models "
1290	com_str += "import %s as disp_func"
1291	exec com_str % disp
1292	disp_model = disp_func()
1293	else:
1294	disp_model = disp
1295
1296	self._disp_obj_dict[key] = disp_model
1297	param_name = key.split('.')[0]
1298	# Try to set dispersion only when available
1299	# for eg., pass the orient. angles for 1D Cal
1300	try:
1301	self.model.set_dispersion(param_name, disp_model)
1302	self.model._persistency_dict[key] = \
1303	[state.values, state.weights]
1304	except:
1305	pass
1306	selection = self._find_polyfunc_selection(disp_model)
1307	for list in self.fittable_param:
1308	if list[1] == key and list[7] != None:
1309	list[7].SetSelection(selection)
1310	# For the array disp_model, set the values and weights
1311	if selection == 1:
1312	disp_model.set_weights(self.values[key],
1313	self.weights[key])
1314	try:
1315	# Diables all fittable params for array
1316	list[0].SetValue(False)
1317	list[0].Disable()
1318	list[2].Disable()
1319	list[5].Disable()
1320	list[6].Disable()
1321	except:
1322	pass
1323	# For array, disable all fixed params
1324	if selection == 1:
1325	for item in self.fixed_param:
1326	if item[1].split(".")[0] == key.split(".")[0]:
1327	# try it and pass it for the orientation for 1D
1328	try:
1329	item[2].Disable()
1330	except:
1331	pass
1332
1333	# Make sure the check box updated when all checked
1334	if self.cb1.GetValue():
1335	self.select_all_param(None)
1336
1337	def _selectDlg(self):
1338	"""
1339	open a dialog file to selected the customized dispersity
1340	"""
1341	import os
1342	if self.parent != None:
1343	self._default_save_location = \
1344	self.parent.parent._default_save_location
1345	dlg = wx.FileDialog(self, "Choose a weight file",
1346	self._default_save_location , "",
1347	".", wx.OPEN)
1348	path = None
1349	if dlg.ShowModal() == wx.ID_OK:
1350	path = dlg.GetPath()
1351	dlg.Destroy()
1352	return path
1353
1354	def _reset_context_menu(self):
1355	"""
1356	reset the context menu
1357	"""
1358	for name, state in self.state.saved_states.iteritems():
1359	self.number_saved_state += 1
1360	## Add item in the context menu
1361	id = wx.NewId()
1362	msg = 'Save model and state %g' % self.number_saved_state
1363	self.popUpMenu.Append(id, name, msg)
1364	wx.EVT_MENU(self, id, self.onResetModel)
1365
1366	def _reset_plotting_range(self, state):
1367	"""
1368	Reset the plotting range to a given state
1369	"""
1370	# if self.check_invalid_panel():
1371	# return
1372	self.qmin.SetValue(str(state.qmin))
1373	self.qmax.SetValue(str(state.qmax))
1374
1375	def _save_typeOfmodel(self):
1376	"""
1377	save radiobutton containing the type model that can be selected
1378	"""
1379	self.state.shape_rbutton = self.shape_rbutton.GetValue()
1380	self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1381	self.state.struct_rbutton = self.struct_rbutton.GetValue()
1382	self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1383	self.state.structurebox= self.structurebox.GetCurrentSelection()
1384	self.state.formfactorbox = self.formfactorbox.GetCurrentSelection()
1385
1386	#self._undo.Enable(True)
1387	## post state to fit panel
1388	event = PageInfoEvent(page = self)
1389	wx.PostEvent(self.parent, event)
1390
1391	def _save_plotting_range(self ):
1392	"""
1393	save the state of plotting range
1394	"""
1395	self.state.qmin = self.qmin_x
1396	self.state.qmax = self.qmax_x
1397	self.state.npts = self.npts_x
1398
1399	def _onparamEnter_helper(self):
1400	"""
1401	check if values entered by the user are changed and valid to replot
1402	model
1403	"""
1404	# Flag to register when a parameter has changed.
1405	is_modified = False
1406	self.fitrange = True
1407	is_2Ddata = False
1408	#self._undo.Enable(True)
1409	# check if 2d data
1410	if self.data.__class__.__name__ == "Data2D":
1411	is_2Ddata = True
1412	if self.model !=None:
1413	try:
1414	is_modified = self._check_value_enter(self.fittable_param,
1415	is_modified)
1416	is_modified = self._check_value_enter(self.fixed_param,
1417	is_modified)
1418	is_modified = self._check_value_enter(self.parameters,
1419	is_modified)
1420	except:
1421	pass
1422	#if is_modified:
1423
1424	# Here we should check whether the boundaries have been modified.
1425	# If qmin and qmax have been modified, update qmin and qmax and
1426	# set the is_modified flag to True
1427	if self._validate_qrange(self.qmin, self.qmax):
1428	tempmin = float(self.qmin.GetValue())
1429	if tempmin != self.qmin_x:
1430	self.qmin_x = tempmin
1431	is_modified = True
1432	tempmax = float(self.qmax.GetValue())
1433	if tempmax != self.qmax_x:
1434	self.qmax_x = tempmax
1435	is_modified = True
1436
1437	if is_2Ddata:
1438	# set mask
1439	is_modified = self._validate_Npts()
1440
1441	else:
1442	self.fitrange = False
1443
1444	## if any value is modify draw model with new value
1445	if not self.fitrange:
1446	#self.btFit.Disable()
1447	if is_2Ddata: self.btEditMask.Disable()
1448	else:
1449	#self.btFit.Enable(True)
1450	if is_2Ddata: self.btEditMask.Enable(True)
1451	if is_modified and self.fitrange:
1452	#if self.data == None:
1453	# Theory case: need to get npts value to draw
1454	self.npts_x = float(self.Npts_total.GetValue())
1455	self.create_default_data()
1456	self.state_change= True
1457	self._draw_model()
1458	self.Refresh()
1459	return is_modified
1460
1461	def _update_paramv_on_fit(self):
1462	"""
1463	make sure that update param values just before the fitting
1464	"""
1465	#flag for qmin qmax check values
1466	flag = True
1467	self.fitrange = True
1468	is_modified = False
1469
1470	#wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1471	#updating ... ",type="update"))
1472
1473	##So make sure that update param values on_Fit.
1474	#self._undo.Enable(True)
1475	if self.model !=None:
1476	##Check the values
1477	self._check_value_enter( self.fittable_param ,is_modified)
1478	self._check_value_enter( self.fixed_param ,is_modified)
1479	self._check_value_enter( self.parameters ,is_modified)
1480
1481	# If qmin and qmax have been modified, update qmin and qmax and
1482	# Here we should check whether the boundaries have been modified.
1483	# If qmin and qmax have been modified, update qmin and qmax and
1484	# set the is_modified flag to True
1485	self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1486	if self.fitrange:
1487	tempmin = float(self.qmin.GetValue())
1488	if tempmin != self.qmin_x:
1489	self.qmin_x = tempmin
1490	tempmax = float(self.qmax.GetValue())
1491	if tempmax != self.qmax_x:
1492	self.qmax_x = tempmax
1493	if tempmax == tempmin:
1494	flag = False
1495	temp_smearer = None
1496	if not self.disable_smearer.GetValue():
1497	temp_smearer= self.current_smearer
1498	if self.slit_smearer.GetValue():
1499	flag = self.update_slit_smear()
1500	elif self.pinhole_smearer.GetValue():
1501	flag = self.update_pinhole_smear()
1502	else:
1503	self._manager.set_smearer(smearer=temp_smearer,
1504	uid=self.uid,
1505	fid=self.data.id,
1506	qmin=float(self.qmin_x),
1507	qmax=float(self.qmax_x),
1508	enable_smearer=not self.disable_smearer.GetValue(),
1509	draw=False)
1510	elif not self._is_2D():
1511	self._manager.set_smearer(smearer=temp_smearer,
1512	qmin=float(self.qmin_x),
1513	uid=self.uid,
1514	fid=self.data.id,
1515	qmax= float(self.qmax_x),
1516	enable_smearer=not self.disable_smearer.GetValue(),
1517	draw=False)
1518	if self.data != None:
1519	index_data = ((self.qmin_x <= self.data.x)&\
1520	(self.data.x <= self.qmax_x))
1521	val = str(len(self.data.x[index_data==True]))
1522	self.Npts_fit.SetValue(val)
1523	else:
1524	# No data in the panel
1525	try:
1526	self.npts_x = float(self.Npts_total.GetValue())
1527	except:
1528	flag = False
1529	return flag
1530	flag = True
1531	if self._is_2D():
1532	# only 2D case set mask
1533	flag = self._validate_Npts()
1534	if not flag:
1535	return flag
1536	else: flag = False
1537	else:
1538	flag = False
1539
1540	#For invalid q range, disable the mask editor and fit button, vs.
1541	if not self.fitrange:
1542	#self.btFit.Disable()
1543	if self._is_2D():
1544	self.btEditMask.Disable()
1545	else:
1546	#self.btFit.Enable(True)
1547	if self._is_2D() and self.data != None:
1548	self.btEditMask.Enable(True)
1549
1550	if not flag:
1551	msg = "Cannot Plot or Fit :Must select a "
1552	msg += " model or Fitting range is not valid!!! "
1553	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
1554
1555	self.save_current_state()
1556
1557	return flag
1558
1559	def _is_modified(self, is_modified):
1560	"""
1561	return to self._is_modified
1562	"""
1563	return is_modified
1564
1565	def _reset_parameters_state(self, listtorestore, statelist):
1566	"""
1567	Reset the parameters at the given state
1568	"""
1569	if len(statelist) == 0 or len(listtorestore) == 0:
1570	return
1571	if len(statelist) != len(listtorestore):
1572	return
1573
1574	for j in range(len(listtorestore)):
1575	item_page = listtorestore[j]
1576	item_page_info = statelist[j]
1577	##change the state of the check box for simple parameters
1578	if item_page[0]!=None:
1579	item_page[0].SetValue(item_page_info[0])
1580	if item_page[2]!=None:
1581	item_page[2].SetValue(item_page_info[2])
1582	if item_page[2].__class__.__name__ == "ComboBox":
1583	if self.model.fun_list.has_key(item_page_info[2]):
1584	fun_val = self.model.fun_list[item_page_info[2]]
1585	self.model.setParam(item_page_info[1],fun_val)
1586	if item_page[3]!=None:
1587	## show or hide text +/-
1588	if item_page_info[2]:
1589	item_page[3].Show(True)
1590	else:
1591	item_page[3].Hide()
1592	if item_page[4]!=None:
1593	## show of hide the text crtl for fitting error
1594	if item_page_info[4][0]:
1595	item_page[4].Show(True)
1596	item_page[4].SetValue(item_page_info[4][1])
1597	else:
1598	item_page[3].Hide()
1599	if item_page[5]!=None:
1600	## show of hide the text crtl for fitting error
1601	item_page[5].Show(item_page_info[5][0])
1602	item_page[5].SetValue(item_page_info[5][1])
1603
1604	if item_page[6]!=None:
1605	## show of hide the text crtl for fitting error
1606	item_page[6].Show(item_page_info[6][0])
1607	item_page[6].SetValue(item_page_info[6][1])
1608
1609
1610	def _reset_strparam_state(self, listtorestore, statelist):
1611	"""
1612	Reset the string parameters at the given state
1613	"""
1614	if len(statelist) == 0:
1615	return
1616
1617	listtorestore = copy.deepcopy(statelist)
1618
1619	for j in range(len(listtorestore)):
1620	item_page = listtorestore[j]
1621	item_page_info = statelist[j]
1622	##change the state of the check box for simple parameters
1623
1624	if item_page[0] != None:
1625	item_page[0].SetValue(format_number(item_page_info[0], True))
1626
1627	if item_page[2] != None:
1628	param_name = item_page_info[1]
1629	value = item_page_info[2]
1630	selection = value
1631	if self.model.fun_list.has_key(value):
1632	selection = self.model.fun_list[value]
1633	item_page[2].SetValue(selection)
1634	self.model.setParam(param_name, selection)
1635
1636	def _copy_parameters_state(self, listtocopy, statelist):
1637	"""
1638	copy the state of button
1639
1640	:param listtocopy: the list of check button to copy
1641	:param statelist: list of state object to store the current state
1642
1643	"""
1644	if len(listtocopy)==0:
1645	return
1646
1647	for item in listtocopy:
1648
1649	checkbox_state = None
1650	if item[0]!= None:
1651	checkbox_state= item[0].GetValue()
1652	parameter_name = item[1]
1653	parameter_value = None
1654	if item[2]!=None:
1655	parameter_value = item[2].GetValue()
1656	static_text = None
1657	if item[3]!=None:
1658	static_text = item[3].IsShown()
1659	error_value = None
1660	error_state = None
1661	if item[4]!= None:
1662	error_value = item[4].GetValue()
1663	error_state = item[4].IsShown()
1664
1665	min_value = None
1666	min_state = None
1667	if item[5]!= None:
1668	min_value = item[5].GetValue()
1669	min_state = item[5].IsShown()
1670
1671	max_value = None
1672	max_state = None
1673	if item[6]!= None:
1674	max_value = item[6].GetValue()
1675	max_state = item[6].IsShown()
1676	unit=None
1677	if item[7]!=None:
1678	unit = item[7].GetLabel()
1679
1680	statelist.append([checkbox_state, parameter_name, parameter_value,
1681	static_text ,[error_state, error_value],
1682	[min_state, min_value],
1683	[max_state, max_value], unit])
1684
1685	def _set_model_sizer_selection(self, model):
1686	"""
1687	Display the sizer according to the type of the current model
1688	"""
1689	if model == None:
1690	return
1691	if hasattr(model ,"s_model"):
1692
1693	class_name = model.s_model.__class__
1694	name = model.s_model.name
1695	flag = (name != "NoStructure")
1696	if flag and \
1697	(class_name in self.model_list_box["Structure Factors"]):
1698	self.structurebox.Show()
1699	self.text2.Show()
1700	self.structurebox.Enable()
1701	self.text2.Enable()
1702	items = self.structurebox.GetItems()
1703	self.sizer1.Layout()
1704
1705	for i in range(len(items)):
1706	if items[i]== str(name):
1707	self.structurebox.SetSelection(i)
1708	break
1709
1710	if hasattr(model ,"p_model"):
1711	class_name = model.p_model.__class__
1712	name = model.p_model.name
1713	self.formfactorbox.Clear()
1714
1715	for k, list in self.model_list_box.iteritems():
1716	if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
1717	self.shape_rbutton.SetValue(True)
1718	## fill the form factor list with new model
1719	self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
1720	items = self.formfactorbox.GetItems()
1721	## set comboxbox to the selected item
1722	for i in range(len(items)):
1723	if items[i]== str(name):
1724	self.formfactorbox.SetSelection(i)
1725	break
1726	return
1727	elif k == "Shape-Independent":
1728	self.shape_indep_rbutton.SetValue(True)
1729	elif k == "Structure Factors":
1730	self.struct_rbutton.SetValue(True)
1731	elif k == "Multi-Functions":
1732	continue
1733	else:
1734	self.plugin_rbutton.SetValue(True)
1735
1736	if class_name in list:
1737	## fill the form factor list with new model
1738	self._populate_box(self.formfactorbox, list)
1739	items = self.formfactorbox.GetItems()
1740	## set comboxbox to the selected item
1741	for i in range(len(items)):
1742	if items[i]== str(name):
1743	self.formfactorbox.SetSelection(i)
1744	break
1745	break
1746	else:
1747
1748	## Select the model from the menu
1749	class_name = model.__class__
1750	name = model.name
1751	self.formfactorbox.Clear()
1752	items = self.formfactorbox.GetItems()
1753
1754	for k, list in self.model_list_box.iteritems():
1755	if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
1756	if class_name in self.model_list_box["P(Q)*S(Q)"]:
1757	self.structurebox.Show()
1758	self.text2.Show()
1759	self.structurebox.Enable()
1760	self.structurebox.SetSelection(0)
1761	self.text2.Enable()
1762	else:
1763	self.structurebox.Hide()
1764	self.text2.Hide()
1765	self.structurebox.Disable()
1766	self.structurebox.SetSelection(0)
1767	self.text2.Disable()
1768
1769	self.shape_rbutton.SetValue(True)
1770	## fill the form factor list with new model
1771	self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
1772	items = self.formfactorbox.GetItems()
1773	## set comboxbox to the selected item
1774	for i in range(len(items)):
1775	if items[i]== str(name):
1776	self.formfactorbox.SetSelection(i)
1777	break
1778	return
1779	elif k == "Shape-Independent":
1780	self.shape_indep_rbutton.SetValue(True)
1781	elif k == "Structure Factors":
1782	self.struct_rbutton.SetValue(True)
1783	elif k == "Multi-Functions":
1784	continue
1785	else:
1786	self.plugin_rbutton.SetValue(True)
1787	if class_name in list:
1788	self.structurebox.SetSelection(0)
1789	self.structurebox.Disable()
1790	self.text2.Disable()
1791	## fill the form factor list with new model
1792	self._populate_box(self.formfactorbox, list)
1793	items = self.formfactorbox.GetItems()
1794	## set comboxbox to the selected item
1795	for i in range(len(items)):
1796	if items[i]== str(name):
1797	self.formfactorbox.SetSelection(i)
1798	break
1799	break
1800
1801	def _draw_model(self, update_chisqr=True, source='model'):
1802	"""
1803	Method to draw or refresh a plotted model.
1804	The method will use the data member from the model page
1805	to build a call to the fitting perspective manager.
1806
1807	:param chisqr: update chisqr value [bool]
1808	"""
1809	#if self.check_invalid_panel():
1810	# return
1811	if self.model !=None:
1812	temp_smear=None
1813	if hasattr(self, "enable_smearer"):
1814	if not self.disable_smearer.GetValue():
1815	temp_smear= self.current_smearer
1816	# compute weight for the current data
1817	from .utils import get_weight
1818	flag = self.get_weight_flag()
1819	weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1820	toggle_mode_on = self.model_view.IsEnabled()
1821	is_2d = self._is_2D()
1822	self._manager.draw_model(self.model,
1823	data=self.data,
1824	smearer= temp_smear,
1825	qmin=float(self.qmin_x),
1826	qmax=float(self.qmax_x),
1827	page_id=self.uid,
1828	toggle_mode_on=toggle_mode_on,
1829	state = self.state,
1830	enable2D=is_2d,
1831	update_chisqr=update_chisqr,
1832	source='model',
1833	weight=weight)
1834
1835
1836	def _on_show_sld(self, event=None):
1837	"""
1838	Plot SLD profile
1839	"""
1840	# get profile data
1841	x,y=self.model.getProfile()
1842
1843	from danse.common.plottools import Data1D
1844	#from sans.perspectives.theory.profile_dialog import SLDPanel
1845	from sans.guiframe.local_perspectives.plotting.profile_dialog \
1846	import SLDPanel
1847	sld_data = Data1D(x,y)
1848	sld_data.name = 'SLD'
1849	sld_data.axes = self.sld_axes
1850	self.panel = SLDPanel(self, data=sld_data, axes =self.sld_axes,id =-1)
1851	self.panel.ShowModal()
1852
1853	def _set_multfactor_combobox(self, multiplicity=10):
1854	"""
1855	Set comboBox for muitfactor of CoreMultiShellModel
1856	:param multiplicit: no. of multi-functionality
1857	"""
1858	# build content of the combobox
1859	for idx in range(0,multiplicity):
1860	self.multifactorbox.Append(str(idx),int(idx))
1861	#self.multifactorbox.SetSelection(1)
1862	self._hide_multfactor_combobox()
1863
1864	def _show_multfactor_combobox(self):
1865	"""
1866	Show the comboBox of muitfactor of CoreMultiShellModel
1867	"""
1868	if not self.mutifactor_text.IsShown():
1869	self.mutifactor_text.Show(True)
1870	self.mutifactor_text1.Show(True)
1871	if not self.multifactorbox.IsShown():
1872	self.multifactorbox.Show(True)
1873
1874	def _hide_multfactor_combobox(self):
1875	"""
1876	Hide the comboBox of muitfactor of CoreMultiShellModel
1877	"""
1878	if self.mutifactor_text.IsShown():
1879	self.mutifactor_text.Hide()
1880	self.mutifactor_text1.Hide()
1881	if self.multifactorbox.IsShown():
1882	self.multifactorbox.Hide()
1883
1884
1885	def _show_combox_helper(self):
1886	"""
1887	Fill panel's combo box according to the type of model selected
1888	"""
1889	if self.shape_rbutton.GetValue():
1890	##fill the combobox with form factor list
1891	self.structurebox.SetSelection(0)
1892	self.structurebox.Disable()
1893	self.formfactorbox.Clear()
1894	self._populate_box( self.formfactorbox,self.model_list_box["Shapes"])
1895	if self.shape_indep_rbutton.GetValue():
1896	##fill the combobox with shape independent factor list
1897	self.structurebox.SetSelection(0)
1898	self.structurebox.Disable()
1899	self.formfactorbox.Clear()
1900	self._populate_box( self.formfactorbox,
1901	self.model_list_box["Shape-Independent"])
1902	if self.struct_rbutton.GetValue():
1903	##fill the combobox with structure factor list
1904	self.structurebox.SetSelection(0)
1905	self.structurebox.Disable()
1906	self.formfactorbox.Clear()
1907	self._populate_box( self.formfactorbox,
1908	self.model_list_box["Structure Factors"])
1909	if self.plugin_rbutton.GetValue():
1910	##fill the combobox with form factor list
1911	self.structurebox.Disable()
1912	self.formfactorbox.Clear()
1913	self._populate_box( self.formfactorbox,
1914	self.model_list_box["Customized Models"])
1915
1916	def _show_combox(self, event=None):
1917	"""
1918	Show combox box associate with type of model selected
1919	"""
1920	#if self.check_invalid_panel():
1921	# self.shape_rbutton.SetValue(True)
1922	# return
1923
1924	self._show_combox_helper()
1925	self._on_select_model(event=None)
1926	self._save_typeOfmodel()
1927	self.sizer4_4.Layout()
1928	self.sizer4.Layout()
1929	self.Layout()
1930	self.Refresh()
1931
1932	def _populate_box(self, combobox, list):
1933	"""
1934	fill combox box with dict item
1935
1936	:param list: contains item to fill the combox
1937	item must model class
1938	"""
1939	for models in list:
1940	model= models()
1941	name = model.__class__.__name__
1942	if models.__name__!="NoStructure":
1943	if hasattr(model, "name"):
1944	name = model.name
1945	combobox.Append(name,models)
1946	return 0
1947
1948	def _onQrangeEnter(self, event):
1949	"""
1950	Check validity of value enter in the Q range field
1951
1952	"""
1953	tcrtl = event.GetEventObject()
1954	#Clear msg if previously shown.
1955	msg = ""
1956	wx.PostEvent(self.parent, StatusEvent(status=msg))
1957	# Flag to register when a parameter has changed.
1958	is_modified = False
1959	if tcrtl.GetValue().lstrip().rstrip() != "":
1960	try:
1961	value = float(tcrtl.GetValue())
1962	tcrtl.SetBackgroundColour(wx.WHITE)
1963	# If qmin and qmax have been modified, update qmin and qmax
1964	if self._validate_qrange(self.qmin, self.qmax):
1965	tempmin = float(self.qmin.GetValue())
1966	if tempmin != self.qmin_x:
1967	self.qmin_x = tempmin
1968	tempmax = float(self.qmax.GetValue())
1969	if tempmax != self.qmax_x:
1970	self.qmax_x = tempmax
1971	else:
1972	tcrtl.SetBackgroundColour("pink")
1973	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1974	wx.PostEvent(self.parent, StatusEvent(status=msg))
1975	return
1976	except:
1977	tcrtl.SetBackgroundColour("pink")
1978	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1979	wx.PostEvent(self.parent, StatusEvent(status=msg))
1980	return
1981	#Check if # of points for theory model are valid(>0).
1982	if self.npts != None:
1983	if check_float(self.npts):
1984	temp_npts = float(self.npts.GetValue())
1985	if temp_npts != self.num_points:
1986	self.num_points = temp_npts
1987	is_modified = True
1988	else:
1989	msg = "Cannot Plot :No npts in that Qrange!!! "
1990	wx.PostEvent(self.parent, StatusEvent(status=msg))
1991	else:
1992	tcrtl.SetBackgroundColour("pink")
1993	msg = "Model Error:wrong value entered!!!"
1994	wx.PostEvent(self.parent, StatusEvent(status=msg))
1995	#self._undo.Enable(True)
1996	self.save_current_state()
1997	event = PageInfoEvent(page=self)
1998	wx.PostEvent(self.parent, event)
1999	self.state_change = False
2000	#Draw the model for a different range
2001	self.create_default_data()
2002	self._draw_model()
2003
2004	def _theory_qrange_enter(self, event):
2005	"""
2006	Check validity of value enter in the Q range field
2007	"""
2008
2009	tcrtl= event.GetEventObject()
2010	#Clear msg if previously shown.
2011	msg= ""
2012	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2013	# Flag to register when a parameter has changed.
2014	is_modified = False
2015	if tcrtl.GetValue().lstrip().rstrip()!="":
2016	try:
2017	value = float(tcrtl.GetValue())
2018	tcrtl.SetBackgroundColour(wx.WHITE)
2019
2020	# If qmin and qmax have been modified, update qmin and qmax
2021	if self._validate_qrange(self.theory_qmin, self.theory_qmax):
2022	tempmin = float(self.theory_qmin.GetValue())
2023	if tempmin != self.theory_qmin_x:
2024	self.theory_qmin_x = tempmin
2025	tempmax = float(self.theory_qmax.GetValue())
2026	if tempmax != self.qmax_x:
2027	self.theory_qmax_x = tempmax
2028	else:
2029	tcrtl.SetBackgroundColour("pink")
2030	msg= "Model Error:wrong value entered : %s"% sys.exc_value
2031	wx.PostEvent(self._manager.parent, StatusEvent(status = msg ))
2032	return
2033	except:
2034	tcrtl.SetBackgroundColour("pink")
2035	msg= "Model Error:wrong value entered : %s"% sys.exc_value
2036	wx.PostEvent(self._manager.parent, StatusEvent(status = msg ))
2037	return
2038	#Check if # of points for theory model are valid(>0).
2039	if self.Npts_total.IsEditable() :
2040	if check_float(self.Npts_total):
2041	temp_npts = float(self.Npts_total.GetValue())
2042	if temp_npts != self.num_points:
2043	self.num_points = temp_npts
2044	is_modified = True
2045	else:
2046	msg= "Cannot Plot :No npts in that Qrange!!! "
2047	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2048	else:
2049	tcrtl.SetBackgroundColour("pink")
2050	msg = "Model Error:wrong value entered!!!"
2051	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
2052	#self._undo.Enable(True)
2053	self.save_current_state()
2054	event = PageInfoEvent(page = self)
2055	wx.PostEvent(self.parent, event)
2056	self.state_change= False
2057	#Draw the model for a different range
2058	self.create_default_data()
2059	self._draw_model()
2060
2061	def _on_select_model_helper(self):
2062	"""
2063	call back for model selection
2064	"""
2065	## reset dictionary containing reference to dispersion
2066	self._disp_obj_dict = {}
2067	self.disp_cb_dict ={}
2068	self.temp_multi_functional = False
2069	f_id = self.formfactorbox.GetCurrentSelection()
2070	#For MAC
2071	form_factor = None
2072	if f_id >= 0:
2073	form_factor = self.formfactorbox.GetClientData(f_id)
2074
2075	if not form_factor in self.model_list_box["multiplication"]:
2076	self.structurebox.Hide()
2077	self.text2.Hide()
2078	self.structurebox.Disable()
2079	self.structurebox.SetSelection(0)
2080	self.text2.Disable()
2081	else:
2082	self.structurebox.Show()
2083	self.text2.Show()
2084	self.structurebox.Enable()
2085	self.text2.Enable()
2086
2087	if form_factor != None:
2088	# set multifactor for Mutifunctional models
2089	if form_factor().__class__ in self.model_list_box["Multi-Functions"]:
2090	m_id = self.multifactorbox.GetCurrentSelection()
2091	multiplicity = form_factor().multiplicity_info[0]
2092	self.multifactorbox.Clear()
2093	#self.mutifactor_text.SetLabel(form_factor().details[])
2094	self._set_multfactor_combobox(multiplicity)
2095	self._show_multfactor_combobox()
2096	#ToDo: this info should be called directly from the model
2097	text = form_factor().multiplicity_info[1]#'No. of Shells: '
2098
2099	#self.mutifactor_text.Clear()
2100	self.mutifactor_text.SetLabel(text)
2101	if m_id > multiplicity -1:
2102	# default value
2103	m_id = 1
2104
2105	self.multi_factor = self.multifactorbox.GetClientData(m_id)
2106	if self.multi_factor == None: self.multi_factor =0
2107	form_factor = form_factor(int(self.multi_factor))
2108	self.multifactorbox.SetSelection(m_id)
2109	# Check len of the text1 and max_multiplicity
2110	text = ''
2111	if form_factor.multiplicity_info[0] == len(form_factor.multiplicity_info[2]):
2112	text = form_factor.multiplicity_info[2][self.multi_factor]
2113	self.mutifactor_text1.SetLabel(text)
2114	# Check if model has get sld profile.
2115	if len(form_factor.multiplicity_info[3]) > 0:
2116	self.sld_axes = form_factor.multiplicity_info[3]
2117	self.show_sld_button.Show(True)
2118	else:
2119	self.sld_axes = ""
2120
2121	else:
2122	self._hide_multfactor_combobox()
2123	self.show_sld_button.Hide()
2124	form_factor = form_factor()
2125	self.multi_factor = None
2126	else:
2127	self._hide_multfactor_combobox()
2128	self.show_sld_button.Hide()
2129	self.multi_factor = None
2130
2131	s_id = self.structurebox.GetCurrentSelection()
2132	struct_factor = self.structurebox.GetClientData( s_id )
2133
2134	if struct_factor !=None:
2135	from sans.models.MultiplicationModel import MultiplicationModel
2136	self.model= MultiplicationModel(form_factor,struct_factor())
2137	# multifunctional form factor
2138	if len(form_factor.non_fittable) > 0:
2139	self.temp_multi_functional = True
2140	else:
2141	if form_factor != None:
2142	self.model= form_factor
2143	else:
2144	self.model = None
2145	return self.model
2146
2147	## post state to fit panel
2148	self.state.parameters =[]
2149	self.state.model =self.model
2150	self.state.qmin = self.qmin_x
2151	self.state.multi_factor = self.multi_factor
2152	self.disp_list =self.model.getDispParamList()
2153	self.state.disp_list = self.disp_list
2154	self.on_set_focus(None)
2155	self.Layout()
2156
2157	def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2158	"""
2159	Verify that the Q range controls have valid values
2160	and that Qmin < Qmax.
2161
2162	:param qmin_ctrl: text control for Qmin
2163	:param qmax_ctrl: text control for Qmax
2164
2165	:return: True is the Q range is value, False otherwise
2166
2167	"""
2168	qmin_validity = check_float(qmin_ctrl)
2169	qmax_validity = check_float(qmax_ctrl)
2170	if not (qmin_validity and qmax_validity):
2171	return False
2172	else:
2173	qmin = float(qmin_ctrl.GetValue())
2174	qmax = float(qmax_ctrl.GetValue())
2175	if qmin < qmax:
2176	#Make sure to set both colours white.
2177	qmin_ctrl.SetBackgroundColour(wx.WHITE)
2178	qmin_ctrl.Refresh()
2179	qmax_ctrl.SetBackgroundColour(wx.WHITE)
2180	qmax_ctrl.Refresh()
2181	else:
2182	qmin_ctrl.SetBackgroundColour("pink")
2183	qmin_ctrl.Refresh()
2184	qmax_ctrl.SetBackgroundColour("pink")
2185	qmax_ctrl.Refresh()
2186	msg= "Invalid Q range: Q min must be smaller than Q max"
2187	wx.PostEvent(self.parent.parent, StatusEvent(status = msg))
2188	return False
2189	return True
2190
2191	def _validate_Npts(self):
2192	"""
2193	Validate the number of points for fitting is more than 10 points.
2194	If valid, setvalues Npts_fit otherwise post msg.
2195	"""
2196	#default flag
2197	flag = True
2198	# Theory
2199	if self.data == None and self.enable2D:
2200	return flag
2201
2202	# q value from qx and qy
2203	radius= numpy.sqrt( self.data.qx_data * self.data.qx_data +
2204	self.data.qy_data * self.data.qy_data )
2205	#get unmasked index
2206	index_data = (float(self.qmin.GetValue()) <= radius) & \
2207	(radius <= float(self.qmax.GetValue()))
2208	index_data = (index_data) & (self.data.mask)
2209	index_data = (index_data) & (numpy.isfinite(self.data.data))
2210
2211	if len(index_data[index_data]) < 10:
2212	# change the color pink.
2213	self.qmin.SetBackgroundColour("pink")
2214	self.qmin.Refresh()
2215	self.qmax.SetBackgroundColour("pink")
2216	self.qmax.Refresh()
2217	msg= "Cannot Plot :No or too little npts in that data range!!! "
2218	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2219	self.fitrange = False
2220	flag = False
2221	else:
2222	self.Npts_fit.SetValue(str(len(self.data.mask[index_data==True])))
2223	self.fitrange = True
2224
2225	return flag
2226
2227	def _check_value_enter(self, list, modified):
2228	"""
2229	:param list: model parameter and panel info
2230	:Note: each item of the list should be as follow:
2231	item=[check button state, parameter's name,
2232	paramater's value, string="+/-",
2233	parameter's error of fit,
2234	parameter's minimum value,
2235	parrameter's maximum value ,
2236	parameter's units]
2237	"""
2238	is_modified = modified
2239	if len(list)==0:
2240	return is_modified
2241	for item in list:
2242	#skip angle parameters for 1D
2243	if not self.enable2D:#self.data.__class__.__name__ !="Data2D":
2244	if item in self.orientation_params:
2245	continue
2246	#try:
2247	name = str(item[1])
2248
2249	if string.find(name,".npts") ==-1 and \
2250	string.find(name,".nsigmas")==-1:
2251	## check model parameters range
2252	param_min= None
2253	param_max= None
2254
2255	## check minimun value
2256	if item[5]!= None and item[5]!= "":
2257	if item[5].GetValue().lstrip().rstrip()!="":
2258	try:
2259
2260	param_min = float(item[5].GetValue())
2261	if not self._validate_qrange(item[5],item[2]):
2262	if numpy.isfinite(param_min):
2263	item[2].SetValue(format_number(param_min))
2264
2265	item[5].SetBackgroundColour(wx.WHITE)
2266	item[2].SetBackgroundColour(wx.WHITE)
2267
2268	except:
2269	msg = "Wrong Fit parameter range entered "
2270	wx.PostEvent(self.parent.parent,
2271	StatusEvent(status = msg))
2272	raise ValueError, msg
2273	is_modified = True
2274	## check maximum value
2275	if item[6]!= None and item[6]!= "":
2276	if item[6].GetValue().lstrip().rstrip()!="":
2277	try:
2278	param_max = float(item[6].GetValue())
2279	if not self._validate_qrange(item[2],item[6]):
2280	if numpy.isfinite(param_max):
2281	item[2].SetValue(format_number(param_max))
2282
2283	item[6].SetBackgroundColour(wx.WHITE)
2284	item[2].SetBackgroundColour(wx.WHITE)
2285	except:
2286	msg = "Wrong Fit parameter range entered "
2287	wx.PostEvent(self.parent.parent,
2288	StatusEvent(status = msg))
2289	raise ValueError, msg
2290	is_modified = True
2291
2292
2293	if param_min != None and param_max !=None:
2294	if not self._validate_qrange(item[5], item[6]):
2295	msg= "Wrong Fit range entered for parameter "
2296	msg+= "name %s of model %s "%(name, self.model.name)
2297	wx.PostEvent(self.parent.parent,
2298	StatusEvent(status = msg))
2299
2300	if name in self.model.details.keys():
2301	self.model.details[name][1:3] = param_min, param_max
2302	is_modified = True
2303
2304	else:
2305	self.model.details [name] = ["", param_min, param_max]
2306	is_modified = True
2307	try:
2308	# Check if the textctr is enabled
2309	if item[2].IsEnabled():
2310	value= float(item[2].GetValue())
2311	item[2].SetBackgroundColour("white")
2312	# If the value of the parameter has changed,
2313	# +update the model and set the is_modified flag
2314	if value != self.model.getParam(name) and \
2315	numpy.isfinite(value):
2316	self.model.setParam(name, value)
2317
2318	except:
2319	item[2].SetBackgroundColour("pink")
2320	msg = "Wrong Fit parameter value entered "
2321	wx.PostEvent(self.parent.parent, StatusEvent(status = msg))
2322
2323	return is_modified
2324
2325
2326	def _set_dipers_Param(self, event):
2327	"""
2328	respond to self.enable_disp and self.disable_disp radio box.
2329	The dispersity object is reset inside the model into Gaussian.
2330	When the user select yes , this method display a combo box for more selection
2331	when the user selects No,the combo box disappears.
2332	Redraw the model with the default dispersity (Gaussian)
2333	"""
2334	#if self.check_invalid_panel():
2335	# return
2336	## On selction if no model exists.
2337	if self.model ==None:
2338	self.disable_disp.SetValue(True)
2339	msg="Please select a Model first..."
2340	wx.MessageBox(msg, 'Info')
2341	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2342	"Polydispersion: %s"%msg))
2343	return
2344
2345	self._reset_dispersity()
2346
2347	if self.model ==None:
2348	self.model_disp.Hide()
2349	self.sizer4_4.Clear(True)
2350	return
2351
2352	if self.enable_disp.GetValue():
2353	## layout for model containing no dispersity parameters
2354
2355	self.disp_list= self.model.getDispParamList()
2356
2357	if len(self.disp_list)==0 and len(self.disp_cb_dict)==0:
2358	self._layout_sizer_noDipers()
2359	else:
2360	## set gaussian sizer
2361	self._on_select_Disp(event=None)
2362	else:
2363	self.sizer4_4.Clear(True)
2364
2365	## post state to fit panel
2366	self.save_current_state()
2367	if event !=None:
2368	#self._undo.Enable(True)
2369	event = PageInfoEvent(page = self)
2370	wx.PostEvent(self.parent, event)
2371	#draw the model with the current dispersity
2372	self._draw_model()
2373	self.sizer4_4.Layout()
2374	self.sizer5.Layout()
2375	self.Layout()
2376	self.Refresh()
2377
2378
2379	def _layout_sizer_noDipers(self):
2380	"""
2381	Draw a sizer with no dispersity info
2382	"""
2383	ix=0
2384	iy=1
2385	self.fittable_param=[]
2386	self.fixed_param=[]
2387	self.orientation_params_disp=[]
2388
2389	self.sizer4_4.Clear(True)
2390	text = "No polydispersity available for this model"
2391	text = "No polydispersity available for this model"
2392	model_disp = wx.StaticText(self, -1, text)
2393	self.sizer4_4.Add(model_disp,( iy, ix),(1,1),
2394	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 10)
2395	self.sizer4_4.Layout()
2396	self.sizer4.Layout()
2397
2398	def _reset_dispersity(self):
2399	"""
2400	put gaussian dispersity into current model
2401	"""
2402	if len(self.param_toFit)>0:
2403	for item in self.fittable_param:
2404	if item in self.param_toFit:
2405	self.param_toFit.remove(item)
2406
2407	for item in self.orientation_params_disp:
2408	if item in self.param_toFit:
2409	self.param_toFit.remove(item)
2410
2411	self.fittable_param=[]
2412	self.fixed_param=[]
2413	self.orientation_params_disp=[]
2414	self.values={}
2415	self.weights={}
2416
2417	from sans.models.dispersion_models import GaussianDispersion, ArrayDispersion
2418	if len(self.disp_cb_dict)==0:
2419	self.save_current_state()
2420	self.sizer4_4.Clear(True)
2421	self.Layout()
2422
2423	return
2424	if (len(self.disp_cb_dict)>0) :
2425	for p in self.disp_cb_dict:
2426	# The parameter was un-selected. Go back to Gaussian model (with 0 pts)
2427	disp_model = GaussianDispersion()
2428
2429	self._disp_obj_dict[p] = disp_model
2430	# Set the new model as the dispersion object for the selected parameter
2431	try:
2432	self.model.set_dispersion(p, disp_model)
2433	except:
2434
2435	pass
2436
2437	## save state into
2438	self.save_current_state()
2439	self.Layout()
2440	self.Refresh()
2441
2442	def _on_select_Disp(self,event):
2443	"""
2444	allow selecting different dispersion
2445	self.disp_list should change type later .now only gaussian
2446	"""
2447	self._set_sizer_dispersion()
2448
2449	## Redraw the model
2450	self._draw_model()
2451	#self._undo.Enable(True)
2452	event = PageInfoEvent(page = self)
2453	wx.PostEvent(self.parent, event)
2454
2455	self.sizer4_4.Layout()
2456	self.sizer4.Layout()
2457	self.SetupScrolling()
2458
2459	def _on_disp_func(self, event=None):
2460	"""
2461	Select a distribution function for the polydispersion
2462
2463	:Param event: ComboBox event
2464	"""
2465	# get ready for new event
2466	if event != None:
2467	event.Skip()
2468	# Get event object
2469	disp_box = event.GetEventObject()
2470
2471	# Try to select a Distr. function
2472	try:
2473	disp_box.SetBackgroundColour("white")
2474	selection = disp_box.GetCurrentSelection()
2475	param_name = disp_box.Name.split('.')[0]
2476	disp_name = disp_box.GetValue()
2477	dispersity= disp_box.GetClientData(selection)
2478
2479	#disp_model = GaussianDispersion()
2480	disp_model = dispersity()
2481	# Get param names to reset the values of the param
2482	name1 = param_name + ".width"
2483	name2 = param_name + ".npts"
2484	name3 = param_name + ".nsigmas"
2485	# Check Disp. function whether or not it is 'array'
2486	if disp_name.lower() == "array":
2487	value2= ""
2488	value3= ""
2489	value1 = self._set_array_disp(name=name1, disp=disp_model)
2490	else:
2491	self._del_array_values(name1)
2492	#self._reset_array_disp(param_name)
2493	self._disp_obj_dict[name1] = disp_model
2494	self.model.set_dispersion(param_name, disp_model)
2495	self.state._disp_obj_dict[name1]= disp_model
2496
2497	value1= str(format_number(self.model.getParam(name1), True))
2498	value2= str(format_number(self.model.getParam(name2)))
2499	value3= str(format_number(self.model.getParam(name3)))
2500	# Reset fittable polydispersin parameter value
2501	for item in self.fittable_param:
2502	if item[1] == name1:
2503	item[2].SetValue(value1)
2504	item[5].SetValue("")
2505	item[6].SetValue("")
2506	# Disable for array
2507	if disp_name.lower() == "array":
2508	item[0].SetValue(False)
2509	item[0].Disable()
2510	item[2].Disable()
2511	item[3].Show(False)
2512	item[4].Show(False)
2513	item[5].Disable()
2514	item[6].Disable()
2515	else:
2516	item[0].Enable()
2517	item[2].Enable()
2518	item[5].Enable()
2519	item[6].Enable()
2520	break
2521	# Reset fixed polydispersion params
2522	for item in self.fixed_param:
2523	if item[1] == name2:
2524	item[2].SetValue(value2)
2525	# Disable Npts for array
2526	if disp_name.lower() == "array":
2527	item[2].Disable()
2528	else:
2529	item[2].Enable()
2530	if item[1] == name3:
2531	item[2].SetValue(value3)
2532	# Disable Nsigs for array
2533	if disp_name.lower() == "array":
2534	item[2].Disable()
2535	else:
2536	item[2].Enable()
2537
2538	# Make sure the check box updated when all checked
2539	if self.cb1.GetValue():
2540	#self.select_all_param(None)
2541	self.get_all_checked_params()
2542
2543	# update params
2544	self._update_paramv_on_fit()
2545	# draw
2546	self._draw_model()
2547	self.Refresh()
2548	except:
2549	# Error msg
2550	msg = "Error occurred:"
2551	msg += " Could not select the distribution function..."
2552	msg += " Please select another distribution function."
2553	disp_box.SetBackgroundColour("pink")
2554	# Focus on Fit button so that users can see the pinky box
2555	self.btFit.SetFocus()
2556	wx.PostEvent(self.parent.parent,
2557	StatusEvent(status=msg, info="error"))
2558
2559
2560	def _set_array_disp(self, name=None, disp=None):
2561	"""
2562	Set array dispersion
2563
2564	:param name: name of the parameter for the dispersion to be set
2565	:param disp: the polydisperion object
2566	"""
2567	# The user wants this parameter to be averaged.
2568	# Pop up the file selection dialog.
2569	path = self._selectDlg()
2570	# Array data
2571	values = []
2572	weights = []
2573	# If nothing was selected, just return
2574	if path is None:
2575	self.disp_cb_dict[name].SetValue(False)
2576	#self.noDisper_rbox.SetValue(True)
2577	return
2578	self._default_save_location = os.path.dirname(path)
2579	if self.parent != None:
2580	self.parent.parent._default_save_location =\
2581	self._default_save_location
2582
2583	basename = os.path.basename(path)
2584	values,weights = self.read_file(path)
2585
2586	# If any of the two arrays is empty, notify the user that we won't
2587	# proceed
2588	if len(self.param_toFit)>0:
2589	if name in self.param_toFit:
2590	self.param_toFit.remove(name)
2591
2592	# Tell the user that we are about to apply the distribution
2593	msg = "Applying loaded %s distribution: %s" % (name, path)
2594	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
2595
2596	disp.set_weights(values, weights)
2597	self._disp_obj_dict[name] = disp
2598	self.model.set_dispersion(name.split('.')[0], disp)
2599	self.state._disp_obj_dict[name]= disp
2600	self.values[name] = values
2601	self.weights[name] = weights
2602	# Store the object to make it persist outside the
2603	# scope of this method
2604	#TODO: refactor model to clean this up?
2605	self.state.values = {}
2606	self.state.weights = {}
2607	self.state.values = copy.deepcopy(self.values)
2608	self.state.weights = copy.deepcopy(self.weights)
2609
2610	# Set the new model as the dispersion object for the
2611	#selected parameter
2612	#self.model.set_dispersion(p, disp_model)
2613	# Store a reference to the weights in the model object
2614	#so that
2615	# it's not lost when we use the model within another thread.
2616	#TODO: total hack - fix this
2617	self.state.model= self.model.clone()
2618	self.model._persistency_dict[name.split('.')[0]] = \
2619	[values, weights]
2620	self.state.model._persistency_dict[name.split('.')[0]] = \
2621	[values,weights]
2622	return basename
2623
2624	def _del_array_values(self, name=None):
2625	"""
2626	Reset array dispersion
2627
2628	:param name: name of the parameter for the dispersion to be set
2629	"""
2630	# Try to delete values and weight of the names array dic if exists
2631	try:
2632	del self.values[name]
2633	del self.weights[name]
2634	# delete all other dic
2635	del self.state.values[name]
2636	del self.state.weights[name]
2637	del self.model._persistency_dict[name.split('.')[0]]
2638	del self.state.model._persistency_dict[name.split('.')[0]]
2639	except:
2640	pass
2641
2642	def _lay_out(self):
2643	"""
2644	returns self.Layout
2645
2646	:Note: Mac seems to like this better when self.
2647	Layout is called after fitting.
2648	"""
2649	self._sleep4sec()
2650	self.Layout()
2651	return
2652
2653	def _sleep4sec(self):
2654	"""
2655	sleep for 1 sec only applied on Mac
2656	Note: This 1sec helps for Mac not to crash on self.:ayout after self._draw_model
2657	"""
2658	if ON_MAC == True:
2659	time.sleep(1)
2660
2661	def _find_polyfunc_selection(self, disp_func = None):
2662	"""
2663	FInd Comboox selection from disp_func
2664
2665	:param disp_function: dispersion distr. function
2666	"""
2667	# List of the poly_model name in the combobox
2668	list = ["RectangleDispersion", "ArrayDispersion",
2669	"LogNormalDispersion", "GaussianDispersion",
2670	"SchulzDispersion"]
2671
2672	# Find the selection
2673	try:
2674	selection = list.index(disp_func.__class__.__name__)
2675	return selection
2676	except:
2677	return 3
2678
2679	def on_reset_clicked(self,event):
2680	"""
2681	On 'Reset' button for Q range clicked
2682	"""
2683	flag = True
2684	#if self.check_invalid_panel():
2685	# return
2686	##For 3 different cases: Data2D, Data1D, and theory
2687	if self.model == None:
2688	msg="Please select a model first..."
2689	wx.MessageBox(msg, 'Info')
2690	flag = False
2691	return
2692
2693	elif self.data.__class__.__name__ == "Data2D":
2694	data_min= 0
2695	x= max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2696	y= max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2697	self.qmin_x = data_min
2698	self.qmax_x = math.sqrt(xx + yy)
2699	#self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
2700	# check smearing
2701	if not self.disable_smearer.GetValue():
2702	temp_smearer= self.current_smearer
2703	## set smearing value whether or not the data contain the smearing info
2704	if self.pinhole_smearer.GetValue():
2705	flag = self.update_pinhole_smear()
2706	else:
2707	flag = True
2708
2709	elif self.data == None:
2710	self.qmin_x = _QMIN_DEFAULT
2711	self.qmax_x = _QMAX_DEFAULT
2712	self.num_points = _NPTS_DEFAULT
2713	self.state.npts = self.num_points
2714
2715	elif self.data.__class__.__name__ != "Data2D":
2716	self.qmin_x = min(self.data.x)
2717	self.qmax_x = max(self.data.x)
2718	# check smearing
2719	if not self.disable_smearer.GetValue():
2720	temp_smearer= self.current_smearer
2721	## set smearing value whether or not the data contain the smearing info
2722	if self.slit_smearer.GetValue():
2723	flag = self.update_slit_smear()
2724	elif self.pinhole_smearer.GetValue():
2725	flag = self.update_pinhole_smear()
2726	else:
2727	flag = True
2728	else:
2729	flag = False
2730
2731	if flag == False:
2732	msg= "Cannot Plot :Must enter a number!!! "
2733	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2734	else:
2735	# set relative text ctrs.
2736	self.qmin.SetValue(str(self.qmin_x))
2737	self.qmax.SetValue(str(self.qmax_x))
2738	self.set_npts2fit()
2739	# At this point, some button and variables satatus (disabled?) should be checked
2740	# such as color that should be reset to white in case that it was pink.
2741	self._onparamEnter_helper()
2742
2743	self.save_current_state()
2744	self.state.qmin = self.qmin_x
2745	self.state.qmax = self.qmax_x
2746
2747	#reset the q range values
2748	self._reset_plotting_range(self.state)
2749	#self.compute_chisqr(smearer=self.current_smearer)
2750	#Re draw plot
2751	self._draw_model()
2752
2753	def get_images(self):
2754	"""
2755	Get the images of the plots corresponding this panel for report
2756
2757	: return graphs: list of figures
2758	: TODO: Move to guiframe
2759	"""
2760	# set list of graphs
2761	graphs = []
2762	canvases = []
2763	# call gui_manager
2764	gui_manager = self.parent.parent
2765	# loops through the panels [dic]
2766	for item1, item2 in gui_manager.plot_panels.iteritems():
2767	data_title = self.data.group_id
2768	data_name = str(self.data.name).split(" [")[0]
2769	# try to get all plots belonging to this control panel
2770	try:
2771	title = ''
2772	# check titles (main plot)
2773	if hasattr(item2,"data2D"):
2774	title = item2.data2D.title
2775	# and data_names (model plot[2D], and residuals)
2776	if item2.group_id == data_title or \
2777	item2.group_id.count("res" + str(self.graph_id)) or \
2778	item2.group_id.count(str(self.uid)) > 0:
2779	#panel = gui_manager._mgr.GetPane(item2.window_name)
2780	# append to the list
2781	graphs.append(item2.figure)
2782	canvases.append(item2.canvas)
2783	except:
2784	# Not for control panels
2785	pass
2786	# return the list of graphs
2787	return graphs, canvases
2788
2789	def on_model_help_clicked(self,event):
2790	"""
2791	on 'More details' button
2792	"""
2793	from help_panel import HelpWindow
2794	from sans.models import get_data_path
2795
2796	# Get models help model_function path
2797	path = get_data_path(media='media')
2798	model_path = os.path.join(path,"model_functions.html")
2799	if self.model == None:
2800	name = 'FuncHelp'
2801	else:
2802	name = self.formfactorbox.GetValue()
2803	#name = self.model.__class__.__name__
2804	frame = HelpWindow(None, -1, pageToOpen=model_path)
2805	frame.Show(True)
2806	if frame.rhelp.HasAnchor(name):
2807	frame.rhelp.ScrollToAnchor(name)
2808	else:
2809	msg= "Model does not contains an available description "
2810	msg +="Please try searching in the Help window"
2811	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2812
2813	def on_pd_help_clicked(self, event):
2814	"""
2815	Button event for PD help
2816	"""
2817	from help_panel import HelpWindow
2818	import sans.models as models
2819
2820	# Get models help model_function path
2821	path = models.get_data_path(media='media')
2822	pd_path = os.path.join(path,"pd_help.html")
2823
2824	frame = HelpWindow(None, -1, pageToOpen=pd_path)
2825	frame.Show(True)
2826
2827	def on_left_down(self, event):
2828	"""
2829	Get key stroke event
2830	"""
2831	# Figuring out key combo: Cmd for copy, Alt for paste
2832	if event.CmdDown() and event.ShiftDown():
2833	flag = self.get_paste()
2834	elif event.CmdDown():
2835	flag = self.get_copy()
2836	else:
2837	event.Skip()
2838	return
2839	# make event free
2840	event.Skip()
2841
2842	def get_copy(self):
2843	"""
2844	Get copy params to clipboard
2845	"""
2846	content = self.get_copy_params()
2847	flag = self.set_clipboard(content)
2848	self._copy_info(flag)
2849	return flag
2850
2851	def get_copy_params(self):
2852	"""
2853	Get the string copies of the param names and values in the tap
2854	"""
2855	content = 'sansview_parameter_values:'
2856	# Do it if params exist
2857	if self.parameters !=[]:
2858
2859	# go through the parameters
2860	string = self._get_copy_helper(self.parameters,
2861	self.orientation_params)
2862	content += string
2863
2864	# go through the fittables
2865	string = self._get_copy_helper(self.fittable_param,
2866	self.orientation_params_disp)
2867	content += string
2868
2869	# go through the fixed params
2870	string = self._get_copy_helper(self.fixed_param,
2871	self.orientation_params_disp)
2872	content += string
2873
2874	# go through the str params
2875	string = self._get_copy_helper(self.str_parameters,
2876	self.orientation_params)
2877	content += string
2878	return content
2879	else:
2880	return False
2881
2882	def set_clipboard(self, content=None):
2883	"""
2884	Put the string to the clipboard
2885	"""
2886	if not content:
2887	return False
2888	if wx.TheClipboard.Open():
2889	wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
2890	data = wx.TextDataObject()
2891	success = wx.TheClipboard.GetData(data)
2892	text = data.GetText()
2893	wx.TheClipboard.Close()
2894	return True
2895	return None
2896
2897	def _get_copy_helper(self, param, orient_param):
2898	"""
2899	Helping get value and name of the params
2900
2901	: param param: parameters
2902	: param orient_param = oritational params
2903	: return content: strings [list] [name,value:....]
2904	"""
2905	content = ''
2906	# go through the str params
2907	for item in param:
2908	disfunc = ''
2909	try:
2910	if item[7].__class__.__name__ == 'ComboBox':
2911	disfunc = str(item[7].GetValue())
2912	except:
2913	pass
2914
2915	# 2D
2916	if self.data.__class__.__name__== "Data2D":
2917	try:
2918	check = item[0].GetValue()
2919	except:
2920	check = None
2921	name = item[1]
2922	value = item[2].GetValue()
2923	# 1D
2924	else:
2925	## for 1D all parameters except orientation
2926	if not item[1] in orient_param:
2927	try:
2928	check = item[0].GetValue()
2929	except:
2930	check = None
2931	name = item[1]
2932	value = item[2].GetValue()
2933
2934	# add to the content
2935	if disfunc != '':
2936
2937	disfunc = ',' + disfunc
2938	# TODO: to support array func for copy/paste
2939	try:
2940	if disfunc.count('array') > 0:
2941	disfunc += ','
2942	for val in self.values[name]:
2943	disfunc += ' ' + str(val)
2944	disfunc += ','
2945	for weight in self.weights[name]:
2946	disfunc += ' ' + str(weight)
2947	except:
2948	pass
2949	#if disfunc.count('array') == 0:
2950	content += name + ',' + str(check) + ',' + value + disfunc + ':'
2951
2952	return content
2953
2954	def get_clipboard(self):
2955	"""
2956	Get strings in the clipboard
2957	"""
2958	text = ""
2959	# Get text from the clip board
2960	if wx.TheClipboard.Open():
2961	if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
2962	data = wx.TextDataObject()
2963	# get wx dataobject
2964	success = wx.TheClipboard.GetData(data)
2965	# get text
2966	text = data.GetText()
2967	# close clipboard
2968	wx.TheClipboard.Close()
2969
2970	return text
2971
2972	def get_paste(self):
2973	"""
2974	Paste params from the clipboard
2975	"""
2976	text = self.get_clipboard()
2977	flag = self.get_paste_params(text)
2978	self._copy_info(flag)
2979	return flag
2980
2981	def get_paste_params(self, text=''):
2982	"""
2983	Get the string copies of the param names and values in the tap
2984	"""
2985	context = {}
2986	# put the text into dictionary
2987	lines = text.split(':')
2988	if lines[0] != 'sansview_parameter_values':
2989	self._copy_info(False)
2990	return False
2991	for line in lines[1:-1]:
2992	if len(line) != 0:
2993	item =line.split(',')
2994	check = item[1]
2995	name = item[0]
2996	value = item[2]
2997	# Transfer the text to content[dictionary]
2998	context[name] = [check, value]
2999	# ToDo: PlugIn this poly disp function for pasting
3000	try:
3001	poly_func = item[3]
3002	context[name].append(poly_func)
3003	try:
3004	# take the vals and weights for array
3005	array_values = item[4].split(' ')
3006	array_weights = item[5].split(' ')
3007	val = [float(a_val) for a_val in array_values[1:]]
3008	weit = [float(a_weit) for a_weit in array_weights[1:]]
3009
3010	context[name].append(val)
3011	context[name].append(weit)
3012	except:
3013	raise
3014	except:
3015	poly_func = ''
3016	context[name].append(poly_func)
3017
3018	# Do it if params exist
3019	if self.parameters != []:
3020	# go through the parameters
3021	self._get_paste_helper(self.parameters,
3022	self.orientation_params, context)
3023
3024	# go through the fittables
3025	self._get_paste_helper(self.fittable_param,
3026	self.orientation_params_disp,
3027	context)
3028
3029	# go through the fixed params
3030	self._get_paste_helper(self.fixed_param,
3031	self.orientation_params_disp, context)
3032
3033	# go through the str params
3034	self._get_paste_helper(self.str_parameters,
3035	self.orientation_params, context)
3036	return True
3037	return None
3038
3039	def _get_paste_helper(self, param, orient_param, content):
3040	"""
3041	Helping set values of the params
3042
3043	: param param: parameters
3044	: param orient_param: oritational params
3045	: param content: dictionary [ name, value: name1.value1,...]
3046	"""
3047	# go through the str params
3048	for item in param:
3049	# 2D
3050	if self.data.__class__.__name__== "Data2D":
3051	name = item[1]
3052	if name in content.keys():
3053	check = content[name][0]
3054	pd = content[name][1]
3055	if name.count('.') > 0:
3056	try:
3057	float(pd)
3058	except:
3059	#continue
3060	if not pd and pd != '':
3061	continue
3062	item[2].SetValue(str(pd))
3063	if item in self.fixed_param and pd == '':
3064	# Only array func has pd == '' case.
3065	item[2].Enable(False)
3066	if item[2].__class__.__name__ == "ComboBox":
3067	if self.model.fun_list.has_key(content[name][1]):
3068	fun_val = self.model.fun_list[content[name][1]]
3069	self.model.setParam(name,fun_val)
3070
3071	value = content[name][1:]
3072	self._paste_poly_help(item, value)
3073	if check == 'True':
3074	is_true = True
3075	elif check == 'False':
3076	is_true = False
3077	else:
3078	is_true = None
3079	if is_true != None:
3080	item[0].SetValue(is_true)
3081	# 1D
3082	else:
3083	## for 1D all parameters except orientation
3084	if not item[1] in orient_param:
3085	name = item[1]
3086	if name in content.keys():
3087	check = content[name][0]
3088	# Avoid changing combox content which needs special care
3089	value = content[name][1:]
3090	pd = value[0]
3091	if name.count('.') > 0:
3092	try:
3093	pd = float(pd)
3094	except:
3095	#continue
3096	if not pd and pd != '':
3097	continue
3098	item[2].SetValue(str(pd))
3099	if item in self.fixed_param and pd == '':
3100	# Only array func has pd == '' case.
3101	item[2].Enable(False)
3102	if item[2].__class__.__name__ == "ComboBox":
3103	if self.model.fun_list.has_key(value[0]):
3104	fun_val = self.model.fun_list[value[0]]
3105	self.model.setParam(name,fun_val)
3106	# save state
3107	#self._copy_parameters_state(self.str_parameters,
3108	# self.state.str_parameters)
3109	self._paste_poly_help(item, value)
3110	if check == 'True':
3111	is_true = True
3112	elif check == 'False':
3113	is_true = False
3114	else:
3115	is_true = None
3116	if is_true != None:
3117	item[0].SetValue(is_true)
3118
3119	def _paste_poly_help(self, item, value):
3120	"""
3121	Helps get paste for poly function
3122
3123	:param item: Gui param items
3124	:param value: the values for parameter ctrols
3125	"""
3126	if len(value[1]) > 0:
3127	# Only for dispersion func.s
3128	try:
3129	item[7].SetValue(value[1])
3130	selection = item[7].GetCurrentSelection()
3131	name = item[7].Name
3132	param_name = name.split('.')[0]
3133	disp_name = item[7].GetValue()
3134	dispersity= item[7].GetClientData(selection)
3135	disp_model = dispersity()
3136	# Only for array disp
3137	try:
3138	pd_vals = numpy.array(value[2])
3139	pd_weights = numpy.array(value[3])
3140	if len(pd_vals) > 0 and len(pd_vals) > 0:
3141	if len(pd_vals) == len(pd_weights):
3142	disp_model.set_weights(pd_vals,
3143	pd_weights)
3144	self.values[name] = pd_vals
3145	self.weights[name] = pd_weights
3146	# disable the fixed items for array
3147	item[0].SetValue(False)
3148	item[0].Enable(False)
3149	item[2].Enable(False)
3150	item[3].Show(False)
3151	item[4].Show(False)
3152	item[5].SetValue('')
3153	item[5].Enable(False)
3154	item[6].SetValue('')
3155	item[6].Enable(False)
3156	except:
3157	pass
3158	self._disp_obj_dict[name] = disp_model
3159	self.model.set_dispersion(name,
3160	disp_model)
3161	self.state._disp_obj_dict[name] = \
3162	disp_model
3163	self.model.set_dispersion(param_name, disp_model)
3164	state.values = self.values
3165	state.weights = self.weights
3166	self.model._persistency_dict[param_name] = \
3167	[state.values, state.weights]
3168
3169
3170	except:
3171	pass

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

SasView

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

Download in other formats: