basepage.py @ 9c9fae1

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 9c9fae1 was 9c9fae1, checked in by Tim Snow <tim.snow@…>, 7 years ago

Threaded plot drawing

However, need a status update as it looks like the plot has hung

Property mode set to 100644

File size: 142.5 KB

Line
1	"""
2	Base Page for fitting
3	"""
4	import sys
5	import os
6	import wx
7	import numpy as np
8	import time
9	import copy
10	import math
11	import json
12	import logging
13	import traceback
14
15	from Queue import Queue
16	from threading import Thread
17
18	from collections import defaultdict
19	from wx.lib.scrolledpanel import ScrolledPanel
20
21	from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
22
23	from sas.sasgui.guiframe.panel_base import PanelBase
24	from sas.sasgui.guiframe.utils import format_number, check_float, IdList, \
25	check_int
26	from sas.sasgui.guiframe.events import PanelOnFocusEvent
27	from sas.sasgui.guiframe.events import StatusEvent
28	from sas.sasgui.guiframe.events import AppendBookmarkEvent
29	from sas.sasgui.guiframe.dataFitting import Data2D
30	from sas.sasgui.guiframe.dataFitting import Data1D
31	from sas.sasgui.guiframe.dataFitting import check_data_validity
32	from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
33	from sas.sascalc.dataloader.data_info import Detector
34	from sas.sascalc.dataloader.data_info import Source
35	from sas.sasgui.perspectives.fitting.pagestate import PageState
36	from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
37	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
38
39	logger = logging.getLogger(__name__)
40
41	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
42	(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent()
43	(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent()
44
45	_BOX_WIDTH = 76
46	_QMIN_DEFAULT = 0.0005
47	_QMAX_DEFAULT = 0.5
48	_NPTS_DEFAULT = 50
49	# Control panel width
50	if sys.platform.count("win32") > 0:
51	PANEL_WIDTH = 450
52	FONT_VARIANT = 0
53	ON_MAC = False
54	else:
55	PANEL_WIDTH = 500
56	FONT_VARIANT = 1
57	ON_MAC = True
58
59	CUSTOM_MODEL = 'Plugin Models'
60
61	class BasicPage(ScrolledPanel, PanelBase):
62	"""
63	This class provide general structure of the fitpanel page
64	"""
65	# Internal name for the AUI manager
66	window_name = "Fit Page"
67	# Title to appear on top of the window
68	window_caption = "Fit Page "
69
70	# These two buttons have specific IDs since they seem to be created more
71	# frequently than they need to. In particular, set_dispers_sizer() is
72	# called by _on_select_model
73	ID_BOOKMARK = wx.NewId()
74	ID_DISPERSER_HELP = wx.NewId()
75	_id_pool = IdList()
76
77	def __init__(self, parent, color='blue', **kwargs):
78	"""
79	"""
80	ScrolledPanel.__init__(self, parent, **kwargs)
81	PanelBase.__init__(self, parent)
82	self.SetupScrolling()
83	# Set window's font size
84	self.SetWindowVariant(variant=FONT_VARIANT)
85	self.SetBackgroundColour(color)
86
87	self._ids = iter(self._id_pool)
88	# parent of the page
89	self.parent = parent
90	# manager is the fitting plugin
91	# owner of the page (fitting plugin)
92	self.event_owner = None
93	# current model
94	self.model = None
95	self.m_name = None
96	self.index_model = None
97	self.panel = None
98	# data
99	self.data = None
100	# list of available data
101	self.data_list = []
102	self.mask = None
103	self.uid = wx.NewId()
104	self.graph_id = None
105	# Q range for data set
106	self.qmin_data_set = np.inf
107	self.qmax_data_set = None
108	self.npts_data_set = 0
109	# Q range
110	self.qmin = None
111	self.qmax = None
112	self.qmax_x = _QMAX_DEFAULT
113	self.qmin_x = _QMIN_DEFAULT
114	self.npts_x = _NPTS_DEFAULT
115	# total number of point: float
116	self.npts = None
117	self.num_points = None
118	# smear default
119	self.current_smearer = None
120	# 2D smear accuracy default
121	self.smear2d_accuracy = 'Low'
122	# slit smear:
123	self.dxl = None
124	self.dxw = None
125	# pinhole smear
126	self.dx_percent = None
127	# smear attrbs
128	self.enable_smearer = None
129	self.disable_smearer = None
130	self.pinhole_smearer = None
131	self.slit_smearer = None
132	# weight attrbs
133	self.dI_noweight = None
134	self.dI_didata = None
135	self.dI_sqrdata = None
136	self.dI_idata = None
137	# other attrbs
138	self.dq_l = None
139	self.dq_r = None
140	self.tcChi = None
141	self.disp_box = None
142	self.model_disp = None
143	self.Npts_fit = None
144	self.Npts_total = None
145	self.theory_qmin = None
146	self.theory_qmax = None
147	self.theory_qmin_x = None
148	self.theory_qmax_x = None
149	self.btEditMask = None
150	self.btFit = None
151	self.sld_axes = None
152	self.multi_factor = None
153
154	self.disp_cb_dict = {}
155
156	# self.state = PageState(parent=parent)
157	# dictionary containing list of models
158	self.model_list_box = {}
159
160	# Data member to store the dispersion object created
161	self._disp_obj_dict = {}
162	# selected parameters to apply dispersion
163	self.disp_cb_dict = {}
164	# smearer object
165	self.enable2D = False
166	self._has_magnetic = False
167	self.magnetic_on = False
168	self.is_mac = ON_MAC
169	self.formfactorbox = None
170	self.structurebox = None
171	self.categorybox = None
172	# list of model parameters. each item must have same length
173	# each item related to a given parameters
174	# [cb state, name, value, "+/-", error of fit, min, max , units]
175	self.parameters = []
176	# non-fittable parameter whose value is astring
177	self.str_parameters = []
178	# list of parameters to fit , must be like self.parameters
179	self.param_toFit = []
180	# list of looking like parameters but with non fittable parameters info
181	self.fixed_param = []
182	# list of looking like parameters but with fittable parameters info
183	self.fittable_param = []
184	# list of dispersion parameters
185	self.disp_list = []
186	self.disp_name = ""
187
188	# list of orientation parameters
189	self.orientation_params = []
190	self.orientation_params_disp = []
191	# Self.model should ALWAYS be None here. It was set to none above in
192	# this long init setting. no obvious function call in between setting
193	# and this - commenting out on 4/8/2014 by PDB. Remove once clear
194	# it is pointless.
195	# if self.model is not None:
196	# self.disp_list = self.model.getDispParamList()
197	self.temp_multi_functional = False
198	# enable model 2D draw
199	self.enable2D = False
200	# check that the fit range is correct to plot the model again
201	self.fitrange = True
202	# Create memento to save the current state
203	self.state = PageState(parent=self.parent,
204	model=self.model, data=self.data)
205	# flag to determine if state has change
206	self.state_change = False
207	# save customized array
208	self.values = {} # type: Dict[str, List[float, ...]]
209	self.weights = {} # type: Dict[str, List[float, ...]]
210	# retrieve saved state
211	self.number_saved_state = 0
212	# dictionary of saved state
213	self.saved_states = {}
214	# Create context menu for page
215	self.popUpMenu = wx.Menu()
216
217	wx_id = self._ids.next()
218	self._keep = wx.MenuItem(self.popUpMenu, wx_id, "Add bookmark",
219	" Keep the panel status to recall it later")
220	self.popUpMenu.AppendItem(self._keep)
221	self._keep.Enable(False)
222	self._set_bookmark_flag(False)
223	self._set_save_flag(False)
224	wx.EVT_MENU(self, wx_id, self.on_bookmark)
225	self.popUpMenu.AppendSeparator()
226
227	# Default locations
228	self._default_save_location = os.getcwd()
229	# save initial state on context menu
230	# self.onSave(event=None)
231	self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
232
233	# bind key event
234	self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
235
236	# create the basic structure of the panel with empty sizer
237	self.define_page_structure()
238	# drawing Initial dispersion parameters sizer
239	self.set_dispers_sizer()
240
241	# layout
242	self.set_layout()
243
244	# Putting matplotlib in the background so as not to hang the interface
245	self.threadedDrawQueue = Queue()
246
247	self.threadedDrawWorker = Thread(target = self._threaded_draw_worker, args = (self.threadedDrawQueue,))
248	self.threadedDrawWorker.setDaemon(True)
249	self.threadedDrawWorker.start()
250
251
252	def set_index_model(self, index):
253	"""
254	Index related to this page
255	"""
256	self.index_model = index
257
258	def create_default_data(self):
259	"""
260	Given the user selection, creates a 1D or 2D data
261	Only when the page is on theory mode.
262	"""
263	if not hasattr(self, "model_view"):
264	return
265	toggle_mode_on = self.model_view.IsEnabled()
266	if toggle_mode_on:
267	if self.enable2D and not check_data_validity(self.data):
268	self._create_default_2d_data()
269	else:
270	if self.pointsbox.GetValue():
271	self._create_log_1d_data()
272	else:
273	self._create_default_1d_data()
274
275	if self.model is not None:
276	if not self.data.is_data:
277	self._manager.page_finder[self.uid].set_fit_data(
278	data=[self.data])
279	self.on_smear_helper(update=True)
280	self.state.enable_smearer = self.enable_smearer.GetValue()
281	self.state.disable_smearer = self.disable_smearer.GetValue()
282	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
283	self.state.slit_smearer = self.slit_smearer.GetValue()
284
285	def _create_default_1d_data(self):
286	"""
287	Create default data for fitting perspective
288	Only when the page is on theory mode.
289	:warning: This data is never plotted.
290
291	"""
292	x = np.linspace(start=self.qmin_x, stop=self.qmax_x,
293	num=self.npts_x, endpoint=True)
294	self.data = Data1D(x=x)
295	self.data.xaxis('\\rm{Q}', "A^{-1}")
296	self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
297	self.data.is_data = False
298	self.data.id = str(self.uid) + " data"
299	self.data.group_id = str(self.uid) + " Model1D"
300
301	def _create_log_1d_data(self):
302	"""
303	Create log-spaced data for fitting perspective
304	Only when the page is on theory mode.
305	:warning: This data is never plotted.
306
307	"""
308	if self.qmin_x >= 1.e-10:
309	qmin = np.log10(self.qmin_x)
310	else:
311	qmin = -10.
312
313	if self.qmax_x <= 1.e10:
314	qmax = np.log10(self.qmax_x)
315	else:
316	qmax = 10.
317
318	x = np.logspace(start=qmin, stop=qmax,
319	num=self.npts_x, endpoint=True, base=10.0)
320	self.data = Data1D(x=x)
321	self.data.xaxis('\\rm{Q}', "A^{-1}")
322	self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
323	self.data.is_data = False
324	self.data.id = str(self.uid) + " data"
325	self.data.group_id = str(self.uid) + " Model1D"
326
327	def _create_default_2d_data(self):
328	"""
329	Create 2D data by default
330	Only when the page is on theory mode.
331	:warning: This data is never plotted.
332	"""
333	self.data = Data2D()
334	qmax = self.qmax_x / math.sqrt(2)
335	self.data.xaxis('\\rm{Q_{x}}', 'A^{-1}')
336	self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}')
337	self.data.is_data = False
338	self.data.id = str(self.uid) + " data"
339	self.data.group_id = str(self.uid) + " Model2D"
340	# Default values
341	self.data.detector.append(Detector())
342	index = len(self.data.detector) - 1
343	self.data.detector[index].distance = 8000 # mm
344	self.data.source.wavelength = 6 # A
345	self.data.detector[index].pixel_size.x = 5 # mm
346	self.data.detector[index].pixel_size.y = 5 # mm
347	self.data.detector[index].beam_center.x = qmax
348	self.data.detector[index].beam_center.y = qmax
349	xmax = qmax
350	xmin = -qmax
351	ymax = qmax
352	ymin = -qmax
353	qstep = self.npts_x
354
355	x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
356	y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
357	# use data info instead
358	new_x = np.tile(x, (len(y), 1))
359	new_y = np.tile(y, (len(x), 1))
360	new_y = new_y.swapaxes(0, 1)
361	# all data reuire now in 1d array
362	qx_data = new_x.flatten()
363	qy_data = new_y.flatten()
364	q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
365	# set all True (standing for unmasked) as default
366	mask = np.ones(len(qx_data), dtype=bool)
367	# store x and y bin centers in q space
368	x_bins = x
369	y_bins = y
370
371	self.data.source = Source()
372	self.data.data = np.ones(len(mask))
373	self.data.err_data = np.ones(len(mask))
374	self.data.qx_data = qx_data
375	self.data.qy_data = qy_data
376	self.data.q_data = q_data
377	self.data.mask = mask
378	self.data.x_bins = x_bins
379	self.data.y_bins = y_bins
380	# max and min taking account of the bin sizes
381	self.data.xmin = xmin
382	self.data.xmax = xmax
383	self.data.ymin = ymin
384	self.data.ymax = ymax
385
386	def on_set_focus(self, event):
387	"""
388	On Set Focus, update guimanger and menu
389	"""
390	if self._manager is not None:
391	wx.PostEvent(self._manager.parent, PanelOnFocusEvent(panel=self))
392	self.on_tap_focus()
393
394	def on_tap_focus(self):
395	"""
396	Update menu1 on cliking the page tap
397	"""
398	if self._manager.menu1 is not None:
399	chain_menu = self._manager.menu1.FindItemById(
400	self._manager.id_reset_flag)
401	chain_menu.Enable(self.batch_on)
402	sim_menu = self._manager.menu1.FindItemById(self._manager.id_simfit)
403	flag = self.data.is_data\
404	and (self.model is not None)
405	sim_menu.Enable(not self.batch_on and flag)
406	batch_menu = \
407	self._manager.menu1.FindItemById(self._manager.id_batchfit)
408	batch_menu.Enable(self.batch_on and flag)
409
410	def onContextMenu(self, event):
411	"""
412	Retrieve the state selected state
413	"""
414	pos = event.GetPosition()
415	pos = self.ScreenToClient(pos)
416	self.PopupMenu(self.popUpMenu, pos)
417
418	def onUndo(self, event):
419	"""
420	Cancel the previous action
421	"""
422	event = PreviousStateEvent(page=self)
423	wx.PostEvent(self.parent, event)
424
425	def onRedo(self, event):
426	"""
427	Restore the previous action cancelled
428	"""
429	event = NextStateEvent(page=self)
430	wx.PostEvent(self.parent, event)
431
432	def define_page_structure(self):
433	"""
434	Create empty sizer for a panel
435	"""
436	self.vbox = wx.BoxSizer(wx.VERTICAL)
437	self.sizer0 = wx.BoxSizer(wx.VERTICAL)
438	self.sizer1 = wx.BoxSizer(wx.VERTICAL)
439	self.sizer2 = wx.BoxSizer(wx.VERTICAL)
440	self.sizer3 = wx.BoxSizer(wx.VERTICAL)
441	self.sizer4 = wx.BoxSizer(wx.VERTICAL)
442	self.sizer5 = wx.BoxSizer(wx.VERTICAL)
443	self.sizer6 = wx.BoxSizer(wx.VERTICAL)
444
445	self.sizer0.SetMinSize((PANEL_WIDTH, -1))
446	self.sizer1.SetMinSize((PANEL_WIDTH, -1))
447	self.sizer2.SetMinSize((PANEL_WIDTH, -1))
448	self.sizer3.SetMinSize((PANEL_WIDTH, -1))
449	self.sizer4.SetMinSize((PANEL_WIDTH, -1))
450	self.sizer5.SetMinSize((PANEL_WIDTH, -1))
451	self.sizer6.SetMinSize((PANEL_WIDTH, -1))
452
453	self.vbox.Add(self.sizer0)
454	self.vbox.Add(self.sizer1)
455	self.vbox.Add(self.sizer2)
456	self.vbox.Add(self.sizer3)
457	self.vbox.Add(self.sizer4)
458	self.vbox.Add(self.sizer5)
459	self.vbox.Add(self.sizer6)
460
461	def set_layout(self):
462	"""
463	layout
464	"""
465	self.vbox.Layout()
466	self.vbox.Fit(self)
467	self.SetSizer(self.vbox)
468	self.Centre()
469
470	def set_owner(self, owner):
471	"""
472	set owner of fitpage
473
474	:param owner: the class responsible of plotting
475
476	"""
477	self.event_owner = owner
478	self.state.event_owner = owner
479
480	def get_state(self):
481	"""
482	return the current page state
483	"""
484	return self.state
485
486	def get_data(self):
487	"""
488	return the current data
489	"""
490	return self.data
491
492	def get_data_list(self):
493	"""
494	return the current data
495	"""
496	return self.data_list
497
498	def set_manager(self, manager):
499	"""
500	set panel manager
501
502	:param manager: instance of plugin fitting
503
504	"""
505	self._manager = manager
506	self.state.manager = manager
507
508	def populate_box(self, model_dict):
509	"""
510	Store list of model
511
512	:param model_dict: dictionary containing list of models
513
514	"""
515	self.model_list_box = model_dict
516	self.state.model_list_box = self.model_list_box
517	self.initialize_combox()
518
519	def set_model_dictionary(self, model_dict):
520	"""
521	Store a dictionary linking model name -> model object
522
523	:param model_dict: dictionary containing list of models
524	"""
525	self.model_dict = model_dict
526
527	def initialize_combox(self):
528	"""
529	put default value in the combo box
530	"""
531	if self.model_list_box is not None and 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	def set_dispers_sizer(self):
542	"""
543	fill sizer containing dispersity info
544	"""
545	# print "==== entering set_dispers_sizer ==="
546	self.sizer4.Clear(True)
547	name = "Polydispersity and Orientational Distribution"
548	box_description = wx.StaticBox(self, wx.ID_ANY, name)
549	box_description.SetForegroundColour(wx.BLUE)
550	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
551	# ----------------------------------------------------
552	self.disable_disp = wx.RadioButton(self, wx.ID_ANY, 'Off', (10, 10),
553	style=wx.RB_GROUP)
554	self.enable_disp = wx.RadioButton(self, wx.ID_ANY, 'On', (10, 30))
555	# best size for MAC and PC
556	if ON_MAC:
557	size_q = (30, 20)
558	else:
559	size_q = (20, 15)
560	self.disp_help_bt = wx.Button(self, self.ID_DISPERSER_HELP, '?',
561	style=wx.BU_EXACTFIT,
562	size=size_q)
563	self.disp_help_bt.Bind(wx.EVT_BUTTON, self.on_pd_help_clicked,
564	id=self.disp_help_bt.GetId())
565	self.disp_help_bt.SetToolTipString("Help for polydispersion.")
566
567	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
568	id=self.disable_disp.GetId())
569	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
570	id=self.enable_disp.GetId())
571	# MAC needs SetValue
572	self.disable_disp.SetValue(True)
573	sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
574	sizer_dispersion.Add((20, 20))
575	name = "" # Polydispersity and \nOrientational Distribution "
576	sizer_dispersion.Add(wx.StaticText(self, wx.ID_ANY, name))
577	sizer_dispersion.Add(self.enable_disp)
578	sizer_dispersion.Add((20, 20))
579	sizer_dispersion.Add(self.disable_disp)
580	sizer_dispersion.Add((25, 20))
581	sizer_dispersion.Add(self.disp_help_bt)
582
583	# fill a sizer for dispersion
584	boxsizer1.Add(sizer_dispersion, 0,
585	wx.TOP\|wx.BOTTOM\|wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE,
586	border=5)
587	self.sizer4_4 = wx.GridBagSizer(6, 5)
588
589	boxsizer1.Add(self.sizer4_4)
590	# -----------------------------------------------------
591	self.sizer4.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
592	self.sizer4_4.Layout()
593	self.sizer4.Layout()
594	self.Layout()
595
596	self.Refresh()
597	# saving the state of enable dispersity button
598	self.state.enable_disp = self.enable_disp.GetValue()
599	self.state.disable_disp = self.disable_disp.GetValue()
600	self.SetupScrolling()
601
602	def onResetModel(self, event):
603	"""
604	Reset model state
605	"""
606	menu = event.GetEventObject()
607	# post help message for the selected model
608	msg = menu.GetHelpString(event.GetId())
609	msg += " reloaded"
610	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
611	self.Show(False)
612	name = menu.GetLabel(event.GetId())
613	self._on_select_model_helper()
614	if self.model is not None:
615	self.m_name = self.model.name
616	if name in self.saved_states.keys():
617	previous_state = self.saved_states[name]
618	# reset state of checkbox,textcrtl and regular parameters value
619
620	self.reset_page(previous_state)
621	self.state.m_name = self.m_name
622	self.Show(True)
623
624	def on_preview(self, event):
625	"""
626	Report the current fit results
627	"""
628	# Get plot image from plotpanel
629	images, canvases = self.get_images()
630	# get the report dialog
631	self.state.report(images, canvases)
632
633	def on_save(self, event):
634	"""
635	Save the current state into file
636	"""
637	self.save_current_state()
638	new_state = self.state.clone()
639	# Ask the user the location of the file to write to.
640	path = None
641	if self.parent is not None:
642	self._default_save_location = \
643	self._manager.parent._default_save_location
644	dlg = wx.FileDialog(self, "Choose a file", self._default_save_location,
645	self.window_caption, "*.fitv", wx.SAVE)
646
647	if dlg.ShowModal() == wx.ID_OK:
648	path = dlg.GetPath()
649	self._default_save_location = os.path.dirname(path)
650	self._manager.parent._default_save_location = \
651	self._default_save_location
652	else:
653	return None
654	# MAC always needs the extension for saving
655	extens = ".fitv"
656	# Make sure the ext included in the file name
657	fName = os.path.splitext(path)[0] + extens
658	# the manager write the state into file
659	self._manager.save_fit_state(filepath=fName, fitstate=new_state)
660	return new_state
661
662	def on_copy(self, event):
663	"""
664	Copy Parameter values to the clipboad
665	"""
666	if event is not None:
667	event.Skip()
668	# It seems MAC needs wxCallAfter
669	if event.GetId() == GUIFRAME_ID.COPYEX_ID:
670	print "copy excel"
671	wx.CallAfter(self.get_copy_excel)
672	elif event.GetId() == GUIFRAME_ID.COPYLAT_ID:
673	print "copy latex"
674	wx.CallAfter(self.get_copy_latex)
675	else:
676	wx.CallAfter(self.get_copy)
677
678	def on_paste(self, event):
679	"""
680	Paste Parameter values to the panel if possible
681	"""
682	# if event is not 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 depending on flag
693
694	: Param flag: flag that distinguishes the event
695	"""
696	# messages depending on the flag
697	if flag is None:
698	msg = " Parameter values are copied to the clipboard..."
699	infor = 'warning'
700	elif flag:
701	msg = " Parameter values are pasted from the clipboard..."
702	infor = "warning"
703	else:
704	msg = "Error occurred: "
705	msg += "No valid parameter values to paste from the clipboard..."
706	infor = "warning"
707	# inform msg to wx
708	wx.PostEvent(self._manager.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, _, _, _ = 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 is 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._manager.parent, StatusEvent(status=msg))
745
746	self.popUpMenu.Append(self.ID_BOOKMARK, name, str(msg))
747	wx.EVT_MENU(self, self.ID_BOOKMARK, self.onResetModel)
748	wx.PostEvent(self._manager.parent,
749	AppendBookmarkEvent(title=name,
750	hint=str(msg),
751	handler=self._back_to_bookmark))
752
753	def _back_to_bookmark(self, event):
754	"""
755	Back to bookmark
756	"""
757	self._manager.on_perspective(event)
758	self.onResetModel(event)
759	self._draw_model()
760
761	def onSetFocus(self, evt):
762	"""
763	highlight the current textcrtl and hide the error text control shown
764	after fitting
765	"""
766	return
767
768	def read_file(self, path):
769	"""
770	Read two columns file
771
772	:param path: the path to the file to read
773
774	"""
775	try:
776	if path is None:
777	status = " Selected Distribution was not loaded: %s" % path
778	wx.PostEvent(self._manager.parent,
779	StatusEvent(status=status))
780	return None, None
781	input_f = open(path, 'r')
782	buff = input_f.read()
783	lines = buff.split('\n')
784	input_f.close()
785	angles = []
786	weights = []
787	for line in lines:
788	toks = line.split()
789	try:
790	angle = float(toks[0])
791	weight = float(toks[1])
792	angles.append(angle)
793	weights.append(weight)
794	except Exception:
795	# Skip non-data lines
796	logger.error(traceback.format_exc())
797	return np.array(angles), np.array(weights)
798	except:
799	raise
800
801	def createMemento(self):
802	"""
803	return the current state of the page
804	"""
805	return self.state.clone()
806
807	def save_current_state(self):
808	"""
809	Store current state
810	"""
811	# save model option
812	if self.model is not None:
813	self.disp_list = self.model.getDispParamList()
814	self.state.disp_list = copy.deepcopy(self.disp_list)
815	self.state.model = self.model.clone()
816
817	# model combobox: complex code because of mac's silent error
818	if self.structurebox is not None:
819	if self.structurebox.IsShown():
820	self.state.structurecombobox = 'None'
821	s_select = self.structurebox.GetSelection()
822	if s_select > 0:
823	self.state.structurecombobox = \
824	self.structurebox.GetString(s_select)
825	if self.formfactorbox is not None:
826	f_select = self.formfactorbox.GetSelection()
827	if f_select > 0:
828	self.state.formfactorcombobox = \
829	self.formfactorbox.GetString(f_select)
830	if self.categorybox is not None:
831	cb_select = self.categorybox.GetSelection()
832	if cb_select > 0:
833	self.state.categorycombobox = \
834	self.categorybox.GetString(cb_select)
835
836	self.state.enable2D = copy.deepcopy(self.enable2D)
837	self.state.values = copy.deepcopy(self.values)
838	self.state.weights = copy.deepcopy(self.weights)
839	# save data
840	self.state.data = copy.deepcopy(self.data)
841	self.state.qmax_x = self.qmax_x
842	self.state.qmin_x = self.qmin_x
843	self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
844	self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
845	self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
846	self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
847	self.state.dq_l = self.dq_l
848	self.state.dq_r = self.dq_r
849	if hasattr(self, "enable_disp"):
850	self.state.enable_disp = self.enable_disp.GetValue()
851	self.state.disable_disp = self.disable_disp.GetValue()
852
853	self.state.smearer = copy.deepcopy(self.current_smearer)
854	if hasattr(self, "enable_smearer"):
855	self.state.enable_smearer = \
856	copy.deepcopy(self.enable_smearer.GetValue())
857	self.state.disable_smearer = \
858	copy.deepcopy(self.disable_smearer.GetValue())
859
860	self.state.pinhole_smearer = \
861	copy.deepcopy(self.pinhole_smearer.GetValue())
862	self.state.dx_percent = copy.deepcopy(self.dx_percent)
863	self.state.dxl = copy.deepcopy(self.dxl)
864	self.state.dxw = copy.deepcopy(self.dxw)
865	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
866
867	if len(self._disp_obj_dict) > 0:
868	for k, v in self._disp_obj_dict.iteritems():
869	self.state._disp_obj_dict[k] = v.type
870
871	self.state.values = copy.deepcopy(self.values)
872	self.state.weights = copy.deepcopy(self.weights)
873	# save plotting range
874	self._save_plotting_range()
875
876	self.state.orientation_params = []
877	self.state.orientation_params_disp = []
878	self.state.parameters = []
879	self.state.fittable_param = []
880	self.state.fixed_param = []
881	self.state.str_parameters = []
882
883	# save checkbutton state and txtcrtl values
884	self._copy_parameters_state(self.str_parameters,
885	self.state.str_parameters)
886	self._copy_parameters_state(self.orientation_params,
887	self.state.orientation_params)
888	self._copy_parameters_state(self.orientation_params_disp,
889	self.state.orientation_params_disp)
890
891	self._copy_parameters_state(self.parameters, self.state.parameters)
892	self._copy_parameters_state(self.fittable_param,
893	self.state.fittable_param)
894	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
895	# save chisqr
896	self.state.tcChi = self.tcChi.GetValue()
897
898	def save_current_state_fit(self):
899	"""
900	Store current state for fit_page
901	"""
902	# save model option
903	if self.model is not None:
904	self.disp_list = self.model.getDispParamList()
905	self.state.disp_list = copy.deepcopy(self.disp_list)
906	self.state.model = self.model.clone()
907
908	self.state.enable2D = copy.deepcopy(self.enable2D)
909	self.state.values = copy.deepcopy(self.values)
910	self.state.weights = copy.deepcopy(self.weights)
911	# save data
912	self.state.data = copy.deepcopy(self.data)
913
914	if hasattr(self, "enable_disp"):
915	self.state.enable_disp = self.enable_disp.GetValue()
916	self.state.disable_disp = self.disable_disp.GetValue()
917
918	self.state.smearer = copy.deepcopy(self.current_smearer)
919	if hasattr(self, "enable_smearer"):
920	self.state.enable_smearer = \
921	copy.deepcopy(self.enable_smearer.GetValue())
922	self.state.disable_smearer = \
923	copy.deepcopy(self.disable_smearer.GetValue())
924
925	self.state.pinhole_smearer = \
926	copy.deepcopy(self.pinhole_smearer.GetValue())
927	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
928	self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
929	self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
930	self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
931	self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
932	if hasattr(self, "disp_box") and self.disp_box is not None:
933	self.state.disp_box = self.disp_box.GetCurrentSelection()
934
935	if len(self.disp_cb_dict) > 0:
936	for k, v in self.disp_cb_dict.iteritems():
937	if v is None:
938	self.state.disp_cb_dict[k] = v
939	else:
940	try:
941	self.state.disp_cb_dict[k] = v.GetValue()
942	except:
943	self.state.disp_cb_dict[k] = None
944	if len(self._disp_obj_dict) > 0:
945	for k, v in self._disp_obj_dict.iteritems():
946	self.state._disp_obj_dict[k] = v.type
947
948	self.state.values = copy.deepcopy(self.values)
949	self.state.weights = copy.deepcopy(self.weights)
950
951	# save plotting range
952	self._save_plotting_range()
953
954	# save checkbutton state and txtcrtl values
955	self._copy_parameters_state(self.orientation_params,
956	self.state.orientation_params)
957	self._copy_parameters_state(self.orientation_params_disp,
958	self.state.orientation_params_disp)
959	self._copy_parameters_state(self.parameters, self.state.parameters)
960	self._copy_parameters_state(self.fittable_param,
961	self.state.fittable_param)
962	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
963
964	def check_invalid_panel(self):
965	"""
966	check if the user can already perform some action with this panel
967	"""
968	if self.data is None:
969	self.disable_smearer.SetValue(True)
970	self.disable_disp.SetValue(True)
971	msg = "Please load Data and select Model to start..."
972	wx.MessageBox(msg, 'Info')
973	return True
974
975	def set_model_state(self, state):
976	"""
977	reset page given a model state
978	"""
979	self.disp_cb_dict = state.disp_cb_dict
980	self.disp_list = state.disp_list
981
982	# fill model combobox
983	self._show_combox_helper()
984	# select the current model
985	try:
986	# to support older version
987	category_pos = int(state.categorycombobox)
988	except:
989	category_pos = 0
990	for ind_cat in range(self.categorybox.GetCount()):
991	if self.categorycombobox.GetString(ind_cat) == \
992	state.categorycombobox:
993	category_pos = int(ind_cat)
994	break
995
996	self.categorybox.Select(category_pos)
997	try:
998	# to support older version
999	formfactor_pos = int(state.formfactorcombobox)
1000	except:
1001	formfactor_pos = 0
1002	for ind_form in range(self.formfactorbox.GetCount()):
1003	if self.formfactorbox.GetString(ind_form) == \
1004	state.formfactorcombobox:
1005	formfactor_pos = int(ind_form)
1006	break
1007
1008	self.formfactorbox.Select(formfactor_pos)
1009
1010	try:
1011	# to support older version
1012	structfactor_pos = int(state.structurecombobox)
1013	except:
1014	structfactor_pos = 0
1015	for ind_struct in range(self.structurebox.GetCount()):
1016	if self.structurebox.GetString(ind_struct) == \
1017	state.structurecombobox:
1018	structfactor_pos = int(ind_struct)
1019	break
1020
1021	self.structurebox.SetSelection(structfactor_pos)
1022
1023	if state.multi_factor is not None:
1024	self.multifactorbox.SetSelection(state.multi_factor)
1025
1026	# reset state of checkbox,textcrtl and regular parameters value
1027	self._reset_parameters_state(self.orientation_params_disp,
1028	state.orientation_params_disp)
1029	self._reset_parameters_state(self.orientation_params,
1030	state.orientation_params)
1031	self._reset_parameters_state(self.str_parameters,
1032	state.str_parameters)
1033	self._reset_parameters_state(self.parameters, state.parameters)
1034	# display dispersion info layer
1035	self.enable_disp.SetValue(state.enable_disp)
1036	self.disable_disp.SetValue(state.disable_disp)
1037
1038	if hasattr(self, "disp_box") and self.disp_box is not None:
1039	self.disp_box.SetSelection(state.disp_box)
1040	n = self.disp_box.GetCurrentSelection()
1041	dispersity = self.disp_box.GetClientData(n)
1042	name = dispersity.__name__
1043	self._set_dipers_Param(event=None)
1044
1045	if name == "ArrayDispersion":
1046
1047	for item in self.disp_cb_dict.keys():
1048
1049	if hasattr(self.disp_cb_dict[item], "SetValue"):
1050	self.disp_cb_dict[item].SetValue(
1051	state.disp_cb_dict[item])
1052	# Create the dispersion objects
1053	disp_model = POLYDISPERSITY_MODELS['array']()
1054	if hasattr(state, "values") and \
1055	self.disp_cb_dict[item].GetValue():
1056	if len(state.values) > 0:
1057	self.values = state.values
1058	self.weights = state.weights
1059	disp_model.set_weights(self.values,
1060	state.weights)
1061	else:
1062	self._reset_dispersity()
1063
1064	self._disp_obj_dict[item] = disp_model
1065	# Set the new model as the dispersion object
1066	# for the selected parameter
1067	self.model.set_dispersion(item, disp_model)
1068
1069	self.model._persistency_dict[item] = \
1070	[state.values, state.weights]
1071
1072	else:
1073	keys = self.model.getParamList()
1074	for item in keys:
1075	if item in self.disp_list and \
1076	item not in self.model.details:
1077	self.model.details[item] = ["", None, None]
1078	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1079	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1080	# smearing info restore
1081	if hasattr(self, "enable_smearer"):
1082	# set smearing value whether or not the data
1083	# contain the smearing info
1084	self.enable_smearer.SetValue(state.enable_smearer)
1085	self.disable_smearer.SetValue(state.disable_smearer)
1086	self.onSmear(event=None)
1087	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1088	self.slit_smearer.SetValue(state.slit_smearer)
1089
1090	self.dI_noweight.SetValue(state.dI_noweight)
1091	self.dI_didata.SetValue(state.dI_didata)
1092	self.dI_sqrdata.SetValue(state.dI_sqrdata)
1093	self.dI_idata.SetValue(state.dI_idata)
1094
1095	# we have two more options for smearing
1096	if self.pinhole_smearer.GetValue():
1097	self.onPinholeSmear(event=None)
1098	elif self.slit_smearer.GetValue():
1099	self.onSlitSmear(event=None)
1100
1101	# reset state of checkbox,textcrtl and dispersity parameters value
1102	self._reset_parameters_state(self.fittable_param, state.fittable_param)
1103	self._reset_parameters_state(self.fixed_param, state.fixed_param)
1104
1105	# draw the model with previous parameters value
1106	self._onparamEnter_helper()
1107	self.select_param(event=None)
1108	# Save state_fit
1109	self.save_current_state_fit()
1110	self._lay_out()
1111	self.Refresh()
1112
1113	def get_cat_combo_box_pos(self, state):
1114	"""
1115	Iterate through the categories to find the structurefactor
1116	:return: combo_box_position
1117	"""
1118	for key, value in self.master_category_dict.iteritems():
1119	formfactor = state.formfactorcombobox.split(":")
1120	if isinstance(formfactor, list):
1121	formfactor = formfactor[0]
1122	for list_item in value:
1123	if formfactor in list_item:
1124	return self.categorybox.Items.index(key)
1125	return 0
1126
1127	def reset_page_helper(self, state):
1128	"""
1129	Use page_state and change the state of existing page
1130
1131	:precondition: the page is already drawn or created
1132
1133	:postcondition: the state of the underlying data changes as well as the
1134	state of the graphic interface
1135	"""
1136	if state is None:
1137	return
1138	# set data, etc. from the state
1139	# reset page between theory and fitting from bookmarking
1140	data = state.data
1141
1142	if data is None:
1143	data_min = state.qmin
1144	data_max = state.qmax
1145	self.qmin_x = data_min
1146	self.qmax_x = data_max
1147	self.qmin.SetValue(str(data_min))
1148	self.qmax.SetValue(str(data_max))
1149
1150	self.state.data = data
1151	self.state.qmin = self.qmin_x
1152	self.state.qmax = self.qmax_x
1153	else:
1154	self.set_data(data)
1155
1156	self.enable2D = state.enable2D
1157	try:
1158	self.magnetic_on = state.magnetic_on
1159	except:
1160	# Backward compatibility (for older state files)
1161	self.magnetic_on = False
1162
1163	self.disp_cb_dict = state.disp_cb_dict
1164	self.disp_list = state.disp_list
1165
1166	# fill model combobox
1167	self._show_combox_helper()
1168	# select the current model
1169	state._convert_to_sasmodels()
1170	state.categorycombobox = unicode(state.categorycombobox)
1171	if state.categorycombobox in self.categorybox.Items:
1172	category_pos = self.categorybox.Items.index(
1173	state.categorycombobox)
1174	else:
1175	# Look in master list for model name (model.lower)
1176	category_pos = self.get_cat_combo_box_pos(state)
1177
1178	self.categorybox.Select(category_pos)
1179	self._show_combox(None)
1180	from models import PLUGIN_NAME_BASE
1181	if self.categorybox.GetValue() == CUSTOM_MODEL \
1182	and PLUGIN_NAME_BASE not in state.formfactorcombobox:
1183	state.formfactorcombobox = \
1184	PLUGIN_NAME_BASE + state.formfactorcombobox
1185	formfactor_pos = 0
1186	for ind_form in range(self.formfactorbox.GetCount()):
1187	if self.formfactorbox.GetString(ind_form) == \
1188	(state.formfactorcombobox):
1189	formfactor_pos = int(ind_form)
1190	break
1191
1192	self.formfactorbox.Select(formfactor_pos)
1193
1194	structfactor_pos = 0
1195	if state.structurecombobox is not None:
1196	state.structurecombobox = unicode(state.structurecombobox)
1197	for ind_struct in range(self.structurebox.GetCount()):
1198	if self.structurebox.GetString(ind_struct) == \
1199	(state.structurecombobox):
1200	structfactor_pos = int(ind_struct)
1201	break
1202
1203	self.structurebox.SetSelection(structfactor_pos)
1204
1205	if state.multi_factor is not None:
1206	self.multifactorbox.SetSelection(state.multi_factor)
1207
1208	# draw the panel according to the new model parameter
1209	self._on_select_model(event=None)
1210
1211	# take care of 2D button
1212	if data is None and self.model_view.IsEnabled():
1213	if self.enable2D:
1214	self.model_view.SetLabel("2D Mode")
1215	else:
1216	self.model_view.SetLabel("1D Mode")
1217
1218	# reset state of checkbox,textcrtl and regular parameters value
1219	self._reset_parameters_state(self.orientation_params_disp,
1220	state.orientation_params_disp)
1221	self._reset_parameters_state(self.orientation_params,
1222	state.orientation_params)
1223	self._reset_parameters_state(self.str_parameters,
1224	state.str_parameters)
1225	self._reset_parameters_state(self.parameters, state.parameters)
1226	# display dispersion info layer
1227	self.enable_disp.SetValue(state.enable_disp)
1228	self.disable_disp.SetValue(state.disable_disp)
1229	# If the polydispersion is ON
1230	if state.enable_disp:
1231	# reset dispersion according the state
1232	self._set_dipers_Param(event=None)
1233	self._reset_page_disp_helper(state)
1234	# plotting range restore
1235	self._reset_plotting_range(state)
1236	# smearing info restore
1237	if hasattr(self, "enable_smearer"):
1238	# set smearing value whether or not the data
1239	# contain the smearing info
1240	self.enable_smearer.SetValue(state.enable_smearer)
1241	self.disable_smearer.SetValue(state.disable_smearer)
1242	self.onSmear(event=None)
1243	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1244	self.slit_smearer.SetValue(state.slit_smearer)
1245	try:
1246	self.dI_noweight.SetValue(state.dI_noweight)
1247	self.dI_didata.SetValue(state.dI_didata)
1248	self.dI_sqrdata.SetValue(state.dI_sqrdata)
1249	self.dI_idata.SetValue(state.dI_idata)
1250	except:
1251	# to support older state file formats
1252	self.dI_noweight.SetValue(False)
1253	self.dI_didata.SetValue(True)
1254	self.dI_sqrdata.SetValue(False)
1255	self.dI_idata.SetValue(False)
1256
1257	# we have two more options for smearing
1258	if self.pinhole_smearer.GetValue():
1259	self.dx_percent = state.dx_percent
1260	if self.dx_percent is not None:
1261	if state.dx_old:
1262	self.dx_percent = 100 * (self.dx_percent / self.data.x[0])
1263	self.smear_pinhole_percent.SetValue("%.2f" % self.dx_percent)
1264	self.onPinholeSmear(event=None)
1265	elif self.slit_smearer.GetValue():
1266	self.dxl = state.dxl
1267	self.dxw = state.dxw
1268	if self.dxl is not None:
1269	self.smear_slit_height.SetValue(str(self.dxl))
1270	if self.dxw is not None:
1271	self.smear_slit_width.SetValue(str(self.dxw))
1272	else:
1273	self.smear_slit_width.SetValue('')
1274	self.onSlitSmear(event=None)
1275
1276	# reset state of checkbox,textcrtl and dispersity parameters value
1277	self._reset_parameters_state(self.fittable_param, state.fittable_param)
1278	self._reset_parameters_state(self.fixed_param, state.fixed_param)
1279
1280	# draw the model with previous parameters value
1281	self._onparamEnter_helper()
1282	# reset the value of chisqr when not consistent with the value computed
1283	self.tcChi.SetValue(str(self.state.tcChi))
1284	# reset context menu items
1285	self._reset_context_menu()
1286
1287	# set the value of the current state to the state given as parameter
1288	self.state = state.clone()
1289	self.state.m_name = self.m_name
1290
1291	def _reset_page_disp_helper(self, state):
1292	"""
1293	Help to rest page for dispersions
1294	"""
1295	keys = self.model.getParamList()
1296	for item in keys:
1297	if item in self.disp_list and \
1298	item not in self.model.details:
1299	self.model.details[item] = ["", None, None]
1300	# for k,v in self.state.disp_cb_dict.iteritems():
1301	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1302	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1303	self.values = copy.deepcopy(state.values)
1304	self.weights = copy.deepcopy(state.weights)
1305
1306	for key, disp_type in state._disp_obj_dict.iteritems():
1307	# disp_model = disp
1308	disp_model = POLYDISPERSITY_MODELS[disp_type]()
1309	self._disp_obj_dict[key] = disp_model
1310	param_name = key.split('.')[0]
1311	# Try to set dispersion only when available
1312	# for eg., pass the orient. angles for 1D Cal
1313	try:
1314	self.model.set_dispersion(param_name, disp_model)
1315	self.model._persistency_dict[key] = \
1316	[state.values, state.weights]
1317	except Exception:
1318	logger.error(traceback.format_exc())
1319	selection = self._find_polyfunc_selection(disp_model)
1320	for list in self.fittable_param:
1321	if list[1] == key and list[7] is not None:
1322	list[7].SetSelection(selection)
1323	# For the array disp_model, set the values and weights
1324	if selection == 1:
1325	disp_model.set_weights(self.values[key],
1326	self.weights[key])
1327	try:
1328	# Diables all fittable params for array
1329	list[0].SetValue(False)
1330	list[0].Disable()
1331	list[2].Disable()
1332	list[5].Disable()
1333	list[6].Disable()
1334	except Exception:
1335	logger.error(traceback.format_exc())
1336	# For array, disable all fixed params
1337	if selection == 1:
1338	for item in self.fixed_param:
1339	if item[1].split(".")[0] == key.split(".")[0]:
1340	# try it and pass it for the orientation for 1D
1341	try:
1342	item[2].Disable()
1343	except Exception:
1344	logger.error(traceback.format_exc())
1345
1346	def _selectDlg(self):
1347	"""
1348	open a dialog file to select the customized polydispersity function
1349	"""
1350	if self.parent is not None:
1351	self._default_save_location = \
1352	self._manager.parent.get_save_location()
1353	dlg = wx.FileDialog(self, "Choose a weight file",
1354	self._default_save_location, "",
1355	".", wx.OPEN)
1356	path = None
1357	if dlg.ShowModal() == wx.ID_OK:
1358	path = dlg.GetPath()
1359	dlg.Destroy()
1360	return path
1361
1362	def _reset_context_menu(self):
1363	"""
1364	reset the context menu
1365	"""
1366	ids = iter(self._id_pool) # Reusing ids for context menu
1367	for name, _ in self.state.saved_states.iteritems():
1368	self.number_saved_state += 1
1369	# Add item in the context menu
1370	wx_id = ids.next()
1371	msg = 'Save model and state %g' % self.number_saved_state
1372	self.popUpMenu.Append(wx_id, name, msg)
1373	wx.EVT_MENU(self, wx_id, self.onResetModel)
1374
1375	def _reset_plotting_range(self, state):
1376	"""
1377	Reset the plotting range to a given state
1378	"""
1379	self.qmin.SetValue(str(state.qmin))
1380	self.qmax.SetValue(str(state.qmax))
1381
1382	def _save_typeOfmodel(self):
1383	"""
1384	save radiobutton containing the type model that can be selected
1385	"""
1386	# self.state.shape_rbutton = self.shape_rbutton.GetValue()
1387	# self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1388	# self.state.struct_rbutton = self.struct_rbutton.GetValue()
1389	# self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1390	self.state.structurecombobox = self.structurebox.GetValue()
1391	self.state.formfactorcombobox = self.formfactorbox.GetValue()
1392	self.state.categorycombobox = self.categorybox.GetValue()
1393
1394	# post state to fit panel
1395	event = PageInfoEvent(page=self)
1396	wx.PostEvent(self.parent, event)
1397
1398	def _save_plotting_range(self):
1399	"""
1400	save the state of plotting range
1401	"""
1402	self.state.qmin = self.qmin_x
1403	self.state.qmax = self.qmax_x
1404	self.state.npts = self.npts_x
1405
1406	def _onparamEnter_helper(self, is_modified=False):
1407	"""
1408	check if values entered by the user are changed and valid to replot
1409	model
1410	"""
1411	# Flag to register when a parameter has changed.
1412	# is_modified = False
1413	self.fitrange = True
1414	is_2Ddata = False
1415	# self._undo.Enable(True)
1416	# check if 2d data
1417	if self.data.__class__.__name__ == "Data2D":
1418	is_2Ddata = True
1419	if self.model is not None:
1420	# Either we get a is_modified = True passed in because
1421	# _update_paramv_on_fit() has been called already or
1422	# we need to check here ourselves.
1423	if not is_modified:
1424	is_modified = (self._check_value_enter(self.fittable_param)
1425	or self._check_value_enter(self.fixed_param)
1426	or self._check_value_enter(self.parameters))
1427
1428	# Here we should check whether the boundaries have been modified.
1429	# If qmin and qmax have been modified, update qmin and qmax and
1430	# set the is_modified flag to True
1431	if self._validate_qrange(self.qmin, self.qmax):
1432	tempmin = float(self.qmin.GetValue())
1433	if tempmin != self.qmin_x:
1434	self.qmin_x = tempmin
1435	is_modified = True
1436	tempmax = float(self.qmax.GetValue())
1437	if tempmax != self.qmax_x:
1438	self.qmax_x = tempmax
1439	is_modified = True
1440	if is_2Ddata:
1441	is_modified = self._validate_Npts()
1442	else:
1443	is_modified = self._validate_Npts_1D()
1444	else:
1445	self.fitrange = False
1446
1447	# if any value is modify draw model with new value
1448	if not self.fitrange:
1449	# self.btFit.Disable()
1450	if is_2Ddata:
1451	self.btEditMask.Disable()
1452	else:
1453	if is_2Ddata and self.data.is_data and not self.batch_on:
1454	self.btEditMask.Enable(True)
1455	if is_modified and self.fitrange:
1456	# Theory case: need to get npts value to draw
1457	self.npts_x = float(self.Npts_total.GetValue())
1458	self.Npts_fit.SetValue(str(self.Npts_total.GetValue()))
1459	self._save_plotting_range()
1460	self.create_default_data()
1461	self.state_change = True
1462	self._draw_model()
1463	self.Refresh()
1464
1465	# logger.info("is_modified flag set to %g",is_modified)
1466	return is_modified
1467
1468	def _update_paramv_on_fit(self):
1469	"""
1470	make sure that update param values just before the fitting
1471	"""
1472	# flag for qmin qmax check values
1473	flag = True
1474	self.fitrange = True
1475	is_modified = False
1476
1477	# wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1478	# updating ... ",type="update"))
1479
1480	# So make sure that update param values on_Fit.
1481	# self._undo.Enable(True)
1482	if self.model is not None:
1483	if self.Npts_total.GetValue() != self.Npts_fit.GetValue():
1484	if not self.data.is_data:
1485	self._manager.page_finder[self.uid].set_fit_data(
1486	data=[self.data])
1487	# Check the values
1488	is_modified = (self._check_value_enter(self.fittable_param)
1489	or self._check_value_enter(self.fixed_param)
1490	or self._check_value_enter(self.parameters))
1491
1492	# If qmin and qmax have been modified, update qmin and qmax and
1493	# Here we should check whether the boundaries have been modified.
1494	# If qmin and qmax have been modified, update qmin and qmax and
1495	# set the is_modified flag to True
1496	self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1497	if self.fitrange:
1498	tempmin = float(self.qmin.GetValue())
1499	if tempmin != self.qmin_x:
1500	self.qmin_x = tempmin
1501	tempmax = float(self.qmax.GetValue())
1502	if tempmax != self.qmax_x:
1503	self.qmax_x = tempmax
1504	if tempmax == tempmin:
1505	flag = False
1506	temp_smearer = None
1507	if not self.disable_smearer.GetValue():
1508	temp_smearer = self.current_smearer
1509	if self.slit_smearer.GetValue():
1510	flag = self.update_slit_smear()
1511	elif self.pinhole_smearer.GetValue():
1512	flag = self.update_pinhole_smear()
1513	else:
1514	enable_smearer = not self.disable_smearer.GetValue()
1515	self._manager.set_smearer(smearer=temp_smearer,
1516	uid=self.uid,
1517	fid=self.data.id,
1518	qmin=float(self.qmin_x),
1519	qmax=float(self.qmax_x),
1520	enable_smearer=enable_smearer,
1521	draw=False)
1522	elif not self._is_2D():
1523	enable_smearer = not self.disable_smearer.GetValue()
1524	self._manager.set_smearer(smearer=temp_smearer,
1525	qmin=float(self.qmin_x),
1526	uid=self.uid,
1527	fid=self.data.id,
1528	qmax=float(self.qmax_x),
1529	enable_smearer=enable_smearer,
1530	draw=False)
1531	if self.data is not None:
1532	index_data = ((self.qmin_x <= self.data.x) &
1533	(self.data.x <= self.qmax_x))
1534	val = str(len(self.data.x[index_data]))
1535	self.Npts_fit.SetValue(val)
1536	else:
1537	# No data in the panel
1538	try:
1539	self.npts_x = float(self.Npts_total.GetValue())
1540	except:
1541	flag = False
1542	return flag
1543	flag = True
1544	if self._is_2D():
1545	# only 2D case set mask
1546	flag = self._validate_Npts()
1547	if not flag:
1548	return flag
1549	else:
1550	flag = False
1551	else:
1552	flag = False
1553
1554	# For invalid q range, disable the mask editor and fit button, vs.
1555	if not self.fitrange:
1556	if self._is_2D():
1557	self.btEditMask.Disable()
1558	else:
1559	if self._is_2D() and self.data.is_data and not self.batch_on:
1560	self.btEditMask.Enable(True)
1561
1562	if not flag:
1563	msg = "Cannot Plot or Fit :Must select a "
1564	msg += " model or Fitting range is not valid!!! "
1565	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1566
1567	try:
1568	self.save_current_state()
1569	except Exception:
1570	logger.error(traceback.format_exc())
1571
1572	return flag, is_modified
1573
1574	def _reset_parameters_state(self, listtorestore, statelist):
1575	"""
1576	Reset the parameters at the given state
1577	"""
1578	if len(statelist) == 0 or len(listtorestore) == 0:
1579	return
1580
1581	for j in range(len(listtorestore)):
1582	for param in statelist:
1583	if param[1] == listtorestore[j][1]:
1584	item_page = listtorestore[j]
1585	item_page_info = param
1586	if (item_page_info[1] == "theta" or item_page_info[1] ==
1587	"phi") and not self._is_2D():
1588	break
1589	# change the state of the check box for simple parameters
1590	if item_page[0] is not None:
1591	item_page[0].SetValue(item_page_info[0])
1592	if item_page[2] is not None:
1593	item_page[2].SetValue(item_page_info[2])
1594	if item_page[2].__class__.__name__ == "ComboBox":
1595	if item_page_info[2] in self.model.fun_list:
1596	fun_val = self.model.fun_list[item_page_info[2]]
1597	self.model.setParam(item_page_info[1], fun_val)
1598	if item_page[3] is not None:
1599	# show or hide text +/-
1600	if item_page_info[2]:
1601	item_page[3].Show(True)
1602	else:
1603	item_page[3].Hide()
1604	if item_page[4] is not None:
1605	# show of hide the text crtl for fitting error
1606	if item_page_info[4][0]:
1607	item_page[4].Show(True)
1608	item_page[4].SetValue(str(item_page_info[4][1]))
1609	else:
1610	item_page[3].Hide()
1611	if item_page[5] is not None:
1612	# show of hide the text crtl for fitting error
1613	item_page[5].Show(True)
1614	item_page[5].SetValue(str(item_page_info[5][1]))
1615	if item_page[6] is not None:
1616	# show of hide the text crtl for fitting error
1617	item_page[6].Show(True)
1618	item_page[6].SetValue(str(item_page_info[6][1]))
1619	break
1620
1621	def _reset_strparam_state(self, listtorestore, statelist):
1622	"""
1623	Reset the string parameters at the given state
1624	"""
1625	if len(statelist) == 0:
1626	return
1627
1628	listtorestore = copy.deepcopy(statelist)
1629
1630	for j in range(len(listtorestore)):
1631	item_page = listtorestore[j]
1632	item_page_info = statelist[j]
1633	# change the state of the check box for simple parameters
1634
1635	if item_page[0] is not None:
1636	item_page[0].SetValue(format_number(item_page_info[0], True))
1637
1638	if item_page[2] is not None:
1639	param_name = item_page_info[1]
1640	value = item_page_info[2]
1641	selection = value
1642	if value in self.model.fun_list:
1643	selection = self.model.fun_list[value]
1644	item_page[2].SetValue(selection)
1645	self.model.setParam(param_name, selection)
1646
1647	def _copy_parameters_state(self, listtocopy, statelist):
1648	"""
1649	copy the state of button
1650
1651	:param listtocopy: the list of check button to copy
1652	:param statelist: list of state object to store the current state
1653
1654	"""
1655	if len(listtocopy) == 0:
1656	return
1657
1658	for item in listtocopy:
1659
1660	checkbox_state = None
1661	if item[0] is not None:
1662	checkbox_state = item[0].GetValue()
1663	parameter_name = item[1]
1664	parameter_value = None
1665	if item[2] is not None:
1666	parameter_value = item[2].GetValue()
1667	static_text = None
1668	if item[3] is not None:
1669	static_text = item[3].IsShown()
1670	error_value = None
1671	error_state = None
1672	if item[4] is not None:
1673	error_value = item[4].GetValue()
1674	error_state = item[4].IsShown()
1675
1676	min_value = None
1677	min_state = None
1678	if item[5] is not None:
1679	min_value = item[5].GetValue()
1680	min_state = item[5].IsShown()
1681
1682	max_value = None
1683	max_state = None
1684	if item[6] is not None:
1685	max_value = item[6].GetValue()
1686	max_state = item[6].IsShown()
1687	unit = None
1688	if item[7] is not None:
1689	unit = item[7].GetLabel()
1690
1691	statelist.append([checkbox_state, parameter_name, parameter_value,
1692	static_text, [error_state, error_value],
1693	[min_state, min_value],
1694	[max_state, max_value], unit])
1695
1696	def _draw_model(self, update_chisqr=True, source='model'):
1697	"""
1698	Method to draw or refresh a plotted model.
1699	The method will use the data member from the model page
1700	to build a call to the fitting perspective manager.
1701
1702	:param chisqr: update chisqr value [bool]
1703	"""
1704	self.threadedDrawQueue.put([update_chisqr, source])
1705
1706	def _threaded_draw_worker(self, threadedDrawQueue):
1707	while True:
1708	inputVariables = threadedDrawQueue.get()
1709	self._draw_model_after(inputVariables[0], inputVariables[1])
1710	self.threadedDrawQueue.task_done()
1711
1712	def _draw_model_after(self, update_chisqr=True, source='model'):
1713	"""
1714	Method to draw or refresh a plotted model.
1715	The method will use the data member from the model page
1716	to build a call to the fitting perspective manager.
1717
1718	:param chisqr: update chisqr value [bool]
1719	"""
1720	# if self.check_invalid_panel():
1721	# return
1722	if self.model is not None:
1723	temp_smear = None
1724	if hasattr(self, "enable_smearer"):
1725	if not self.disable_smearer.GetValue():
1726	temp_smear = self.current_smearer
1727	# compute weight for the current data
1728	from sas.sasgui.perspectives.fitting.utils import get_weight
1729	flag = self.get_weight_flag()
1730	weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1731	toggle_mode_on = self.model_view.IsEnabled()
1732	is_2d = self._is_2D()
1733	self._manager.draw_model(self.model,
1734	data=self.data,
1735	smearer=temp_smear,
1736	qmin=float(self.qmin_x),
1737	qmax=float(self.qmax_x),
1738	page_id=self.uid,
1739	toggle_mode_on=toggle_mode_on,
1740	state=self.state,
1741	enable2D=is_2d,
1742	update_chisqr=update_chisqr,
1743	source='model',
1744	weight=weight)
1745
1746	def _on_show_sld(self, event=None):
1747	"""
1748	Plot SLD profile
1749	"""
1750	# get profile data
1751	x, y = self.model.getProfile()
1752
1753	from sas.sasgui.plottools import Data1D as pf_data1d
1754	# from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
1755	from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
1756	import SLDPanel
1757	sld_data = pf_data1d(x, y)
1758	sld_data.name = 'SLD'
1759	sld_data.axes = self.sld_axes
1760	self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes,
1761	id=wx.ID_ANY)
1762	self.panel.ShowModal()
1763
1764	def _set_multfactor_combobox(self, multiplicity=10):
1765	"""
1766	Set comboBox for multitfactor of CoreMultiShellModel
1767	:param multiplicit: no. of multi-functionality
1768	"""
1769	# build content of the combobox
1770	for idx in range(0, multiplicity):
1771	self.multifactorbox.Append(str(idx), int(idx))
1772	self._hide_multfactor_combobox()
1773
1774	def _show_multfactor_combobox(self):
1775	"""
1776	Show the comboBox of muitfactor of CoreMultiShellModel
1777	"""
1778	if not self.mutifactor_text.IsShown():
1779	self.mutifactor_text.Show(True)
1780	self.mutifactor_text1.Show(True)
1781	if not self.multifactorbox.IsShown():
1782	self.multifactorbox.Show(True)
1783
1784	def _hide_multfactor_combobox(self):
1785	"""
1786	Hide the comboBox of muitfactor of CoreMultiShellModel
1787	"""
1788	if self.mutifactor_text.IsShown():
1789	self.mutifactor_text.Hide()
1790	self.mutifactor_text1.Hide()
1791	if self.multifactorbox.IsShown():
1792	self.multifactorbox.Hide()
1793
1794	def formfactor_combo_init(self):
1795	"""
1796	First time calls _show_combox_helper
1797	"""
1798	self._show_combox(None)
1799
1800	def _show_combox_helper(self):
1801	"""
1802	Fill panel's combo box according to the type of model selected
1803	"""
1804
1805	mod_cat = self.categorybox.GetStringSelection()
1806	self.structurebox.SetSelection(0)
1807	self.structurebox.Disable()
1808	self.formfactorbox.Clear()
1809	if mod_cat is None:
1810	return
1811	m_list = []
1812	try:
1813	if mod_cat == CUSTOM_MODEL:
1814	for model in self.model_list_box[mod_cat]:
1815	m_list.append(self.model_dict[model.name])
1816	else:
1817	cat_dic = self.master_category_dict[mod_cat]
1818	for (model, enabled) in cat_dic:
1819	if enabled:
1820	m_list.append(self.model_dict[model])
1821	except Exception:
1822	msg = traceback.format_exc()
1823	wx.PostEvent(self._manager.parent,
1824	StatusEvent(status=msg, info="error"))
1825	self._populate_box(self.formfactorbox, m_list)
1826
1827	def _on_modify_cat(self, event=None):
1828	"""
1829	Called when category manager is opened
1830	"""
1831	self._manager.parent.on_category_panel(event)
1832
1833	def _show_combox(self, event=None):
1834	"""
1835	Show combox box associate with type of model selected
1836	"""
1837	self.Show(False)
1838	self._show_combox_helper()
1839	self._on_select_model(event=None)
1840	self.Show(True)
1841	self._save_typeOfmodel()
1842	self.sizer4_4.Layout()
1843	self.sizer4.Layout()
1844	self.Layout()
1845	self.Refresh()
1846
1847	def _populate_box(self, combobox, list):
1848	"""
1849	fill combox box with dict item
1850
1851	:param list: contains item to fill the combox
1852	item must model class
1853	"""
1854	mlist = []
1855	for models in list:
1856	if models.name != "NoStructure":
1857	mlist.append((models.name, models))
1858
1859	# Sort the models
1860	mlist_sorted = sorted(mlist)
1861	for item in mlist_sorted:
1862	combobox.Append(item[0], item[1])
1863	return 0
1864
1865	def _onQrangeEnter(self, event):
1866	"""
1867	Check validity of value enter in the Q range field
1868
1869	"""
1870	tcrtl = event.GetEventObject()
1871	# Clear msg if previously shown.
1872	msg = ""
1873	wx.PostEvent(self.parent, StatusEvent(status=msg))
1874	# Flag to register when a parameter has changed.
1875	if tcrtl.GetValue().lstrip().rstrip() != "":
1876	try:
1877	float(tcrtl.GetValue())
1878	tcrtl.SetBackgroundColour(wx.WHITE)
1879	# If qmin and qmax have been modified, update qmin and qmax
1880	if self._validate_qrange(self.qmin, self.qmax):
1881	tempmin = float(self.qmin.GetValue())
1882	if tempmin != self.qmin_x:
1883	self.qmin_x = tempmin
1884	tempmax = float(self.qmax.GetValue())
1885	if tempmax != self.qmax_x:
1886	self.qmax_x = tempmax
1887	else:
1888	tcrtl.SetBackgroundColour("pink")
1889	msg = "Model Error: wrong value entered: %s" % \
1890	sys.exc_info()[1]
1891	wx.PostEvent(self.parent, StatusEvent(status=msg))
1892	return
1893	except:
1894	tcrtl.SetBackgroundColour("pink")
1895	msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1896	wx.PostEvent(self.parent, StatusEvent(status=msg))
1897	return
1898	# Check if # of points for theory model are valid(>0).
1899	if self.npts is not None:
1900	if check_float(self.npts):
1901	temp_npts = float(self.npts.GetValue())
1902	if temp_npts != self.num_points:
1903	self.num_points = temp_npts
1904	else:
1905	msg = "Cannot plot: No points in Q range!!! "
1906	wx.PostEvent(self.parent, StatusEvent(status=msg))
1907	else:
1908	tcrtl.SetBackgroundColour("pink")
1909	msg = "Model Error: wrong value entered!!!"
1910	wx.PostEvent(self.parent, StatusEvent(status=msg))
1911	self.save_current_state()
1912	event = PageInfoEvent(page=self)
1913	wx.PostEvent(self.parent, event)
1914	self.state_change = False
1915	# Draw the model for a different range
1916	if not self.data.is_data:
1917	self.create_default_data()
1918	self._draw_model()
1919
1920	def _theory_qrange_enter(self, event):
1921	"""
1922	Check validity of value enter in the Q range field
1923	"""
1924
1925	tcrtl = event.GetEventObject()
1926	# Clear msg if previously shown.
1927	msg = ""
1928	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1929	# Flag to register when a parameter has changed.
1930	is_modified = False
1931	if tcrtl.GetValue().lstrip().rstrip() != "":
1932	try:
1933	value = float(tcrtl.GetValue())
1934	tcrtl.SetBackgroundColour(wx.WHITE)
1935
1936	# If qmin and qmax have been modified, update qmin and qmax
1937	if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1938	tempmin = float(self.theory_qmin.GetValue())
1939	if tempmin != self.theory_qmin_x:
1940	self.theory_qmin_x = tempmin
1941	tempmax = float(self.theory_qmax.GetValue())
1942	if tempmax != self.qmax_x:
1943	self.theory_qmax_x = tempmax
1944	else:
1945	tcrtl.SetBackgroundColour("pink")
1946	msg = "Model Error: wrong value entered: %s" % \
1947	sys.exc_info()[1]
1948	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1949	return
1950	except:
1951	tcrtl.SetBackgroundColour("pink")
1952	msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1953	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1954	return
1955	# Check if # of points for theory model are valid(>0).
1956	if self.Npts_total.IsEditable():
1957	if check_float(self.Npts_total):
1958	temp_npts = float(self.Npts_total.GetValue())
1959	if temp_npts != self.num_points:
1960	self.num_points = temp_npts
1961	is_modified = True
1962	else:
1963	msg = "Cannot Plot: No points in Q range!!! "
1964	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1965	else:
1966	tcrtl.SetBackgroundColour("pink")
1967	msg = "Model Error: wrong value entered!!!"
1968	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1969	self.save_current_state()
1970	event = PageInfoEvent(page=self)
1971	wx.PostEvent(self.parent, event)
1972	self.state_change = False
1973	# Draw the model for a different range
1974	self.create_default_data()
1975	self._draw_model()
1976
1977	def _on_select_model_helper(self):
1978	"""
1979	call back for model selection
1980	"""
1981	# reset dictionary containing reference to dispersion
1982	self._disp_obj_dict = {}
1983	self.disp_cb_dict = {}
1984	self.temp_multi_functional = False
1985	f_id = self.formfactorbox.GetCurrentSelection()
1986	# For MAC
1987	form_factor = None
1988	if f_id >= 0:
1989	form_factor = self.formfactorbox.GetClientData(f_id)
1990
1991	if form_factor is None or \
1992	not hasattr(form_factor, 'is_form_factor') or \
1993	not form_factor.is_form_factor:
1994	self.structurebox.Hide()
1995	self.text2.Hide()
1996	self.structurebox.Disable()
1997	self.structurebox.SetSelection(0)
1998	self.text2.Disable()
1999	else:
2000	self.structurebox.Show()
2001	self.text2.Show()
2002	self.structurebox.Enable()
2003	self.text2.Enable()
2004
2005	if form_factor is not None:
2006	# set multifactor for Mutifunctional models
2007	if form_factor.is_multiplicity_model:
2008	m_id = self.multifactorbox.GetCurrentSelection()
2009	multiplicity = form_factor.multiplicity_info[0]
2010	self.multifactorbox.Clear()
2011	self._set_multfactor_combobox(multiplicity)
2012	self._show_multfactor_combobox()
2013	# ToDo: this info should be called directly from the model
2014	text = form_factor.multiplicity_info[1] # 'No. of Shells: '
2015
2016	self.mutifactor_text.SetLabel(text)
2017	if m_id > multiplicity - 1:
2018	# default value
2019	m_id = 1
2020
2021	self.multi_factor = self.multifactorbox.GetClientData(m_id)
2022	if self.multi_factor is None:
2023	self.multi_factor = 0
2024	self.multifactorbox.SetSelection(m_id)
2025	# Check len of the text1 and max_multiplicity
2026	text = ''
2027	if form_factor.multiplicity_info[0] == \
2028	len(form_factor.multiplicity_info[2]):
2029	text = form_factor.multiplicity_info[2][self.multi_factor]
2030	self.mutifactor_text1.SetLabel(text)
2031	# Check if model has get sld profile.
2032	if len(form_factor.multiplicity_info[3]) > 0:
2033	self.sld_axes = form_factor.multiplicity_info[3]
2034	self.show_sld_button.Show(True)
2035	else:
2036	self.sld_axes = ""
2037	else:
2038	self._hide_multfactor_combobox()
2039	self.show_sld_button.Hide()
2040	self.multi_factor = None
2041	else:
2042	self._hide_multfactor_combobox()
2043	self.show_sld_button.Hide()
2044	self.multi_factor = None
2045
2046	s_id = self.structurebox.GetCurrentSelection()
2047	struct_factor = self.structurebox.GetClientData(s_id)
2048
2049	if struct_factor is not None:
2050	from sasmodels.sasview_model import MultiplicationModel
2051	self.model = MultiplicationModel(form_factor(self.multi_factor),
2052	struct_factor())
2053	# multifunctional form factor
2054	if len(form_factor.non_fittable) > 0:
2055	self.temp_multi_functional = True
2056	elif form_factor is not None:
2057	if self.multi_factor is not None:
2058	self.model = form_factor(self.multi_factor)
2059	else:
2060	# old style plugin models do not accept a multiplicity argument
2061	self.model = form_factor()
2062	else:
2063	self.model = None
2064	return
2065
2066	# check if model has magnetic parameters
2067	if len(self.model.magnetic_params) > 0:
2068	self._has_magnetic = True
2069	else:
2070	self._has_magnetic = False
2071	# post state to fit panel
2072	self.state.parameters = []
2073	self.state.model = self.model
2074	self.state.qmin = self.qmin_x
2075	self.state.multi_factor = self.multi_factor
2076	self.disp_list = self.model.getDispParamList()
2077	self.state.disp_list = self.disp_list
2078	self.on_set_focus(None)
2079	self.Layout()
2080
2081	def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2082	"""
2083	Verify that the Q range controls have valid values
2084	and that Qmin < Qmax.
2085
2086	:param qmin_ctrl: text control for Qmin
2087	:param qmax_ctrl: text control for Qmax
2088
2089	:return: True is the Q range is value, False otherwise
2090
2091	"""
2092	qmin_validity = check_float(qmin_ctrl)
2093	qmax_validity = check_float(qmax_ctrl)
2094	if not (qmin_validity and qmax_validity):
2095	return False
2096	else:
2097	qmin = float(qmin_ctrl.GetValue())
2098	qmax = float(qmax_ctrl.GetValue())
2099	if qmin < qmax:
2100	# Make sure to set both colours white.
2101	qmin_ctrl.SetBackgroundColour(wx.WHITE)
2102	qmin_ctrl.Refresh()
2103	qmax_ctrl.SetBackgroundColour(wx.WHITE)
2104	qmax_ctrl.Refresh()
2105	else:
2106	qmin_ctrl.SetBackgroundColour("pink")
2107	qmin_ctrl.Refresh()
2108	qmax_ctrl.SetBackgroundColour("pink")
2109	qmax_ctrl.Refresh()
2110	msg = "Invalid Q range: Q min must be smaller than Q max"
2111	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2112	return False
2113	return True
2114
2115	def _validate_Npts(self):
2116	"""
2117	Validate the number of points for fitting is more than 10 points.
2118	If valid, setvalues Npts_fit otherwise post msg.
2119	"""
2120	# default flag
2121	flag = True
2122	# Theory
2123	if self.data is None and self.enable2D:
2124	return flag
2125	for data in self.data_list:
2126	# q value from qx and qy
2127	radius = np.sqrt(data.qx_data * data.qx_data +
2128	data.qy_data * data.qy_data)
2129	# get unmasked index
2130	index_data = (float(self.qmin.GetValue()) <= radius) & \
2131	(radius <= float(self.qmax.GetValue()))
2132	index_data = (index_data) & (data.mask)
2133	index_data = (index_data) & (np.isfinite(data.data))
2134
2135	if len(index_data[index_data]) < 10:
2136	# change the color pink.
2137	self.qmin.SetBackgroundColour("pink")
2138	self.qmin.Refresh()
2139	self.qmax.SetBackgroundColour("pink")
2140	self.qmax.Refresh()
2141	msg = "Data Error: "
2142	msg += "Too few points in %s." % data.name
2143	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2144	self.fitrange = False
2145	flag = False
2146	else:
2147	self.Npts_fit.SetValue(str(len(index_data[index_data])))
2148	self.fitrange = True
2149
2150	return flag
2151
2152	def _validate_Npts_1D(self):
2153	"""
2154	Validate the number of points for fitting is more than 5 points.
2155	If valid, setvalues Npts_fit otherwise post msg.
2156	"""
2157	# default flag
2158	flag = True
2159	# Theory
2160	if self.data is None:
2161	return flag
2162	for data in self.data_list:
2163	# q value from qx and qy
2164	radius = data.x
2165	# get unmasked index
2166	index_data = (float(self.qmin.GetValue()) <= radius) & \
2167	(radius <= float(self.qmax.GetValue()))
2168	index_data = (index_data) & (np.isfinite(data.y))
2169
2170	if len(index_data[index_data]) < 5:
2171	# change the color pink.
2172	self.qmin.SetBackgroundColour("pink")
2173	self.qmin.Refresh()
2174	self.qmax.SetBackgroundColour("pink")
2175	self.qmax.Refresh()
2176	msg = "Data Error: "
2177	msg += "Too few points in %s." % data.name
2178	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2179	self.fitrange = False
2180	flag = False
2181	else:
2182	self.Npts_fit.SetValue(str(len(index_data[index_data])))
2183	self.fitrange = True
2184
2185	return flag
2186
2187	def _check_value_enter(self, list):
2188	"""
2189	:param list: model parameter and panel info
2190	:Note: each item of the list should be as follow:
2191	item=[check button state, parameter's name,
2192	paramater's value, string="+/-",
2193	parameter's error of fit,
2194	parameter's minimum value,
2195	parameter's maximum value ,
2196	parameter's units]
2197
2198	Returns True if the model parameters have changed.
2199	"""
2200	is_modified = False
2201	for item in list:
2202	# skip angle parameters for 1D
2203	if not self.enable2D and item in self.orientation_params:
2204	continue
2205
2206	value_ctrl = item[2]
2207	if not value_ctrl.IsEnabled():
2208	# ArrayDispersion disables PD, Min, Max, Npts, Nsigs
2209	continue
2210
2211	name = item[1]
2212	value_str = value_ctrl.GetValue().strip()
2213	if name.endswith(".npts"):
2214	validity = check_int(value_ctrl)
2215	if not validity:
2216	continue
2217	value = int(value_str)
2218
2219	elif name.endswith(".nsigmas"):
2220	validity = check_float(value_ctrl)
2221	if not validity:
2222	continue
2223	value = float(value_str)
2224
2225	else: # value or polydispersity
2226
2227	# Check that min, max and value are floats
2228	min_ctrl, max_ctrl = item[5], item[6]
2229	min_str = min_ctrl.GetValue().strip()
2230	max_str = max_ctrl.GetValue().strip()
2231	validity = check_float(value_ctrl)
2232	if min_str != "":
2233	validity = validity and check_float(min_ctrl)
2234	if max_str != "":
2235	validity = validity and check_float(max_ctrl)
2236	if not validity:
2237	continue
2238
2239	# Check that min is less than max
2240	low = -np.inf if min_str == "" else float(min_str)
2241	high = np.inf if max_str == "" else float(max_str)
2242	if high < low:
2243	min_ctrl.SetBackgroundColour("pink")
2244	min_ctrl.Refresh()
2245	max_ctrl.SetBackgroundColour("pink")
2246	max_ctrl.Refresh()
2247	# msg = "Invalid fit range for %s: min must be smaller
2248	# than max"%name
2249	# wx.PostEvent(self._manager.parent,
2250	# StatusEvent(status=msg))
2251	continue
2252
2253	# Force value between min and max
2254	value = float(value_str)
2255	if value < low:
2256	value = low
2257	value_ctrl.SetValue(format_number(value))
2258	elif value > high:
2259	value = high
2260	value_ctrl.SetValue(format_number(value))
2261
2262	if name not in self.model.details.keys():
2263	self.model.details[name] = ["", None, None]
2264	old_low, old_high = self.model.details[name][1:3]
2265	if old_low != low or old_high != high:
2266	# The configuration has changed but it won't change the
2267	# computed curve so no need to set is_modified to True
2268	# is_modified = True
2269	self.model.details[name][1:3] = low, high
2270
2271	# Update value in model if it has changed
2272	if value != self.model.getParam(name):
2273	self.model.setParam(name, value)
2274	is_modified = True
2275
2276	return is_modified
2277
2278	def _set_dipers_Param(self, event):
2279	"""
2280	respond to self.enable_disp and self.disable_disp radio box.
2281	The dispersity object is reset inside the model into Gaussian.
2282	When the user select yes , this method display a combo box for
2283	more selection when the user selects No,the combo box disappears.
2284	Redraw the model with the default dispersity (Gaussian)
2285	"""
2286	# On selction if no model exists.
2287	if self.model is None:
2288	self.disable_disp.SetValue(True)
2289	msg = "Please select a Model first..."
2290	wx.MessageBox(msg, 'Info')
2291	wx.PostEvent(self._manager.parent,
2292	StatusEvent(status="Polydispersion: %s" % msg))
2293	return
2294
2295	self._reset_dispersity()
2296
2297	if self.model is None:
2298	self.model_disp.Hide()
2299	self.sizer4_4.Clear(True)
2300	return
2301
2302	if self.enable_disp.GetValue():
2303	# layout for model containing no dispersity parameters
2304
2305	self.disp_list = self.model.getDispParamList()
2306
2307	if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0:
2308	self._layout_sizer_noDipers()
2309	else:
2310	# set gaussian sizer
2311	self._on_select_Disp(event=None)
2312	else:
2313	self.sizer4_4.Clear(True)
2314
2315	# post state to fit panel
2316	self.save_current_state()
2317	if event is not None:
2318	event = PageInfoEvent(page=self)
2319	wx.PostEvent(self.parent, event)
2320	# draw the model with the current dispersity
2321
2322	# Wojtek P, Oct 8, 2016: Calling draw_model seems to be unessecary.
2323	# By comenting it we save an extra Iq calculation
2324	# self._draw_model()
2325
2326	# Need to use FitInside again here to replace the next four lines.
2327	# Otherwised polydispersity off does not resize the scrollwindow.
2328	# PDB Nov 28, 2015
2329	self.FitInside()
2330	# self.sizer4_4.Layout()
2331	# self.sizer5.Layout()
2332	# self.Layout()
2333	# self.Refresh()
2334
2335	def _layout_sizer_noDipers(self):
2336	"""
2337	Draw a sizer with no dispersity info
2338	"""
2339	ix = 0
2340	iy = 1
2341	self.fittable_param = []
2342	self.fixed_param = []
2343	self.orientation_params_disp = []
2344
2345	self.sizer4_4.Clear(True)
2346	text = "No polydispersity available for this model"
2347	model_disp = wx.StaticText(self, wx.ID_ANY, text)
2348	self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
2349	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
2350	self.sizer4_4.Layout()
2351	self.sizer4.Layout()
2352
2353	def _reset_dispersity(self):
2354	"""
2355	put gaussian dispersity into current model
2356	"""
2357	if len(self.param_toFit) > 0:
2358	for item in self.fittable_param:
2359	if item in self.param_toFit:
2360	self.param_toFit.remove(item)
2361
2362	for item in self.orientation_params_disp:
2363	if item in self.param_toFit:
2364	self.param_toFit.remove(item)
2365
2366	self.fittable_param = []
2367	self.fixed_param = []
2368	self.orientation_params_disp = []
2369	self.values = {}
2370	self.weights = {}
2371
2372	# from sas.models.dispersion_models import GaussianDispersion
2373	from sasmodels.weights import GaussianDispersion
2374	if len(self.disp_cb_dict) == 0:
2375	self.save_current_state()
2376	self.sizer4_4.Clear(True)
2377	self.Layout()
2378	return
2379	if (len(self.disp_cb_dict) > 0):
2380	for p in self.disp_cb_dict:
2381	# The parameter was un-selected.
2382	# Go back to Gaussian model (with 0 pts)
2383	disp_model = GaussianDispersion()
2384
2385	self._disp_obj_dict[p] = disp_model
2386	# Set the new model as the dispersion object
2387	# for the selected parameter
2388	try:
2389	self.model.set_dispersion(p, disp_model)
2390	except Exception:
2391	logger.error(traceback.format_exc())
2392
2393	# save state into
2394	self.save_current_state()
2395	self.Layout()
2396	self.Refresh()
2397
2398	def _on_select_Disp(self, event):
2399	"""
2400	allow selecting different dispersion
2401	self.disp_list should change type later .now only gaussian
2402	"""
2403	self._set_sizer_dispersion()
2404
2405	# Redraw the model
2406	# Wojtek P. Nov 7, 2016: Redrawing seems to be unnecessary here
2407	# self._draw_model()
2408	# self._undo.Enable(True)
2409	event = PageInfoEvent(page=self)
2410	wx.PostEvent(self.parent, event)
2411
2412	self.sizer4_4.Layout()
2413	self.sizer4.Layout()
2414	self.SetupScrolling()
2415
2416	def _on_disp_func(self, event=None):
2417	"""
2418	Select a distribution function for the polydispersion
2419
2420	:Param event: ComboBox event
2421	"""
2422	# get ready for new event
2423	if event is not None:
2424	event.Skip()
2425	# Get event object
2426	disp_box = event.GetEventObject()
2427
2428	# Try to select a Distr. function
2429	try:
2430	disp_box.SetBackgroundColour("white")
2431	selection = disp_box.GetCurrentSelection()
2432	param_name = disp_box.Name.split('.')[0]
2433	disp_name = disp_box.GetValue()
2434	dispersity = disp_box.GetClientData(selection)
2435
2436	# disp_model = GaussianDispersion()
2437	disp_model = dispersity()
2438	# Get param names to reset the values of the param
2439	name1 = param_name + ".width"
2440	name2 = param_name + ".npts"
2441	name3 = param_name + ".nsigmas"
2442	# Check Disp. function whether or not it is 'array'
2443	if disp_name.lower() == "array":
2444	value2 = ""
2445	value3 = ""
2446	value1 = self._set_array_disp(name=name1, disp=disp_model)
2447	else:
2448	self._del_array_values(name1)
2449	# self._reset_array_disp(param_name)
2450	self._disp_obj_dict[name1] = disp_model
2451	self.model.set_dispersion(param_name, disp_model)
2452	self.state._disp_obj_dict[name1] = disp_model.type
2453
2454	value1 = str(format_number(self.model.getParam(name1), True))
2455	value2 = str(format_number(self.model.getParam(name2)))
2456	value3 = str(format_number(self.model.getParam(name3)))
2457	# Reset fittable polydispersin parameter value
2458	for item in self.fittable_param:
2459	if item[1] == name1:
2460	item[2].SetValue(value1)
2461	item[5].SetValue("")
2462	item[6].SetValue("")
2463	# Disable for array
2464	if disp_name.lower() == "array":
2465	item[0].SetValue(False)
2466	item[0].Disable()
2467	item[2].Disable()
2468	item[3].Show(False)
2469	item[4].Show(False)
2470	item[5].Disable()
2471	item[6].Disable()
2472	else:
2473	item[0].Enable()
2474	item[2].Enable()
2475	item[3].Show(True)
2476	item[4].Show(True)
2477	item[5].Enable()
2478	item[6].Enable()
2479	break
2480	# Reset fixed polydispersion params
2481	for item in self.fixed_param:
2482	if item[1] == name2:
2483	item[2].SetValue(value2)
2484	# Disable Npts for array
2485	if disp_name.lower() == "array":
2486	item[2].Disable()
2487	else:
2488	item[2].Enable()
2489	if item[1] == name3:
2490	item[2].SetValue(value3)
2491	# Disable Nsigs for array
2492	if disp_name.lower() == "array":
2493	item[2].Disable()
2494	else:
2495	item[2].Enable()
2496
2497	# Make sure the check box updated
2498	self.get_all_checked_params()
2499
2500	# update params
2501	self._update_paramv_on_fit()
2502	# draw
2503	self._draw_model()
2504	self.Refresh()
2505	except Exception:
2506	logger.error(traceback.format_exc())
2507	# Error msg
2508	msg = "Error occurred:"
2509	msg += " Could not select the distribution function..."
2510	msg += " Please select another distribution function."
2511	disp_box.SetBackgroundColour("pink")
2512	# Focus on Fit button so that users can see the pinky box
2513	self.btFit.SetFocus()
2514	wx.PostEvent(self._manager.parent,
2515	StatusEvent(status=msg, info="error"))
2516
2517	def _set_array_disp(self, name=None, disp=None):
2518	"""
2519	Set array dispersion
2520
2521	:param name: name of the parameter for the dispersion to be set
2522	:param disp: the polydisperion object
2523	"""
2524	# The user wants this parameter to be averaged.
2525	# Pop up the file selection dialog.
2526	path = self._selectDlg()
2527	# Array data
2528	values = []
2529	weights = []
2530	# If nothing was selected, just return
2531	if path is None:
2532	self.disp_cb_dict[name].SetValue(False)
2533	# self.noDisper_rbox.SetValue(True)
2534	return
2535	self._default_save_location = os.path.dirname(path)
2536	if self._manager is not None:
2537	self._manager.parent._default_save_location = \
2538	self._default_save_location
2539
2540	basename = os.path.basename(path)
2541	values, weights = self.read_file(path)
2542
2543	# If any of the two arrays is empty, notify the user that we won't
2544	# proceed
2545	if len(self.param_toFit) > 0:
2546	if name in self.param_toFit:
2547	self.param_toFit.remove(name)
2548
2549	# Tell the user that we are about to apply the distribution
2550	msg = "Applying loaded %s distribution: %s" % (name, path)
2551	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2552	self._set_array_disp_model(name=name, disp=disp,
2553	values=values, weights=weights)
2554	return basename
2555
2556	def _set_array_disp_model(self, name=None, disp=None,
2557	values=[], weights=[]):
2558	"""
2559	Set array dispersion model
2560
2561	:param name: name of the parameter for the dispersion to be set
2562	:param disp: the polydisperion object
2563	"""
2564	disp.set_weights(values, weights)
2565	self._disp_obj_dict[name] = disp
2566	self.model.set_dispersion(name.split('.')[0], disp)
2567	self.state._disp_obj_dict[name] = disp.type
2568	self.values[name] = values
2569	self.weights[name] = weights
2570	# Store the object to make it persist outside the
2571	# scope of this method
2572	# TODO: refactor model to clean this up?
2573	self.state.values = {}
2574	self.state.weights = {}
2575	self.state.values = copy.deepcopy(self.values)
2576	self.state.weights = copy.deepcopy(self.weights)
2577
2578	# Set the new model as the dispersion object for the
2579	# selected parameter
2580	# self.model.set_dispersion(p, disp_model)
2581	# Store a reference to the weights in the model object
2582	# so that
2583	# it's not lost when we use the model within another thread.
2584	self.state.model = self.model.clone()
2585	self.model._persistency_dict[name.split('.')[0]] = \
2586	[values, weights]
2587	self.state.model._persistency_dict[name.split('.')[0]] = \
2588	[values, weights]
2589
2590	def _del_array_values(self, name=None):
2591	"""
2592	Reset array dispersion
2593
2594	:param name: name of the parameter for the dispersion to be set
2595	"""
2596	# Try to delete values and weight of the names array dic if exists
2597	try:
2598	if name in self.values:
2599	del self.values[name]
2600	del self.weights[name]
2601	# delete all other dic
2602	del self.state.values[name]
2603	del self.state.weights[name]
2604	del self.model._persistency_dict[name.split('.')[0]]
2605	del self.state.model._persistency_dict[name.split('.')[0]]
2606	except Exception:
2607	logger.error(traceback.format_exc())
2608
2609	def _lay_out(self):
2610	"""
2611	returns self.Layout
2612
2613	:Note: Mac seems to like this better when self.
2614	Layout is called after fitting.
2615	"""
2616	self.Layout()
2617	return
2618
2619	def _find_polyfunc_selection(self, disp_func=None):
2620	"""
2621	FInd Comboox selection from disp_func
2622
2623	:param disp_function: dispersion distr. function
2624	"""
2625	# Find the selection
2626	if disp_func is not None:
2627	try:
2628	return POLYDISPERSITY_MODELS.values().index(disp_func.__class__)
2629	except ValueError:
2630	pass # Fall through to default class
2631	return POLYDISPERSITY_MODELS.keys().index('gaussian')
2632
2633	def on_reset_clicked(self, event):
2634	"""
2635	On 'Reset' button for Q range clicked
2636	"""
2637	flag = True
2638	# For 3 different cases: Data2D, Data1D, and theory
2639	if self.model is None:
2640	msg = "Please select a model first..."
2641	wx.MessageBox(msg, 'Info')
2642	flag = False
2643	return
2644
2645	elif self.data.__class__.__name__ == "Data2D":
2646	data_min = 0
2647	x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2648	y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2649	self.qmin_x = data_min
2650	self.qmax_x = math.sqrt(x * x + y * y)
2651	# self.data.mask = np.ones(len(self.data.data),dtype=bool)
2652	# check smearing
2653	if not self.disable_smearer.GetValue():
2654	# set smearing value whether or
2655	# not the data contain the smearing info
2656	if self.pinhole_smearer.GetValue():
2657	flag = self.update_pinhole_smear()
2658	else:
2659	flag = True
2660
2661	elif self.data is None:
2662	self.qmin_x = _QMIN_DEFAULT
2663	self.qmax_x = _QMAX_DEFAULT
2664	self.num_points = _NPTS_DEFAULT
2665	self.state.npts = self.num_points
2666
2667	elif self.data.__class__.__name__ != "Data2D":
2668	self.qmin_x = min(self.data.x)
2669	self.qmax_x = max(self.data.x)
2670	# check smearing
2671	if not self.disable_smearer.GetValue():
2672	# set smearing value whether or
2673	# not the data contain the smearing info
2674	if self.slit_smearer.GetValue():
2675	flag = self.update_slit_smear()
2676	elif self.pinhole_smearer.GetValue():
2677	flag = self.update_pinhole_smear()
2678	else:
2679	flag = True
2680	else:
2681	flag = False
2682
2683	if flag is False:
2684	msg = "Cannot Plot :Must enter a number!!! "
2685	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2686	else:
2687	# set relative text ctrs.
2688	self.qmin.SetValue(str(self.qmin_x))
2689	self.qmax.SetValue(str(self.qmax_x))
2690	self.show_npts2fit()
2691	# At this point, some button and variables satatus (disabled?)
2692	# should be checked such as color that should be reset to
2693	# white in case that it was pink.
2694	self._onparamEnter_helper()
2695
2696	self.save_current_state()
2697	self.state.qmin = self.qmin_x
2698	self.state.qmax = self.qmax_x
2699
2700	# reset the q range values
2701	self._reset_plotting_range(self.state)
2702	self._draw_model()
2703
2704	def select_log(self, event):
2705	"""
2706	Log checked to generate log spaced points for theory model
2707	"""
2708
2709	def get_images(self):
2710	"""
2711	Get the images of the plots corresponding this panel for report
2712
2713	: return graphs: list of figures
2714	: Need Move to guiframe
2715	"""
2716	# set list of graphs
2717	graphs = []
2718	canvases = []
2719	res_item = None
2720	# call gui_manager
2721	gui_manager = self._manager.parent
2722	# loops through the panels [dic]
2723	for _, item2 in gui_manager.plot_panels.iteritems():
2724	data_title = self.data.group_id
2725	# try to get all plots belonging to this control panel
2726	try:
2727	g_id = item2.group_id
2728	if g_id == data_title or \
2729	str(g_id).count("res" + str(self.graph_id)) or \
2730	str(g_id).count(str(self.uid)) > 0:
2731	if str(g_id).count("res" + str(self.graph_id)) > 0:
2732	res_item = [item2.figure, item2.canvas]
2733	else:
2734	# append to the list
2735	graphs.append(item2.figure)
2736	canvases.append(item2.canvas)
2737	except Exception:
2738	# Not for control panels
2739	logger.error(traceback.format_exc())
2740	# Make sure the resduals plot goes to the last
2741	if res_item is not None:
2742	graphs.append(res_item[0])
2743	canvases.append(res_item[1])
2744	# return the list of graphs
2745	return graphs, canvases
2746
2747	def on_function_help_clicked(self, event):
2748	"""
2749	Function called when 'Help' button is pressed next to model
2750	of interest. This calls DocumentationWindow from
2751	documentation_window.py. It will load the top level of the model
2752	help documenation sphinx generated html if no model is presented.
2753	If a model IS present then if documention for that model exists
2754	it will load to that point otherwise again it will go to the top.
2755	For Wx2.8 and below is used (i.e. non-released through installer)
2756	a browser is loaded and the top of the model documentation only is
2757	accessible because webbrowser module does not pass anything after
2758	the # to the browser.
2759
2760	:param event: on Help Button pressed event
2761	"""
2762
2763	if self.model is not None:
2764	name = self.formfactorbox.GetValue()
2765	_TreeLocation = 'user/models/' + name.lower()+'.html'
2766	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2767	"", name + " Help")
2768	else:
2769	_TreeLocation = 'user/index.html'
2770	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2771	"", "General Model Help")
2772
2773	def on_model_help_clicked(self, event):
2774	"""
2775	Function called when 'Description' button is pressed next to model
2776	of interest. This calls the Description embedded in the model. This
2777	should work with either Wx2.8 and lower or higher. If no model is
2778	selected it will give the message that a model must be chosen first
2779	in the box that would normally contain the description. If a badly
2780	behaved model is encountered which has no description then it will
2781	give the message that none is available.
2782
2783	:param event: on Description Button pressed event
2784	"""
2785
2786	if self.model is None:
2787	name = 'index.html'
2788	else:
2789	name = self.formfactorbox.GetValue()
2790
2791	msg = 'Model description:\n'
2792	info = "Info"
2793	if self.model is not None:
2794	# frame.Destroy()
2795	if str(self.model.description).rstrip().lstrip() == '':
2796	msg += "Sorry, no information is available for this model."
2797	else:
2798	msg += self.model.description + '\n'
2799	wx.MessageBox(msg, info)
2800	else:
2801	msg += "You must select a model to get information on this"
2802	wx.MessageBox(msg, info)
2803
2804	def _on_mag_angle_help(self, event):
2805	"""
2806	Bring up Magnetic Angle definition bmp image whenever the ? button
2807	is clicked. Calls DocumentationWindow with the path of the location
2808	within the documentation tree (after /doc/ ....". When using old
2809	versions of Wx (i.e. before 2.9 and therefore not part of release
2810	versions distributed via installer) it brings up an image viewer
2811	box which allows the user to click through the rest of the images in
2812	the directory. Not ideal but probably better than alternative which
2813	would bring up the entire discussion of how magnetic models work?
2814	Specially since it is not likely to be accessed. The normal release
2815	versions bring up the normal image box.
2816
2817	:param evt: Triggers on clicking ? in Magnetic Angles? box
2818	"""
2819
2820	_TreeLocation = "_images/M_angles_pic.bmp"
2821	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2822	"Magnetic Angle Defintions")
2823
2824	def _on_mag_help(self, event):
2825	"""
2826	Bring up Magnetic Angle definition bmp image whenever the ? button
2827	is clicked. Calls DocumentationWindow with the path of the location
2828	within the documentation tree (after /doc/ ....". When using old
2829	versions of Wx (i.e. before 2.9 and therefore not part of release
2830	versions distributed via installer) it brings up an image viewer
2831	box which allows the user to click through the rest of the images in
2832	the directory. Not ideal but probably better than alternative which
2833	would bring up the entire discussion of how magnetic models work?
2834	Specially since it is not likely to be accessed. The normal release
2835	versions bring up the normal image box.
2836
2837	:param evt: Triggers on clicking ? in Magnetic Angles? box
2838	"""
2839
2840	_TreeLocation = "user/magnetism.html"
2841	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2842	"Polarized Beam/Magnetc Help")
2843
2844	def _on_mag_on(self, event):
2845	"""
2846	Magnetic Parameters ON/OFF
2847	"""
2848	button = event.GetEventObject()
2849
2850	if button.GetLabel().count('ON') > 0:
2851	self.magnetic_on = True
2852	button.SetLabel("Magnetic OFF")
2853	m_value = 1.0e-06
2854	for key in self.model.magnetic_params:
2855	if key.count('M0') > 0:
2856	self.model.setParam(key, m_value)
2857	m_value += 0.5e-06
2858	else:
2859	self.magnetic_on = False
2860	button.SetLabel("Magnetic ON")
2861	for key in self.model.magnetic_params:
2862	if key.count('M0') > 0:
2863	# reset mag value to zero fo safety
2864	self.model.setParam(key, 0.0)
2865
2866	self.Show(False)
2867	self.set_model_param_sizer(self.model)
2868	# self._set_sizer_dispersion()
2869	self.state.magnetic_on = self.magnetic_on
2870	self.SetupScrolling()
2871	self.Show(True)
2872
2873	def on_pd_help_clicked(self, event):
2874	"""
2875	Bring up Polydispersity Documentation whenever the ? button is clicked.
2876	Calls DocumentationWindow with the path of the location within the
2877	documentation tree (after /doc/ ....". Note that when using old
2878	versions of Wx (before 2.9) and thus not the release version of
2879	istallers, the help comes up at the top level of the file as
2880	webbrowser does not pass anything past the # to the browser when it is
2881	running "file:///...."
2882
2883	:param event: Triggers on clicking ? in polydispersity box
2884	"""
2885
2886	_TreeLocation = "user/sasgui/perspectives/fitting/pd_help.html"
2887	_PageAnchor = ""
2888	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2889	_PageAnchor, "Polydispersity Help")
2890
2891	def on_left_down(self, event):
2892	"""
2893	Get key stroke event
2894	"""
2895	# Figuring out key combo: Cmd for copy, Alt for paste
2896	if event.CmdDown() and event.ShiftDown():
2897	self.get_paste()
2898	elif event.CmdDown():
2899	self.get_copy()
2900	else:
2901	event.Skip()
2902	return
2903	# make event free
2904	event.Skip()
2905
2906	def get_copy(self):
2907	"""
2908	Get copy params to clipboard
2909	"""
2910	content = self.get_copy_params()
2911	flag = self.set_clipboard(content)
2912	self._copy_info(flag)
2913	return flag
2914
2915	def get_copy_params(self):
2916	"""
2917	Get the string copies of the param names and values in the tap
2918	"""
2919	content = 'sasview_parameter_values:'
2920	# Do it if params exist
2921	if self.parameters:
2922
2923	# go through the parameters
2924	strings = self._get_copy_helper(self.parameters,
2925	self.orientation_params)
2926	content += strings
2927
2928	# go through the fittables
2929	strings = self._get_copy_helper(self.fittable_param,
2930	self.orientation_params_disp)
2931	content += strings
2932
2933	# go through the fixed params
2934	strings = self._get_copy_helper(self.fixed_param,
2935	self.orientation_params_disp)
2936	content += strings
2937
2938	# go through the str params
2939	strings = self._get_copy_helper(self.str_parameters,
2940	self.orientation_params)
2941	content += strings
2942	return content
2943	else:
2944	return False
2945
2946	def get_copy_excel(self):
2947	"""
2948	Get copy params to clipboard
2949	"""
2950	content = self.get_copy_params_excel()
2951	flag = self.set_clipboard(content)
2952	self._copy_info(flag)
2953	return flag
2954
2955	def get_copy_params_excel(self):
2956	"""
2957	Get the string copies of the param names and values in the tap
2958	"""
2959	content = ''
2960
2961	crlf = chr(13) + chr(10)
2962	tab = chr(9)
2963
2964	# Do it if params exist
2965	if self.parameters:
2966
2967	for param in self.parameters:
2968	content += param[1] # parameter name
2969	content += tab
2970	content += param[1] + "_err"
2971	content += tab
2972
2973	content += crlf
2974
2975	# row of values and errors...
2976	for param in self.parameters:
2977	content += param[2].GetValue() # value
2978	content += tab
2979	content += param[4].GetValue() # error
2980	content += tab
2981
2982	return content
2983	else:
2984	return False
2985
2986	def get_copy_latex(self):
2987	"""
2988	Get copy params to clipboard
2989	"""
2990	content = self.get_copy_params_latex()
2991	flag = self.set_clipboard(content)
2992	self._copy_info(flag)
2993	return flag
2994
2995	def get_copy_params_latex(self):
2996	"""
2997	Get the string copies of the param names and values in the tap
2998	"""
2999	content = '\\begin{table}'
3000	content += '\\begin{tabular}[h]'
3001
3002	crlf = chr(13) + chr(10)
3003	tab = chr(9)
3004
3005	# Do it if params exist
3006	if self.parameters:
3007
3008	content += '{\|'
3009	for param in self.parameters:
3010	content += 'l\|l\|'
3011	content += '}\hline'
3012	content += crlf
3013
3014	for index, param in enumerate(self.parameters):
3015	content += param[1].replace('_', '\_') # parameter name
3016	content += ' & '
3017	content += param[1].replace('_', '\_') + "\_err"
3018	if index < len(self.parameters) - 1:
3019	content += ' & '
3020	content += '\\\\ \\hline'
3021	content += crlf
3022
3023	# row of values and errors...
3024	for index, param in enumerate(self.parameters):
3025	content += param[2].GetValue() # parameter value
3026	content += ' & '
3027	content += param[4].GetValue() # parameter error
3028	if index < len(self.parameters) - 1:
3029	content += ' & '
3030	content += '\\\\ \\hline'
3031	content += crlf
3032
3033	content += '\\end{tabular}'
3034	content += '\\end{table}'
3035	return content
3036	else:
3037	return False
3038
3039	def set_clipboard(self, content=None):
3040	"""
3041	Put the string to the clipboard
3042	"""
3043	if not content:
3044	return False
3045	if wx.TheClipboard.Open():
3046	wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
3047	wx.TheClipboard.Close()
3048	return True
3049	return None
3050
3051	def _get_copy_helper(self, param, orient_param):
3052	"""
3053	Helping get value and name of the params
3054
3055	: param param: parameters
3056	: param orient_param = oritational params
3057	: return content: strings [list] [name,value:....]
3058	"""
3059	content = ''
3060	bound_hi = ''
3061	bound_lo = ''
3062	# go through the str params
3063	for item in param:
3064	# copy only the params shown
3065	if not item[2].IsShown():
3066	continue
3067	disfunc = ''
3068	try:
3069	if item[7].__class__.__name__ == 'ComboBox':
3070	disfunc = str(item[7].GetValue())
3071	except Exception:
3072	logger.error(traceback.format_exc())
3073
3074	# 2D
3075	if self.data.__class__.__name__ == "Data2D":
3076	try:
3077	check = item[0].GetValue()
3078	except Exception:
3079	check = None
3080	name = item[1]
3081	value = item[2].GetValue()
3082	# 1D
3083	else:
3084	# for 1D all parameters except orientation
3085	if not item[1] in orient_param:
3086	try:
3087	check = item[0].GetValue()
3088	except:
3089	check = None
3090	name = item[1]
3091	value = item[2].GetValue()
3092
3093	# Bounds
3094	try:
3095	bound_lo = item[5].GetValue()
3096	bound_hi = item[6].GetValue()
3097	except Exception:
3098	# harmless - need to just pass
3099	pass
3100
3101	# add to the content
3102	if disfunc != '':
3103
3104	disfunc = ',' + disfunc
3105	# Need to support array func for copy/paste
3106	try:
3107	if disfunc.count('array') > 0:
3108	disfunc += ','
3109	for val in self.values[name]:
3110	disfunc += ' ' + str(val)
3111	disfunc += ','
3112	for weight in self.weights[name]:
3113	disfunc += ' ' + str(weight)
3114	except Exception:
3115	logger.error(traceback.format_exc())
3116	content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
3117	bound_lo + ',' + bound_hi + ':'
3118
3119	return content
3120
3121	def get_clipboard(self):
3122	"""
3123	Get strings in the clipboard
3124	"""
3125	text = ""
3126	# Get text from the clip board
3127	if wx.TheClipboard.Open():
3128	if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
3129	data = wx.TextDataObject()
3130	# get wx dataobject
3131	success = wx.TheClipboard.GetData(data)
3132	# get text
3133	if success:
3134	text = data.GetText()
3135	else:
3136	text = ''
3137	# close clipboard
3138	wx.TheClipboard.Close()
3139	return text
3140
3141	def get_paste(self):
3142	"""
3143	Paste params from the clipboard
3144	"""
3145	text = self.get_clipboard()
3146	flag = self.get_paste_params(text)
3147	self._copy_info(flag)
3148	return flag
3149
3150	def get_paste_params(self, text=''):
3151	"""
3152	Get the string copies of the param names and values in the tap
3153	"""
3154	context = {}
3155	# put the text into dictionary
3156	lines = text.split(':')
3157	if lines[0] != 'sasview_parameter_values':
3158	self._copy_info(False)
3159	return False
3160	for line in lines[1:-1]:
3161	if len(line) != 0:
3162	item = line.split(',')
3163	check = item[1]
3164	name = item[0]
3165	value = item[2]
3166	# Transfer the text to content[dictionary]
3167	context[name] = [check, value]
3168
3169	# limits
3170	limit_lo = item[3]
3171	context[name].append(limit_lo)
3172	limit_hi = item[4]
3173	context[name].append(limit_hi)
3174
3175	# ToDo: PlugIn this poly disp function for pasting
3176	try:
3177	poly_func = item[5]
3178	context[name].append(poly_func)
3179	try:
3180	# take the vals and weights for array
3181	array_values = item[6].split(' ')
3182	array_weights = item[7].split(' ')
3183	val = [float(a_val) for a_val in array_values[1:]]
3184	weit = [float(a_weit) for a_weit in array_weights[1:]]
3185
3186	context[name].append(val)
3187	context[name].append(weit)
3188	except:
3189	raise
3190	except:
3191	poly_func = ''
3192	context[name].append(poly_func)
3193
3194	# Do it if params exist
3195	if self.parameters:
3196	# go through the parameters
3197	self._get_paste_helper(self.parameters,
3198	self.orientation_params, context)
3199
3200	# go through the fittables
3201	self._get_paste_helper(self.fittable_param,
3202	self.orientation_params_disp,
3203	context)
3204
3205	# go through the fixed params
3206	self._get_paste_helper(self.fixed_param,
3207	self.orientation_params_disp, context)
3208
3209	# go through the str params
3210	self._get_paste_helper(self.str_parameters,
3211	self.orientation_params, context)
3212
3213	return True
3214	return None
3215
3216	def _get_paste_helper(self, param, orient_param, content):
3217	"""
3218	Helping set values of the params
3219
3220	: param param: parameters
3221	: param orient_param: oritational params
3222	: param content: dictionary [ name, value: name1.value1,...]
3223	"""
3224	# go through the str params
3225	for item in param:
3226	# 2D
3227	if self.data.__class__.__name__ == "Data2D":
3228	name = item[1]
3229	if name in content.keys():
3230	values = content[name]
3231	check = values[0]
3232	pd = values[1]
3233
3234	if name.count('.') > 0:
3235	# If this is parameter.width, then pd may be a floating
3236	# point value or it may be an array distribution.
3237	# Nothing to do for parameter.npts or parameter.nsigmas.
3238	try:
3239	float(pd)
3240	if name.endswith('.npts'):
3241	pd = int(pd)
3242	except Exception:
3243	# continue
3244	if not pd and pd != '':
3245	continue
3246	item[2].SetValue(str(pd))
3247	if item in self.fixed_param and pd == '':
3248	# Only array func has pd == '' case.
3249	item[2].Enable(False)
3250	else:
3251	item[2].Enable(True)
3252	if item[2].__class__.__name__ == "ComboBox":
3253	if content[name][1] in self.model.fun_list:
3254	fun_val = self.model.fun_list[content[name][1]]
3255	self.model.setParam(name, fun_val)
3256	try:
3257	item[5].SetValue(str(values[-3]))
3258	item[6].SetValue(str(values[-2]))
3259	except Exception:
3260	# passing as harmless non-update
3261	pass
3262
3263	value = content[name][1:]
3264	self._paste_poly_help(item, value)
3265	if check == 'True':
3266	is_true = True
3267	elif check == 'False':
3268	is_true = False
3269	else:
3270	is_true = None
3271	if is_true is not None:
3272	item[0].SetValue(is_true)
3273	# 1D
3274	else:
3275	# for 1D all parameters except orientation
3276	if not item[1] in orient_param:
3277	name = item[1]
3278	if name in content.keys():
3279	check = content[name][0]
3280	# Avoid changing combox content
3281	value = content[name][1:]
3282	pd = value[0]
3283	if name.count('.') > 0:
3284	# If this is parameter.width, then pd may be a
3285	# floating point value or it may be an array
3286	# distribution. Nothing to do for parameter.npts or
3287	# parameter.nsigmas.
3288	try:
3289	pd = float(pd)
3290	if name.endswith('.npts'):
3291	pd = int(pd)
3292	except:
3293	# continue
3294	if not pd and pd != '':
3295	continue
3296	item[2].SetValue(str(pd))
3297	if item in self.fixed_param and pd == '':
3298	# Only array func has pd == '' case.
3299	item[2].Enable(False)
3300	else:
3301	item[2].Enable(True)
3302	if item[2].__class__.__name__ == "ComboBox":
3303	if value[0] in self.model.fun_list:
3304	fun_val = self.model.fun_list[value[0]]
3305	self.model.setParam(name, fun_val)
3306	# save state
3307	try:
3308	item[5].SetValue(str(value[-3]))
3309	item[6].SetValue(str(value[-2]))
3310	except Exception:
3311	# passing as harmless non-update
3312	pass
3313
3314	self._paste_poly_help(item, value)
3315	if check == 'True':
3316	is_true = True
3317	elif check == 'False':
3318	is_true = False
3319	else:
3320	is_true = None
3321	if is_true is not None:
3322	item[0].SetValue(is_true)
3323
3324	self.select_param(event=None)
3325	self.Refresh()
3326
3327	def _paste_poly_help(self, item, value):
3328	"""
3329	Helps get paste for poly function
3330
3331	item is the parameter name
3332
3333	value depends on which parameter is being processed, and whether it
3334	has array polydispersity.
3335
3336	For parameters without array polydispersity:
3337
3338	parameter => ['FLOAT', '']
3339	parameter.width => ['FLOAT', 'DISTRIBUTION', '']
3340	parameter.npts => ['FLOAT', '']
3341	parameter.nsigmas => ['FLOAT', '']
3342
3343	For parameters with array polydispersity:
3344
3345	parameter => ['FLOAT', '']
3346	parameter.width => ['FILENAME', 'array', [x1, ...], [w1, ...]]
3347	parameter.npts => ['FLOAT', '']
3348	parameter.nsigmas => ['FLOAT', '']
3349	"""
3350	# Do nothing if not setting polydispersity
3351	if len(value[3]) == 0:
3352	return
3353
3354	try:
3355	name = item[7].Name
3356	param_name = name.split('.')[0]
3357	item[7].SetValue(value[1])
3358	selection = item[7].GetCurrentSelection()
3359	dispersity = item[7].GetClientData(selection)
3360	disp_model = dispersity()
3361
3362	if value[1] == 'array':
3363	pd_vals = np.array(value[2])
3364	pd_weights = np.array(value[3])
3365	if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
3366	msg = ("bad array distribution parameters for %s"
3367	% param_name)
3368	raise ValueError(msg)
3369	self._set_disp_cb(True, item=item)
3370	self._set_array_disp_model(name=name,
3371	disp=disp_model,
3372	values=pd_vals,
3373	weights=pd_weights)
3374	else:
3375	self._set_disp_cb(False, item=item)
3376	self._disp_obj_dict[name] = disp_model
3377	self.model.set_dispersion(param_name, disp_model)
3378	self.state._disp_obj_dict[name] = disp_model.type
3379	# TODO: It's not an array, why update values and weights?
3380	self.model._persistency_dict[param_name] = \
3381	[self.values, self.weights]
3382	self.state.values = self.values
3383	self.state.weights = self.weights
3384
3385	except Exception:
3386	logger.error(traceback.format_exc())
3387	print "Error in BasePage._paste_poly_help: %s" % \
3388	sys.exc_info()[1]
3389
3390	def _set_disp_cb(self, isarray, item):
3391	"""
3392	Set cb for array disp
3393	"""
3394	if isarray:
3395	item[0].SetValue(False)
3396	item[0].Enable(False)
3397	item[2].Enable(False)
3398	item[3].Show(False)
3399	item[4].Show(False)
3400	item[5].SetValue('')
3401	item[5].Enable(False)
3402	item[6].SetValue('')
3403	item[6].Enable(False)
3404	else:
3405	item[0].Enable()
3406	item[2].Enable()
3407	item[3].Show(True)
3408	item[4].Show(True)
3409	item[5].Enable()
3410	item[6].Enable()
3411
3412	def update_pinhole_smear(self):
3413	"""
3414	Method to be called by sub-classes
3415	Moveit; This method doesn't belong here
3416	"""
3417	print "BasicPage.update_pinhole_smear was called: skipping"
3418	return
3419
3420	def _read_category_info(self):
3421	"""
3422	Reads the categories in from file
3423	"""
3424	# # ILL mod starts here - July 2012 kieranrcampbell@gmail.com
3425	self.master_category_dict = defaultdict(list)
3426	self.by_model_dict = defaultdict(list)
3427	self.model_enabled_dict = defaultdict(bool)
3428	categorization_file = CategoryInstaller.get_user_file()
3429	with open(categorization_file, 'rb') as f:
3430	self.master_category_dict = json.load(f)
3431	self._regenerate_model_dict()
3432
3433	def _regenerate_model_dict(self):
3434	"""
3435	regenerates self.by_model_dict which has each model name as the
3436	key and the list of categories belonging to that model
3437	along with the enabled mapping
3438	"""
3439	self.by_model_dict = defaultdict(list)
3440	for category in self.master_category_dict:
3441	for (model, enabled) in self.master_category_dict[category]:
3442	self.by_model_dict[model].append(category)
3443	self.model_enabled_dict[model] = enabled
3444
3445	def _populate_listbox(self):
3446	"""
3447	fills out the category list box
3448	"""
3449	uncat_str = 'Plugin Models'
3450	self._read_category_info()
3451
3452	self.categorybox.Clear()
3453	cat_list = sorted(self.master_category_dict.keys())
3454	if uncat_str not in cat_list:
3455	cat_list.append(uncat_str)
3456
3457	for category in cat_list:
3458	if category != '':
3459	self.categorybox.Append(category)
3460
3461	if self.categorybox.GetSelection() == wx.NOT_FOUND:
3462	self.categorybox.SetSelection(0)
3463	else:
3464	self.categorybox.SetSelection(
3465	self.categorybox.GetSelection())
3466	# self._on_change_cat(None)
3467
3468	def _on_change_cat(self, event):
3469	"""
3470	Callback for category change action
3471	"""
3472	self.model_name = None
3473	category = self.categorybox.GetStringSelection()
3474	if category is None:
3475	return
3476	self.model_box.Clear()
3477
3478	if category == 'Plugin Models':
3479	for model in self.model_list_box[category]:
3480	str_m = str(model).split(".")[0]
3481	self.model_box.Append(str_m)
3482
3483	else:
3484	for (model, enabled) in sorted(self.master_category_dict[category],
3485	key=lambda name: name[0]):
3486	if(enabled):
3487	self.model_box.Append(model)
3488
3489	def _fill_model_sizer(self, sizer):
3490	"""
3491	fill sizer containing model info
3492	"""
3493	# This should only be called once per fit tab
3494	# print "==== Entering _fill_model_sizer"
3495	# Add model function Details button in fitpanel.
3496	# The following 3 lines are for Mac. Let JHC know before modifying...
3497	title = "Model"
3498	self.formfactorbox = None
3499	self.multifactorbox = None
3500	self.mbox_description = wx.StaticBox(self, wx.ID_ANY, str(title))
3501	boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
3502	sizer_cat = wx.BoxSizer(wx.HORIZONTAL)
3503	self.mbox_description.SetForegroundColour(wx.RED)
3504	wx_id = self._ids.next()
3505	self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23))
3506	self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked,
3507	id=wx_id)
3508	self.model_func.SetToolTipString("Full Model Function Help")
3509	wx_id = self._ids.next()
3510	self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23))
3511	self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,
3512	id=wx_id)
3513	self.model_help.SetToolTipString("Short Model Function Description")
3514	wx_id = self._ids.next()
3515	self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23))
3516	self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id)
3517	hint = "toggle view of model from 1D to 2D or 2D to 1D"
3518	self.model_view.SetToolTipString(hint)
3519
3520	cat_set_box = wx.StaticBox(self, wx.ID_ANY, 'Category')
3521	sizer_cat_box = wx.StaticBoxSizer(cat_set_box, wx.HORIZONTAL)
3522	sizer_cat_box.SetMinSize((200, 50))
3523	self.categorybox = wx.ComboBox(self, wx.ID_ANY,
3524	style=wx.CB_READONLY)
3525	self.categorybox.SetToolTip(wx.ToolTip("Select a Category/Type"))
3526	self._populate_listbox()
3527	wx.EVT_COMBOBOX(self.categorybox, wx.ID_ANY, self._show_combox)
3528	# self.shape_rbutton = wx.RadioButton(self, wx.ID_ANY, 'Shapes',
3529	# style=wx.RB_GROUP)
3530	# self.shape_indep_rbutton = wx.RadioButton(self, wx.ID_ANY,
3531	# "Shape-Independent")
3532	# self.struct_rbutton = wx.RadioButton(self, wx.ID_ANY,
3533	# "Structure Factor ")
3534	# self.plugin_rbutton = wx.RadioButton(self, wx.ID_ANY,
3535	# "Uncategorized")
3536
3537	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3538	# id=self.shape_rbutton.GetId())
3539	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3540	# id=self.shape_indep_rbutton.GetId())
3541	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3542	# id=self.struct_rbutton.GetId())
3543	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3544	# id=self.plugin_rbutton.GetId())
3545	# MAC needs SetValue
3546
3547	show_cat_button = wx.Button(self, wx.ID_ANY, "Modify")
3548	cat_tip = "Modify model categories \n"
3549	cat_tip += "(also accessible from the menu bar)."
3550	show_cat_button.SetToolTip(wx.ToolTip(cat_tip))
3551	show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat)
3552	sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3)
3553	sizer_cat_box.Add((10, 10))
3554	sizer_cat_box.Add(show_cat_button)
3555	# self.shape_rbutton.SetValue(True)
3556
3557	sizer_radiobutton = wx.GridSizer(2, 2, 5, 5)
3558	# sizer_radiobutton.Add(self.shape_rbutton)
3559	# sizer_radiobutton.Add(self.shape_indep_rbutton)
3560	sizer_radiobutton.Add((5, 5))
3561	sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5)
3562	# sizer_radiobutton.Add(self.plugin_rbutton)
3563	# sizer_radiobutton.Add(self.struct_rbutton)
3564	# sizer_radiobutton.Add((5,5))
3565	sizer_radiobutton.Add(self.model_help, 1, wx.RIGHT \| wx.LEFT, 5)
3566	# sizer_radiobutton.Add((5,5))
3567	sizer_radiobutton.Add(self.model_func, 1, wx.RIGHT, 5)
3568	sizer_cat.Add(sizer_cat_box, 1, wx.LEFT, 2.5)
3569	sizer_cat.Add(sizer_radiobutton)
3570	sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
3571	mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
3572
3573	self.text1 = wx.StaticText(self, wx.ID_ANY, "")
3574	self.text2 = wx.StaticText(self, wx.ID_ANY, "P(Q)*S(Q)")
3575	self.mutifactor_text = wx.StaticText(self, wx.ID_ANY, "No. of Shells: ")
3576	self.mutifactor_text1 = wx.StaticText(self, wx.ID_ANY, "")
3577	self.show_sld_button = wx.Button(self, wx.ID_ANY, "Show SLD Profile")
3578	self.show_sld_button.Bind(wx.EVT_BUTTON, self._on_show_sld)
3579
3580	self.formfactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3581	self.formfactorbox.SetToolTip(wx.ToolTip("Select a Model"))
3582	if self.model is not None:
3583	self.formfactorbox.SetValue(self.model.name)
3584	self.structurebox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3585	self.multifactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3586	self.initialize_combox()
3587	wx.EVT_COMBOBOX(self.formfactorbox, wx.ID_ANY, self._on_select_model)
3588
3589	wx.EVT_COMBOBOX(self.structurebox, wx.ID_ANY, self._on_select_model)
3590	wx.EVT_COMBOBOX(self.multifactorbox, wx.ID_ANY, self._on_select_model)
3591	# check model type to show sizer
3592	if self.model is not None:
3593	print "_set_model_sizer_selection: disabled."
3594	# self._set_model_sizer_selection(self.model)
3595
3596	sizer_selection.Add(self.text1)
3597	sizer_selection.Add((10, 5))
3598	sizer_selection.Add(self.formfactorbox)
3599	sizer_selection.Add((5, 5))
3600	sizer_selection.Add(self.text2)
3601	sizer_selection.Add((5, 5))
3602	sizer_selection.Add(self.structurebox)
3603
3604	mutifactor_selection.Add((13, 5))
3605	mutifactor_selection.Add(self.mutifactor_text)
3606	mutifactor_selection.Add(self.multifactorbox)
3607	mutifactor_selection.Add((5, 5))
3608	mutifactor_selection.Add(self.mutifactor_text1)
3609	mutifactor_selection.Add((10, 5))
3610	mutifactor_selection.Add(self.show_sld_button)
3611
3612	boxsizer1.Add(sizer_cat)
3613	boxsizer1.Add((10, 10))
3614	boxsizer1.Add(sizer_selection)
3615	boxsizer1.Add((10, 10))
3616	boxsizer1.Add(mutifactor_selection)
3617
3618	self._set_multfactor_combobox()
3619	self.multifactorbox.SetSelection(1)
3620	self.show_sld_button.Hide()
3621	sizer.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
3622	sizer.Layout()
3623
3624	def on_smear_helper(self, update=False):
3625	"""
3626	Help for onSmear if implemented
3627
3628	:param update: force or not to update
3629	"""
3630	def reset_page(self, state, first=False):
3631	"""
3632	reset the state if implemented
3633	"""
3634	def onSmear(self, event):
3635	"""
3636	Create a smear object if implemented
3637	"""
3638	def onPinholeSmear(self, event):
3639	"""
3640	Create a custom pinhole smear object if implemented
3641	"""
3642	def onSlitSmear(self, event):
3643	"""
3644	Create a custom slit smear object if implemented
3645	"""
3646	def update_slit_smear(self):
3647	"""
3648	called by kill_focus on pinhole TextCntrl
3649	to update the changes if implemented
3650	"""
3651	def select_param(self, event):
3652	"""
3653	Select TextCtrl checked if implemented
3654	"""
3655	def set_data(self, data=None):
3656	"""
3657	Sets data if implemented
3658	"""
3659	def _is_2D(self):
3660	"""
3661	Check if data_name is Data2D if implemented
3662	"""
3663	def _on_select_model(self, event=None):
3664	"""
3665	call back for model selection if implemented
3666	"""
3667	def get_weight_flag(self):
3668	"""
3669	Get flag corresponding to a given weighting dI data if implemented
3670	"""
3671	def _set_sizer_dispersion(self):
3672	"""
3673	draw sizer for dispersity if implemented
3674	"""
3675	def get_all_checked_params(self):
3676	"""
3677	Found all parameters current check and add them to list of parameters
3678	to fit if implemented
3679	"""
3680	def show_npts2fit(self):
3681	"""
3682	setValue Npts for fitting if implemented
3683	"""
3684	def _onModel2D(self, event):
3685	"""
3686	toggle view of model from 1D to 2D or 2D from 1D if implemented
3687	"""
3688
3689
3690	class ModelTextCtrl(wx.TextCtrl):
3691	"""
3692	Text control for model and fit parameters.
3693	Binds the appropriate events for user interactions.
3694	Default callback methods can be overwritten on initialization
3695
3696	:param kill_focus_callback: callback method for EVT_KILL_FOCUS event
3697	:param set_focus_callback: callback method for EVT_SET_FOCUS event
3698	:param mouse_up_callback: callback method for EVT_LEFT_UP event
3699	:param text_enter_callback: callback method for EVT_TEXT_ENTER event
3700
3701	"""
3702	# Set to True when the mouse is clicked while whole string is selected
3703	full_selection = False
3704	# Call back for EVT_SET_FOCUS events
3705	_on_set_focus_callback = None
3706
3707	def __init__(self, parent, id=-1,
3708	value=wx.EmptyString,
3709	pos=wx.DefaultPosition,
3710	size=wx.DefaultSize,
3711	style=0,
3712	validator=wx.DefaultValidator,
3713	name=wx.TextCtrlNameStr,
3714	kill_focus_callback=None,
3715	set_focus_callback=None,
3716	mouse_up_callback=None,
3717	text_enter_callback=None):
3718
3719	wx.TextCtrl.__init__(self, parent, id, value, pos,
3720	size, style, validator, name)
3721
3722	# Bind appropriate events
3723	self._on_set_focus_callback = parent.onSetFocus \
3724	if set_focus_callback is None else set_focus_callback
3725	self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
3726	self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
3727	if kill_focus_callback is None else kill_focus_callback)
3728	self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
3729	if text_enter_callback is None else text_enter_callback)
3730	if not ON_MAC:
3731	self.Bind(wx.EVT_LEFT_UP, self._highlight_text
3732	if mouse_up_callback is None else mouse_up_callback)
3733
3734	def _on_set_focus(self, event):
3735	"""
3736	Catch when the text control is set in focus to highlight the whole
3737	text if necessary
3738
3739	:param event: mouse event
3740
3741	"""
3742	event.Skip()
3743	self.full_selection = True
3744	return self._on_set_focus_callback(event)
3745
3746	def _highlight_text(self, event):
3747	"""
3748	Highlight text of a TextCtrl only of no text has be selected
3749
3750	:param event: mouse event
3751
3752	"""
3753	# Make sure the mouse event is available to other listeners
3754	event.Skip()
3755	control = event.GetEventObject()
3756	if self.full_selection:
3757	self.full_selection = False
3758	# Check that we have a TextCtrl
3759	if issubclass(control.__class__, wx.TextCtrl):
3760	# Check whether text has been selected,
3761	# if not, select the whole string
3762	(start, end) = control.GetSelection()
3763	if start == end:
3764	control.SetSelection(-1, -1)
3765
3766	def _silent_kill_focus(self, event):
3767	"""
3768	Save the state of the page
3769	"""
3770
3771	event.Skip()
3772	# pass

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/basepage.py @ 9c9fae1

Download in other formats: