basepage.py @ db5294e

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since db5294e was db5294e, checked in by krzywon, 7 years ago
#795: Small fix to invariant to check for None type when loading values. Working toward loading rpa and coreshellellipsoid integration.
Property mode set to `100644`
File size: 142.4 KB

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

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

SasView

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

Download in other formats: