basepage.py @ d70f6d2

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 d70f6d2 was d70f6d2, checked in by Tim Snow <tim.snow@…>, 7 years ago

User feedback

Now updates the user via the message box when a calculation is being
performed

Property mode set to 100644

File size: 142.6 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	wx.PostEvent(self._manager.parent, StatusEvent(status="Computation is in progress...", type = "progress"))
1712
1713	def _draw_model_after(self, update_chisqr=True, source='model'):
1714	"""
1715	Method to draw or refresh a plotted model.
1716	The method will use the data member from the model page
1717	to build a call to the fitting perspective manager.
1718
1719	:param chisqr: update chisqr value [bool]
1720	"""
1721	# if self.check_invalid_panel():
1722	# return
1723	if self.model is not None:
1724	temp_smear = None
1725	if hasattr(self, "enable_smearer"):
1726	if not self.disable_smearer.GetValue():
1727	temp_smear = self.current_smearer
1728	# compute weight for the current data
1729	from sas.sasgui.perspectives.fitting.utils import get_weight
1730	flag = self.get_weight_flag()
1731	weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1732	toggle_mode_on = self.model_view.IsEnabled()
1733	is_2d = self._is_2D()
1734	self._manager.draw_model(self.model,
1735	data=self.data,
1736	smearer=temp_smear,
1737	qmin=float(self.qmin_x),
1738	qmax=float(self.qmax_x),
1739	page_id=self.uid,
1740	toggle_mode_on=toggle_mode_on,
1741	state=self.state,
1742	enable2D=is_2d,
1743	update_chisqr=update_chisqr,
1744	source='model',
1745	weight=weight)
1746
1747	def _on_show_sld(self, event=None):
1748	"""
1749	Plot SLD profile
1750	"""
1751	# get profile data
1752	x, y = self.model.getProfile()
1753
1754	from sas.sasgui.plottools import Data1D as pf_data1d
1755	# from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
1756	from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
1757	import SLDPanel
1758	sld_data = pf_data1d(x, y)
1759	sld_data.name = 'SLD'
1760	sld_data.axes = self.sld_axes
1761	self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes,
1762	id=wx.ID_ANY)
1763	self.panel.ShowModal()
1764
1765	def _set_multfactor_combobox(self, multiplicity=10):
1766	"""
1767	Set comboBox for multitfactor of CoreMultiShellModel
1768	:param multiplicit: no. of multi-functionality
1769	"""
1770	# build content of the combobox
1771	for idx in range(0, multiplicity):
1772	self.multifactorbox.Append(str(idx), int(idx))
1773	self._hide_multfactor_combobox()
1774
1775	def _show_multfactor_combobox(self):
1776	"""
1777	Show the comboBox of muitfactor of CoreMultiShellModel
1778	"""
1779	if not self.mutifactor_text.IsShown():
1780	self.mutifactor_text.Show(True)
1781	self.mutifactor_text1.Show(True)
1782	if not self.multifactorbox.IsShown():
1783	self.multifactorbox.Show(True)
1784
1785	def _hide_multfactor_combobox(self):
1786	"""
1787	Hide the comboBox of muitfactor of CoreMultiShellModel
1788	"""
1789	if self.mutifactor_text.IsShown():
1790	self.mutifactor_text.Hide()
1791	self.mutifactor_text1.Hide()
1792	if self.multifactorbox.IsShown():
1793	self.multifactorbox.Hide()
1794
1795	def formfactor_combo_init(self):
1796	"""
1797	First time calls _show_combox_helper
1798	"""
1799	self._show_combox(None)
1800
1801	def _show_combox_helper(self):
1802	"""
1803	Fill panel's combo box according to the type of model selected
1804	"""
1805
1806	mod_cat = self.categorybox.GetStringSelection()
1807	self.structurebox.SetSelection(0)
1808	self.structurebox.Disable()
1809	self.formfactorbox.Clear()
1810	if mod_cat is None:
1811	return
1812	m_list = []
1813	try:
1814	if mod_cat == CUSTOM_MODEL:
1815	for model in self.model_list_box[mod_cat]:
1816	m_list.append(self.model_dict[model.name])
1817	else:
1818	cat_dic = self.master_category_dict[mod_cat]
1819	for (model, enabled) in cat_dic:
1820	if enabled:
1821	m_list.append(self.model_dict[model])
1822	except Exception:
1823	msg = traceback.format_exc()
1824	wx.PostEvent(self._manager.parent,
1825	StatusEvent(status=msg, info="error"))
1826	self._populate_box(self.formfactorbox, m_list)
1827
1828	def _on_modify_cat(self, event=None):
1829	"""
1830	Called when category manager is opened
1831	"""
1832	self._manager.parent.on_category_panel(event)
1833
1834	def _show_combox(self, event=None):
1835	"""
1836	Show combox box associate with type of model selected
1837	"""
1838	self.Show(False)
1839	self._show_combox_helper()
1840	self._on_select_model(event=None)
1841	self.Show(True)
1842	self._save_typeOfmodel()
1843	self.sizer4_4.Layout()
1844	self.sizer4.Layout()
1845	self.Layout()
1846	self.Refresh()
1847
1848	def _populate_box(self, combobox, list):
1849	"""
1850	fill combox box with dict item
1851
1852	:param list: contains item to fill the combox
1853	item must model class
1854	"""
1855	mlist = []
1856	for models in list:
1857	if models.name != "NoStructure":
1858	mlist.append((models.name, models))
1859
1860	# Sort the models
1861	mlist_sorted = sorted(mlist)
1862	for item in mlist_sorted:
1863	combobox.Append(item[0], item[1])
1864	return 0
1865
1866	def _onQrangeEnter(self, event):
1867	"""
1868	Check validity of value enter in the Q range field
1869
1870	"""
1871	tcrtl = event.GetEventObject()
1872	# Clear msg if previously shown.
1873	msg = ""
1874	wx.PostEvent(self.parent, StatusEvent(status=msg))
1875	# Flag to register when a parameter has changed.
1876	if tcrtl.GetValue().lstrip().rstrip() != "":
1877	try:
1878	float(tcrtl.GetValue())
1879	tcrtl.SetBackgroundColour(wx.WHITE)
1880	# If qmin and qmax have been modified, update qmin and qmax
1881	if self._validate_qrange(self.qmin, self.qmax):
1882	tempmin = float(self.qmin.GetValue())
1883	if tempmin != self.qmin_x:
1884	self.qmin_x = tempmin
1885	tempmax = float(self.qmax.GetValue())
1886	if tempmax != self.qmax_x:
1887	self.qmax_x = tempmax
1888	else:
1889	tcrtl.SetBackgroundColour("pink")
1890	msg = "Model Error: wrong value entered: %s" % \
1891	sys.exc_info()[1]
1892	wx.PostEvent(self.parent, StatusEvent(status=msg))
1893	return
1894	except:
1895	tcrtl.SetBackgroundColour("pink")
1896	msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1897	wx.PostEvent(self.parent, StatusEvent(status=msg))
1898	return
1899	# Check if # of points for theory model are valid(>0).
1900	if self.npts is not None:
1901	if check_float(self.npts):
1902	temp_npts = float(self.npts.GetValue())
1903	if temp_npts != self.num_points:
1904	self.num_points = temp_npts
1905	else:
1906	msg = "Cannot plot: No points in Q range!!! "
1907	wx.PostEvent(self.parent, StatusEvent(status=msg))
1908	else:
1909	tcrtl.SetBackgroundColour("pink")
1910	msg = "Model Error: wrong value entered!!!"
1911	wx.PostEvent(self.parent, StatusEvent(status=msg))
1912	self.save_current_state()
1913	event = PageInfoEvent(page=self)
1914	wx.PostEvent(self.parent, event)
1915	self.state_change = False
1916	# Draw the model for a different range
1917	if not self.data.is_data:
1918	self.create_default_data()
1919	self._draw_model()
1920
1921	def _theory_qrange_enter(self, event):
1922	"""
1923	Check validity of value enter in the Q range field
1924	"""
1925
1926	tcrtl = event.GetEventObject()
1927	# Clear msg if previously shown.
1928	msg = ""
1929	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1930	# Flag to register when a parameter has changed.
1931	is_modified = False
1932	if tcrtl.GetValue().lstrip().rstrip() != "":
1933	try:
1934	value = float(tcrtl.GetValue())
1935	tcrtl.SetBackgroundColour(wx.WHITE)
1936
1937	# If qmin and qmax have been modified, update qmin and qmax
1938	if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1939	tempmin = float(self.theory_qmin.GetValue())
1940	if tempmin != self.theory_qmin_x:
1941	self.theory_qmin_x = tempmin
1942	tempmax = float(self.theory_qmax.GetValue())
1943	if tempmax != self.qmax_x:
1944	self.theory_qmax_x = tempmax
1945	else:
1946	tcrtl.SetBackgroundColour("pink")
1947	msg = "Model Error: wrong value entered: %s" % \
1948	sys.exc_info()[1]
1949	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1950	return
1951	except:
1952	tcrtl.SetBackgroundColour("pink")
1953	msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1954	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1955	return
1956	# Check if # of points for theory model are valid(>0).
1957	if self.Npts_total.IsEditable():
1958	if check_float(self.Npts_total):
1959	temp_npts = float(self.Npts_total.GetValue())
1960	if temp_npts != self.num_points:
1961	self.num_points = temp_npts
1962	is_modified = True
1963	else:
1964	msg = "Cannot Plot: No points in Q range!!! "
1965	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1966	else:
1967	tcrtl.SetBackgroundColour("pink")
1968	msg = "Model Error: wrong value entered!!!"
1969	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1970	self.save_current_state()
1971	event = PageInfoEvent(page=self)
1972	wx.PostEvent(self.parent, event)
1973	self.state_change = False
1974	# Draw the model for a different range
1975	self.create_default_data()
1976	self._draw_model()
1977
1978	def _on_select_model_helper(self):
1979	"""
1980	call back for model selection
1981	"""
1982	# reset dictionary containing reference to dispersion
1983	self._disp_obj_dict = {}
1984	self.disp_cb_dict = {}
1985	self.temp_multi_functional = False
1986	f_id = self.formfactorbox.GetCurrentSelection()
1987	# For MAC
1988	form_factor = None
1989	if f_id >= 0:
1990	form_factor = self.formfactorbox.GetClientData(f_id)
1991
1992	if form_factor is None or \
1993	not hasattr(form_factor, 'is_form_factor') or \
1994	not form_factor.is_form_factor:
1995	self.structurebox.Hide()
1996	self.text2.Hide()
1997	self.structurebox.Disable()
1998	self.structurebox.SetSelection(0)
1999	self.text2.Disable()
2000	else:
2001	self.structurebox.Show()
2002	self.text2.Show()
2003	self.structurebox.Enable()
2004	self.text2.Enable()
2005
2006	if form_factor is not None:
2007	# set multifactor for Mutifunctional models
2008	if form_factor.is_multiplicity_model:
2009	m_id = self.multifactorbox.GetCurrentSelection()
2010	multiplicity = form_factor.multiplicity_info[0]
2011	self.multifactorbox.Clear()
2012	self._set_multfactor_combobox(multiplicity)
2013	self._show_multfactor_combobox()
2014	# ToDo: this info should be called directly from the model
2015	text = form_factor.multiplicity_info[1] # 'No. of Shells: '
2016
2017	self.mutifactor_text.SetLabel(text)
2018	if m_id > multiplicity - 1:
2019	# default value
2020	m_id = 1
2021
2022	self.multi_factor = self.multifactorbox.GetClientData(m_id)
2023	if self.multi_factor is None:
2024	self.multi_factor = 0
2025	self.multifactorbox.SetSelection(m_id)
2026	# Check len of the text1 and max_multiplicity
2027	text = ''
2028	if form_factor.multiplicity_info[0] == \
2029	len(form_factor.multiplicity_info[2]):
2030	text = form_factor.multiplicity_info[2][self.multi_factor]
2031	self.mutifactor_text1.SetLabel(text)
2032	# Check if model has get sld profile.
2033	if len(form_factor.multiplicity_info[3]) > 0:
2034	self.sld_axes = form_factor.multiplicity_info[3]
2035	self.show_sld_button.Show(True)
2036	else:
2037	self.sld_axes = ""
2038	else:
2039	self._hide_multfactor_combobox()
2040	self.show_sld_button.Hide()
2041	self.multi_factor = None
2042	else:
2043	self._hide_multfactor_combobox()
2044	self.show_sld_button.Hide()
2045	self.multi_factor = None
2046
2047	s_id = self.structurebox.GetCurrentSelection()
2048	struct_factor = self.structurebox.GetClientData(s_id)
2049
2050	if struct_factor is not None:
2051	from sasmodels.sasview_model import MultiplicationModel
2052	self.model = MultiplicationModel(form_factor(self.multi_factor),
2053	struct_factor())
2054	# multifunctional form factor
2055	if len(form_factor.non_fittable) > 0:
2056	self.temp_multi_functional = True
2057	elif form_factor is not None:
2058	if self.multi_factor is not None:
2059	self.model = form_factor(self.multi_factor)
2060	else:
2061	# old style plugin models do not accept a multiplicity argument
2062	self.model = form_factor()
2063	else:
2064	self.model = None
2065	return
2066
2067	# check if model has magnetic parameters
2068	if len(self.model.magnetic_params) > 0:
2069	self._has_magnetic = True
2070	else:
2071	self._has_magnetic = False
2072	# post state to fit panel
2073	self.state.parameters = []
2074	self.state.model = self.model
2075	self.state.qmin = self.qmin_x
2076	self.state.multi_factor = self.multi_factor
2077	self.disp_list = self.model.getDispParamList()
2078	self.state.disp_list = self.disp_list
2079	self.on_set_focus(None)
2080	self.Layout()
2081
2082	def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2083	"""
2084	Verify that the Q range controls have valid values
2085	and that Qmin < Qmax.
2086
2087	:param qmin_ctrl: text control for Qmin
2088	:param qmax_ctrl: text control for Qmax
2089
2090	:return: True is the Q range is value, False otherwise
2091
2092	"""
2093	qmin_validity = check_float(qmin_ctrl)
2094	qmax_validity = check_float(qmax_ctrl)
2095	if not (qmin_validity and qmax_validity):
2096	return False
2097	else:
2098	qmin = float(qmin_ctrl.GetValue())
2099	qmax = float(qmax_ctrl.GetValue())
2100	if qmin < qmax:
2101	# Make sure to set both colours white.
2102	qmin_ctrl.SetBackgroundColour(wx.WHITE)
2103	qmin_ctrl.Refresh()
2104	qmax_ctrl.SetBackgroundColour(wx.WHITE)
2105	qmax_ctrl.Refresh()
2106	else:
2107	qmin_ctrl.SetBackgroundColour("pink")
2108	qmin_ctrl.Refresh()
2109	qmax_ctrl.SetBackgroundColour("pink")
2110	qmax_ctrl.Refresh()
2111	msg = "Invalid Q range: Q min must be smaller than Q max"
2112	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2113	return False
2114	return True
2115
2116	def _validate_Npts(self):
2117	"""
2118	Validate the number of points for fitting is more than 10 points.
2119	If valid, setvalues Npts_fit otherwise post msg.
2120	"""
2121	# default flag
2122	flag = True
2123	# Theory
2124	if self.data is None and self.enable2D:
2125	return flag
2126	for data in self.data_list:
2127	# q value from qx and qy
2128	radius = np.sqrt(data.qx_data * data.qx_data +
2129	data.qy_data * data.qy_data)
2130	# get unmasked index
2131	index_data = (float(self.qmin.GetValue()) <= radius) & \
2132	(radius <= float(self.qmax.GetValue()))
2133	index_data = (index_data) & (data.mask)
2134	index_data = (index_data) & (np.isfinite(data.data))
2135
2136	if len(index_data[index_data]) < 10:
2137	# change the color pink.
2138	self.qmin.SetBackgroundColour("pink")
2139	self.qmin.Refresh()
2140	self.qmax.SetBackgroundColour("pink")
2141	self.qmax.Refresh()
2142	msg = "Data Error: "
2143	msg += "Too few points in %s." % data.name
2144	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2145	self.fitrange = False
2146	flag = False
2147	else:
2148	self.Npts_fit.SetValue(str(len(index_data[index_data])))
2149	self.fitrange = True
2150
2151	return flag
2152
2153	def _validate_Npts_1D(self):
2154	"""
2155	Validate the number of points for fitting is more than 5 points.
2156	If valid, setvalues Npts_fit otherwise post msg.
2157	"""
2158	# default flag
2159	flag = True
2160	# Theory
2161	if self.data is None:
2162	return flag
2163	for data in self.data_list:
2164	# q value from qx and qy
2165	radius = data.x
2166	# get unmasked index
2167	index_data = (float(self.qmin.GetValue()) <= radius) & \
2168	(radius <= float(self.qmax.GetValue()))
2169	index_data = (index_data) & (np.isfinite(data.y))
2170
2171	if len(index_data[index_data]) < 5:
2172	# change the color pink.
2173	self.qmin.SetBackgroundColour("pink")
2174	self.qmin.Refresh()
2175	self.qmax.SetBackgroundColour("pink")
2176	self.qmax.Refresh()
2177	msg = "Data Error: "
2178	msg += "Too few points in %s." % data.name
2179	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2180	self.fitrange = False
2181	flag = False
2182	else:
2183	self.Npts_fit.SetValue(str(len(index_data[index_data])))
2184	self.fitrange = True
2185
2186	return flag
2187
2188	def _check_value_enter(self, list):
2189	"""
2190	:param list: model parameter and panel info
2191	:Note: each item of the list should be as follow:
2192	item=[check button state, parameter's name,
2193	paramater's value, string="+/-",
2194	parameter's error of fit,
2195	parameter's minimum value,
2196	parameter's maximum value ,
2197	parameter's units]
2198
2199	Returns True if the model parameters have changed.
2200	"""
2201	is_modified = False
2202	for item in list:
2203	# skip angle parameters for 1D
2204	if not self.enable2D and item in self.orientation_params:
2205	continue
2206
2207	value_ctrl = item[2]
2208	if not value_ctrl.IsEnabled():
2209	# ArrayDispersion disables PD, Min, Max, Npts, Nsigs
2210	continue
2211
2212	name = item[1]
2213	value_str = value_ctrl.GetValue().strip()
2214	if name.endswith(".npts"):
2215	validity = check_int(value_ctrl)
2216	if not validity:
2217	continue
2218	value = int(value_str)
2219
2220	elif name.endswith(".nsigmas"):
2221	validity = check_float(value_ctrl)
2222	if not validity:
2223	continue
2224	value = float(value_str)
2225
2226	else: # value or polydispersity
2227
2228	# Check that min, max and value are floats
2229	min_ctrl, max_ctrl = item[5], item[6]
2230	min_str = min_ctrl.GetValue().strip()
2231	max_str = max_ctrl.GetValue().strip()
2232	validity = check_float(value_ctrl)
2233	if min_str != "":
2234	validity = validity and check_float(min_ctrl)
2235	if max_str != "":
2236	validity = validity and check_float(max_ctrl)
2237	if not validity:
2238	continue
2239
2240	# Check that min is less than max
2241	low = -np.inf if min_str == "" else float(min_str)
2242	high = np.inf if max_str == "" else float(max_str)
2243	if high < low:
2244	min_ctrl.SetBackgroundColour("pink")
2245	min_ctrl.Refresh()
2246	max_ctrl.SetBackgroundColour("pink")
2247	max_ctrl.Refresh()
2248	# msg = "Invalid fit range for %s: min must be smaller
2249	# than max"%name
2250	# wx.PostEvent(self._manager.parent,
2251	# StatusEvent(status=msg))
2252	continue
2253
2254	# Force value between min and max
2255	value = float(value_str)
2256	if value < low:
2257	value = low
2258	value_ctrl.SetValue(format_number(value))
2259	elif value > high:
2260	value = high
2261	value_ctrl.SetValue(format_number(value))
2262
2263	if name not in self.model.details.keys():
2264	self.model.details[name] = ["", None, None]
2265	old_low, old_high = self.model.details[name][1:3]
2266	if old_low != low or old_high != high:
2267	# The configuration has changed but it won't change the
2268	# computed curve so no need to set is_modified to True
2269	# is_modified = True
2270	self.model.details[name][1:3] = low, high
2271
2272	# Update value in model if it has changed
2273	if value != self.model.getParam(name):
2274	self.model.setParam(name, value)
2275	is_modified = True
2276
2277	return is_modified
2278
2279	def _set_dipers_Param(self, event):
2280	"""
2281	respond to self.enable_disp and self.disable_disp radio box.
2282	The dispersity object is reset inside the model into Gaussian.
2283	When the user select yes , this method display a combo box for
2284	more selection when the user selects No,the combo box disappears.
2285	Redraw the model with the default dispersity (Gaussian)
2286	"""
2287	# On selction if no model exists.
2288	if self.model is None:
2289	self.disable_disp.SetValue(True)
2290	msg = "Please select a Model first..."
2291	wx.MessageBox(msg, 'Info')
2292	wx.PostEvent(self._manager.parent,
2293	StatusEvent(status="Polydispersion: %s" % msg))
2294	return
2295
2296	self._reset_dispersity()
2297
2298	if self.model is None:
2299	self.model_disp.Hide()
2300	self.sizer4_4.Clear(True)
2301	return
2302
2303	if self.enable_disp.GetValue():
2304	# layout for model containing no dispersity parameters
2305
2306	self.disp_list = self.model.getDispParamList()
2307
2308	if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0:
2309	self._layout_sizer_noDipers()
2310	else:
2311	# set gaussian sizer
2312	self._on_select_Disp(event=None)
2313	else:
2314	self.sizer4_4.Clear(True)
2315
2316	# post state to fit panel
2317	self.save_current_state()
2318	if event is not None:
2319	event = PageInfoEvent(page=self)
2320	wx.PostEvent(self.parent, event)
2321	# draw the model with the current dispersity
2322
2323	# Wojtek P, Oct 8, 2016: Calling draw_model seems to be unessecary.
2324	# By comenting it we save an extra Iq calculation
2325	# self._draw_model()
2326
2327	# Need to use FitInside again here to replace the next four lines.
2328	# Otherwised polydispersity off does not resize the scrollwindow.
2329	# PDB Nov 28, 2015
2330	self.FitInside()
2331	# self.sizer4_4.Layout()
2332	# self.sizer5.Layout()
2333	# self.Layout()
2334	# self.Refresh()
2335
2336	def _layout_sizer_noDipers(self):
2337	"""
2338	Draw a sizer with no dispersity info
2339	"""
2340	ix = 0
2341	iy = 1
2342	self.fittable_param = []
2343	self.fixed_param = []
2344	self.orientation_params_disp = []
2345
2346	self.sizer4_4.Clear(True)
2347	text = "No polydispersity available for this model"
2348	model_disp = wx.StaticText(self, wx.ID_ANY, text)
2349	self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
2350	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 10)
2351	self.sizer4_4.Layout()
2352	self.sizer4.Layout()
2353
2354	def _reset_dispersity(self):
2355	"""
2356	put gaussian dispersity into current model
2357	"""
2358	if len(self.param_toFit) > 0:
2359	for item in self.fittable_param:
2360	if item in self.param_toFit:
2361	self.param_toFit.remove(item)
2362
2363	for item in self.orientation_params_disp:
2364	if item in self.param_toFit:
2365	self.param_toFit.remove(item)
2366
2367	self.fittable_param = []
2368	self.fixed_param = []
2369	self.orientation_params_disp = []
2370	self.values = {}
2371	self.weights = {}
2372
2373	# from sas.models.dispersion_models import GaussianDispersion
2374	from sasmodels.weights import GaussianDispersion
2375	if len(self.disp_cb_dict) == 0:
2376	self.save_current_state()
2377	self.sizer4_4.Clear(True)
2378	self.Layout()
2379	return
2380	if (len(self.disp_cb_dict) > 0):
2381	for p in self.disp_cb_dict:
2382	# The parameter was un-selected.
2383	# Go back to Gaussian model (with 0 pts)
2384	disp_model = GaussianDispersion()
2385
2386	self._disp_obj_dict[p] = disp_model
2387	# Set the new model as the dispersion object
2388	# for the selected parameter
2389	try:
2390	self.model.set_dispersion(p, disp_model)
2391	except Exception:
2392	logger.error(traceback.format_exc())
2393
2394	# save state into
2395	self.save_current_state()
2396	self.Layout()
2397	self.Refresh()
2398
2399	def _on_select_Disp(self, event):
2400	"""
2401	allow selecting different dispersion
2402	self.disp_list should change type later .now only gaussian
2403	"""
2404	self._set_sizer_dispersion()
2405
2406	# Redraw the model
2407	# Wojtek P. Nov 7, 2016: Redrawing seems to be unnecessary here
2408	# self._draw_model()
2409	# self._undo.Enable(True)
2410	event = PageInfoEvent(page=self)
2411	wx.PostEvent(self.parent, event)
2412
2413	self.sizer4_4.Layout()
2414	self.sizer4.Layout()
2415	self.SetupScrolling()
2416
2417	def _on_disp_func(self, event=None):
2418	"""
2419	Select a distribution function for the polydispersion
2420
2421	:Param event: ComboBox event
2422	"""
2423	# get ready for new event
2424	if event is not None:
2425	event.Skip()
2426	# Get event object
2427	disp_box = event.GetEventObject()
2428
2429	# Try to select a Distr. function
2430	try:
2431	disp_box.SetBackgroundColour("white")
2432	selection = disp_box.GetCurrentSelection()
2433	param_name = disp_box.Name.split('.')[0]
2434	disp_name = disp_box.GetValue()
2435	dispersity = disp_box.GetClientData(selection)
2436
2437	# disp_model = GaussianDispersion()
2438	disp_model = dispersity()
2439	# Get param names to reset the values of the param
2440	name1 = param_name + ".width"
2441	name2 = param_name + ".npts"
2442	name3 = param_name + ".nsigmas"
2443	# Check Disp. function whether or not it is 'array'
2444	if disp_name.lower() == "array":
2445	value2 = ""
2446	value3 = ""
2447	value1 = self._set_array_disp(name=name1, disp=disp_model)
2448	else:
2449	self._del_array_values(name1)
2450	# self._reset_array_disp(param_name)
2451	self._disp_obj_dict[name1] = disp_model
2452	self.model.set_dispersion(param_name, disp_model)
2453	self.state._disp_obj_dict[name1] = disp_model.type
2454
2455	value1 = str(format_number(self.model.getParam(name1), True))
2456	value2 = str(format_number(self.model.getParam(name2)))
2457	value3 = str(format_number(self.model.getParam(name3)))
2458	# Reset fittable polydispersin parameter value
2459	for item in self.fittable_param:
2460	if item[1] == name1:
2461	item[2].SetValue(value1)
2462	item[5].SetValue("")
2463	item[6].SetValue("")
2464	# Disable for array
2465	if disp_name.lower() == "array":
2466	item[0].SetValue(False)
2467	item[0].Disable()
2468	item[2].Disable()
2469	item[3].Show(False)
2470	item[4].Show(False)
2471	item[5].Disable()
2472	item[6].Disable()
2473	else:
2474	item[0].Enable()
2475	item[2].Enable()
2476	item[3].Show(True)
2477	item[4].Show(True)
2478	item[5].Enable()
2479	item[6].Enable()
2480	break
2481	# Reset fixed polydispersion params
2482	for item in self.fixed_param:
2483	if item[1] == name2:
2484	item[2].SetValue(value2)
2485	# Disable Npts for array
2486	if disp_name.lower() == "array":
2487	item[2].Disable()
2488	else:
2489	item[2].Enable()
2490	if item[1] == name3:
2491	item[2].SetValue(value3)
2492	# Disable Nsigs for array
2493	if disp_name.lower() == "array":
2494	item[2].Disable()
2495	else:
2496	item[2].Enable()
2497
2498	# Make sure the check box updated
2499	self.get_all_checked_params()
2500
2501	# update params
2502	self._update_paramv_on_fit()
2503	# draw
2504	self._draw_model()
2505	self.Refresh()
2506	except Exception:
2507	logger.error(traceback.format_exc())
2508	# Error msg
2509	msg = "Error occurred:"
2510	msg += " Could not select the distribution function..."
2511	msg += " Please select another distribution function."
2512	disp_box.SetBackgroundColour("pink")
2513	# Focus on Fit button so that users can see the pinky box
2514	self.btFit.SetFocus()
2515	wx.PostEvent(self._manager.parent,
2516	StatusEvent(status=msg, info="error"))
2517
2518	def _set_array_disp(self, name=None, disp=None):
2519	"""
2520	Set array dispersion
2521
2522	:param name: name of the parameter for the dispersion to be set
2523	:param disp: the polydisperion object
2524	"""
2525	# The user wants this parameter to be averaged.
2526	# Pop up the file selection dialog.
2527	path = self._selectDlg()
2528	# Array data
2529	values = []
2530	weights = []
2531	# If nothing was selected, just return
2532	if path is None:
2533	self.disp_cb_dict[name].SetValue(False)
2534	# self.noDisper_rbox.SetValue(True)
2535	return
2536	self._default_save_location = os.path.dirname(path)
2537	if self._manager is not None:
2538	self._manager.parent._default_save_location = \
2539	self._default_save_location
2540
2541	basename = os.path.basename(path)
2542	values, weights = self.read_file(path)
2543
2544	# If any of the two arrays is empty, notify the user that we won't
2545	# proceed
2546	if len(self.param_toFit) > 0:
2547	if name in self.param_toFit:
2548	self.param_toFit.remove(name)
2549
2550	# Tell the user that we are about to apply the distribution
2551	msg = "Applying loaded %s distribution: %s" % (name, path)
2552	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2553	self._set_array_disp_model(name=name, disp=disp,
2554	values=values, weights=weights)
2555	return basename
2556
2557	def _set_array_disp_model(self, name=None, disp=None,
2558	values=[], weights=[]):
2559	"""
2560	Set array dispersion model
2561
2562	:param name: name of the parameter for the dispersion to be set
2563	:param disp: the polydisperion object
2564	"""
2565	disp.set_weights(values, weights)
2566	self._disp_obj_dict[name] = disp
2567	self.model.set_dispersion(name.split('.')[0], disp)
2568	self.state._disp_obj_dict[name] = disp.type
2569	self.values[name] = values
2570	self.weights[name] = weights
2571	# Store the object to make it persist outside the
2572	# scope of this method
2573	# TODO: refactor model to clean this up?
2574	self.state.values = {}
2575	self.state.weights = {}
2576	self.state.values = copy.deepcopy(self.values)
2577	self.state.weights = copy.deepcopy(self.weights)
2578
2579	# Set the new model as the dispersion object for the
2580	# selected parameter
2581	# self.model.set_dispersion(p, disp_model)
2582	# Store a reference to the weights in the model object
2583	# so that
2584	# it's not lost when we use the model within another thread.
2585	self.state.model = self.model.clone()
2586	self.model._persistency_dict[name.split('.')[0]] = \
2587	[values, weights]
2588	self.state.model._persistency_dict[name.split('.')[0]] = \
2589	[values, weights]
2590
2591	def _del_array_values(self, name=None):
2592	"""
2593	Reset array dispersion
2594
2595	:param name: name of the parameter for the dispersion to be set
2596	"""
2597	# Try to delete values and weight of the names array dic if exists
2598	try:
2599	if name in self.values:
2600	del self.values[name]
2601	del self.weights[name]
2602	# delete all other dic
2603	del self.state.values[name]
2604	del self.state.weights[name]
2605	del self.model._persistency_dict[name.split('.')[0]]
2606	del self.state.model._persistency_dict[name.split('.')[0]]
2607	except Exception:
2608	logger.error(traceback.format_exc())
2609
2610	def _lay_out(self):
2611	"""
2612	returns self.Layout
2613
2614	:Note: Mac seems to like this better when self.
2615	Layout is called after fitting.
2616	"""
2617	self.Layout()
2618	return
2619
2620	def _find_polyfunc_selection(self, disp_func=None):
2621	"""
2622	FInd Comboox selection from disp_func
2623
2624	:param disp_function: dispersion distr. function
2625	"""
2626	# Find the selection
2627	if disp_func is not None:
2628	try:
2629	return POLYDISPERSITY_MODELS.values().index(disp_func.__class__)
2630	except ValueError:
2631	pass # Fall through to default class
2632	return POLYDISPERSITY_MODELS.keys().index('gaussian')
2633
2634	def on_reset_clicked(self, event):
2635	"""
2636	On 'Reset' button for Q range clicked
2637	"""
2638	flag = True
2639	# For 3 different cases: Data2D, Data1D, and theory
2640	if self.model is None:
2641	msg = "Please select a model first..."
2642	wx.MessageBox(msg, 'Info')
2643	flag = False
2644	return
2645
2646	elif self.data.__class__.__name__ == "Data2D":
2647	data_min = 0
2648	x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2649	y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2650	self.qmin_x = data_min
2651	self.qmax_x = math.sqrt(x * x + y * y)
2652	# self.data.mask = np.ones(len(self.data.data),dtype=bool)
2653	# check smearing
2654	if not self.disable_smearer.GetValue():
2655	# set smearing value whether or
2656	# not the data contain the smearing info
2657	if self.pinhole_smearer.GetValue():
2658	flag = self.update_pinhole_smear()
2659	else:
2660	flag = True
2661
2662	elif self.data is None:
2663	self.qmin_x = _QMIN_DEFAULT
2664	self.qmax_x = _QMAX_DEFAULT
2665	self.num_points = _NPTS_DEFAULT
2666	self.state.npts = self.num_points
2667
2668	elif self.data.__class__.__name__ != "Data2D":
2669	self.qmin_x = min(self.data.x)
2670	self.qmax_x = max(self.data.x)
2671	# check smearing
2672	if not self.disable_smearer.GetValue():
2673	# set smearing value whether or
2674	# not the data contain the smearing info
2675	if self.slit_smearer.GetValue():
2676	flag = self.update_slit_smear()
2677	elif self.pinhole_smearer.GetValue():
2678	flag = self.update_pinhole_smear()
2679	else:
2680	flag = True
2681	else:
2682	flag = False
2683
2684	if flag is False:
2685	msg = "Cannot Plot :Must enter a number!!! "
2686	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2687	else:
2688	# set relative text ctrs.
2689	self.qmin.SetValue(str(self.qmin_x))
2690	self.qmax.SetValue(str(self.qmax_x))
2691	self.show_npts2fit()
2692	# At this point, some button and variables satatus (disabled?)
2693	# should be checked such as color that should be reset to
2694	# white in case that it was pink.
2695	self._onparamEnter_helper()
2696
2697	self.save_current_state()
2698	self.state.qmin = self.qmin_x
2699	self.state.qmax = self.qmax_x
2700
2701	# reset the q range values
2702	self._reset_plotting_range(self.state)
2703	self._draw_model()
2704
2705	def select_log(self, event):
2706	"""
2707	Log checked to generate log spaced points for theory model
2708	"""
2709
2710	def get_images(self):
2711	"""
2712	Get the images of the plots corresponding this panel for report
2713
2714	: return graphs: list of figures
2715	: Need Move to guiframe
2716	"""
2717	# set list of graphs
2718	graphs = []
2719	canvases = []
2720	res_item = None
2721	# call gui_manager
2722	gui_manager = self._manager.parent
2723	# loops through the panels [dic]
2724	for _, item2 in gui_manager.plot_panels.iteritems():
2725	data_title = self.data.group_id
2726	# try to get all plots belonging to this control panel
2727	try:
2728	g_id = item2.group_id
2729	if g_id == data_title or \
2730	str(g_id).count("res" + str(self.graph_id)) or \
2731	str(g_id).count(str(self.uid)) > 0:
2732	if str(g_id).count("res" + str(self.graph_id)) > 0:
2733	res_item = [item2.figure, item2.canvas]
2734	else:
2735	# append to the list
2736	graphs.append(item2.figure)
2737	canvases.append(item2.canvas)
2738	except Exception:
2739	# Not for control panels
2740	logger.error(traceback.format_exc())
2741	# Make sure the resduals plot goes to the last
2742	if res_item is not None:
2743	graphs.append(res_item[0])
2744	canvases.append(res_item[1])
2745	# return the list of graphs
2746	return graphs, canvases
2747
2748	def on_function_help_clicked(self, event):
2749	"""
2750	Function called when 'Help' button is pressed next to model
2751	of interest. This calls DocumentationWindow from
2752	documentation_window.py. It will load the top level of the model
2753	help documenation sphinx generated html if no model is presented.
2754	If a model IS present then if documention for that model exists
2755	it will load to that point otherwise again it will go to the top.
2756	For Wx2.8 and below is used (i.e. non-released through installer)
2757	a browser is loaded and the top of the model documentation only is
2758	accessible because webbrowser module does not pass anything after
2759	the # to the browser.
2760
2761	:param event: on Help Button pressed event
2762	"""
2763
2764	if self.model is not None:
2765	name = self.formfactorbox.GetValue()
2766	_TreeLocation = 'user/models/' + name.lower()+'.html'
2767	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2768	"", name + " Help")
2769	else:
2770	_TreeLocation = 'user/index.html'
2771	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2772	"", "General Model Help")
2773
2774	def on_model_help_clicked(self, event):
2775	"""
2776	Function called when 'Description' button is pressed next to model
2777	of interest. This calls the Description embedded in the model. This
2778	should work with either Wx2.8 and lower or higher. If no model is
2779	selected it will give the message that a model must be chosen first
2780	in the box that would normally contain the description. If a badly
2781	behaved model is encountered which has no description then it will
2782	give the message that none is available.
2783
2784	:param event: on Description Button pressed event
2785	"""
2786
2787	if self.model is None:
2788	name = 'index.html'
2789	else:
2790	name = self.formfactorbox.GetValue()
2791
2792	msg = 'Model description:\n'
2793	info = "Info"
2794	if self.model is not None:
2795	# frame.Destroy()
2796	if str(self.model.description).rstrip().lstrip() == '':
2797	msg += "Sorry, no information is available for this model."
2798	else:
2799	msg += self.model.description + '\n'
2800	wx.MessageBox(msg, info)
2801	else:
2802	msg += "You must select a model to get information on this"
2803	wx.MessageBox(msg, info)
2804
2805	def _on_mag_angle_help(self, event):
2806	"""
2807	Bring up Magnetic Angle definition bmp image whenever the ? button
2808	is clicked. Calls DocumentationWindow with the path of the location
2809	within the documentation tree (after /doc/ ....". When using old
2810	versions of Wx (i.e. before 2.9 and therefore not part of release
2811	versions distributed via installer) it brings up an image viewer
2812	box which allows the user to click through the rest of the images in
2813	the directory. Not ideal but probably better than alternative which
2814	would bring up the entire discussion of how magnetic models work?
2815	Specially since it is not likely to be accessed. The normal release
2816	versions bring up the normal image box.
2817
2818	:param evt: Triggers on clicking ? in Magnetic Angles? box
2819	"""
2820
2821	_TreeLocation = "_images/M_angles_pic.bmp"
2822	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2823	"Magnetic Angle Defintions")
2824
2825	def _on_mag_help(self, event):
2826	"""
2827	Bring up Magnetic Angle definition bmp image whenever the ? button
2828	is clicked. Calls DocumentationWindow with the path of the location
2829	within the documentation tree (after /doc/ ....". When using old
2830	versions of Wx (i.e. before 2.9 and therefore not part of release
2831	versions distributed via installer) it brings up an image viewer
2832	box which allows the user to click through the rest of the images in
2833	the directory. Not ideal but probably better than alternative which
2834	would bring up the entire discussion of how magnetic models work?
2835	Specially since it is not likely to be accessed. The normal release
2836	versions bring up the normal image box.
2837
2838	:param evt: Triggers on clicking ? in Magnetic Angles? box
2839	"""
2840
2841	_TreeLocation = "user/magnetism.html"
2842	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2843	"Polarized Beam/Magnetc Help")
2844
2845	def _on_mag_on(self, event):
2846	"""
2847	Magnetic Parameters ON/OFF
2848	"""
2849	button = event.GetEventObject()
2850
2851	if button.GetLabel().count('ON') > 0:
2852	self.magnetic_on = True
2853	button.SetLabel("Magnetic OFF")
2854	m_value = 1.0e-06
2855	for key in self.model.magnetic_params:
2856	if key.count('M0') > 0:
2857	self.model.setParam(key, m_value)
2858	m_value += 0.5e-06
2859	else:
2860	self.magnetic_on = False
2861	button.SetLabel("Magnetic ON")
2862	for key in self.model.magnetic_params:
2863	if key.count('M0') > 0:
2864	# reset mag value to zero fo safety
2865	self.model.setParam(key, 0.0)
2866
2867	self.Show(False)
2868	self.set_model_param_sizer(self.model)
2869	# self._set_sizer_dispersion()
2870	self.state.magnetic_on = self.magnetic_on
2871	self.SetupScrolling()
2872	self.Show(True)
2873
2874	def on_pd_help_clicked(self, event):
2875	"""
2876	Bring up Polydispersity Documentation whenever the ? button is clicked.
2877	Calls DocumentationWindow with the path of the location within the
2878	documentation tree (after /doc/ ....". Note that when using old
2879	versions of Wx (before 2.9) and thus not the release version of
2880	istallers, the help comes up at the top level of the file as
2881	webbrowser does not pass anything past the # to the browser when it is
2882	running "file:///...."
2883
2884	:param event: Triggers on clicking ? in polydispersity box
2885	"""
2886
2887	_TreeLocation = "user/sasgui/perspectives/fitting/pd_help.html"
2888	_PageAnchor = ""
2889	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2890	_PageAnchor, "Polydispersity Help")
2891
2892	def on_left_down(self, event):
2893	"""
2894	Get key stroke event
2895	"""
2896	# Figuring out key combo: Cmd for copy, Alt for paste
2897	if event.CmdDown() and event.ShiftDown():
2898	self.get_paste()
2899	elif event.CmdDown():
2900	self.get_copy()
2901	else:
2902	event.Skip()
2903	return
2904	# make event free
2905	event.Skip()
2906
2907	def get_copy(self):
2908	"""
2909	Get copy params to clipboard
2910	"""
2911	content = self.get_copy_params()
2912	flag = self.set_clipboard(content)
2913	self._copy_info(flag)
2914	return flag
2915
2916	def get_copy_params(self):
2917	"""
2918	Get the string copies of the param names and values in the tap
2919	"""
2920	content = 'sasview_parameter_values:'
2921	# Do it if params exist
2922	if self.parameters:
2923
2924	# go through the parameters
2925	strings = self._get_copy_helper(self.parameters,
2926	self.orientation_params)
2927	content += strings
2928
2929	# go through the fittables
2930	strings = self._get_copy_helper(self.fittable_param,
2931	self.orientation_params_disp)
2932	content += strings
2933
2934	# go through the fixed params
2935	strings = self._get_copy_helper(self.fixed_param,
2936	self.orientation_params_disp)
2937	content += strings
2938
2939	# go through the str params
2940	strings = self._get_copy_helper(self.str_parameters,
2941	self.orientation_params)
2942	content += strings
2943	return content
2944	else:
2945	return False
2946
2947	def get_copy_excel(self):
2948	"""
2949	Get copy params to clipboard
2950	"""
2951	content = self.get_copy_params_excel()
2952	flag = self.set_clipboard(content)
2953	self._copy_info(flag)
2954	return flag
2955
2956	def get_copy_params_excel(self):
2957	"""
2958	Get the string copies of the param names and values in the tap
2959	"""
2960	content = ''
2961
2962	crlf = chr(13) + chr(10)
2963	tab = chr(9)
2964
2965	# Do it if params exist
2966	if self.parameters:
2967
2968	for param in self.parameters:
2969	content += param[1] # parameter name
2970	content += tab
2971	content += param[1] + "_err"
2972	content += tab
2973
2974	content += crlf
2975
2976	# row of values and errors...
2977	for param in self.parameters:
2978	content += param[2].GetValue() # value
2979	content += tab
2980	content += param[4].GetValue() # error
2981	content += tab
2982
2983	return content
2984	else:
2985	return False
2986
2987	def get_copy_latex(self):
2988	"""
2989	Get copy params to clipboard
2990	"""
2991	content = self.get_copy_params_latex()
2992	flag = self.set_clipboard(content)
2993	self._copy_info(flag)
2994	return flag
2995
2996	def get_copy_params_latex(self):
2997	"""
2998	Get the string copies of the param names and values in the tap
2999	"""
3000	content = '\\begin{table}'
3001	content += '\\begin{tabular}[h]'
3002
3003	crlf = chr(13) + chr(10)
3004	tab = chr(9)
3005
3006	# Do it if params exist
3007	if self.parameters:
3008
3009	content += '{\|'
3010	for param in self.parameters:
3011	content += 'l\|l\|'
3012	content += '}\hline'
3013	content += crlf
3014
3015	for index, param in enumerate(self.parameters):
3016	content += param[1].replace('_', '\_') # parameter name
3017	content += ' & '
3018	content += param[1].replace('_', '\_') + "\_err"
3019	if index < len(self.parameters) - 1:
3020	content += ' & '
3021	content += '\\\\ \\hline'
3022	content += crlf
3023
3024	# row of values and errors...
3025	for index, param in enumerate(self.parameters):
3026	content += param[2].GetValue() # parameter value
3027	content += ' & '
3028	content += param[4].GetValue() # parameter error
3029	if index < len(self.parameters) - 1:
3030	content += ' & '
3031	content += '\\\\ \\hline'
3032	content += crlf
3033
3034	content += '\\end{tabular}'
3035	content += '\\end{table}'
3036	return content
3037	else:
3038	return False
3039
3040	def set_clipboard(self, content=None):
3041	"""
3042	Put the string to the clipboard
3043	"""
3044	if not content:
3045	return False
3046	if wx.TheClipboard.Open():
3047	wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
3048	wx.TheClipboard.Close()
3049	return True
3050	return None
3051
3052	def _get_copy_helper(self, param, orient_param):
3053	"""
3054	Helping get value and name of the params
3055
3056	: param param: parameters
3057	: param orient_param = oritational params
3058	: return content: strings [list] [name,value:....]
3059	"""
3060	content = ''
3061	bound_hi = ''
3062	bound_lo = ''
3063	# go through the str params
3064	for item in param:
3065	# copy only the params shown
3066	if not item[2].IsShown():
3067	continue
3068	disfunc = ''
3069	try:
3070	if item[7].__class__.__name__ == 'ComboBox':
3071	disfunc = str(item[7].GetValue())
3072	except Exception:
3073	logger.error(traceback.format_exc())
3074
3075	# 2D
3076	if self.data.__class__.__name__ == "Data2D":
3077	try:
3078	check = item[0].GetValue()
3079	except Exception:
3080	check = None
3081	name = item[1]
3082	value = item[2].GetValue()
3083	# 1D
3084	else:
3085	# for 1D all parameters except orientation
3086	if not item[1] in orient_param:
3087	try:
3088	check = item[0].GetValue()
3089	except:
3090	check = None
3091	name = item[1]
3092	value = item[2].GetValue()
3093
3094	# Bounds
3095	try:
3096	bound_lo = item[5].GetValue()
3097	bound_hi = item[6].GetValue()
3098	except Exception:
3099	# harmless - need to just pass
3100	pass
3101
3102	# add to the content
3103	if disfunc != '':
3104
3105	disfunc = ',' + disfunc
3106	# Need to support array func for copy/paste
3107	try:
3108	if disfunc.count('array') > 0:
3109	disfunc += ','
3110	for val in self.values[name]:
3111	disfunc += ' ' + str(val)
3112	disfunc += ','
3113	for weight in self.weights[name]:
3114	disfunc += ' ' + str(weight)
3115	except Exception:
3116	logger.error(traceback.format_exc())
3117	content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
3118	bound_lo + ',' + bound_hi + ':'
3119
3120	return content
3121
3122	def get_clipboard(self):
3123	"""
3124	Get strings in the clipboard
3125	"""
3126	text = ""
3127	# Get text from the clip board
3128	if wx.TheClipboard.Open():
3129	if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
3130	data = wx.TextDataObject()
3131	# get wx dataobject
3132	success = wx.TheClipboard.GetData(data)
3133	# get text
3134	if success:
3135	text = data.GetText()
3136	else:
3137	text = ''
3138	# close clipboard
3139	wx.TheClipboard.Close()
3140	return text
3141
3142	def get_paste(self):
3143	"""
3144	Paste params from the clipboard
3145	"""
3146	text = self.get_clipboard()
3147	flag = self.get_paste_params(text)
3148	self._copy_info(flag)
3149	return flag
3150
3151	def get_paste_params(self, text=''):
3152	"""
3153	Get the string copies of the param names and values in the tap
3154	"""
3155	context = {}
3156	# put the text into dictionary
3157	lines = text.split(':')
3158	if lines[0] != 'sasview_parameter_values':
3159	self._copy_info(False)
3160	return False
3161	for line in lines[1:-1]:
3162	if len(line) != 0:
3163	item = line.split(',')
3164	check = item[1]
3165	name = item[0]
3166	value = item[2]
3167	# Transfer the text to content[dictionary]
3168	context[name] = [check, value]
3169
3170	# limits
3171	limit_lo = item[3]
3172	context[name].append(limit_lo)
3173	limit_hi = item[4]
3174	context[name].append(limit_hi)
3175
3176	# ToDo: PlugIn this poly disp function for pasting
3177	try:
3178	poly_func = item[5]
3179	context[name].append(poly_func)
3180	try:
3181	# take the vals and weights for array
3182	array_values = item[6].split(' ')
3183	array_weights = item[7].split(' ')
3184	val = [float(a_val) for a_val in array_values[1:]]
3185	weit = [float(a_weit) for a_weit in array_weights[1:]]
3186
3187	context[name].append(val)
3188	context[name].append(weit)
3189	except:
3190	raise
3191	except:
3192	poly_func = ''
3193	context[name].append(poly_func)
3194
3195	# Do it if params exist
3196	if self.parameters:
3197	# go through the parameters
3198	self._get_paste_helper(self.parameters,
3199	self.orientation_params, context)
3200
3201	# go through the fittables
3202	self._get_paste_helper(self.fittable_param,
3203	self.orientation_params_disp,
3204	context)
3205
3206	# go through the fixed params
3207	self._get_paste_helper(self.fixed_param,
3208	self.orientation_params_disp, context)
3209
3210	# go through the str params
3211	self._get_paste_helper(self.str_parameters,
3212	self.orientation_params, context)
3213
3214	return True
3215	return None
3216
3217	def _get_paste_helper(self, param, orient_param, content):
3218	"""
3219	Helping set values of the params
3220
3221	: param param: parameters
3222	: param orient_param: oritational params
3223	: param content: dictionary [ name, value: name1.value1,...]
3224	"""
3225	# go through the str params
3226	for item in param:
3227	# 2D
3228	if self.data.__class__.__name__ == "Data2D":
3229	name = item[1]
3230	if name in content.keys():
3231	values = content[name]
3232	check = values[0]
3233	pd = values[1]
3234
3235	if name.count('.') > 0:
3236	# If this is parameter.width, then pd may be a floating
3237	# point value or it may be an array distribution.
3238	# Nothing to do for parameter.npts or parameter.nsigmas.
3239	try:
3240	float(pd)
3241	if name.endswith('.npts'):
3242	pd = int(pd)
3243	except Exception:
3244	# continue
3245	if not pd and pd != '':
3246	continue
3247	item[2].SetValue(str(pd))
3248	if item in self.fixed_param and pd == '':
3249	# Only array func has pd == '' case.
3250	item[2].Enable(False)
3251	else:
3252	item[2].Enable(True)
3253	if item[2].__class__.__name__ == "ComboBox":
3254	if content[name][1] in self.model.fun_list:
3255	fun_val = self.model.fun_list[content[name][1]]
3256	self.model.setParam(name, fun_val)
3257	try:
3258	item[5].SetValue(str(values[-3]))
3259	item[6].SetValue(str(values[-2]))
3260	except Exception:
3261	# passing as harmless non-update
3262	pass
3263
3264	value = content[name][1:]
3265	self._paste_poly_help(item, value)
3266	if check == 'True':
3267	is_true = True
3268	elif check == 'False':
3269	is_true = False
3270	else:
3271	is_true = None
3272	if is_true is not None:
3273	item[0].SetValue(is_true)
3274	# 1D
3275	else:
3276	# for 1D all parameters except orientation
3277	if not item[1] in orient_param:
3278	name = item[1]
3279	if name in content.keys():
3280	check = content[name][0]
3281	# Avoid changing combox content
3282	value = content[name][1:]
3283	pd = value[0]
3284	if name.count('.') > 0:
3285	# If this is parameter.width, then pd may be a
3286	# floating point value or it may be an array
3287	# distribution. Nothing to do for parameter.npts or
3288	# parameter.nsigmas.
3289	try:
3290	pd = float(pd)
3291	if name.endswith('.npts'):
3292	pd = int(pd)
3293	except:
3294	# continue
3295	if not pd and pd != '':
3296	continue
3297	item[2].SetValue(str(pd))
3298	if item in self.fixed_param and pd == '':
3299	# Only array func has pd == '' case.
3300	item[2].Enable(False)
3301	else:
3302	item[2].Enable(True)
3303	if item[2].__class__.__name__ == "ComboBox":
3304	if value[0] in self.model.fun_list:
3305	fun_val = self.model.fun_list[value[0]]
3306	self.model.setParam(name, fun_val)
3307	# save state
3308	try:
3309	item[5].SetValue(str(value[-3]))
3310	item[6].SetValue(str(value[-2]))
3311	except Exception:
3312	# passing as harmless non-update
3313	pass
3314
3315	self._paste_poly_help(item, value)
3316	if check == 'True':
3317	is_true = True
3318	elif check == 'False':
3319	is_true = False
3320	else:
3321	is_true = None
3322	if is_true is not None:
3323	item[0].SetValue(is_true)
3324
3325	self.select_param(event=None)
3326	self.Refresh()
3327
3328	def _paste_poly_help(self, item, value):
3329	"""
3330	Helps get paste for poly function
3331
3332	item is the parameter name
3333
3334	value depends on which parameter is being processed, and whether it
3335	has array polydispersity.
3336
3337	For parameters without array polydispersity:
3338
3339	parameter => ['FLOAT', '']
3340	parameter.width => ['FLOAT', 'DISTRIBUTION', '']
3341	parameter.npts => ['FLOAT', '']
3342	parameter.nsigmas => ['FLOAT', '']
3343
3344	For parameters with array polydispersity:
3345
3346	parameter => ['FLOAT', '']
3347	parameter.width => ['FILENAME', 'array', [x1, ...], [w1, ...]]
3348	parameter.npts => ['FLOAT', '']
3349	parameter.nsigmas => ['FLOAT', '']
3350	"""
3351	# Do nothing if not setting polydispersity
3352	if len(value[3]) == 0:
3353	return
3354
3355	try:
3356	name = item[7].Name
3357	param_name = name.split('.')[0]
3358	item[7].SetValue(value[1])
3359	selection = item[7].GetCurrentSelection()
3360	dispersity = item[7].GetClientData(selection)
3361	disp_model = dispersity()
3362
3363	if value[1] == 'array':
3364	pd_vals = np.array(value[2])
3365	pd_weights = np.array(value[3])
3366	if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
3367	msg = ("bad array distribution parameters for %s"
3368	% param_name)
3369	raise ValueError(msg)
3370	self._set_disp_cb(True, item=item)
3371	self._set_array_disp_model(name=name,
3372	disp=disp_model,
3373	values=pd_vals,
3374	weights=pd_weights)
3375	else:
3376	self._set_disp_cb(False, item=item)
3377	self._disp_obj_dict[name] = disp_model
3378	self.model.set_dispersion(param_name, disp_model)
3379	self.state._disp_obj_dict[name] = disp_model.type
3380	# TODO: It's not an array, why update values and weights?
3381	self.model._persistency_dict[param_name] = \
3382	[self.values, self.weights]
3383	self.state.values = self.values
3384	self.state.weights = self.weights
3385
3386	except Exception:
3387	logger.error(traceback.format_exc())
3388	print "Error in BasePage._paste_poly_help: %s" % \
3389	sys.exc_info()[1]
3390
3391	def _set_disp_cb(self, isarray, item):
3392	"""
3393	Set cb for array disp
3394	"""
3395	if isarray:
3396	item[0].SetValue(False)
3397	item[0].Enable(False)
3398	item[2].Enable(False)
3399	item[3].Show(False)
3400	item[4].Show(False)
3401	item[5].SetValue('')
3402	item[5].Enable(False)
3403	item[6].SetValue('')
3404	item[6].Enable(False)
3405	else:
3406	item[0].Enable()
3407	item[2].Enable()
3408	item[3].Show(True)
3409	item[4].Show(True)
3410	item[5].Enable()
3411	item[6].Enable()
3412
3413	def update_pinhole_smear(self):
3414	"""
3415	Method to be called by sub-classes
3416	Moveit; This method doesn't belong here
3417	"""
3418	print "BasicPage.update_pinhole_smear was called: skipping"
3419	return
3420
3421	def _read_category_info(self):
3422	"""
3423	Reads the categories in from file
3424	"""
3425	# # ILL mod starts here - July 2012 kieranrcampbell@gmail.com
3426	self.master_category_dict = defaultdict(list)
3427	self.by_model_dict = defaultdict(list)
3428	self.model_enabled_dict = defaultdict(bool)
3429	categorization_file = CategoryInstaller.get_user_file()
3430	with open(categorization_file, 'rb') as f:
3431	self.master_category_dict = json.load(f)
3432	self._regenerate_model_dict()
3433
3434	def _regenerate_model_dict(self):
3435	"""
3436	regenerates self.by_model_dict which has each model name as the
3437	key and the list of categories belonging to that model
3438	along with the enabled mapping
3439	"""
3440	self.by_model_dict = defaultdict(list)
3441	for category in self.master_category_dict:
3442	for (model, enabled) in self.master_category_dict[category]:
3443	self.by_model_dict[model].append(category)
3444	self.model_enabled_dict[model] = enabled
3445
3446	def _populate_listbox(self):
3447	"""
3448	fills out the category list box
3449	"""
3450	uncat_str = 'Plugin Models'
3451	self._read_category_info()
3452
3453	self.categorybox.Clear()
3454	cat_list = sorted(self.master_category_dict.keys())
3455	if uncat_str not in cat_list:
3456	cat_list.append(uncat_str)
3457
3458	for category in cat_list:
3459	if category != '':
3460	self.categorybox.Append(category)
3461
3462	if self.categorybox.GetSelection() == wx.NOT_FOUND:
3463	self.categorybox.SetSelection(0)
3464	else:
3465	self.categorybox.SetSelection(
3466	self.categorybox.GetSelection())
3467	# self._on_change_cat(None)
3468
3469	def _on_change_cat(self, event):
3470	"""
3471	Callback for category change action
3472	"""
3473	self.model_name = None
3474	category = self.categorybox.GetStringSelection()
3475	if category is None:
3476	return
3477	self.model_box.Clear()
3478
3479	if category == 'Plugin Models':
3480	for model in self.model_list_box[category]:
3481	str_m = str(model).split(".")[0]
3482	self.model_box.Append(str_m)
3483
3484	else:
3485	for (model, enabled) in sorted(self.master_category_dict[category],
3486	key=lambda name: name[0]):
3487	if(enabled):
3488	self.model_box.Append(model)
3489
3490	def _fill_model_sizer(self, sizer):
3491	"""
3492	fill sizer containing model info
3493	"""
3494	# This should only be called once per fit tab
3495	# print "==== Entering _fill_model_sizer"
3496	# Add model function Details button in fitpanel.
3497	# The following 3 lines are for Mac. Let JHC know before modifying...
3498	title = "Model"
3499	self.formfactorbox = None
3500	self.multifactorbox = None
3501	self.mbox_description = wx.StaticBox(self, wx.ID_ANY, str(title))
3502	boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
3503	sizer_cat = wx.BoxSizer(wx.HORIZONTAL)
3504	self.mbox_description.SetForegroundColour(wx.RED)
3505	wx_id = self._ids.next()
3506	self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23))
3507	self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked,
3508	id=wx_id)
3509	self.model_func.SetToolTipString("Full Model Function Help")
3510	wx_id = self._ids.next()
3511	self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23))
3512	self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,
3513	id=wx_id)
3514	self.model_help.SetToolTipString("Short Model Function Description")
3515	wx_id = self._ids.next()
3516	self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23))
3517	self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id)
3518	hint = "toggle view of model from 1D to 2D or 2D to 1D"
3519	self.model_view.SetToolTipString(hint)
3520
3521	cat_set_box = wx.StaticBox(self, wx.ID_ANY, 'Category')
3522	sizer_cat_box = wx.StaticBoxSizer(cat_set_box, wx.HORIZONTAL)
3523	sizer_cat_box.SetMinSize((200, 50))
3524	self.categorybox = wx.ComboBox(self, wx.ID_ANY,
3525	style=wx.CB_READONLY)
3526	self.categorybox.SetToolTip(wx.ToolTip("Select a Category/Type"))
3527	self._populate_listbox()
3528	wx.EVT_COMBOBOX(self.categorybox, wx.ID_ANY, self._show_combox)
3529	# self.shape_rbutton = wx.RadioButton(self, wx.ID_ANY, 'Shapes',
3530	# style=wx.RB_GROUP)
3531	# self.shape_indep_rbutton = wx.RadioButton(self, wx.ID_ANY,
3532	# "Shape-Independent")
3533	# self.struct_rbutton = wx.RadioButton(self, wx.ID_ANY,
3534	# "Structure Factor ")
3535	# self.plugin_rbutton = wx.RadioButton(self, wx.ID_ANY,
3536	# "Uncategorized")
3537
3538	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3539	# id=self.shape_rbutton.GetId())
3540	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3541	# id=self.shape_indep_rbutton.GetId())
3542	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3543	# id=self.struct_rbutton.GetId())
3544	# self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3545	# id=self.plugin_rbutton.GetId())
3546	# MAC needs SetValue
3547
3548	show_cat_button = wx.Button(self, wx.ID_ANY, "Modify")
3549	cat_tip = "Modify model categories \n"
3550	cat_tip += "(also accessible from the menu bar)."
3551	show_cat_button.SetToolTip(wx.ToolTip(cat_tip))
3552	show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat)
3553	sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3)
3554	sizer_cat_box.Add((10, 10))
3555	sizer_cat_box.Add(show_cat_button)
3556	# self.shape_rbutton.SetValue(True)
3557
3558	sizer_radiobutton = wx.GridSizer(2, 2, 5, 5)
3559	# sizer_radiobutton.Add(self.shape_rbutton)
3560	# sizer_radiobutton.Add(self.shape_indep_rbutton)
3561	sizer_radiobutton.Add((5, 5))
3562	sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5)
3563	# sizer_radiobutton.Add(self.plugin_rbutton)
3564	# sizer_radiobutton.Add(self.struct_rbutton)
3565	# sizer_radiobutton.Add((5,5))
3566	sizer_radiobutton.Add(self.model_help, 1, wx.RIGHT \| wx.LEFT, 5)
3567	# sizer_radiobutton.Add((5,5))
3568	sizer_radiobutton.Add(self.model_func, 1, wx.RIGHT, 5)
3569	sizer_cat.Add(sizer_cat_box, 1, wx.LEFT, 2.5)
3570	sizer_cat.Add(sizer_radiobutton)
3571	sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
3572	mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
3573
3574	self.text1 = wx.StaticText(self, wx.ID_ANY, "")
3575	self.text2 = wx.StaticText(self, wx.ID_ANY, "P(Q)*S(Q)")
3576	self.mutifactor_text = wx.StaticText(self, wx.ID_ANY, "No. of Shells: ")
3577	self.mutifactor_text1 = wx.StaticText(self, wx.ID_ANY, "")
3578	self.show_sld_button = wx.Button(self, wx.ID_ANY, "Show SLD Profile")
3579	self.show_sld_button.Bind(wx.EVT_BUTTON, self._on_show_sld)
3580
3581	self.formfactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3582	self.formfactorbox.SetToolTip(wx.ToolTip("Select a Model"))
3583	if self.model is not None:
3584	self.formfactorbox.SetValue(self.model.name)
3585	self.structurebox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3586	self.multifactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3587	self.initialize_combox()
3588	wx.EVT_COMBOBOX(self.formfactorbox, wx.ID_ANY, self._on_select_model)
3589
3590	wx.EVT_COMBOBOX(self.structurebox, wx.ID_ANY, self._on_select_model)
3591	wx.EVT_COMBOBOX(self.multifactorbox, wx.ID_ANY, self._on_select_model)
3592	# check model type to show sizer
3593	if self.model is not None:
3594	print "_set_model_sizer_selection: disabled."
3595	# self._set_model_sizer_selection(self.model)
3596
3597	sizer_selection.Add(self.text1)
3598	sizer_selection.Add((10, 5))
3599	sizer_selection.Add(self.formfactorbox)
3600	sizer_selection.Add((5, 5))
3601	sizer_selection.Add(self.text2)
3602	sizer_selection.Add((5, 5))
3603	sizer_selection.Add(self.structurebox)
3604
3605	mutifactor_selection.Add((13, 5))
3606	mutifactor_selection.Add(self.mutifactor_text)
3607	mutifactor_selection.Add(self.multifactorbox)
3608	mutifactor_selection.Add((5, 5))
3609	mutifactor_selection.Add(self.mutifactor_text1)
3610	mutifactor_selection.Add((10, 5))
3611	mutifactor_selection.Add(self.show_sld_button)
3612
3613	boxsizer1.Add(sizer_cat)
3614	boxsizer1.Add((10, 10))
3615	boxsizer1.Add(sizer_selection)
3616	boxsizer1.Add((10, 10))
3617	boxsizer1.Add(mutifactor_selection)
3618
3619	self._set_multfactor_combobox()
3620	self.multifactorbox.SetSelection(1)
3621	self.show_sld_button.Hide()
3622	sizer.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
3623	sizer.Layout()
3624
3625	def on_smear_helper(self, update=False):
3626	"""
3627	Help for onSmear if implemented
3628
3629	:param update: force or not to update
3630	"""
3631	def reset_page(self, state, first=False):
3632	"""
3633	reset the state if implemented
3634	"""
3635	def onSmear(self, event):
3636	"""
3637	Create a smear object if implemented
3638	"""
3639	def onPinholeSmear(self, event):
3640	"""
3641	Create a custom pinhole smear object if implemented
3642	"""
3643	def onSlitSmear(self, event):
3644	"""
3645	Create a custom slit smear object if implemented
3646	"""
3647	def update_slit_smear(self):
3648	"""
3649	called by kill_focus on pinhole TextCntrl
3650	to update the changes if implemented
3651	"""
3652	def select_param(self, event):
3653	"""
3654	Select TextCtrl checked if implemented
3655	"""
3656	def set_data(self, data=None):
3657	"""
3658	Sets data if implemented
3659	"""
3660	def _is_2D(self):
3661	"""
3662	Check if data_name is Data2D if implemented
3663	"""
3664	def _on_select_model(self, event=None):
3665	"""
3666	call back for model selection if implemented
3667	"""
3668	def get_weight_flag(self):
3669	"""
3670	Get flag corresponding to a given weighting dI data if implemented
3671	"""
3672	def _set_sizer_dispersion(self):
3673	"""
3674	draw sizer for dispersity if implemented
3675	"""
3676	def get_all_checked_params(self):
3677	"""
3678	Found all parameters current check and add them to list of parameters
3679	to fit if implemented
3680	"""
3681	def show_npts2fit(self):
3682	"""
3683	setValue Npts for fitting if implemented
3684	"""
3685	def _onModel2D(self, event):
3686	"""
3687	toggle view of model from 1D to 2D or 2D from 1D if implemented
3688	"""
3689
3690
3691	class ModelTextCtrl(wx.TextCtrl):
3692	"""
3693	Text control for model and fit parameters.
3694	Binds the appropriate events for user interactions.
3695	Default callback methods can be overwritten on initialization
3696
3697	:param kill_focus_callback: callback method for EVT_KILL_FOCUS event
3698	:param set_focus_callback: callback method for EVT_SET_FOCUS event
3699	:param mouse_up_callback: callback method for EVT_LEFT_UP event
3700	:param text_enter_callback: callback method for EVT_TEXT_ENTER event
3701
3702	"""
3703	# Set to True when the mouse is clicked while whole string is selected
3704	full_selection = False
3705	# Call back for EVT_SET_FOCUS events
3706	_on_set_focus_callback = None
3707
3708	def __init__(self, parent, id=-1,
3709	value=wx.EmptyString,
3710	pos=wx.DefaultPosition,
3711	size=wx.DefaultSize,
3712	style=0,
3713	validator=wx.DefaultValidator,
3714	name=wx.TextCtrlNameStr,
3715	kill_focus_callback=None,
3716	set_focus_callback=None,
3717	mouse_up_callback=None,
3718	text_enter_callback=None):
3719
3720	wx.TextCtrl.__init__(self, parent, id, value, pos,
3721	size, style, validator, name)
3722
3723	# Bind appropriate events
3724	self._on_set_focus_callback = parent.onSetFocus \
3725	if set_focus_callback is None else set_focus_callback
3726	self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
3727	self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
3728	if kill_focus_callback is None else kill_focus_callback)
3729	self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
3730	if text_enter_callback is None else text_enter_callback)
3731	if not ON_MAC:
3732	self.Bind(wx.EVT_LEFT_UP, self._highlight_text
3733	if mouse_up_callback is None else mouse_up_callback)
3734
3735	def _on_set_focus(self, event):
3736	"""
3737	Catch when the text control is set in focus to highlight the whole
3738	text if necessary
3739
3740	:param event: mouse event
3741
3742	"""
3743	event.Skip()
3744	self.full_selection = True
3745	return self._on_set_focus_callback(event)
3746
3747	def _highlight_text(self, event):
3748	"""
3749	Highlight text of a TextCtrl only of no text has be selected
3750
3751	:param event: mouse event
3752
3753	"""
3754	# Make sure the mouse event is available to other listeners
3755	event.Skip()
3756	control = event.GetEventObject()
3757	if self.full_selection:
3758	self.full_selection = False
3759	# Check that we have a TextCtrl
3760	if issubclass(control.__class__, wx.TextCtrl):
3761	# Check whether text has been selected,
3762	# if not, select the whole string
3763	(start, end) = control.GetSelection()
3764	if start == end:
3765	control.SetSelection(-1, -1)
3766
3767	def _silent_kill_focus(self, event):
3768	"""
3769	Save the state of the page
3770	"""
3771
3772	event.Skip()
3773	# pass

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

SasView

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

Download in other formats: