basepage.py @ a321c52

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 a321c52 was a321c52, checked in by krzywon, 7 years ago
Force all models to go through _convert_to_sasmodels routine to ensure all sasmodels version changes are applied.
Property mode set to `100644`
File size: 142.5 KB

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

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

SasView

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

Download in other formats: