basepage.py @ 5c6002a

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

Logic sorted

We now check for a) quick submissions b) whether something is already
running and if it is chuck any intermediate stages

Property mode set to 100644

File size: 143.9 KB

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

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

SasView

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

Download in other formats: