basepage.py @ f0a16d5

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

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

Incorporated changes

In addition to the new logic, a copy operation was also required as
without it the objects were lost causing SasView? to crash.

Property mode set to 100644

File size: 143.1 KB

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

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

SasView

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

Download in other formats: