basepage.py @ 00f7ff1

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 00f7ff1 was 00f7ff1, checked in by Paul Kienzle <pkienzle@…>, 7 years ago
move sim fit state to sascalc pagestate
Property mode set to `100644`
File size: 143.3 KB

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

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

SasView

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

Download in other formats: