basepage.py @ 3f8c7bb

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

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

SasView

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

Download in other formats: