basepage.py @ 05fb6d12

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

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

SasView

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

Download in other formats: