fitpage.py @ 1a8e13f0

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

Last change on this file since 1a8e13f0 was 1a8e13f0, checked in by Paul Kienzle <pkienzle@…>, 7 years ago
remove unnecessary sleep
Property mode set to `100644`
File size: 128.1 KB

Rev	Line
[682c432]	1	"""
	2	FitPanel class contains fields allowing to display results when
	3	fitting a model and one data
	4	"""
	5	import sys
	6	import wx
	7	import wx.lib.newevent
	8	import numpy
	9	import copy
	10	import math
	11	import time
[6c382da]	12	import traceback
[cb4ef58]	13
	14	from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
	15
[c8e1996]	16	from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \
	17	PlotQrangeEvent
[d85c194]	18	from sas.sasgui.guiframe.dataFitting import check_data_validity
[c8e1996]	19	from sas.sasgui.guiframe.utils import format_number, check_float
[d85c194]	20	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
[682c432]	21
[c8e1996]	22	from sas.sasgui.perspectives.fitting.basepage import BasicPage as BasicPage
	23	from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \
	24	PageInfoEvent
	25	from sas.sascalc.data_util.qsmearing import smear_selection
	26	from .basepage import ModelTextCtrl
	27
[682c432]	28	(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent()
	29	_BOX_WIDTH = 76
	30	_DATA_BOX_WIDTH = 300
	31	SMEAR_SIZE_L = 0.00
	32	SMEAR_SIZE_H = 0.00
	33
	34
	35	class FitPage(BasicPage):
	36	"""
	37	FitPanel class contains fields allowing to display results when
	38	fitting a model and one data
	39
	40	:note: For Fit to be performed the user should check at least one parameter
	41	on fit Panel window.
	42	"""
	43
	44	def __init__(self, parent, color=None):
	45	"""
	46	Initialization of the Panel
	47	"""
	48	BasicPage.__init__(self, parent, color=color)
	49
[c8e1996]	50	# draw sizer
[682c432]	51	self._fill_data_sizer()
	52	self.is_2D = None
	53	self.fit_started = False
	54	self.weightbt_string = None
	55	self.m_name = None
	56	# get smear info from data
	57	self._get_smear_info()
	58	self._fill_model_sizer(self.sizer1)
	59	self._get_defult_custom_smear()
	60	self._fill_range_sizer()
	61	self._set_smear(self.data)
	62	self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr)
	63	# bind key event
	64	self.Bind(wx.EVT_RIGHT_DOWN, self.on_right_down)
	65	self._set_bookmark_flag(False)
	66	self._set_save_flag(False)
	67	self._set_preview_flag(False)
	68	self._set_copy_flag(False)
	69	self._set_paste_flag(False)
	70	self.btFit.SetFocus()
	71	self.enable_fit_button()
	72	self.fill_data_combobox(data_list=self.data_list)
[c8e1996]	73	# create a default data for an empty panel
[682c432]	74	self.create_default_data()
	75	self._manager.frame.Bind(wx.EVT_SET_FOCUS, self.on_set_focus)
	76
	77	def enable_fit_button(self):
	78	"""
	79	Enable fit button if data is valid and model is valid
	80	"""
	81	flag = check_data_validity(self.data) & (self.model is not None)
	82	self.btFit.Enable(flag)
[bf44249e]	83
[682c432]	84	def on_set_focus(self, event):
	85	"""
[bf44249e]	86	Override the basepage focus method to ensure the save flag is set
[682c432]	87	properly when focusing on the fit page.
	88	"""
	89	flag = check_data_validity(self.data) & (self.model is not None)
	90	self._set_save_flag(flag)
	91	self.parent.on_set_focus(event)
[85ccd3a]	92	self.on_tap_focus()
[682c432]	93
	94	def _fill_data_sizer(self):
	95	"""
	96	fill sizer 0 with data info
	97	"""
[6f16e25]	98	self.data_box_description = wx.StaticBox(self, wx.ID_ANY,
	99	'I(q) Data Source')
[682c432]	100	if check_data_validity(self.data):
	101	dname_color = wx.BLUE
	102	else:
	103	dname_color = wx.RED
	104	self.data_box_description.SetForegroundColour(dname_color)
	105	boxsizer1 = wx.StaticBoxSizer(self.data_box_description, wx.VERTICAL)
[c8e1996]	106	# ----------------------------------------------------------
[682c432]	107	sizer_data = wx.BoxSizer(wx.HORIZONTAL)
[6f16e25]	108	self.dataSource = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
	109	wx.EVT_COMBOBOX(self.dataSource, wx.ID_ANY, self.on_select_data)
[682c432]	110	self.dataSource.SetMinSize((_DATA_BOX_WIDTH, -1))
[6f16e25]	111	sizer_data.Add(wx.StaticText(self, wx.ID_ANY, 'Name : '))
[682c432]	112	sizer_data.Add(self.dataSource)
	113	sizer_data.Add((0, 5))
	114	boxsizer1.Add(sizer_data, 0, wx.ALL, 10)
	115	self.sizer0.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
	116	self.sizer0.Layout()
	117
	118	def enable_datasource(self):
	119	"""
	120	Enable or disable data source control depending on existing data
	121	"""
	122	if not self.data_list:
	123	self.dataSource.Disable()
	124	else:
	125	self.dataSource.Enable()
	126
	127	def fill_data_combobox(self, data_list):
	128	"""
	129	Get a list of data and fill the corresponding combobox
	130	"""
	131	self.dataSource.Clear()
	132	self.data_list = data_list
	133	self.enable_datasource()
	134	if len(data_list) > 0:
[c8e1996]	135	# find the maximum range covering all data
[682c432]	136	qmin, qmax, npts = self.compute_data_set_range(data_list)
	137	self.qmin_data_set = qmin
	138	self.qmax_data_set = qmax
	139	self.npts_data_set = npts
	140
	141	self.qmin.SetValue(str(self.qmin_data_set))
	142	self.qmax.SetValue(str(self.qmax_data_set))
	143	self.qmin.SetBackgroundColour("white")
	144	self.qmax.SetBackgroundColour("white")
	145	self.qmin_x = self.qmin_data_set
	146	self.qmax_x = self.qmax_data_set
	147	self.state.qmin = self.qmin_x
	148	self.state.qmax = self.qmax_x
	149	is_data = False
	150	for data in self.data_list:
	151	if data is not None:
	152	self.dataSource.Append(str(data.name), clientData=data)
	153	if not is_data:
	154	is_data = check_data_validity(data)
	155	if is_data:
	156	self.dataSource.SetSelection(0)
	157	self.on_select_data(event=None)
	158
	159	if len(data_list) == 1:
	160	self.dataSource.Disable()
	161
	162	def on_select_data(self, event=None):
	163	"""
	164	On_select_data
	165	"""
	166	if event is None and self.dataSource.GetCount() > 0:
	167	data = self.dataSource.GetClientData(0)
	168	self.set_data(data)
	169	elif self.dataSource.GetCount() > 0:
	170	pos = self.dataSource.GetSelection()
	171	data = self.dataSource.GetClientData(pos)
	172	self.set_data(data)
	173
	174	def _on_fit_complete(self):
	175	"""
	176	When fit is complete ,reset the fit button label.
	177	"""
	178	self.fit_started = False
	179	self.set_fitbutton()
	180
	181	def _is_2D(self):
	182	"""
	183	Check if data_name is Data2D
	184
	185	:return: True or False
	186	"""
	187	if self.data.__class__.__name__ == "Data2D" or \
	188	self.enable2D:
	189	return True
	190	return False
	191
	192	def _fill_range_sizer(self):
	193	"""
[7801df8]	194	Fill the Fitting sizer on the fit panel which contains: the smearing
	195	information (dq), the weighting information (dI or other), the plotting
	196	range, access to the 2D mask editor, the compute, fit, and help
	197	buttons, xi^2, number of points etc.
[682c432]	198	"""
[c8e1996]	199	is_2d_data = False
[682c432]	200
	201	# Check if data is 2D
	202	if self.data.__class__.__name__ == "Data2D" or \
	203	self.enable2D:
[c8e1996]	204	is_2d_data = True
[682c432]	205
	206	title = "Fitting"
[c8e1996]	207	# smear messages & titles
[682c432]	208	smear_message_none = "No smearing is selected..."
	209	smear_message_dqdata = "The dQ data is being used for smearing..."
	210	smear_message_2d = \
	211	"Higher accuracy is very time-expensive. Use it with care..."
	212	smear_message_new_ssmear = \
	213	"Please enter only the value of interest to customize smearing..."
	214	smear_message_new_psmear = \
	215	"Please enter both; the dQ will be generated by interpolation..."
	216	smear_message_2d_x_title = "<dQp>[1/A]:"
	217	smear_message_2d_y_title = "<dQs>[1/A]:"
	218	smear_message_pinhole_min_title = "dQ_low[1/A]:"
	219	smear_message_pinhole_max_title = "dQ_high[1/A]:"
	220	smear_message_slit_height_title = "Slit height[1/A]:"
	221	smear_message_slit_width_title = "Slit width[1/A]:"
	222
	223	self._get_smear_info()
	224
[c8e1996]	225	# Sizers
[6f16e25]	226	box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title))
[682c432]	227	box_description_range.SetForegroundColour(wx.BLUE)
	228	boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)
	229	self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
	230	sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
	231	self.sizer_new_smear = wx.BoxSizer(wx.HORIZONTAL)
	232	self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
	233	sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
[6f16e25]	234	smear_set_box = wx.StaticBox(self, wx.ID_ANY,
	235	'Set Instrumental Smearing')
[682c432]	236	sizer_smearer_box = wx.StaticBoxSizer(smear_set_box, wx.HORIZONTAL)
	237	sizer_smearer_box.SetMinSize((_DATA_BOX_WIDTH, 60))
	238
[6f16e25]	239	weighting_set_box = wx.StaticBox(self, wx.ID_ANY,
[bf44249e]	240	'Set Weighting by Selecting dI Source')
[682c432]	241	weighting_box = wx.StaticBoxSizer(weighting_set_box, wx.HORIZONTAL)
	242	sizer_weighting = wx.BoxSizer(wx.HORIZONTAL)
	243	weighting_box.SetMinSize((_DATA_BOX_WIDTH, 40))
[c8e1996]	244	# Filling the sizer containing weighting info.
[6f16e25]	245	self.dI_noweight = wx.RadioButton(self, wx.ID_ANY,
	246	'No Weighting', style=wx.RB_GROUP)
	247	self.dI_didata = wx.RadioButton(self, wx.ID_ANY, 'Use dI Data')
	248	self.dI_sqrdata = wx.RadioButton(self, wx.ID_ANY, 'Use \|sqrt(I Data)\|')
	249	self.dI_idata = wx.RadioButton(self, wx.ID_ANY, 'Use \|I Data\|')
[682c432]	250	self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
	251	id=self.dI_noweight.GetId())
	252	self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
	253	id=self.dI_didata.GetId())
	254	self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
	255	id=self.dI_sqrdata.GetId())
	256	self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
	257	id=self.dI_idata.GetId())
	258	self.dI_didata.SetValue(True)
	259	# add 4 types of weighting to the sizer
	260	sizer_weighting.Add(self.dI_noweight, 0, wx.LEFT, 10)
	261	sizer_weighting.Add((14, 10))
	262	sizer_weighting.Add(self.dI_didata)
	263	sizer_weighting.Add((14, 10))
	264	sizer_weighting.Add(self.dI_sqrdata)
	265	sizer_weighting.Add((14, 10))
	266	sizer_weighting.Add(self.dI_idata)
	267	sizer_weighting.Add((10, 10))
	268	self.dI_noweight.Enable(False)
	269	self.dI_didata.Enable(False)
	270	self.dI_sqrdata.Enable(False)
	271	self.dI_idata.Enable(False)
	272	weighting_box.Add(sizer_weighting)
	273
	274	# combobox for smear2d accuracy selection
[6f16e25]	275	self.smear_accuracy = wx.ComboBox(self, wx.ID_ANY,
	276	size=(50, -1), style=wx.CB_READONLY)
[682c432]	277	self._set_accuracy_list()
	278	self.smear_accuracy.SetValue(self.smear2d_accuracy)
	279	self.smear_accuracy.SetSelection(0)
[6f16e25]	280	self.smear_accuracy.SetToolTipString(
[682c432]	281	"'Higher' uses more Gaussian points for smearing computation.")
	282
[6f16e25]	283	wx.EVT_COMBOBOX(self.smear_accuracy, wx.ID_ANY,
	284	self._on_select_accuracy)
[682c432]	285
[c8e1996]	286	# Fit button
[6f16e25]	287	self.btFit = wx.Button(self, self._ids.next(), 'Fit')
[682c432]	288	self.default_bt_colour = self.btFit.GetDefaultAttributes()
	289	self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id=self.btFit.GetId())
	290	self.btFit.SetToolTipString("Start fitting.")
	291
[c8e1996]	292	# General Help button
[6f16e25]	293	self.btFitHelp = wx.Button(self, wx.ID_ANY, 'Help')
[d06c34c]	294	self.btFitHelp.SetToolTipString("General fitting help.")
[7801df8]	295	self.btFitHelp.Bind(wx.EVT_BUTTON, self._onFitHelp)
	296
[c8e1996]	297	# Resolution Smearing Help button (for now use same technique as
	298	# used for dI help to get tiniest possible button that works
	299	# both on MAC and PC. Should completely rewrite the fitting sizer
	300	# in future. This is minimum to get out release 3.1
[f3dc56c]	301	# comment June 14, 2015 --- PDB
	302	if sys.platform.count("win32") > 0:
[c8e1996]	303	size_q = (20, 15) # on PC
[f3dc56c]	304	else:
[c8e1996]	305	size_q = (30, 20) # on MAC
[6f16e25]	306	self.btSmearHelp = wx.Button(self, wx.ID_ANY, '?',
	307	style=wx.BU_EXACTFIT, size=size_q)
[d06c34c]	308	self.btSmearHelp.SetToolTipString("Resolution smearing help.")
[7801df8]	309	self.btSmearHelp.Bind(wx.EVT_BUTTON, self._onSmearHelp)
	310
[c8e1996]	311	# textcntrl for custom resolution
[6f16e25]	312	self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY,
[682c432]	313	size=(_BOX_WIDTH - 25, 20),
	314	style=wx.TE_PROCESS_ENTER,
	315	text_enter_callback=self.onPinholeSmear)
[6f16e25]	316	self.smear_pinhole_min = ModelTextCtrl(self, wx.ID_ANY,
[682c432]	317	size=(_BOX_WIDTH - 25, 20),
	318	style=wx.TE_PROCESS_ENTER,
	319	text_enter_callback=self.onPinholeSmear)
[6f16e25]	320	self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY,
[682c432]	321	size=(_BOX_WIDTH - 25, 20),
	322	style=wx.TE_PROCESS_ENTER,
	323	text_enter_callback=self.onSlitSmear)
[6f16e25]	324	self.smear_slit_width = ModelTextCtrl(self, wx.ID_ANY,
[682c432]	325	size=(_BOX_WIDTH - 25, 20),
	326	style=wx.TE_PROCESS_ENTER,
	327	text_enter_callback=self.onSlitSmear)
	328
[c8e1996]	329	# smear
[6f16e25]	330	self.smear_data_left = BGTextCtrl(self, wx.ID_ANY,
[373d4ee]	331	size=(_BOX_WIDTH - 25, 20), style=0)
[682c432]	332	self.smear_data_left.SetValue(str(self.dq_l))
[6f16e25]	333	self.smear_data_right = BGTextCtrl(self, wx.ID_ANY,
[373d4ee]	334	size=(_BOX_WIDTH - 25, 20), style=0)
[682c432]	335	self.smear_data_right.SetValue(str(self.dq_r))
	336
[c8e1996]	337	# set default values for smear
[682c432]	338	self.smear_pinhole_max.SetValue(str(self.dx_max))
	339	self.smear_pinhole_min.SetValue(str(self.dx_min))
	340	self.smear_slit_height.SetValue(str(self.dxl))
	341	self.smear_slit_width.SetValue(str(self.dxw))
	342
[c8e1996]	343	# Filling the sizer containing instruments smearing info.
[6f16e25]	344	self.disable_smearer = wx.RadioButton(self, wx.ID_ANY,
[682c432]	345	'None', style=wx.RB_GROUP)
[6f16e25]	346	self.enable_smearer = wx.RadioButton(self, wx.ID_ANY, 'Use dQ Data')
[c8e1996]	347	# self.enable_smearer.SetToolTipString(
	348	# "Click to use the loaded dQ data for smearing.")
[6f16e25]	349	self.pinhole_smearer = wx.RadioButton(self, wx.ID_ANY,
[682c432]	350	'Custom Pinhole Smear')
[c8e1996]	351	# self.pinhole_smearer.SetToolTipString
	352	# ("Click to input custom resolution for pinhole smearing.")
[6f16e25]	353	self.slit_smearer = wx.RadioButton(self, wx.ID_ANY, 'Custom Slit Smear')
[c8e1996]	354	# self.slit_smearer.SetToolTipString
	355	# ("Click to input custom resolution for slit smearing.")
[682c432]	356	self.Bind(wx.EVT_RADIOBUTTON, self.onSmear,
	357	id=self.disable_smearer.GetId())
	358	self.Bind(wx.EVT_RADIOBUTTON, self.onSmear,
	359	id=self.enable_smearer.GetId())
	360	self.Bind(wx.EVT_RADIOBUTTON, self.onPinholeSmear,
	361	id=self.pinhole_smearer.GetId())
	362	self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear,
	363	id=self.slit_smearer.GetId())
[b4818d9]	364	self.enable_smearer.SetValue(True)
[682c432]	365
	366	sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10)
	367	sizer_smearer.Add(self.enable_smearer)
	368	sizer_smearer.Add(self.pinhole_smearer)
	369	sizer_smearer.Add(self.slit_smearer)
[f3dc56c]	370	sizer_smearer.Add(self.btSmearHelp)
[682c432]	371	sizer_smearer.Add((10, 10))
	372
	373	# StaticText for chi2, N(for fitting), Npts + Log/linear spacing
[6f16e25]	374	self.tcChi = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0)
[682c432]	375	self.tcChi.SetToolTipString("Chi2/Npts(Fit)")
[6f16e25]	376	self.Npts_fit = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0)
	377	self.Npts_fit.SetToolTipString(
[c8e1996]	378	" Npts : number of points selected for fitting")
[6f16e25]	379	self.Npts_total = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
[c8e1996]	380	style=wx.TE_PROCESS_ENTER,
	381	text_enter_callback=self._onQrangeEnter)
[682c432]	382	self.Npts_total.SetValue(format_number(self.npts_x))
[c8e1996]	383	self.Npts_total.SetToolTipString(
	384	" Total Npts : total number of data points")
[682c432]	385
	386	# Update and Draw button
[6f16e25]	387	self.draw_button = wx.Button(self, self._ids.next(), 'Compute')
	388	self.draw_button.Bind(wx.EVT_BUTTON,
[682c432]	389	self._onDraw, id=self.draw_button.GetId())
	390	self.draw_button.SetToolTipString("Compute and Draw.")
	391
	392	self.points_sizer = wx.BoxSizer(wx.HORIZONTAL)
[6f16e25]	393	self.pointsbox = wx.CheckBox(self, wx.ID_ANY, 'Log?', (10, 10))
[682c432]	394	self.pointsbox.SetValue(False)
	395	self.pointsbox.SetToolTipString("Check mark to use log spaced points")
	396	wx.EVT_CHECKBOX(self, self.pointsbox.GetId(), self.select_log)
	397
[6f16e25]	398	self.points_sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Npts '))
[682c432]	399	self.points_sizer.Add(self.pointsbox)
	400
[6f16e25]	401	box_description_1 = wx.StaticText(self, wx.ID_ANY, ' Chi2/Npts')
	402	box_description_2 = wx.StaticText(self, wx.ID_ANY, 'Npts(Fit)')
[682c432]	403
	404	# StaticText for smear
[6f16e25]	405	self.smear_description_none = wx.StaticText(self, wx.ID_ANY,
[682c432]	406	smear_message_none, style=wx.ALIGN_LEFT)
[6f16e25]	407	self.smear_description_dqdata = wx.StaticText(self, wx.ID_ANY,
	408	smear_message_dqdata, style=wx.ALIGN_LEFT)
	409	self.smear_description_type = wx.StaticText(self, wx.ID_ANY,
	410	"Type:", style=wx.ALIGN_LEFT)
	411	self.smear_description_accuracy_type = wx.StaticText(self, wx.ID_ANY,
	412	"Accuracy:", style=wx.ALIGN_LEFT)
	413	self.smear_description_smear_type = BGTextCtrl(self, wx.ID_ANY,
[682c432]	414	size=(57, 20), style=0)
	415	self.smear_description_smear_type.SetValue(str(self.dq_l))
	416	self.SetBackgroundColour(self.GetParent().GetBackgroundColour())
[6f16e25]	417	self.smear_description_2d = wx.StaticText(self, wx.ID_ANY,
[682c432]	418	smear_message_2d, style=wx.ALIGN_LEFT)
[6f16e25]	419	self.smear_message_new_s = wx.StaticText(self, wx.ID_ANY,
[682c432]	420	smear_message_new_ssmear, style=wx.ALIGN_LEFT)
[6f16e25]	421	self.smear_message_new_p = wx.StaticText(self, wx.ID_ANY,
[682c432]	422	smear_message_new_psmear, style=wx.ALIGN_LEFT)
[6f16e25]	423	self.smear_description_2d_x = wx.StaticText(self, wx.ID_ANY,
[682c432]	424	smear_message_2d_x_title, style=wx.ALIGN_LEFT)
[6f16e25]	425	self.smear_description_2d_x.SetToolTipString(
[682c432]	426	" dQp(parallel) in q_r direction.")
[6f16e25]	427	self.smear_description_2d_y = wx.StaticText(self, wx.ID_ANY,
[682c432]	428	smear_message_2d_y_title, style=wx.ALIGN_LEFT)
[c8e1996]	429	self.smear_description_2d_y.SetToolTipString(
[682c432]	430	" dQs(perpendicular) in q_phi direction.")
[6f16e25]	431	self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY,
[682c432]	432	smear_message_pinhole_min_title, style=wx.ALIGN_LEFT)
[6f16e25]	433	self.smear_description_pin_max = wx.StaticText(self, wx.ID_ANY,
[682c432]	434	smear_message_pinhole_max_title, style=wx.ALIGN_LEFT)
[6f16e25]	435	self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY,
[682c432]	436	smear_message_slit_height_title, style=wx.ALIGN_LEFT)
[6f16e25]	437	self.smear_description_slit_width = wx.StaticText(self, wx.ID_ANY,
[682c432]	438	smear_message_slit_width_title, style=wx.ALIGN_LEFT)
	439
[c8e1996]	440	# arrange sizers
[682c432]	441	self.sizer_set_smearer.Add(sizer_smearer)
	442	self.sizer_set_smearer.Add((10, 10))
	443	self.sizer_set_smearer.Add(self.smear_description_none,
[c8e1996]	444	0, wx.CENTER, 10)
[682c432]	445	self.sizer_set_smearer.Add(self.smear_description_dqdata,
[c8e1996]	446	0, wx.CENTER, 10)
[682c432]	447	self.sizer_set_smearer.Add(self.smear_description_2d,
[c8e1996]	448	0, wx.CENTER, 10)
[682c432]	449	self.sizer_new_smear.Add(self.smear_description_type,
[c8e1996]	450	0, wx.CENTER, 10)
[682c432]	451	self.sizer_new_smear.Add(self.smear_description_accuracy_type,
[c8e1996]	452	0, wx.CENTER, 10)
[682c432]	453	self.sizer_new_smear.Add(self.smear_accuracy)
	454	self.sizer_new_smear.Add(self.smear_description_smear_type,
[c8e1996]	455	0, wx.CENTER, 10)
[682c432]	456	self.sizer_new_smear.Add((15, -1))
[c8e1996]	457	self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10)
[682c432]	458	self.sizer_new_smear.Add(self.smear_description_pin_min,
[c8e1996]	459	0, wx.CENTER, 10)
[682c432]	460	self.sizer_new_smear.Add(self.smear_description_slit_height,
[c8e1996]	461	0, wx.CENTER, 10)
	462
	463	self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10)
	464	self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10)
	465	self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10)
[682c432]	466	self.sizer_new_smear.Add((20, -1))
	467	self.sizer_new_smear.Add(self.smear_description_2d_y,
[c8e1996]	468	0, wx.CENTER, 10)
[682c432]	469	self.sizer_new_smear.Add(self.smear_description_pin_max,
[c8e1996]	470	0, wx.CENTER, 10)
[682c432]	471	self.sizer_new_smear.Add(self.smear_description_slit_width,
[c8e1996]	472	0, wx.CENTER, 10)
[682c432]	473
	474	self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10)
	475	self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10)
	476	self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10)
	477
	478	self.sizer_set_smearer.Add(self.smear_message_new_s, 0, wx.CENTER, 10)
	479	self.sizer_set_smearer.Add(self.smear_message_new_p, 0, wx.CENTER, 10)
	480	self.sizer_set_smearer.Add((5, 2))
	481	self.sizer_set_smearer.Add(self.sizer_new_smear, 0, wx.CENTER, 10)
	482
	483	# add all to chi2 sizer
	484	sizer_smearer_box.Add(self.sizer_set_smearer)
	485	sizer_chi2.Add(sizer_smearer_box)
	486	sizer_chi2.Add((-1, 5))
	487	sizer_chi2.Add(weighting_box)
	488	sizer_chi2.Add((-1, 5))
	489
	490	# hide all smear messages and textctrl
	491	self._hide_all_smear_info()
	492
	493	# get smear_selection
	494	self.current_smearer = smear_selection(self.data, self.model)
	495
	496	# Show only the relevant smear messages, etc
[c8e1996]	497	if self.current_smearer is None:
	498	if not is_2d_data:
[682c432]	499	self.smear_description_none.Show(True)
	500	self.enable_smearer.Disable()
	501	else:
	502	self.smear_description_none.Show(True)
	503	self.slit_smearer.Disable()
[c8e1996]	504	if self.data is None:
[682c432]	505	self.slit_smearer.Disable()
	506	self.pinhole_smearer.Disable()
	507	self.enable_smearer.Disable()
	508	else:
	509	self._show_smear_sizer()
	510	boxsizer_range.Add(self.sizer_set_masking)
[c8e1996]	511	# 2D data? default
	512	is_2d_data = False
[682c432]	513
[c8e1996]	514	# check if it is 2D data
[682c432]	515	if self.data.__class__.__name__ == "Data2D" or self.enable2D:
[c8e1996]	516	is_2d_data = True
[682c432]	517
	518	self.sizer5.Clear(True)
	519
[6f16e25]	520	self.qmin = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
[373d4ee]	521	style=wx.TE_PROCESS_ENTER,
	522	set_focus_callback=self.qrang_set_focus,
	523	text_enter_callback=self._onQrangeEnter,
	524	name='qmin')
[682c432]	525	self.qmin.SetValue(str(self.qmin_x))
	526	q_tip = "Click outside of the axes\n to remove the lines."
	527	qmin_tip = "Minimun value of Q.\n"
	528	qmin_tip += q_tip
	529	self.qmin.SetToolTipString(qmin_tip)
	530
[6f16e25]	531	self.qmax = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
[373d4ee]	532	style=wx.TE_PROCESS_ENTER,
	533	set_focus_callback=self.qrang_set_focus,
	534	text_enter_callback=self._onQrangeEnter,
	535	name='qmax')
[682c432]	536	self.qmax.SetValue(str(self.qmax_x))
	537	qmax_tip = "Maximum value of Q.\n"
	538	qmax_tip += q_tip
	539	self.qmax.SetToolTipString(qmax_tip)
	540	self.qmin.Bind(wx.EVT_MOUSE_EVENTS, self.qrange_click)
	541	self.qmax.Bind(wx.EVT_MOUSE_EVENTS, self.qrange_click)
	542	self.qmin.Bind(wx.EVT_KEY_DOWN, self.on_key)
	543	self.qmax.Bind(wx.EVT_KEY_DOWN, self.on_key)
	544	self.qmin.Bind(wx.EVT_TEXT, self.on_qrange_text)
	545	self.qmax.Bind(wx.EVT_TEXT, self.on_qrange_text)
[6f16e25]	546	wx_id = self._ids.next()
[d06c34c]	547	self.reset_qrange = wx.Button(self, wx_id, 'Reset')
[682c432]	548
[d06c34c]	549	self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=wx_id)
[682c432]	550	self.reset_qrange.SetToolTipString("Reset Q range to the default")
	551
[d06c34c]	552	sizer = wx.GridSizer(5, 5, 2, 6)
[682c432]	553
[6f16e25]	554	self.btEditMask = wx.Button(self, self._ids.next(), 'Editor')
[682c432]	555	self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask,
	556	id=self.btEditMask.GetId())
	557	self.btEditMask.SetToolTipString("Edit Mask.")
[6f16e25]	558	self.EditMask_title = wx.StaticText(self, wx.ID_ANY, ' Masking(2D)')
[682c432]	559
[6f16e25]	560	sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Q range'))
	561	sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Min[1/A]'))
	562	sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]'))
[682c432]	563	sizer.Add(self.EditMask_title)
[c8e1996]	564	sizer.Add((-1, 5))
[d06c34c]	565
[682c432]	566	sizer.Add(self.reset_qrange)
	567	sizer.Add(self.qmin)
	568	sizer.Add(self.qmax)
	569	sizer.Add(self.btEditMask)
[c8e1996]	570	sizer.Add((-1, 5))
[d06c34c]	571
[c8e1996]	572	sizer.AddMany(5*[(-1, 5)])
[d06c34c]	573
	574	sizer.Add(box_description_1, 0, 0)
	575	sizer.Add(box_description_2, 0, 0)
	576	sizer.Add(self.points_sizer, 0, 0)
	577	sizer.Add(self.draw_button, 0, 0)
[c8e1996]	578	sizer.Add((-1, 5))
[d06c34c]	579
	580	sizer.Add(self.tcChi, 0, 0)
	581	sizer.Add(self.Npts_fit, 0, 0)
	582	sizer.Add(self.Npts_total, 0, 0)
	583	sizer.Add(self.btFit, 0, 0)
	584	sizer.Add(self.btFitHelp, 0, 0)
	585
[682c432]	586	boxsizer_range.Add(sizer_chi2)
	587	boxsizer_range.Add(sizer)
[c8e1996]	588	if is_2d_data:
[682c432]	589	self.btEditMask.Enable()
	590	self.EditMask_title.Enable()
	591	else:
	592	self.btEditMask.Disable()
	593	self.EditMask_title.Disable()
[c8e1996]	594	# save state
[682c432]	595	self.save_current_state()
	596	self.sizer5.Add(boxsizer_range, 0, wx.EXPAND \| wx.ALL, 10)
	597	self.sizer5.Layout()
	598
	599	def _set_sizer_dispersion(self):
	600	"""
	601	draw sizer with gaussian dispersity parameters
	602	"""
	603	self.fittable_param = []
	604	self.fixed_param = []
	605	self.orientation_params_disp = []
	606
	607	self.sizer4_4.Clear(True)
[c8e1996]	608	if self.model is None:
	609	# no model is selected
[682c432]	610	return
	611	if not self.enable_disp.GetValue():
[c8e1996]	612	# the user didn't select dispersity display
[682c432]	613	return
	614
	615	self._reset_dispersity()
	616
[c8e1996]	617	# fill a sizer with the combobox to select dispersion type
[6f16e25]	618	model_disp = wx.StaticText(self, wx.ID_ANY, 'Function')
[4c3be25]	619	CHECK_STATE = False
[682c432]	620
	621	ix = 0
	622	iy = 0
[6f16e25]	623	disp = wx.StaticText(self, wx.ID_ANY, ' ')
[682c432]	624	self.sizer4_4.Add(disp, (iy, ix), (1, 1),
	625	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	626	ix += 1
[6f16e25]	627	values = wx.StaticText(self, wx.ID_ANY, 'PD[ratio]')
[682c432]	628	polytext = "Polydispersity (= STD/mean); "
	629	polytext += "the standard deviation over the mean value."
	630	values.SetToolTipString(polytext)
	631
	632	self.sizer4_4.Add(values, (iy, ix), (1, 1),
	633	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	634	ix += 2
	635	if self.is_mac:
	636	err_text = 'Error'
	637	else:
	638	err_text = ''
[6f16e25]	639	self.text_disp_1 = wx.StaticText(self, wx.ID_ANY, err_text)
[c8e1996]	640	self.sizer4_4.Add(self.text_disp_1, (iy, ix), (1, 1),
[682c432]	641	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	642
	643	ix += 1
[6f16e25]	644	self.text_disp_min = wx.StaticText(self, wx.ID_ANY, 'Min')
[c8e1996]	645	self.sizer4_4.Add(self.text_disp_min, (iy, ix), (1, 1),
[682c432]	646	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	647
	648	ix += 1
[6f16e25]	649	self.text_disp_max = wx.StaticText(self, wx.ID_ANY, 'Max')
[682c432]	650	self.sizer4_4.Add(self.text_disp_max, (iy, ix), (1, 1),
	651	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	652
	653	ix += 1
[6f16e25]	654	npts = wx.StaticText(self, wx.ID_ANY, 'Npts')
[682c432]	655	npts.SetToolTipString("Number of sampling points for the numerical\n\
	656	integration over the distribution function.")
	657	self.sizer4_4.Add(npts, (iy, ix), (1, 1),
	658	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	659	ix += 1
[6f16e25]	660	nsigmas = wx.StaticText(self, wx.ID_ANY, 'Nsigs')
[682c432]	661	nsigmas.SetToolTipString("Number of sigmas between which the range\n\
	662	of the distribution function will be used for weighting. \n\
	663	The value '3' covers 99.5% for Gaussian distribution \n\
	664	function. Note: Not recommended to change this value.")
	665	self.sizer4_4.Add(nsigmas, (iy, ix), (1, 1),
	666	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	667	ix += 1
	668	self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
	669	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	670
	671	self.text_disp_max.Show(True)
	672	self.text_disp_min.Show(True)
	673
	674	for item in self.model.dispersion.keys():
	675	if not self.magnetic_on:
	676	if item in self.model.magnetic_params:
	677	continue
[c8e1996]	678	if item not in self.model.orientation_params:
	679	if item not in self.disp_cb_dict:
[682c432]	680	self.disp_cb_dict[item] = None
	681	name0 = "Distribution of " + item
	682	name1 = item + ".width"
	683	name2 = item + ".npts"
	684	name3 = item + ".nsigmas"
[c8e1996]	685	if name1 not in self.model.details:
[682c432]	686	self.model.details[name1] = ["", None, None]
	687
	688	iy += 1
	689	for p in self.model.dispersion[item].keys():
	690
	691	if p == "width":
	692	ix = 0
[6f16e25]	693	cb = wx.CheckBox(self, wx.ID_ANY, name0, (10, 10))
[682c432]	694	cb.SetValue(CHECK_STATE)
	695	cb.SetToolTipString("Check mark to fit")
	696	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
	697	self.sizer4_4.Add(cb, (iy, ix), (1, 1),
	698	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
	699	ix = 1
	700	value = self.model.getParam(name1)
[6f16e25]	701	ctl1 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	702	size=(_BOX_WIDTH / 1.3, 20),
	703	style=wx.TE_PROCESS_ENTER)
[682c432]	704	ctl1.SetLabel('PD[ratio]')
	705	poly_text = "Polydispersity (STD/mean) of %s\n" % item
	706	poly_text += "STD: the standard deviation"
	707	poly_text += " from the mean value."
	708	ctl1.SetToolTipString(poly_text)
	709	ctl1.SetValue(str(format_number(value, True)))
	710	self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
[c8e1996]	711	# text to show error sign
[682c432]	712	ix = 2
[6f16e25]	713	text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
[682c432]	714	self.sizer4_4.Add(text2, (iy, ix), (1, 1),
	715	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	716	if not self.is_mac:
	717	text2.Hide()
	718
	719	ix = 3
[6f16e25]	720	ctl2 = wx.TextCtrl(self, wx.ID_ANY,
[682c432]	721	size=(_BOX_WIDTH / 1.3, 20),
	722	style=0)
	723
	724	self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
	725	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	726	if not self.is_mac:
	727	ctl2.Hide()
	728
	729	ix = 4
[6f16e25]	730	ctl3 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	731	size=(_BOX_WIDTH / 2, 20),
	732	style=wx.TE_PROCESS_ENTER,
	733	text_enter_callback=self._onparamRangeEnter)
[682c432]	734
	735	self.sizer4_4.Add(ctl3, (iy, ix), (1, 1),
	736	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	737
	738	ix = 5
[6f16e25]	739	ctl4 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	740	size=(_BOX_WIDTH / 2, 20),
	741	style=wx.TE_PROCESS_ENTER,
[682c432]	742	text_enter_callback=self._onparamRangeEnter)
	743
	744	self.sizer4_4.Add(ctl4, (iy, ix), (1, 1),
	745	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	746
	747	ctl3.Show(True)
	748	ctl4.Show(True)
	749
	750	elif p == "npts":
	751	ix = 6
	752	value = self.model.getParam(name2)
[6f16e25]	753	Tctl = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	754	size=(_BOX_WIDTH / 2.2, 20),
	755	style=wx.TE_PROCESS_ENTER)
[682c432]	756
	757	Tctl.SetValue(str(format_number(value)))
	758	self.sizer4_4.Add(Tctl, (iy, ix), (1, 1),
	759	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	760	self.fixed_param.append([None, name2, Tctl, None, None,
	761	None, None, None])
	762	elif p == "nsigmas":
	763	ix = 7
	764	value = self.model.getParam(name3)
[6f16e25]	765	Tct2 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	766	size=(_BOX_WIDTH / 2.2, 20),
	767	style=wx.TE_PROCESS_ENTER)
[682c432]	768
	769	Tct2.SetValue(str(format_number(value)))
	770	self.sizer4_4.Add(Tct2, (iy, ix), (1, 1),
[c8e1996]	771	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
[682c432]	772	self.fixed_param.append([None, name3, Tct2,
	773	None, None, None,
	774	None, None])
	775
	776	ix = 8
[6f16e25]	777	disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1),
[682c432]	778	style=wx.CB_READONLY, name='%s' % name1)
[cb4ef58]	779	for key, value in POLYDISPERSITY_MODELS.iteritems():
[682c432]	780	name_disp = str(key)
	781	disp_box.Append(name_disp, value)
	782	disp_box.SetStringSelection("gaussian")
[6f16e25]	783	wx.EVT_COMBOBOX(disp_box, wx.ID_ANY, self._on_disp_func)
[682c432]	784	self.sizer4_4.Add(disp_box, (iy, ix), (1, 1), wx.EXPAND)
	785	self.fittable_param.append([cb, name1, ctl1, text2,
	786	ctl2, ctl3, ctl4, disp_box])
	787
	788	ix = 0
	789	iy += 1
	790	self.sizer4_4.Add((20, 20), (iy, ix), (1, 1),
	791	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	792	first_orient = True
	793	for item in self.model.dispersion.keys():
	794	if not self.magnetic_on:
	795	if item in self.model.magnetic_params:
	796	continue
[c8e1996]	797	if item in self.model.orientation_params:
	798	if item not in self.disp_cb_dict:
[682c432]	799	self.disp_cb_dict[item] = None
	800	name0 = "Distribution of " + item
	801	name1 = item + ".width"
	802	name2 = item + ".npts"
	803	name3 = item + ".nsigmas"
	804
[c8e1996]	805	if name1 not in self.model.details:
[682c432]	806	self.model.details[name1] = ["", None, None]
	807
	808	iy += 1
	809	for p in self.model.dispersion[item].keys():
	810
	811	if p == "width":
	812	ix = 0
[6f16e25]	813	cb = wx.CheckBox(self, wx.ID_ANY, name0, (10, 10))
[682c432]	814	cb.SetValue(CHECK_STATE)
	815	cb.SetToolTipString("Check mark to fit")
	816	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
	817	self.sizer4_4.Add(cb, (iy, ix), (1, 1),
	818	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
	819	if self.data.__class__.__name__ == "Data2D" or \
	820	self.enable2D:
	821	cb.Show(True)
	822	elif cb.IsShown():
	823	cb.Hide()
	824	ix = 1
	825	value = self.model.getParam(name1)
[6f16e25]	826	ctl1 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	827	size=(_BOX_WIDTH / 1.3, 20),
	828	style=wx.TE_PROCESS_ENTER)
[682c432]	829	poly_tip = "Absolute Sigma for %s." % item
	830	ctl1.SetToolTipString(poly_tip)
	831	ctl1.SetValue(str(format_number(value, True)))
	832	if self.data.__class__.__name__ == "Data2D" or \
	833	self.enable2D:
	834	if first_orient:
	835	values.SetLabel('PD[ratio], Sig[deg]')
	836	poly_text = "PD(polydispersity for lengths):\n"
	837	poly_text += "It should be a value between"
	838	poly_text += "0 and 1\n"
	839	poly_text += "Sigma for angles: \n"
	840	poly_text += "It is the STD (ratio*mean)"
	841	poly_text += " of the distribution.\n "
	842
	843	values.SetToolTipString(poly_text)
	844	first_orient = False
	845	ctl1.Show(True)
	846	elif ctl1.IsShown():
	847	ctl1.Hide()
	848
	849	self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
[c8e1996]	850	# text to show error sign
[682c432]	851	ix = 2
[6f16e25]	852	text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
[682c432]	853	self.sizer4_4.Add(text2, (iy, ix), (1, 1),
	854	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	855
	856	text2.Hide()
	857
	858	ix = 3
[6f16e25]	859	ctl2 = wx.TextCtrl(self, wx.ID_ANY,
[682c432]	860	size=(_BOX_WIDTH / 1.3, 20),
	861	style=0)
	862
	863	self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
	864	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	865
	866	ctl2.Hide()
	867	if self.data.__class__.__name__ == "Data2D" or \
	868	self.enable2D:
	869	if self.is_mac:
	870	text2.Show(True)
	871	ctl2.Show(True)
	872
	873	ix = 4
[6f16e25]	874	ctl3 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	875	size=(_BOX_WIDTH / 2, 20),
	876	style=wx.TE_PROCESS_ENTER,
[682c432]	877	text_enter_callback=self._onparamRangeEnter)
	878
	879	self.sizer4_4.Add(ctl3, (iy, ix), (1, 1),
	880	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	881
	882	ctl3.Hide()
	883
	884	ix = 5
[6f16e25]	885	ctl4 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	886	size=(_BOX_WIDTH / 2, 20),
	887	style=wx.TE_PROCESS_ENTER,
[682c432]	888	text_enter_callback=self._onparamRangeEnter)
	889	self.sizer4_4.Add(ctl4, (iy, ix), (1, 1),
	890	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	891	ctl4.Hide()
	892
	893	if self.data.__class__.__name__ == "Data2D" or \
	894	self.enable2D:
	895	ctl3.Show(True)
	896	ctl4.Show(True)
	897
	898	elif p == "npts":
	899	ix = 6
	900	value = self.model.getParam(name2)
[6f16e25]	901	Tctl = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	902	size=(_BOX_WIDTH / 2.2, 20),
	903	style=wx.TE_PROCESS_ENTER)
[682c432]	904
	905	Tctl.SetValue(str(format_number(value)))
	906	if self.data.__class__.__name__ == "Data2D" or \
	907	self.enable2D:
	908	Tctl.Show(True)
	909	else:
	910	Tctl.Hide()
	911	self.sizer4_4.Add(Tctl, (iy, ix), (1, 1),
	912	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	913	self.fixed_param.append([None, name2, Tctl, None, None,
	914	None, None, None])
	915	self.orientation_params_disp.append([None, name2,
	916	Tctl, None, None,
	917	None, None, None])
	918	elif p == "nsigmas":
	919	ix = 7
	920	value = self.model.getParam(name3)
[6f16e25]	921	Tct2 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	922	size=(_BOX_WIDTH / 2.2, 20),
	923	style=wx.TE_PROCESS_ENTER)
[682c432]	924
	925	Tct2.SetValue(str(format_number(value)))
	926	if self.data.__class__.__name__ == "Data2D" or \
	927	self.enable2D:
	928	Tct2.Show(True)
	929	else:
	930	Tct2.Hide()
	931	self.sizer4_4.Add(Tct2, (iy, ix), (1, 1),
	932	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	933
	934	self.fixed_param.append([None, name3, Tct2,
	935	None, None, None, None, None])
	936
	937	self.orientation_params_disp.append([None, name3,
	938	Tct2, None, None, None, None, None])
	939
	940	ix = 8
[6f16e25]	941	disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1),
[682c432]	942	style=wx.CB_READONLY, name='%s' % name1)
[cb4ef58]	943	for key, value in POLYDISPERSITY_MODELS.iteritems():
[682c432]	944	name_disp = str(key)
	945	disp_box.Append(name_disp, value)
	946	disp_box.SetStringSelection("gaussian")
[6f16e25]	947	wx.EVT_COMBOBOX(disp_box, wx.ID_ANY, self._on_disp_func)
[682c432]	948	self.sizer4_4.Add(disp_box, (iy, ix), (1, 1), wx.EXPAND)
	949	self.fittable_param.append([cb, name1, ctl1, text2,
	950	ctl2, ctl3, ctl4, disp_box])
	951	self.orientation_params_disp.append([cb, name1, ctl1,
	952	text2, ctl2, ctl3, ctl4, disp_box])
	953
	954	if self.data.__class__.__name__ == "Data2D" or \
	955	self.enable2D:
	956	disp_box.Show(True)
	957	else:
	958	disp_box.Hide()
	959
	960	self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)
	961
	962	self.state.model = self.model.clone()
[c8e1996]	963	# save state into
[682c432]	964	self._copy_parameters_state(self.parameters, self.state.parameters)
	965	self._copy_parameters_state(self.orientation_params_disp,
	966	self.state.orientation_params_disp)
	967	self._copy_parameters_state(self.fittable_param,
	968	self.state.fittable_param)
	969	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
	970
	971	wx.PostEvent(self.parent,
	972	StatusEvent(status=" Selected Distribution: Gaussian"))
[c8e1996]	973	# Fill the list of fittable parameters
[682c432]	974	self.get_all_checked_params()
	975	self.Layout()
	976
	977	def _onDraw(self, event):
	978	"""
	979	Update and Draw the model
	980	"""
[c8e1996]	981	if self.model is None:
[682c432]	982	msg = "Please select a Model first..."
	983	wx.MessageBox(msg, 'Info')
	984	return
	985	"""
	986	if not self.data.is_data:
	987	self.npts_x = self.Npts_total.GetValue()
	988	self.Npts_fit.SetValue(self.npts_x)
	989	self.create_default_data()
	990	"""
[c8e1996]	991	flag, is_modified = self._update_paramv_on_fit()
[682c432]	992
[c8e1996]	993	wx.CallAfter(self._onparamEnter_helper, is_modified)
[682c432]	994	if not flag:
	995	msg = "The parameters are invalid"
	996	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	997	return
	998
	999	def _onFit(self, event):
	1000	"""
	1001	Allow to fit
	1002	"""
[c8e1996]	1003	if event is not None:
[682c432]	1004	event.Skip()
	1005	if self.fit_started:
	1006	self._StopFit()
	1007	self.fit_started = False
	1008	wx.CallAfter(self.set_fitbutton)
	1009	return
	1010
	1011	if self.data is None:
	1012	msg = "Please get Data first..."
	1013	wx.MessageBox(msg, 'Info')
	1014	wx.PostEvent(self._manager.parent,
	1015	StatusEvent(status="Fit: %s" % msg))
	1016	return
	1017	if self.model is None:
	1018	msg = "Please select a Model first..."
	1019	wx.MessageBox(msg, 'Info')
	1020	wx.PostEvent(self._manager.parent,
	1021	StatusEvent(status="Fit: %s" % msg, type="stop"))
	1022	return
	1023
	1024	if len(self.param_toFit) <= 0:
	1025	msg = "Select at least one parameter to fit"
	1026	wx.MessageBox(msg, 'Info')
	1027	wx.PostEvent(self._manager.parent,
	1028	StatusEvent(status=msg, type="stop"))
	1029	return
	1030
	1031	flag = self._update_paramv_on_fit()
	1032
	1033	if self.batch_on and not self._is_2D():
	1034	if not self._validate_Npts_1D():
	1035	return
	1036
	1037	if not flag:
	1038	msg = "Fitting range or parameters are invalid"
	1039	wx.PostEvent(self._manager.parent,
	1040	StatusEvent(status=msg, type="stop"))
	1041	return
	1042
[c8e1996]	1043	self.select_param()
[682c432]	1044
	1045	# Remove or do not allow fitting on the Q=0 point, especially
	1046	# when y(q=0)=None at x[0].
	1047	self.qmin_x = float(self.qmin.GetValue())
	1048	self.qmax_x = float(self.qmax.GetValue())
	1049	self._manager._reset_schedule_problem(value=0, uid=self.uid)
	1050	self._manager.schedule_for_fit(uid=self.uid, value=1)
	1051	self._manager.set_fit_range(uid=self.uid, qmin=self.qmin_x,
	1052	qmax=self.qmax_x)
	1053
[c8e1996]	1054	# single fit
	1055	# self._manager.onFit(uid=self.uid)
[682c432]	1056	self.fit_started = self._manager.onFit(uid=self.uid)
	1057	wx.CallAfter(self.set_fitbutton)
	1058
[7801df8]	1059	def _onFitHelp(self, event):
	1060	"""
	1061	Bring up the Full Fitting Documentation whenever the HELP button is
	1062	clicked.
	1063
	1064	Calls DocumentationWindow with the path of the location within the
	1065	documentation tree (after /doc/ ....". Note that when using old
	1066	versions of Wx (before 2.9) and thus not the release version of
	1067	installers, the help comes up at the top level of the file as
[c8e1996]	1068	web browser does not pass anything past the # to the browser when it is
[7801df8]	1069	running "file:///...."
	1070
[c8e1996]	1071	:param evt: Triggers on clicking the help button
	1072	"""
[7801df8]	1073
[f27dd1e]	1074	_TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
[6f16e25]	1075	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
[7801df8]	1076	"General Fitting Help")
	1077
	1078	def _onSmearHelp(self, event):
	1079	"""
	1080	Bring up the instrumental resolution smearing Documentation whenever
	1081	the ? button in the smearing box is clicked.
	1082
	1083	Calls DocumentationWindow with the path of the location within the
	1084	documentation tree (after /doc/ ....". Note that when using old
	1085	versions of Wx (before 2.9) and thus not the release version of
	1086	installers, the help comes up at the top level of the file as
[c8e1996]	1087	web browser does not pass anything past the # to the browser when it is
[7801df8]	1088	running "file:///...."
	1089
[c8e1996]	1090	:param evt: Triggers on clicking the help button
	1091	"""
[7801df8]	1092
[f27dd1e]	1093	_TreeLocation = "user/sasgui/perspectives/fitting/sm_help.html"
[6f16e25]	1094	_doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
[7801df8]	1095	"Instrumental Resolution Smearing \
	1096	Help")
	1097
[682c432]	1098	def set_fitbutton(self):
	1099	"""
	1100	Set fit button label depending on the fit_started[bool]
	1101	"""
	1102	# Skip this feature if we are not on Windows
[c8e1996]	1103	# NOTE: the is_mac data member actually means "is no Windows".
[682c432]	1104	if self.is_mac:
	1105	return
	1106
	1107	if self.fit_started:
	1108	label = "Stop"
	1109	color = "red"
	1110	else:
	1111	label = "Fit"
	1112	color = "black"
[c8e1996]	1113	# self.btFit.Enable(False)
[682c432]	1114	self.btFit.SetLabel(label)
	1115	self.btFit.SetForegroundColour(color)
	1116	self.btFit.Enable(True)
	1117
	1118	def get_weight_flag(self):
	1119	"""
	1120	Get flag corresponding to a given weighting dI data.
	1121	"""
	1122	button_list = [self.dI_noweight,
	1123	self.dI_didata,
	1124	self.dI_sqrdata,
	1125	self.dI_idata]
	1126	flag = 1
	1127	for item in button_list:
	1128	if item.GetValue():
	1129	if button_list.index(item) == 0:
	1130	flag = 0 # dy = numpy.ones_like(dy_data)
	1131	elif button_list.index(item) == 1:
	1132	flag = 1 # dy = dy_data
	1133	elif button_list.index(item) == 2:
	1134	flag = 2 # dy = numpy.sqrt(numpy.abs(data))
	1135	elif button_list.index(item) == 3:
	1136	flag = 3 # dy = numpy.abs(data)
	1137	break
	1138	return flag
	1139
	1140	def _StopFit(self, event=None):
	1141	"""
	1142	Stop fit
	1143	"""
[c8e1996]	1144	if event is not None:
[682c432]	1145	event.Skip()
	1146	self._manager.stop_fit(self.uid)
	1147	self._manager._reset_schedule_problem(value=0)
	1148	self._on_fit_complete()
	1149
	1150	def rename_model(self):
	1151	"""
	1152	find a short name for model
	1153	"""
	1154	if self.model is not None:
	1155	self.model.name = "M" + str(self.index_model)
	1156
	1157	def _on_select_model(self, event=None):
	1158	"""
	1159	call back for model selection
	1160	"""
	1161	self.Show(False)
	1162	copy_flag = False
	1163	is_poly_enabled = None
[c8e1996]	1164	if event is not None:
	1165	if (event.GetEventObject() == self.formfactorbox
[bf44249e]	1166	and self.structurebox.GetLabel() != 'None')\
	1167	or event.GetEventObject() == self.structurebox\
	1168	or event.GetEventObject() == self.multifactorbox:
[682c432]	1169	copy_flag = self.get_copy_params()
	1170	is_poly_enabled = self.enable_disp.GetValue()
	1171
	1172	self._on_select_model_helper()
	1173	self.set_model_param_sizer(self.model)
	1174	if self.model is None:
	1175	self._set_bookmark_flag(False)
	1176	self._keep.Enable(False)
	1177	self._set_save_flag(False)
	1178	self.enable_disp.SetValue(False)
	1179	self.disable_disp.SetValue(True)
[6f16e25]	1180	# TODO: should not have an untrapped exception when displaying disperser
	1181	# TODO: do we need to create the disperser panel on every model change?
	1182	# Note: if we fix this, then remove ID_DISPERSER_HELP from basepage
[682c432]	1183	try:
	1184	self.set_dispers_sizer()
	1185	except:
	1186	pass
	1187	self.state.enable_disp = self.enable_disp.GetValue()
	1188	self.state.disable_disp = self.disable_disp.GetValue()
	1189	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
	1190	self.state.slit_smearer = self.slit_smearer.GetValue()
	1191
[77910cf]	1192	self.state.structurecombobox = self.structurebox.GetValue()
	1193	self.state.formfactorcombobox = self.formfactorbox.GetValue()
	1194	self.state.categorycombobox = self.categorybox.GetValue()
[682c432]	1195	self.enable_fit_button()
[373d4ee]	1196	if self.model is not None:
[682c432]	1197	self.m_name = self.model.name
	1198	self.state.m_name = self.m_name
	1199	self.rename_model()
	1200	self._set_copy_flag(True)
	1201	self._set_paste_flag(True)
	1202	if self.data is not None:
	1203	is_data = check_data_validity(self.data)
	1204	if is_data:
	1205	self._set_bookmark_flag(not self.batch_on)
	1206	self._keep.Enable(not self.batch_on)
	1207	self._set_save_flag(True)
[e0d9ed2]	1208	#Setting smearing for cases with and without data.
	1209	self._set_smear(self.data)
[682c432]	1210
	1211	# more disables for 2D
	1212	self._set_smear_buttons()
	1213
	1214	try:
	1215	# update smearer sizer
[e0d9ed2]	1216	#This call for smearing set up caused double evaluation of
	1217	#I(q) and double compilation as results
	1218	#self.onSmear(None)
[682c432]	1219	temp_smear = None
	1220	if not self.disable_smearer.GetValue():
	1221	# Set the smearer environments
	1222	temp_smear = self.current_smearer
	1223	except:
	1224	raise
[c8e1996]	1225	# error occured on chisqr computation
	1226	# pass
	1227	# event to post model to fit to fitting plugins
[682c432]	1228	(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
	1229
[c8e1996]	1230	# set smearing value whether or not data contain the smearing info
[682c432]	1231	evt = ModelEventbox(model=self.model,
[bf44249e]	1232	smearer=temp_smear,
	1233	enable_smearer=not self.disable_smearer.GetValue(),
	1234	qmin=float(self.qmin_x),
	1235	uid=self.uid,
	1236	caption=self.window_caption,
	1237	qmax=float(self.qmax_x))
[682c432]	1238
	1239	self._manager._on_model_panel(evt=evt)
[c8e1996]	1240	self.mbox_description.SetLabel("Model [ %s ]" %
	1241	str(self.model.name))
[682c432]	1242	self.mbox_description.SetForegroundColour(wx.BLUE)
	1243	self.state.model = self.model.clone()
	1244	self.state.model.name = self.model.name
	1245
[c8e1996]	1246	if event is not None:
	1247	# post state to fit panel
[682c432]	1248	new_event = PageInfoEvent(page=self)
	1249	wx.PostEvent(self.parent, new_event)
[c8e1996]	1250	# update list of plugins if new plugin is available
[682c432]	1251	custom_model = 'Customized Models'
	1252	mod_cat = self.categorybox.GetStringSelection()
	1253	if mod_cat == custom_model:
	1254	temp = self.parent.update_model_list()
	1255	if temp:
	1256	self.model_list_box = temp
	1257	current_val = self.formfactorbox.GetLabel()
	1258	pos = self.formfactorbox.GetSelection()
	1259	self._show_combox_helper()
	1260	self.formfactorbox.SetSelection(pos)
	1261	self.formfactorbox.SetValue(current_val)
	1262	# when select a model only from guictr/button
[c8e1996]	1263	if is_poly_enabled is not None:
[682c432]	1264	self.enable_disp.SetValue(is_poly_enabled)
	1265	self.disable_disp.SetValue(not is_poly_enabled)
	1266	self._set_dipers_Param(event=None)
	1267	self.state.enable_disp = self.enable_disp.GetValue()
	1268	self.state.disable_disp = self.disable_disp.GetValue()
	1269
	1270	# Keep the previous param values
	1271	if copy_flag:
	1272	self.get_paste_params(copy_flag)
	1273	wx.CallAfter(self._onDraw, None)
	1274
	1275	else:
	1276	self._draw_model()
	1277
	1278	if self.batch_on:
	1279	self.slit_smearer.Enable(False)
	1280	self.pinhole_smearer.Enable(False)
	1281	self.btEditMask.Disable()
	1282	self.EditMask_title.Disable()
	1283
	1284	self.Show(True)
	1285	self.SetupScrolling()
	1286
	1287	def _onparamEnter(self, event):
	1288	"""
	1289	when enter value on panel redraw model according to changed
	1290	"""
[c8e1996]	1291	if self.model is None:
[682c432]	1292	msg = "Please select a Model first..."
	1293	wx.MessageBox(msg, 'Info')
	1294	return
	1295
[c8e1996]	1296	# default flag
[682c432]	1297	flag = False
	1298	self.fitrange = True
[c8e1996]	1299	# get event object
[682c432]	1300	tcrtl = event.GetEventObject()
[c8e1996]	1301	# Clear msg if previously shown.
[682c432]	1302	msg = ""
	1303	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1304
	1305	if check_float(tcrtl):
	1306	flag = self._onparamEnter_helper()
	1307	self.show_npts2fit()
	1308	if self.fitrange:
	1309	temp_smearer = None
	1310	if not self.disable_smearer.GetValue():
	1311	temp_smearer = self.current_smearer
[c8e1996]	1312	# set smearing value whether or not data contain the
	1313	# smearing info
[682c432]	1314	if self.slit_smearer.GetValue():
	1315	flag1 = self.update_slit_smear()
	1316	flag = flag or flag1
	1317	elif self.pinhole_smearer.GetValue():
	1318	flag1 = self.update_pinhole_smear()
	1319	flag = flag or flag1
	1320	elif self.data.__class__.__name__ != "Data2D" and \
	1321	not self.enable2D:
[373d4ee]	1322	enable_smearer = not self.disable_smearer.GetValue()
[682c432]	1323	self._manager.set_smearer(smearer=temp_smearer,
	1324	fid=self.data.id,
	1325	uid=self.uid,
	1326	qmin=float(self.qmin_x),
	1327	qmax=float(self.qmax_x),
[934ce649]	1328	enable_smearer=enable_smearer)
[682c432]	1329	if flag:
[c8e1996]	1330	# self.compute_chisqr(smearer= temp_smearer)
[682c432]	1331
[c8e1996]	1332	# new state posted
[682c432]	1333	if self.state_change:
[c8e1996]	1334	# self._undo.Enable(True)
[682c432]	1335	event = PageInfoEvent(page=self)
	1336	wx.PostEvent(self.parent, event)
	1337	self.state_change = False
	1338	else:
	1339	# invalid fit range: do nothing here:
	1340	# msg already displayed in validate
	1341	return
	1342	else:
	1343	self.save_current_state()
[c8e1996]	1344	msg = "Cannot Plot: Must enter a number!!! "
[682c432]	1345	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1346
	1347	self.save_current_state()
	1348	return
	1349
	1350	def _onparamRangeEnter(self, event):
	1351	"""
	1352	Check validity of value enter in the parameters range field
	1353	"""
	1354	tcrtl = event.GetEventObject()
[c8e1996]	1355	# Clear msg if previously shown.
[682c432]	1356	msg = ""
	1357	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1358	# Flag to register when a parameter has changed.
	1359	is_modified = False
	1360	if tcrtl.GetValue().lstrip().rstrip() != "":
	1361	try:
	1362	tcrtl.SetBackgroundColour(wx.WHITE)
[ee4b3cb]	1363	self._check_value_enter(self.fittable_param)
	1364	self._check_value_enter(self.parameters)
[682c432]	1365	except:
	1366	tcrtl.SetBackgroundColour("pink")
	1367	msg = "Model Error:wrong value entered : %s" % sys.exc_value
	1368	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1369	return
	1370	else:
	1371	tcrtl.SetBackgroundColour(wx.WHITE)
	1372
[c8e1996]	1373	# self._undo.Enable(True)
[682c432]	1374	self.save_current_state()
	1375	event = PageInfoEvent(page=self)
	1376	wx.PostEvent(self.parent, event)
	1377	self.state_change = False
	1378
	1379	def qrang_set_focus(self, event=None):
	1380	"""
	1381	ON Qrange focus
	1382	"""
[c8e1996]	1383	if event is not None:
[682c432]	1384	event.Skip()
[c8e1996]	1385	# tcrtl = event.GetEventObject()
[682c432]	1386	self._validate_qrange(self.qmin, self.qmax)
	1387
	1388	def qrange_click(self, event):
	1389	"""
	1390	On Qrange textctrl click, make the qrange lines in the plot
	1391	"""
[c8e1996]	1392	if event is not None:
[682c432]	1393	event.Skip()
	1394	if self.data.__class__.__name__ == "Data2D":
	1395	return
	1396	is_click = event.LeftDown()
	1397	if is_click:
	1398	d_id = self.data.id
	1399	d_group_id = self.data.group_id
	1400	act_ctrl = event.GetEventObject()
	1401	wx.PostEvent(self._manager.parent,
	1402	PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
	1403	group_id=d_group_id, leftdown=is_click,
	1404	active=act_ctrl))
	1405
	1406	def on_qrange_text(self, event):
	1407	"""
	1408	#On q range value updated. DO not combine with qrange_click().
	1409	"""
[c8e1996]	1410	if event is not None:
[682c432]	1411	event.Skip()
	1412	if self.data.__class__.__name__ == "Data2D":
	1413	return
	1414	act_ctrl = event.GetEventObject()
	1415	d_id = self.data.id
	1416	d_group_id = self.data.group_id
	1417	wx.PostEvent(self._manager.parent,
	1418	PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
	1419	group_id=d_group_id, leftdown=False,
	1420	active=act_ctrl))
	1421	self._validate_qrange(self.qmin, self.qmax)
	1422
	1423	def on_key(self, event):
	1424	"""
	1425	On Key down
	1426	"""
	1427	event.Skip()
	1428	if self.data.__class__.__name__ == "Data2D":
	1429	return
	1430	ctrl = event.GetEventObject()
	1431	try:
	1432	x_data = float(ctrl.GetValue())
	1433	except:
	1434	return
	1435	key = event.GetKeyCode()
	1436	length = len(self.data.x)
	1437	indx = (numpy.abs(self.data.x - x_data)).argmin()
[c8e1996]	1438	# return array.flat[idx]
[682c432]	1439	if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP:
	1440	indx += 1
	1441	if indx >= length:
	1442	indx = length - 1
	1443	elif key == wx.WXK_PAGEDOWN or key == wx.WXK_NUMPAD_PAGEDOWN:
	1444	indx -= 1
	1445	if indx < 0:
	1446	indx = 0
	1447	else:
	1448	return
	1449	ctrl.SetValue(str(self.data.x[indx]))
	1450	self._validate_qrange(self.qmin, self.qmax)
	1451
	1452	def _onQrangeEnter(self, event):
	1453	"""
	1454	Check validity of value enter in the Q range field
	1455	"""
	1456	tcrtl = event.GetEventObject()
[c8e1996]	1457	# Clear msg if previously shown.
[682c432]	1458	msg = ""
	1459	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1460	# For theory mode
	1461	if not self.data.is_data:
	1462	self.npts_x = self.Npts_total.GetValue()
	1463	self.Npts_fit.SetValue(self.npts_x)
	1464	self.create_default_data()
	1465	# Flag to register when a parameter has changed.
	1466	if tcrtl.GetValue().lstrip().rstrip() != "":
	1467	try:
	1468	tcrtl.SetBackgroundColour(wx.WHITE)
	1469	# If qmin and qmax have been modified, update qmin and qmax
	1470	if self._validate_qrange(self.qmin, self.qmax):
	1471	tempmin = float(self.qmin.GetValue())
	1472	if tempmin != self.qmin_x:
	1473	self.qmin_x = tempmin
	1474	tempmax = float(self.qmax.GetValue())
	1475	if tempmax != self.qmax_x:
	1476	self.qmax_x = tempmax
	1477	else:
	1478	tcrtl.SetBackgroundColour("pink")
	1479	msg = "Model Error:wrong value entered : %s" % sys.exc_value
	1480	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1481	return
	1482	except:
	1483	tcrtl.SetBackgroundColour("pink")
	1484	msg = "Model Error:wrong value entered : %s" % sys.exc_value
	1485	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1486	return
[c8e1996]	1487	# Check if # of points for theory model are valid(>0).
[682c432]	1488	# check for 2d
	1489	if self.data.__class__.__name__ == "Data2D" or \
	1490	self.enable2D:
	1491	# set mask
	1492	radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
	1493	self.data.qy_data * self.data.qy_data)
[c8e1996]	1494	index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x))
[682c432]	1495	index_data = (index_data) & (self.data.mask)
	1496	index_data = (index_data) & (numpy.isfinite(self.data.data))
	1497	if len(index_data[index_data]) < 10:
	1498	msg = "Cannot Plot :No or too little npts in"
	1499	msg += " that data range!!! "
	1500	wx.PostEvent(self._manager.parent,
	1501	StatusEvent(status=msg))
	1502	return
	1503	else:
[c8e1996]	1504	# self.data.mask = index_data
	1505	# self.Npts_fit.SetValue(str(len(self.data.mask)))
[682c432]	1506	self.show_npts2fit()
	1507	else:
[c8e1996]	1508	index_data = ((self.qmin_x <= self.data.x) &
[682c432]	1509	(self.data.x <= self.qmax_x))
	1510	self.Npts_fit.SetValue(str(len(self.data.x[index_data])))
	1511
	1512	self.npts_x = self.Npts_total.GetValue()
	1513	self.create_default_data()
	1514	self._save_plotting_range()
	1515	else:
	1516	tcrtl.SetBackgroundColour("pink")
	1517	msg = "Model Error:wrong value entered!!!"
	1518	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1519
	1520	self._draw_model()
	1521	self.save_current_state()
	1522	event = PageInfoEvent(page=self)
	1523	wx.PostEvent(self.parent, event)
	1524	self.state_change = False
	1525	return
	1526
	1527	def _clear_Err_on_Fit(self):
	1528	"""
	1529	hide the error text control shown
	1530	after fitting
	1531	"""
	1532
	1533	if self.is_mac:
	1534	return
	1535	if hasattr(self, "text2_3"):
	1536	self.text2_3.Hide()
	1537
	1538	if len(self.parameters) > 0:
	1539	for item in self.parameters:
	1540	if item[0].IsShown():
[c8e1996]	1541	# Skip the angle parameters if 1D data
[682c432]	1542	if self.data.__class__.__name__ != "Data2D" and \
	1543	not self.enable2D:
	1544	if item in self.orientation_params:
	1545	continue
	1546	if item in self.param_toFit:
	1547	continue
[c8e1996]	1548	# hide statictext +/-
[682c432]	1549	if len(item) < 4:
	1550	continue
[c8e1996]	1551	if item[3] is not None and item[3].IsShown():
[682c432]	1552	item[3].Hide()
[c8e1996]	1553	# hide textcrtl for error after fit
	1554	if item[4] is not None and item[4].IsShown():
[682c432]	1555	item[4].Hide()
	1556
	1557	if len(self.fittable_param) > 0:
	1558	for item in self.fittable_param:
	1559	if item[0].IsShown():
[c8e1996]	1560	# Skip the angle parameters if 1D data
[682c432]	1561	if self.data.__class__.__name__ != "Data2D" and \
	1562	not self.enable2D:
	1563	if item in self.orientation_params:
	1564	continue
	1565	if item in self.param_toFit:
	1566	continue
	1567	if len(item) < 4:
	1568	continue
[c8e1996]	1569	# hide statictext +/-
	1570	if item[3] is not None and item[3].IsShown():
[682c432]	1571	item[3].Hide()
[c8e1996]	1572	# hide textcrtl for error after fit
	1573	if item[4] is not None and item[4].IsShown():
[682c432]	1574	item[4].Hide()
	1575	return
	1576
	1577	def _get_defult_custom_smear(self):
	1578	"""
	1579	Get the defult values for custum smearing.
	1580	"""
	1581	# get the default values
[c8e1996]	1582	if self.dxl is None:
[682c432]	1583	self.dxl = 0.0
[c8e1996]	1584	if self.dxw is None:
[682c432]	1585	self.dxw = ""
[c8e1996]	1586	if self.dx_min is None:
[682c432]	1587	self.dx_min = SMEAR_SIZE_L
[c8e1996]	1588	if self.dx_max is None:
[682c432]	1589	self.dx_max = SMEAR_SIZE_H
	1590
	1591	def _get_smear_info(self):
	1592	"""
	1593	Get the smear info from data.
	1594
	1595	:return: self.smear_type, self.dq_l and self.dq_r,
	1596	respectively the type of the smear, dq_min and
	1597	dq_max for pinhole smear data
	1598	while dxl and dxw for slit smear
	1599	"""
	1600	# default
	1601	self.smear_type = None
	1602	self.dq_l = None
	1603	self.dq_r = None
	1604	data = self.data
	1605	if self.data is None:
	1606	return
	1607	elif self.data.__class__.__name__ == "Data2D" or \
	1608	self.enable2D:
[c8e1996]	1609	if data.dqx_data is None or data.dqy_data is None:
[682c432]	1610	return
[c8e1996]	1611	elif self.current_smearer is not None \
[682c432]	1612	and data.dqx_data.any() != 0 \
	1613	and data.dqx_data.any() != 0:
	1614	self.smear_type = "Pinhole2d"
	1615	self.dq_l = format_number(numpy.average(data.dqx_data))
	1616	self.dq_r = format_number(numpy.average(data.dqy_data))
	1617	return
	1618	else:
	1619	return
	1620	# check if it is pinhole smear and get min max if it is.
[24fd27a]	1621	if data.dx is not None and numpy.any(data.dx):
[682c432]	1622	self.smear_type = "Pinhole"
	1623	self.dq_l = data.dx[0]
	1624	self.dq_r = data.dx[-1]
	1625
	1626	# check if it is slit smear and get min max if it is.
[c8e1996]	1627	elif data.dxl is not None or data.dxw is not None:
[682c432]	1628	self.smear_type = "Slit"
[c8e1996]	1629	if data.dxl is not None and not numpy.all(data.dxl, 0):
[682c432]	1630	self.dq_l = data.dxl[0]
[c8e1996]	1631	if data.dxw is not None and not numpy.all(data.dxw, 0):
[682c432]	1632	self.dq_r = data.dxw[0]
[c8e1996]	1633	# return self.smear_type,self.dq_l,self.dq_r
[682c432]	1634
	1635	def _show_smear_sizer(self):
	1636	"""
	1637	Show only the sizers depending on smear selection
	1638	"""
	1639	# smear disabled
	1640	if self.disable_smearer.GetValue():
	1641	self.smear_description_none.Show(True)
	1642	# 2Dsmear
	1643	elif self._is_2D():
	1644	self.smear_description_accuracy_type.Show(True)
	1645	self.smear_accuracy.Show(True)
	1646	self.smear_description_accuracy_type.Show(True)
	1647	self.smear_description_2d.Show(True)
	1648	self.smear_description_2d_x.Show(True)
	1649	self.smear_description_2d_y.Show(True)
	1650	if self.pinhole_smearer.GetValue():
	1651	self.smear_pinhole_min.Show(True)
	1652	self.smear_pinhole_max.Show(True)
	1653	# smear from data
	1654	elif self.enable_smearer.GetValue():
	1655
	1656	self.smear_description_dqdata.Show(True)
[c8e1996]	1657	if self.smear_type is not None:
[682c432]	1658	self.smear_description_smear_type.Show(True)
	1659	if self.smear_type == 'Slit':
	1660	self.smear_description_slit_height.Show(True)
	1661	self.smear_description_slit_width.Show(True)
	1662	elif self.smear_type == 'Pinhole':
	1663	self.smear_description_pin_min.Show(True)
	1664	self.smear_description_pin_max.Show(True)
	1665	self.smear_description_smear_type.Show(True)
	1666	self.smear_description_type.Show(True)
	1667	self.smear_data_left.Show(True)
	1668	self.smear_data_right.Show(True)
	1669	# custom pinhole smear
	1670	elif self.pinhole_smearer.GetValue():
	1671	if self.smear_type == 'Pinhole':
	1672	self.smear_message_new_p.Show(True)
	1673	self.smear_description_pin_min.Show(True)
	1674	self.smear_description_pin_max.Show(True)
	1675
	1676	self.smear_pinhole_min.Show(True)
	1677	self.smear_pinhole_max.Show(True)
	1678	# custom slit smear
	1679	elif self.slit_smearer.GetValue():
	1680	self.smear_message_new_s.Show(True)
	1681	self.smear_description_slit_height.Show(True)
	1682	self.smear_slit_height.Show(True)
	1683	self.smear_description_slit_width.Show(True)
	1684	self.smear_slit_width.Show(True)
	1685
	1686	def _hide_all_smear_info(self):
	1687	"""
	1688	Hide all smearing messages in the set_smearer sizer
	1689	"""
	1690	self.smear_description_none.Hide()
	1691	self.smear_description_dqdata.Hide()
	1692	self.smear_description_type.Hide()
	1693	self.smear_description_smear_type.Hide()
	1694	self.smear_description_accuracy_type.Hide()
	1695	self.smear_description_2d_x.Hide()
	1696	self.smear_description_2d_y.Hide()
	1697	self.smear_description_2d.Hide()
	1698
	1699	self.smear_accuracy.Hide()
	1700	self.smear_data_left.Hide()
	1701	self.smear_data_right.Hide()
	1702	self.smear_description_pin_min.Hide()
	1703	self.smear_pinhole_min.Hide()
	1704	self.smear_description_pin_max.Hide()
	1705	self.smear_pinhole_max.Hide()
	1706	self.smear_description_slit_height.Hide()
	1707	self.smear_slit_height.Hide()
	1708	self.smear_description_slit_width.Hide()
	1709	self.smear_slit_width.Hide()
	1710	self.smear_message_new_p.Hide()
	1711	self.smear_message_new_s.Hide()
	1712
	1713	def _set_accuracy_list(self):
	1714	"""
	1715	Set the list of an accuracy in 2D custum smear:
	1716	Xhigh, High, Med, or Low
	1717	"""
	1718	# list of accuracy choices
	1719	list = ['Low', 'Med', 'High', 'Xhigh']
	1720	for idx in range(len(list)):
	1721	self.smear_accuracy.Append(list[idx], idx)
	1722
	1723	def _set_fun_box_list(self, fun_box):
	1724	"""
	1725	Set the list of func for multifunctional models
	1726	"""
	1727	# Check if it is multi_functional model
	1728	if self.model.__class__ not in self.model_list_box["Multi-Functions"] \
	1729	and not self.temp_multi_functional:
	1730	return None
	1731	# Get the func name list
	1732	list = self.model.fun_list
	1733	if len(list) == 0:
	1734	return None
	1735	# build function (combo)box
	1736	ind = 0
	1737	while(ind < len(list)):
	1738	for key, val in list.iteritems():
	1739	if (val == ind):
	1740	fun_box.Append(key, val)
	1741	break
	1742	ind += 1
	1743
	1744	def _on_select_accuracy(self, event):
	1745	"""
	1746	Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
	1747	"""
[c8e1996]	1748	# event.Skip()
[682c432]	1749	# Check if the accuracy is same as before
[c8e1996]	1750	# self.smear2d_accuracy = event.GetEventObject().GetValue()
[682c432]	1751	self.smear2d_accuracy = self.smear_accuracy.GetValue()
	1752	if self.pinhole_smearer.GetValue():
	1753	self.onPinholeSmear(event=None)
	1754	else:
	1755	self.onSmear(event=None)
[c8e1996]	1756	if self.current_smearer is not None:
[682c432]	1757	self.current_smearer.set_accuracy(accuracy=\
	1758	self.smear2d_accuracy)
	1759	event.Skip()
	1760
	1761	def _on_fun_box(self, event):
	1762	"""
	1763	Select an func: Erf,Rparabola,LParabola
	1764	"""
	1765	fun_val = None
	1766	fun_box = event.GetEventObject()
	1767	name = fun_box.Name
	1768	value = fun_box.GetValue()
	1769	if value in self.model.fun_list:
	1770	fun_val = self.model.fun_list[value]
	1771
	1772	self.model.setParam(name, fun_val)
	1773	# save state
	1774	self._copy_parameters_state(self.str_parameters,
	1775	self.state.str_parameters)
	1776	# update params
	1777	self._update_paramv_on_fit()
	1778	# draw
	1779	self._draw_model()
	1780	self.Refresh()
	1781	# get ready for new event
	1782	event.Skip()
	1783
	1784	def _onMask(self, event):
	1785	"""
	1786	Build a panel to allow to edit Mask
	1787	"""
[c8e1996]	1788	from sas.sasgui.guiframe.local_perspectives.plotting.masking import \
	1789	MaskPanel as MaskDialog
[682c432]	1790
	1791	self.panel = MaskDialog(base=self, data=self.data, id=wx.NewId())
	1792	self.panel.ShowModal()
	1793
	1794	def _draw_masked_model(self, event):
	1795	"""
	1796	Draw model image w/mask
	1797	"""
	1798	is_valid_qrange = self._update_paramv_on_fit()
	1799
[c8e1996]	1800	if is_valid_qrange and self.model is not None:
[682c432]	1801	self.panel.MakeModal(False)
	1802	event.Skip()
	1803	# try re draw the model plot if it exists
	1804	self._draw_model()
	1805	self.show_npts2fit()
[c8e1996]	1806	elif self.model is None:
[682c432]	1807	self.panel.MakeModal(False)
	1808	event.Skip()
	1809	self.show_npts2fit()
	1810	msg = "No model is found on updating MASK in the model plot... "
	1811	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	1812	else:
	1813	event.Skip()
	1814	msg = ' Please consider your Q range, too.'
	1815	self.panel.ShowMessage(msg)
	1816
	1817	def _set_smear(self, data):
	1818	"""
	1819	Set_smear
	1820	"""
	1821	if data is None:
	1822	return
	1823	self.current_smearer = smear_selection(data, self.model)
	1824	flag = self.disable_smearer.GetValue()
[373d4ee]	1825	if self.current_smearer is None:
[682c432]	1826	self.enable_smearer.Disable()
	1827	else:
	1828	self.enable_smearer.Enable()
	1829	if not flag:
	1830	self.onSmear(None)
	1831
	1832	def get_view_mode(self):
	1833	"""
	1834	return True if the panel allow 2D or False if 1D
	1835	"""
	1836	return self.enable2D
	1837
	1838	def compute_data_set_range(self, data_list):
	1839	"""
	1840	find the range that include all data in the set
	1841	return the minimum and the maximum values
	1842	"""
	1843	if data_list is not None and data_list != []:
	1844	for data in data_list:
	1845	qmin, qmax, npts = self.compute_data_range(data)
	1846	self.qmin_data_set = min(self.qmin_data_set, qmin)
	1847	self.qmax_data_set = max(self.qmax_data_set, qmax)
	1848	self.npts_data_set += npts
	1849	return self.qmin_data_set, self.qmax_data_set, self.npts_data_set
	1850
	1851	def compute_data_range(self, data):
	1852	"""
	1853	compute the minimum and the maximum range of the data
	1854	return the npts contains in data
	1855	:param data:
	1856	"""
	1857	qmin, qmax, npts = None, None, None
	1858	if data is not None:
	1859	if not hasattr(data, "data"):
	1860	try:
	1861	qmin = min(data.x)
	1862	# Maximum value of data
	1863	qmax = max(data.x)
	1864	npts = len(data.x)
	1865	except:
[c8e1996]	1866	msg = "Unable to find min/max/length of \n data named %s" %\
[682c432]	1867	data.filename
	1868	wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
	1869	info="error"))
	1870	raise ValueError, msg
	1871
	1872	else:
	1873	qmin = 0
	1874	try:
	1875	x = max(math.fabs(data.xmin), math.fabs(data.xmax))
	1876	y = max(math.fabs(data.ymin), math.fabs(data.ymax))
	1877	except:
	1878	msg = "Unable to find min/max of \n data named %s" % \
	1879	data.filename
	1880	wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
	1881	info="error"))
	1882	raise ValueError, msg
[c8e1996]	1883	# Maximum value of data
[682c432]	1884	qmax = math.sqrt(x * x + y * y)
	1885	npts = len(data.data)
	1886	return qmin, qmax, npts
	1887
	1888	def set_data(self, data):
	1889	"""
	1890	reset the current data
	1891	"""
	1892	id = None
	1893	flag = False
	1894	is_data = False
[c8e1996]	1895	npts = 0
[682c432]	1896	try:
	1897	old_id = self.data.id
	1898	old_group_id = self.data.group_id
	1899	except:
	1900	old_id = id
	1901	old_group_id = id
	1902	if self.data is not None:
	1903	is_data = check_data_validity(self.data)
	1904	if not is_data and data is not None:
	1905	flag = True
	1906	if data is not None:
	1907	if is_data:
	1908	self.graph_id = self.data.group_id
	1909	flag = (data.id != self.data.id)
	1910	self.data = data
	1911	if check_data_validity(data):
	1912	self.graph_id = data.group_id
	1913	self.data.group_id = self.graph_id
	1914
	1915	if self.data is None:
	1916	data_name = ""
	1917	self._set_bookmark_flag(False)
	1918	self._keep.Enable(False)
	1919	self._set_save_flag(False)
	1920	else:
[c8e1996]	1921	if self.model is not None:
[682c432]	1922	self._set_bookmark_flag(not self.batch_on)
	1923	self._keep.Enable(not self.batch_on)
	1924	if self.data.is_data:
	1925	self._set_save_flag(True)
	1926	self._set_preview_flag(True)
	1927
	1928	# more disables for 2D
	1929	if self.data.__class__.__name__ == "Data2D" or \
	1930	self.enable2D:
	1931	self.slit_smearer.Disable()
	1932	self.pinhole_smearer.Enable(True)
	1933	self.default_mask = copy.deepcopy(self.data.mask)
[c8e1996]	1934	if self.data.err_data is None or\
	1935	numpy.all(err == 1 for err in self.data.err_data) or \
	1936	not numpy.any(self.data.err_data):
[682c432]	1937	self.dI_didata.Enable(False)
	1938	self.dI_noweight.SetValue(True)
	1939	self.weightbt_string = self.dI_noweight.GetLabelText()
	1940	else:
	1941	self.dI_didata.Enable(True)
	1942	self.dI_didata.SetValue(True)
	1943	self.weightbt_string = self.dI_didata.GetLabelText()
	1944	else:
	1945	self.slit_smearer.Enable(True)
	1946	self.pinhole_smearer.Enable(True)
[c8e1996]	1947
	1948	if self.data.dy is None or\
	1949	numpy.all(self.data.dy == 1) or\
	1950	not numpy.any(self.data.dy):
[682c432]	1951	self.dI_didata.Enable(False)
	1952	self.dI_noweight.SetValue(True)
	1953	self.weightbt_string = self.dI_noweight.GetLabelText()
	1954	else:
	1955	self.dI_didata.Enable(True)
	1956	self.dI_didata.SetValue(True)
	1957	self.weightbt_string = self.dI_didata.GetLabelText()
[c8e1996]	1958	# Enable weighting radio buttons
[682c432]	1959	self.dI_noweight.Enable(True)
	1960	self.dI_sqrdata.Enable(True)
	1961	self.dI_idata.Enable(True)
	1962
	1963	self.formfactorbox.Enable()
	1964	self.structurebox.Enable()
	1965	data_name = self.data.name
	1966	_, _, npts = self.compute_data_range(self.data)
[c8e1996]	1967	# set maximum range for x in linear scale
[682c432]	1968	if not hasattr(self.data, "data"): # Display only for 1D data fit
	1969	self.btEditMask.Disable()
	1970	self.EditMask_title.Disable()
	1971	else:
	1972	self.btEditMask.Enable()
	1973	self.EditMask_title.Enable()
	1974
	1975	self.Npts_total.SetValue(str(npts))
[c8e1996]	1976	# default:number of data points selected to fit
[682c432]	1977	self.Npts_fit.SetValue(str(npts))
	1978	self.Npts_total.SetEditable(False)
[c8e1996]	1979	self.Npts_total.SetBackgroundColour(
[682c432]	1980	self.GetParent().GetBackgroundColour())
	1981
	1982	self.Npts_total.Bind(wx.EVT_MOUSE_EVENTS, self._npts_click)
	1983	self.pointsbox.Disable()
	1984	self.dataSource.SetValue(data_name)
	1985	self.state.data = data
	1986	self.enable_fit_button()
	1987	# send graph_id to page_finder
	1988	self._manager.set_graph_id(uid=self.uid, graph_id=self.graph_id)
[c8e1996]	1989	# focus the page
[682c432]	1990	if check_data_validity(data):
	1991	self.data_box_description.SetForegroundColour(wx.BLUE)
	1992
	1993	if self.batch_on:
	1994	self.slit_smearer.Enable(False)
	1995	self.pinhole_smearer.Enable(False)
	1996	self.btEditMask.Disable()
	1997	self.EditMask_title.Disable()
	1998
	1999	self.on_set_focus(None)
	2000	self.Refresh()
[c8e1996]	2001	# update model plot with new data information
[682c432]	2002	if flag:
	2003	if self.data.__class__.__name__ == "Data2D":
	2004	self.enable2D = True
	2005	self.model_view.SetLabel("2D Mode")
	2006	else:
	2007	self.enable2D = False
	2008	self.model_view.SetLabel("1D Mode")
	2009	self.model_view.Disable()
[c8e1996]	2010	# replace data plot on combo box selection
	2011	# by removing the previous selected data
[682c432]	2012	try:
	2013	wx.PostEvent(self._manager.parent,
	2014	NewPlotEvent(action="delete",
	2015	group_id=old_group_id, id=old_id))
	2016	except:
	2017	pass
[c8e1996]	2018	# plot the current selected data
[682c432]	2019	wx.PostEvent(self._manager.parent,
	2020	NewPlotEvent(action="check", plot=self.data,
	2021	title=str(self.data.title)))
	2022	self._draw_model()
	2023
	2024	def _npts_click(self, event):
	2025	"""
	2026	Prevent further handling of the mouse event on Npts_total
	2027	by not calling Skip().
	2028	"""
	2029	pass
	2030
	2031	def reset_page(self, state, first=False):
	2032	"""
	2033	reset the state
	2034	"""
	2035	try:
	2036	self.reset_page_helper(state)
	2037
[c8e1996]	2038	self.select_param()
	2039	# Save state_fit
[682c432]	2040	self.save_current_state_fit()
	2041	except:
	2042	self._show_combox_helper()
	2043	msg = "Error: This model state has missing or outdated "
	2044	msg += "information.\n"
[6c382da]	2045	msg += traceback.format_exc()
[682c432]	2046	wx.PostEvent(self._manager.parent,
	2047	StatusEvent(status=msg, info="error"))
	2048	self._lay_out()
	2049	self.Refresh()
	2050
	2051	def get_range(self):
	2052	"""
	2053	return the fitting range
	2054	"""
	2055	return float(self.qmin_x), float(self.qmax_x)
	2056
	2057	def get_npts2fit(self):
	2058	"""
	2059	return numbers of data points within qrange
	2060
	2061	:Note: This is to normalize chisq by Npts of fit
	2062
	2063	"""
	2064	if self.data is None:
	2065	return
	2066	npts2fit = 0
	2067	qmin, qmax = self.get_range()
	2068	if self.data.__class__.__name__ == "Data2D" or \
	2069	self.enable2D:
	2070	radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
	2071	self.data.qy_data * self.data.qy_data)
	2072	index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x)
	2073	index_data = (index_data) & (self.data.mask)
	2074	index_data = (index_data) & (numpy.isfinite(self.data.data))
	2075	npts2fit = len(self.data.data[index_data])
	2076	else:
	2077	for qx in self.data.x:
[c8e1996]	2078	if qmax >= qx >= qmin:
[682c432]	2079	npts2fit += 1
	2080	return npts2fit
	2081
	2082	def show_npts2fit(self):
	2083	"""
	2084	setValue Npts for fitting
	2085	"""
	2086	self.Npts_fit.SetValue(str(self.get_npts2fit()))
	2087
	2088	def get_chi2(self):
	2089	"""
	2090	return the current chi2
	2091	"""
	2092	return self.tcChi.GetValue()
	2093
	2094	def onsetValues(self, chisqr, p_name, out, cov):
	2095	"""
	2096	Build the panel from the fit result
	2097
	2098	:param chisqr: Value of the goodness of fit metric
	2099	:param p_name: the name of parameters
	2100	:param out: list of parameter with the best value found during fitting
	2101	:param cov: Covariance matrix
	2102
	2103	"""
	2104
	2105	# make sure stop button to fit button all the time
	2106	self._on_fit_complete()
[c8e1996]	2107	if out is None or not numpy.isfinite(chisqr):
[682c432]	2108	raise ValueError, "Fit error occured..."
	2109
	2110	is_modified = False
	2111	has_error = False
	2112	dispersity = ''
	2113
[c8e1996]	2114	# Hide textctrl boxes of errors.
[682c432]	2115	self._clear_Err_on_Fit()
	2116
[c8e1996]	2117	# Check if chi2 is finite
	2118	if chisqr is not None and numpy.isfinite(chisqr):
	2119	# format chi2
[682c432]	2120	chi2 = format_number(chisqr, True)
	2121	self.tcChi.SetValue(chi2)
	2122	self.tcChi.Refresh()
	2123	else:
	2124	self.tcChi.SetValue("-")
	2125
[c8e1996]	2126	# Hide error title
[682c432]	2127	if self.text2_3.IsShown() and not self.is_mac:
	2128	self.text2_3.Hide()
	2129
	2130	try:
	2131	if self.enable_disp.GetValue():
	2132	if hasattr(self, "text_disp_1"):
[c8e1996]	2133	if self.text_disp_1 is not None and not self.is_mac:
[682c432]	2134	self.text_disp_1.Hide()
	2135	except:
	2136	dispersity = None
	2137	pass
	2138
	2139	i = 0
[c8e1996]	2140	# Set the panel when fit result are list
[682c432]	2141
	2142	for item in self.param_toFit:
[c8e1996]	2143	if len(item) > 5 and item is not None:
[682c432]	2144
	2145	if item[0].IsShown():
[c8e1996]	2146	# reset error value to initial state
[682c432]	2147	if not self.is_mac:
	2148	item[3].Hide()
	2149	item[4].Hide()
	2150	for ind in range(len(out)):
	2151	if item[1] == p_name[ind]:
	2152	break
[c8e1996]	2153	if len(out) > 0 and out[ind] is not None:
[682c432]	2154	val_out = format_number(out[ind], True)
	2155	item[2].SetValue(val_out)
	2156
[c8e1996]	2157	if(cov is not None and len(cov) == len(out)):
[682c432]	2158	try:
[c8e1996]	2159	if dispersity is not None:
[682c432]	2160	if self.enable_disp.GetValue():
	2161	if hasattr(self, "text_disp_1"):
[c8e1996]	2162	if self.text_disp_1 is not None:
[682c432]	2163	if not self.text_disp_1.IsShown()\
[c8e1996]	2164	and not self.is_mac:
[682c432]	2165	self.text_disp_1.Show(True)
	2166	except:
	2167	pass
	2168
[c8e1996]	2169	if cov[ind] is not None:
[682c432]	2170	if numpy.isfinite(float(cov[ind])):
	2171	val_err = format_number(cov[ind], True)
[c8e1996]	2172	item[4].SetForegroundColour(wx.BLACK)
[373d4ee]	2173	else:
	2174	val_err = 'NaN'
[60d08fd]	2175	item[4].SetForegroundColour(wx.RED)
[373d4ee]	2176	if not self.is_mac:
	2177	item[3].Show(True)
	2178	item[4].Show(True)
	2179	item[4].SetValue(val_err)
	2180	has_error = True
[682c432]	2181	i += 1
	2182	else:
	2183	raise ValueError, "onsetValues: Invalid parameters..."
[c8e1996]	2184	# Show error title when any errors displayed
[682c432]	2185	if has_error:
	2186	if not self.text2_3.IsShown():
	2187	self.text2_3.Show(True)
[c8e1996]	2188	# save current state
[682c432]	2189	self.save_current_state()
	2190
[c8e1996]	2191	# plot model ( when drawing, do not update chisqr value again)
[682c432]	2192	self._draw_model(update_chisqr=False, source='fit')
	2193
	2194	def onWeighting(self, event):
	2195	"""
	2196	On Weighting radio button event, sets the weightbt_string
	2197	"""
	2198	self.weightbt_string = event.GetEventObject().GetLabelText()
	2199	self._set_weight()
	2200
	2201	def _set_weight(self, is_2D=None):
	2202	"""
	2203	Set weight in fit problem
	2204	"""
	2205	# compute weight for the current data
	2206	flag_weight = self.get_weight_flag()
[c8e1996]	2207	if is_2D is None:
[682c432]	2208	is_2D = self._is_2D()
	2209	self._manager.set_fit_weight(uid=self.uid,
	2210	flag=flag_weight,
	2211	is2d=is_2D,
	2212	fid=None)
	2213
	2214	def onPinholeSmear(self, event):
	2215	"""
	2216	Create a custom pinhole smear object that will change the way residuals
	2217	are compute when fitting
	2218
	2219	:Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
	2220	None for 1D
	2221
	2222	"""
	2223	# Need update param values
	2224	self._update_paramv_on_fit()
	2225
[c8e1996]	2226	if event is not None:
[682c432]	2227	tcrtl = event.GetEventObject()
	2228	# event case of radio button
[c8e1996]	2229	if tcrtl.GetValue():
[682c432]	2230	self.dx_min = 0.0
	2231	self.dx_max = 0.0
	2232	is_new_pinhole = True
	2233	else:
	2234	is_new_pinhole = self._is_changed_pinhole()
	2235	else:
	2236	is_new_pinhole = True
	2237	# if any value is changed
	2238	if is_new_pinhole:
[098f3d2]	2239	self._set_pinhole_smear()
[682c432]	2240	# hide all silt sizer
	2241	self._hide_all_smear_info()
	2242
	2243	# show relevant slit sizers
	2244	self._show_smear_sizer()
	2245
	2246	self.sizer_set_smearer.Layout()
[c8e1996]	2247	# we need FitInside here not just self.Layout to ensure all the sizers
	2248	# end up with the necessasary space to in the scroll panel. In
	2249	# particular the compute and fit buttons end up on top of each other
	2250	# PDB Nov 28 2015.
[1c2bf90]	2251	self.FitInside()
[682c432]	2252
[c8e1996]	2253	if event is not None:
[682c432]	2254	event.Skip()
[c8e1996]	2255	# self._undo.Enable(True)
[682c432]	2256	self.save_current_state()
	2257	event = PageInfoEvent(page=self)
	2258	wx.PostEvent(self.parent, event)
	2259
	2260	def _is_changed_pinhole(self):
	2261	"""
	2262	check if any of pinhole smear is changed
	2263
	2264	:return: True or False
	2265
	2266	"""
	2267	# get the values
	2268	pin_min = self.smear_pinhole_min.GetValue()
	2269	pin_max = self.smear_pinhole_max.GetValue()
	2270
	2271	# Check changes in slit width
	2272	try:
	2273	dx_min = float(pin_min)
	2274	except:
	2275	return True
	2276	if self.dx_min != dx_min:
	2277	return True
	2278
	2279	# Check changes in slit heigth
	2280	try:
	2281	dx_max = float(pin_max)
	2282	except:
	2283	return True
	2284	if self.dx_max != dx_max:
	2285	return True
	2286	return False
	2287
	2288	def _set_pinhole_smear(self):
	2289	"""
	2290	Set custom pinhole smear
	2291
	2292	:return: msg
	2293
	2294	"""
	2295	# copy data
	2296	data = copy.deepcopy(self.data)
	2297	if self._is_2D():
	2298	self.smear_type = 'Pinhole2d'
	2299	len_data = len(data.data)
	2300	data.dqx_data = numpy.zeros(len_data)
	2301	data.dqy_data = numpy.zeros(len_data)
	2302	else:
	2303	self.smear_type = 'Pinhole'
	2304	len_data = len(data.x)
	2305	data.dx = numpy.zeros(len_data)
	2306	data.dxl = None
	2307	data.dxw = None
	2308	msg = None
	2309
	2310	get_pin_min = self.smear_pinhole_min
	2311	get_pin_max = self.smear_pinhole_max
	2312
	2313	if not check_float(get_pin_min):
	2314	get_pin_min.SetBackgroundColour("pink")
	2315	msg = "Model Error:wrong value entered!!!"
	2316	elif not check_float(get_pin_max):
	2317	get_pin_max.SetBackgroundColour("pink")
	2318	msg = "Model Error:wrong value entered!!!"
	2319	else:
	2320	if len_data < 2:
	2321	len_data = 2
	2322	self.dx_min = float(get_pin_min.GetValue())
	2323	self.dx_max = float(get_pin_max.GetValue())
	2324	if self.dx_min < 0:
	2325	get_pin_min.SetBackgroundColour("pink")
	2326	msg = "Model Error:This value can not be negative!!!"
	2327	elif self.dx_max < 0:
	2328	get_pin_max.SetBackgroundColour("pink")
	2329	msg = "Model Error:This value can not be negative!!!"
[c8e1996]	2330	elif self.dx_min is not None and self.dx_max is not None:
[682c432]	2331	if self._is_2D():
	2332	data.dqx_data[data.dqx_data == 0] = self.dx_min
	2333	data.dqy_data[data.dqy_data == 0] = self.dx_max
	2334	elif self.dx_min == self.dx_max:
	2335	data.dx[data.dx == 0] = self.dx_min
	2336	else:
	2337	step = (self.dx_max - self.dx_min) / (len_data - 1)
	2338	data.dx = numpy.arange(self.dx_min,
	2339	self.dx_max + step / 1.1,
	2340	step)
[c8e1996]	2341	elif self.dx_min is not None:
[682c432]	2342	if self._is_2D():
	2343	data.dqx_data[data.dqx_data == 0] = self.dx_min
	2344	else:
	2345	data.dx[data.dx == 0] = self.dx_min
[c8e1996]	2346	elif self.dx_max is not None:
[682c432]	2347	if self._is_2D():
	2348	data.dqy_data[data.dqy_data == 0] = self.dx_max
	2349	else:
	2350	data.dx[data.dx == 0] = self.dx_max
	2351	self.current_smearer = smear_selection(data, self.model)
	2352	# 2D need to set accuracy
	2353	if self._is_2D():
[c8e1996]	2354	self.current_smearer.set_accuracy(
	2355	accuracy=self.smear2d_accuracy)
[682c432]	2356
[c8e1996]	2357	if msg is not None:
[682c432]	2358	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	2359	else:
	2360	get_pin_min.SetBackgroundColour("white")
	2361	get_pin_max.SetBackgroundColour("white")
[c8e1996]	2362	# set smearing value whether or not the data contain the smearing info
[682c432]	2363
[373d4ee]	2364	enable_smearer = not self.disable_smearer.GetValue()
[682c432]	2365	self._manager.set_smearer(smearer=self.current_smearer,
[373d4ee]	2366	fid=self.data.id,
	2367	qmin=float(self.qmin_x),
	2368	qmax=float(self.qmax_x),
	2369	enable_smearer=enable_smearer,
	2370	uid=self.uid)
[682c432]	2371	return msg
	2372
	2373	def update_pinhole_smear(self):
	2374	"""
	2375	called by kill_focus on pinhole TextCntrl
	2376	to update the changes
	2377
	2378	:return: False when wrong value was entered
	2379
	2380	"""
	2381	# msg default
	2382	msg = None
	2383	# check if any value is changed
	2384	if self._is_changed_pinhole():
	2385	msg = self._set_pinhole_smear()
	2386	wx.CallAfter(self.save_current_state)
	2387
[c8e1996]	2388	if msg is not None:
[682c432]	2389	return False
	2390	else:
	2391	return True
	2392
	2393	def onSlitSmear(self, event):
	2394	"""
	2395	Create a custom slit smear object that will change the way residuals
	2396	are compute when fitting
	2397	"""
	2398	# Need update param values
	2399	self._update_paramv_on_fit()
	2400
	2401	# msg default
	2402	msg = None
	2403	# for event given
[c8e1996]	2404	if event is not None:
[682c432]	2405	tcrtl = event.GetEventObject()
	2406	# event case of radio button
	2407	if tcrtl.GetValue():
	2408	self.dxl = 0.0
	2409	self.dxw = 0.0
	2410	is_new_slit = True
	2411	else:
	2412	is_new_slit = self._is_changed_slit()
	2413	else:
	2414	is_new_slit = True
	2415
	2416	# if any value is changed
	2417	if is_new_slit:
	2418	msg = self._set_slit_smear()
	2419
	2420	# hide all silt sizer
	2421	self._hide_all_smear_info()
	2422	# show relevant slit sizers
	2423	self._show_smear_sizer()
	2424	self.sizer_set_smearer.Layout()
[c8e1996]	2425	# we need FitInside here not just self.Layout to ensure all the sizers
	2426	# end up with the necessasary space to in the scroll panel. In
	2427	# particular the compute and fit buttons end up on top of each other
	2428	# PDB Nov 28 2015.
[1c2bf90]	2429	self.FitInside()
[682c432]	2430
[c8e1996]	2431	if event is not None:
[682c432]	2432	event.Skip()
	2433	self.save_current_state()
	2434	event = PageInfoEvent(page=self)
	2435	wx.PostEvent(self.parent, event)
[c8e1996]	2436	if msg is not None:
[682c432]	2437	wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
	2438
	2439	def _is_changed_slit(self):
	2440	"""
	2441	check if any of slit lengths is changed
	2442
	2443	:return: True or False
	2444
	2445	"""
	2446	# get the values
	2447	width = self.smear_slit_width.GetValue()
	2448	height = self.smear_slit_height.GetValue()
	2449
	2450	# check and change the box bg color if it was pink
	2451	# but it should be white now
	2452	# because this is the case that _set_slit_smear() will not handle
	2453	if height.lstrip().rstrip() == "":
	2454	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
	2455	if width.lstrip().rstrip() == "":
	2456	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
	2457
	2458	# Check changes in slit width
	2459	if width == "":
	2460	dxw = 0.0
	2461	else:
	2462	try:
	2463	dxw = float(width)
	2464	except:
	2465	return True
	2466	if self.dxw != dxw:
	2467	return True
	2468
	2469	# Check changes in slit heigth
	2470	if height == "":
	2471	dxl = 0.0
	2472	else:
	2473	try:
	2474	dxl = float(height)
	2475	except:
	2476	return True
	2477	if self.dxl != dxl:
	2478	return True
	2479
	2480	return False
	2481
	2482	def _set_slit_smear(self):
	2483	"""
	2484	Set custom slit smear
	2485
	2486	:return: message to inform the user about the validity
	2487	of the values entered for slit smear
	2488	"""
[373d4ee]	2489	if self.data.__class__.__name__ == "Data2D" or self.enable2D:
[682c432]	2490	return
	2491	# make sure once more if it is smearer
	2492	data = copy.deepcopy(self.data)
	2493	data_len = len(data.x)
	2494	data.dx = None
	2495	data.dxl = None
	2496	data.dxw = None
	2497	msg = None
	2498
	2499	try:
	2500	self.dxl = float(self.smear_slit_height.GetValue())
	2501	data.dxl = self.dxl * numpy.ones(data_len)
	2502	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
	2503	except:
	2504	self.dxl = None
	2505	data.dxl = numpy.zeros(data_len)
	2506	if self.smear_slit_height.GetValue().lstrip().rstrip() != "":
	2507	self.smear_slit_height.SetBackgroundColour("pink")
	2508	msg = "Wrong value entered... "
	2509	else:
	2510	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
	2511	try:
	2512	self.dxw = float(self.smear_slit_width.GetValue())
	2513	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
	2514	data.dxw = self.dxw * numpy.ones(data_len)
	2515	except:
	2516	self.dxw = None
	2517	data.dxw = numpy.zeros(data_len)
	2518	if self.smear_slit_width.GetValue().lstrip().rstrip() != "":
	2519	self.smear_slit_width.SetBackgroundColour("pink")
	2520	msg = "Wrong Fit value entered... "
	2521	else:
	2522	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
	2523
	2524	self.current_smearer = smear_selection(data, self.model)
[c8e1996]	2525	# set smearing value whether or not the data contain the smearing info
[373d4ee]	2526	enable_smearer = not self.disable_smearer.GetValue()
[682c432]	2527	self._manager.set_smearer(smearer=self.current_smearer,
[373d4ee]	2528	fid=self.data.id,
	2529	qmin=float(self.qmin_x),
	2530	qmax=float(self.qmax_x),
	2531	enable_smearer=enable_smearer,
	2532	uid=self.uid)
[682c432]	2533	return msg
	2534
	2535	def update_slit_smear(self):
	2536	"""
	2537	called by kill_focus on pinhole TextCntrl
	2538	to update the changes
	2539
	2540	:return: False when wrong value was entered
	2541
	2542	"""
	2543	# msg default
	2544	msg = None
	2545	# check if any value is changed
	2546	if self._is_changed_slit():
	2547	msg = self._set_slit_smear()
[c8e1996]	2548	# self._undo.Enable(True)
[682c432]	2549	self.save_current_state()
	2550
[c8e1996]	2551	if msg is not None:
[682c432]	2552	return False
	2553	else:
	2554	return True
	2555
	2556	def onSmear(self, event):
	2557	"""
	2558	Create a smear object that will change the way residuals
[1c2bf90]	2559	are computed when fitting
[682c432]	2560	"""
[c8e1996]	2561	if event is not None:
[682c432]	2562	event.Skip()
	2563	if self.data is None:
	2564	return
	2565
	2566	# Need update param values
	2567	self._update_paramv_on_fit()
[373d4ee]	2568	if self.model is not None:
[682c432]	2569	if self.data.is_data:
	2570	self._manager.page_finder[self.uid].add_data(data=self.data)
	2571	temp_smearer = self.on_smear_helper()
	2572
	2573	self.sizer_set_smearer.Layout()
[c8e1996]	2574	# we need FitInside here not just self.Layout to ensure all the sizers
	2575	# end up with the necessasary space to in the scroll panel. In
	2576	# particular the compute and fit buttons end up on top of each other
	2577	# PDB Nov 28 2015.
[1c2bf90]	2578	self.FitInside()
[682c432]	2579	self._set_weight()
	2580
[c8e1996]	2581	# set smearing value whether or not the data contain the smearing info
[373d4ee]	2582	enable_smearer = not self.disable_smearer.GetValue()
[682c432]	2583	wx.CallAfter(self._manager.set_smearer, uid=self.uid,
	2584	smearer=temp_smearer,
	2585	fid=self.data.id,
	2586	qmin=float(self.qmin_x),
	2587	qmax=float(self.qmax_x),
[934ce649]	2588	enable_smearer=enable_smearer)
[682c432]	2589
	2590	self.state.enable_smearer = self.enable_smearer.GetValue()
	2591	self.state.disable_smearer = self.disable_smearer.GetValue()
	2592	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
	2593	self.state.slit_smearer = self.slit_smearer.GetValue()
	2594
	2595	def on_smear_helper(self, update=False):
	2596	"""
	2597	Help for onSmear
	2598
	2599	:param update: force or not to update
	2600	"""
	2601	self._get_smear_info()
[c8e1996]	2602	# renew smear sizer
[373d4ee]	2603	if self.smear_type is not None:
[682c432]	2604	self.smear_description_smear_type.SetValue(str(self.smear_type))
	2605	self.smear_data_left.SetValue(str(self.dq_l))
	2606	self.smear_data_right.SetValue(str(self.dq_r))
	2607
	2608	self._hide_all_smear_info()
	2609	data = copy.deepcopy(self.data)
	2610
	2611	# make sure once more if it is smearer
	2612	temp_smearer = smear_selection(data, self.model)
	2613	if self.current_smearer != temp_smearer or update:
	2614	self.current_smearer = temp_smearer
	2615	if self.enable_smearer.GetValue():
[373d4ee]	2616	if self.current_smearer is None:
[682c432]	2617	wx.PostEvent(self._manager.parent,
	2618	StatusEvent(status="Data contains no smearing information"))
	2619	else:
	2620	wx.PostEvent(self._manager.parent,
	2621	StatusEvent(status="Data contains smearing information"))
	2622
	2623	self.smear_data_left.Show(True)
	2624	self.smear_data_right.Show(True)
	2625	temp_smearer = self.current_smearer
	2626	elif self.disable_smearer.GetValue():
	2627	self.smear_description_none.Show(True)
	2628	elif self.pinhole_smearer.GetValue():
	2629	self.onPinholeSmear(None)
	2630	elif self.slit_smearer.GetValue():
	2631	self.onSlitSmear(None)
	2632	self._show_smear_sizer()
	2633
	2634	return temp_smearer
	2635
	2636	def on_complete_chisqr(self, event):
	2637	"""
	2638	Display result chisqr on the panel
	2639	:event: activated by fitting/ complete after draw
	2640	"""
	2641	try:
[c8e1996]	2642	if event is None:
[682c432]	2643	output = "-"
	2644	elif not numpy.isfinite(event.output):
	2645	output = "-"
	2646	else:
	2647	output = event.output
	2648	self.tcChi.SetValue(str(format_number(output, True)))
	2649	self.state.tcChi = self.tcChi.GetValue()
	2650	except:
	2651	pass
	2652
	2653	def get_all_checked_params(self):
	2654	"""
	2655	Found all parameters current check and add them to list of parameters
	2656	to fit
	2657	"""
	2658	self.param_toFit = []
	2659	for item in self.parameters:
	2660	if item[0].GetValue() and item not in self.param_toFit:
	2661	if item[0].IsShown():
	2662	self.param_toFit.append(item)
	2663	for item in self.fittable_param:
	2664	if item[0].GetValue() and item not in self.param_toFit:
	2665	if item[0].IsShown():
	2666	self.param_toFit.append(item)
	2667	self.save_current_state_fit()
	2668
	2669	event = PageInfoEvent(page=self)
	2670	wx.PostEvent(self.parent, event)
	2671	param2fit = []
	2672	for item in self.param_toFit:
	2673	if item[0] and item[0].IsShown():
	2674	param2fit.append(item[1])
	2675	self._manager.set_param2fit(self.uid, param2fit)
	2676
[c8e1996]	2677	def select_param(self, event=None):
[682c432]	2678	"""
	2679	Select TextCtrl checked for fitting purpose and stores them
	2680	in self.param_toFit=[] list
	2681	"""
	2682	self.param_toFit = []
	2683	for item in self.parameters:
[c8e1996]	2684	# Skip t ifhe angle parameters if 1D data
[682c432]	2685	if self.data.__class__.__name__ != "Data2D" and\
	2686	not self.enable2D:
	2687	if item in self.orientation_params:
	2688	continue
[c8e1996]	2689	# Select parameters to fit for list of primary parameters
[682c432]	2690	if item[0].GetValue() and item[0].IsShown():
	2691	if not (item in self.param_toFit):
	2692	self.param_toFit.append(item)
	2693	else:
	2694	#remove parameters from the fitting list
	2695	if item in self.param_toFit:
	2696	self.param_toFit.remove(item)
	2697
[c8e1996]	2698	# Select parameters to fit for list of fittable parameters
[682c432]	2699	# with dispersion
	2700	for item in self.fittable_param:
[c8e1996]	2701	# Skip t ifhe angle parameters if 1D data
[682c432]	2702	if self.data.__class__.__name__ != "Data2D" and\
	2703	not self.enable2D:
	2704	if item in self.orientation_params:
	2705	continue
	2706	if item[0].GetValue() and item[0].IsShown():
	2707	if not (item in self.param_toFit):
	2708	self.param_toFit.append(item)
	2709	else:
[c8e1996]	2710	# remove parameters from the fitting list
[682c432]	2711	if item in self.param_toFit:
	2712	self.param_toFit.remove(item)
	2713
[c8e1996]	2714	# Calculate num. of angle parameters
[682c432]	2715	if self.data.__class__.__name__ == "Data2D" or \
	2716	self.enable2D:
	2717	len_orient_para = 0
	2718	else:
	2719	len_orient_para = len(self.orientation_params) # assume even len
[c8e1996]	2720	# Total num. of angle parameters
[682c432]	2721	if len(self.fittable_param) > 0:
	2722	len_orient_para *= 2
	2723
	2724	self.save_current_state_fit()
[c8e1996]	2725	if event is not None:
	2726	# post state to fit panel
[682c432]	2727	event = PageInfoEvent(page=self)
	2728	wx.PostEvent(self.parent, event)
	2729
	2730	param2fit = []
	2731	for item in self.param_toFit:
	2732	if item[0] and item[0].IsShown():
	2733	param2fit.append(item[1])
	2734	self._manager.set_param2fit(self.uid, param2fit)
	2735
	2736	def set_model_param_sizer(self, model):
	2737	"""
	2738	Build the panel from the model content
	2739
	2740	:param model: the model selected in combo box for fitting purpose
	2741
	2742	"""
	2743	self.sizer3.Clear(True)
	2744	self.parameters = []
	2745	self.str_parameters = []
	2746	self.param_toFit = []
	2747	self.fittable_param = []
	2748	self.fixed_param = []
	2749	self.orientation_params = []
	2750	self.orientation_params_disp = []
	2751
[c8e1996]	2752	if model is None:
[682c432]	2753	self.sizer3.Layout()
	2754	self.SetupScrolling()
	2755	return
	2756
[6f16e25]	2757	box_description = wx.StaticBox(self, wx.ID_ANY, str("Model Parameters"))
[682c432]	2758	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
	2759	sizer = wx.GridBagSizer(5, 5)
[c8e1996]	2760	# save the current model
[682c432]	2761	self.model = model
	2762
	2763	keys = self.model.getParamList()
	2764
[c8e1996]	2765	# list of dispersion parameters
[682c432]	2766	self.disp_list = self.model.getDispParamList()
	2767
	2768	def custom_compare(a, b):
	2769	"""
	2770	Custom compare to order, first by alphabets then second by number.
	2771	"""
	2772	# number at the last digit
	2773	a_last = a[len(a) - 1]
	2774	b_last = b[len(b) - 1]
	2775	# default
	2776	num_a = None
	2777	num_b = None
	2778	# split the names
	2779	a2 = a.lower().split('_')
	2780	b2 = b.lower().split('_')
	2781	# check length of a2, b2
	2782	len_a2 = len(a2)
	2783	len_b2 = len(b2)
	2784	# check if it contains a int number(<10)
	2785	try:
	2786	num_a = int(a_last)
	2787	except:
	2788	pass
	2789	try:
	2790	num_b = int(b_last)
	2791	except:
	2792	pass
	2793	# Put 'scale' near the top; happens
	2794	# when numbered param name exists
	2795	if a == 'scale':
	2796	return -1
	2797	# both have a number
[c8e1996]	2798	if num_a is not None and num_b is not None:
[682c432]	2799	if num_a > num_b:
	2800	return -1
	2801	# same number
	2802	elif num_a == num_b:
	2803	# different last names
	2804	if a2[len_a2 - 1] != b2[len_b2 - 1] and num_a != 0:
	2805	return -cmp(a2[len_a2 - 1], b2[len_b2 - 1])
	2806	else:
	2807	return cmp(a, b)
	2808	else:
	2809	return 1
	2810	# one of them has a number
[c8e1996]	2811	elif num_a is not None:
[682c432]	2812	return 1
[c8e1996]	2813	elif num_b is not None:
[682c432]	2814	return -1
	2815	# no numbers
	2816	else:
	2817	return cmp(a.lower(), b.lower())
[7d265a8]	2818
[c8e1996]	2819	# keys obtained now from ordered dict, so commenting alphabetical
	2820	# ordering keys.sort(custom_compare)
[682c432]	2821
	2822	iy = 0
	2823	ix = 0
[4c3be25]	2824	sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Parameter'),
	2825	(iy, ix), (1, 1), wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
[682c432]	2826	ix += 1
[6f16e25]	2827	self.text2_2 = wx.StaticText(self, wx.ID_ANY, 'Value')
[c8e1996]	2828	sizer.Add(self.text2_2, (iy, ix), (1, 1),
[682c432]	2829	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2830	ix += 2
[6f16e25]	2831	self.text2_3 = wx.StaticText(self, wx.ID_ANY, 'Error')
[c8e1996]	2832	sizer.Add(self.text2_3, (iy, ix), (1, 1),
	2833	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
[682c432]	2834	if not self.is_mac:
	2835	self.text2_3.Hide()
	2836	ix += 1
[6f16e25]	2837	self.text2_min = wx.StaticText(self, wx.ID_ANY, 'Min')
[c8e1996]	2838	sizer.Add(self.text2_min, (iy, ix), (1, 1),
	2839	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2840	# self.text2_min.Hide()
[682c432]	2841	ix += 1
[6f16e25]	2842	self.text2_max = wx.StaticText(self, wx.ID_ANY, 'Max')
[c8e1996]	2843	sizer.Add(self.text2_max, (iy, ix), (1, 1),
	2844	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2845	# self.text2_max.Hide()
[682c432]	2846	ix += 1
[6f16e25]	2847	self.text2_4 = wx.StaticText(self, wx.ID_ANY, '[Units]')
[c8e1996]	2848	sizer.Add(self.text2_4, (iy, ix), (1, 1),
	2849	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
[682c432]	2850	self.text2_4.Hide()
	2851
[4c3be25]	2852	CHECK_STATE = False
[682c432]	2853	for item in keys:
	2854
[c8e1996]	2855	if item not in self.disp_list and not item in \
[682c432]	2856	self.model.orientation_params:
	2857
[c8e1996]	2858	# prepare a spot to store errors
	2859	if item not in self.model.details:
[682c432]	2860	self.model.details[item] = ["", None, None]
	2861
	2862	iy += 1
	2863	ix = 0
[c8e1996]	2864	if (self.model.__class__ in
	2865	self.model_list_box["Multi-Functions"] or
[682c432]	2866	self.temp_multi_functional)\
	2867	and (item in self.model.non_fittable):
[6f16e25]	2868	non_fittable_name = wx.StaticText(self, wx.ID_ANY, item)
[c8e1996]	2869	sizer.Add(non_fittable_name, (iy, ix), (1, 1),
[682c432]	2870	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 21)
[c8e1996]	2871	# add parameter value
[682c432]	2872	ix += 1
	2873	value = self.model.getParam(item)
	2874	if len(self.model.fun_list) > 0:
[c8e1996]	2875	# num = item.split('_')[1][5:7]
[6f16e25]	2876	fun_box = wx.ComboBox(self, wx.ID_ANY, size=(100, -1),
[682c432]	2877	style=wx.CB_READONLY, name='%s' % item)
	2878	self._set_fun_box_list(fun_box)
	2879	fun_box.SetSelection(0)
[c8e1996]	2880	# self.fun_box.SetToolTipString("A function
[682c432]	2881	# describing the interface")
[6f16e25]	2882	wx.EVT_COMBOBOX(fun_box, wx.ID_ANY, self._on_fun_box)
[682c432]	2883	else:
[6f16e25]	2884	fun_box = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	2885	size=(_BOX_WIDTH, 20),
[682c432]	2886	style=wx.TE_PROCESS_ENTER, name='%s' % item)
[c8e1996]	2887	fun_box.SetToolTipString(
[682c432]	2888	"Hit 'Enter' after typing to update the plot.")
	2889	fun_box.SetValue(format_number(value, True))
	2890	sizer.Add(fun_box, (iy, ix), (1, 1), wx.EXPAND)
	2891	self.str_parameters.append([None, item, fun_box,
	2892	None, None, None,
	2893	None, None])
	2894	else:
[c8e1996]	2895	# add parameters name with checkbox for selecting to fit
[6f16e25]	2896	cb = wx.CheckBox(self, wx.ID_ANY, item)
[682c432]	2897	cb.SetValue(CHECK_STATE)
	2898	cb.SetToolTipString(" Check mark to fit.")
[c8e1996]	2899	# cb.SetValue(True)
[682c432]	2900	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
	2901
	2902	sizer.Add(cb, (iy, ix), (1, 1),
	2903	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
	2904
[c8e1996]	2905	# add parameter value
[682c432]	2906	ix += 1
	2907	value = self.model.getParam(item)
[6f16e25]	2908	ctl1 = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
[373d4ee]	2909	style=wx.TE_PROCESS_ENTER)
[c8e1996]	2910	ctl1.SetToolTipString(
[682c432]	2911	"Hit 'Enter' after typing to update the plot.")
	2912	ctl1.SetValue(format_number(value, True))
	2913	sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
[c8e1996]	2914	# text to show error sign
[682c432]	2915	ix += 1
[6f16e25]	2916	text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
[c8e1996]	2917	sizer.Add(text2, (iy, ix), (1, 1),
[682c432]	2918	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2919	if not self.is_mac:
	2920	text2.Hide()
	2921	ix += 1
[6f16e25]	2922	ctl2 = wx.TextCtrl(self, wx.ID_ANY,
[682c432]	2923	size=(_BOX_WIDTH / 1.2, 20), style=0)
	2924	sizer.Add(ctl2, (iy, ix), (1, 1),
	2925	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2926	if not self.is_mac:
	2927	ctl2.Hide()
	2928
	2929	ix += 1
[6f16e25]	2930	ctl3 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	2931	size=(_BOX_WIDTH / 1.9, 20),
	2932	style=wx.TE_PROCESS_ENTER,
[682c432]	2933	text_enter_callback=self._onparamRangeEnter)
	2934	min_bound = self.model.details[item][1]
	2935	if min_bound is not None:
	2936	ctl3.SetValue(format_number(min_bound, True))
	2937
	2938	sizer.Add(ctl3, (iy, ix), (1, 1),
	2939	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2940
	2941	ix += 1
[6f16e25]	2942	ctl4 = ModelTextCtrl(self, wx.ID_ANY,
[373d4ee]	2943	size=(_BOX_WIDTH / 1.9, 20),
	2944	style=wx.TE_PROCESS_ENTER,
[682c432]	2945	text_enter_callback=self._onparamRangeEnter)
	2946	max_bound = self.model.details[item][2]
	2947	if max_bound is not None:
	2948	ctl4.SetValue(format_number(max_bound, True))
	2949	sizer.Add(ctl4, (iy, ix), (1, 1),
	2950	wx.EXPAND \| wx.FIXED_MINSIZE, 0)
	2951
	2952	ix += 1
	2953	# Units
	2954	if item in self.model.details:
[6f16e25]	2955	units = wx.StaticText(self, wx.ID_ANY,
[682c432]	2956	self.model.details[item][0], style=wx.ALIGN_LEFT)
	2957	else:
[6f16e25]	2958	units = wx.StaticText(self, wx.ID_ANY, "",
[682c432]	2959	style=wx.ALIGN_LEFT)
	2960	sizer.Add(units, (iy, ix), (1, 1),
	2961	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	2962
	2963	self.parameters.append([cb, item, ctl1,
	2964	text2, ctl2, ctl3, ctl4, units])
	2965
	2966	iy += 1
	2967	sizer.Add((10, 10), (iy, ix), (1, 1),
	2968	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	2969
	2970	# type can be either Guassian or Array
	2971	if len(self.model.dispersion.values()) > 0:
	2972	type = self.model.dispersion.values()[0]["type"]
	2973	else:
	2974	type = "Gaussian"
	2975
	2976	iy += 1
	2977	ix = 0
[c8e1996]	2978	# Add tile for orientational angle
[682c432]	2979	for item in keys:
	2980	if item in self.model.orientation_params:
[6f16e25]	2981	orient_angle = wx.StaticText(self, wx.ID_ANY, '[For 2D only]:')
	2982	mag_on_button = wx.Button(self, wx.ID_ANY, "Magnetic ON")
[7116dffd]	2983	mag_on_button.SetToolTipString("Turn Pol Beam/Mag scatt on/off")
[682c432]	2984	mag_on_button.Bind(wx.EVT_BUTTON, self._on_mag_on)
[c8e1996]	2985	mag_angle_help_button = wx.Button(self, wx.ID_ANY,
	2986	"Magnetic angles?")
[7116dffd]	2987	mag_angle_help_button.SetToolTipString("see angle definitions")
[6f16e25]	2988	mag_help_button = wx.Button(self, wx.ID_ANY, "Mag HELP")
[7116dffd]	2989	mag_help_button.SetToolTipString("Help on pol beam/mag fitting")
[682c432]	2990	mag_help_button.Bind(wx.EVT_BUTTON, self._on_mag_help)
[c8e1996]	2991	mag_angle_help_button.Bind(wx.EVT_BUTTON,
[7116dffd]	2992	self._on_mag_angle_help)
[682c432]	2993	sizer.Add(orient_angle, (iy, ix), (1, 1),
	2994	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	2995	iy += 1
	2996	sizer.Add(mag_on_button, (iy, ix), (1, 1),
	2997	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
[7116dffd]	2998	ix += 1
	2999	sizer.Add(mag_angle_help_button, (iy, ix), (1, 1),
	3000	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
[682c432]	3001	sizer.Add(mag_help_button, (iy, ix + 1), (1, 1),
	3002	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
	3003
[c8e1996]	3004	# handle the magnetic buttons
	3005	# clean this up so that assume mag is off then turn
	3006	# all buttons on IF mag has mag and has 2D
[682c432]	3007	if not self._has_magnetic:
	3008	mag_on_button.Show(False)
	3009	elif not self.data.__class__.__name__ == "Data2D":
	3010	mag_on_button.Show(False)
	3011	else:
	3012	mag_on_button.Show(True)
	3013	mag_help_button.Show(False)
[2b58fa5]	3014	mag_angle_help_button.Show(False)
[682c432]	3015	if mag_on_button.IsShown():
	3016	if self.magnetic_on:
	3017	mag_on_button.SetLabel("Magnetic OFF")
	3018	mag_help_button.Show(True)
[7116dffd]	3019	mag_angle_help_button.Show(True)
[682c432]	3020	else:
	3021	mag_on_button.SetLabel("Magnetic ON")
	3022	mag_help_button.Show(False)
[7116dffd]	3023	mag_angle_help_button.Show(False)
[682c432]	3024
	3025	if not self.data.__class__.__name__ == "Data2D" and \
	3026	not self.enable2D:
	3027	orient_angle.Hide()
	3028	else:
	3029	orient_angle.Show(True)
	3030	break
	3031
[c8e1996]	3032	# For Gaussian only
[682c432]	3033	if type.lower() != "array":
	3034	for item in self.model.orientation_params:
	3035	if not self.magnetic_on:
	3036	if item in self.model.magnetic_params:
	3037	continue
[c8e1996]	3038	if item not in self.disp_list:
	3039	# prepare a spot to store min max
	3040	if item not in self.model.details:
[682c432]	3041	self.model.details[item] = ["", None, None]
	3042
	3043	iy += 1
	3044	ix = 0
[c8e1996]	3045	# add parameters name with checkbox for selecting to fit
[6f16e25]	3046	cb = wx.CheckBox(self, wx.ID_ANY, item)
[682c432]	3047	cb.SetValue(CHECK_STATE)
	3048	cb.SetToolTipString("Check mark to fit")
	3049	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
	3050	if self.data.__class__.__name__ == "Data2D" or \
	3051	self.enable2D:
	3052	cb.Show(True)
	3053	else:
	3054	cb.Hide()
	3055	sizer.Add(cb, (iy, ix), (1, 1),
	3056	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 5)
	3057
[c8e1996]	3058	# add parameter value
[682c432]	3059	ix += 1
	3060	value = self.model.getParam(item)
[373d4ee]	3061	ctl1 = ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
	3062	style=wx.TE_PROCESS_ENTER)
[c8e1996]	3063	ctl1.SetToolTipString(
[682c432]	3064	"Hit 'Enter' after typing to update the plot.")
	3065	ctl1.SetValue(format_number(value, True))
	3066	if self.data.__class__.__name__ == "Data2D" or \
	3067	self.enable2D:
	3068	ctl1.Show(True)
	3069	else:
	3070	ctl1.Hide()
	3071	sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
[c8e1996]	3072	# text to show error sign
[682c432]	3073	ix += 1
	3074	text2 = wx.StaticText(self, -1, '+/-')
[c8e1996]	3075	sizer.Add(text2, (iy, ix), (1, 1),
[682c432]	3076	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	3077
	3078	text2.Hide()
	3079	ix += 1
	3080	ctl2 = wx.TextCtrl(self, -1,
	3081	size=(_BOX_WIDTH / 1.2, 20), style=0)
	3082	sizer.Add(ctl2, (iy, ix), (1, 1),
	3083	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	3084
	3085	ctl2.Hide()
	3086
	3087	ix += 1
[373d4ee]	3088	ctl3 = ModelTextCtrl(self, -1,
	3089	size=(_BOX_WIDTH / 1.8, 20),
	3090	style=wx.TE_PROCESS_ENTER,
[682c432]	3091	text_enter_callback=self._onparamRangeEnter)
	3092
	3093	sizer.Add(ctl3, (iy, ix), (1, 1),
	3094	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	3095	ctl3.Hide()
	3096
	3097	ix += 1
[373d4ee]	3098	ctl4 = ModelTextCtrl(self, -1,
	3099	size=(_BOX_WIDTH / 1.8, 20),
	3100	style=wx.TE_PROCESS_ENTER,
[682c432]	3101	text_enter_callback=self._onparamRangeEnter)
	3102	sizer.Add(ctl4, (iy, ix), (1, 1),
	3103	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	3104
	3105	ctl4.Hide()
	3106
	3107	if self.data.__class__.__name__ == "Data2D" or \
	3108	self.enable2D:
	3109	if self.is_mac:
	3110	text2.Show(True)
	3111	ctl2.Show(True)
	3112	ctl3.Show(True)
	3113	ctl4.Show(True)
	3114
	3115	ix += 1
	3116	# Units
	3117	if item in self.model.details:
	3118	units = wx.StaticText(self, -1,
	3119	self.model.details[item][0],
	3120	style=wx.ALIGN_LEFT)
	3121	else:
	3122	units = wx.StaticText(self, -1, "",
	3123	style=wx.ALIGN_LEFT)
	3124	if self.data.__class__.__name__ == "Data2D" or \
	3125	self.enable2D:
	3126	units.Show(True)
	3127	else:
	3128	units.Hide()
	3129
	3130	sizer.Add(units, (iy, ix), (1, 1),
	3131	wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
	3132
	3133	self.parameters.append([cb, item, ctl1,
	3134	text2, ctl2, ctl3, ctl4, units])
	3135	self.orientation_params.append([cb, item, ctl1,
	3136	text2, ctl2, ctl3, ctl4, units])
	3137
	3138	iy += 1
	3139	box_description.SetForegroundColour(wx.BLUE)
[c8e1996]	3140	# Display units text on panel
[682c432]	3141	for item in keys:
	3142	if item in self.model.details:
	3143	self.text2_4.Show()
[c8e1996]	3144	# Fill the list of fittable parameters
[682c432]	3145	self.get_all_checked_params()
	3146	self.save_current_state_fit()
	3147	boxsizer1.Add(sizer)
	3148	self.sizer3.Add(boxsizer1, 0, wx.EXPAND \| wx.ALL, 10)
	3149	self.sizer3.Layout()
	3150	self.Layout()
	3151
	3152	def on_right_down(self, event):
	3153	"""
	3154	Get key stroke event
	3155	"""
[c8e1996]	3156	if self.data is None:
[682c432]	3157	return
	3158	# Figuring out key combo: Cmd for copy, Alt for paste
	3159	if event.AltDown() and event.ShiftDown():
	3160	flag = True
	3161	elif event.AltDown() or event.ShiftDown():
	3162	flag = False
	3163	else:
	3164	return
	3165	# make event free
	3166	event.Skip()
	3167	# messages depending on the flag
	3168	if not flag:
	3169	infor = 'warning'
	3170	# inform msg to wx
	3171	wx.PostEvent(self._manager.parent,
	3172	StatusEvent(status=msg, info=infor))
	3173
	3174	def _onModel2D(self, event):
	3175	"""
	3176	toggle view of model from 1D to 2D or 2D from 1D
	3177	"""
	3178	if self.model_view.GetLabelText() == "Show 2D":
	3179	self.model_view.SetLabel("Show 1D")
	3180	self.enable2D = True
	3181
	3182	else:
	3183	self.model_view.SetLabel("Show 2D")
	3184	self.enable2D = False
	3185	self.Show(False)
	3186	self.create_default_data()
	3187	self._manager.store_data(self.uid, data_list=[self.data])
	3188
	3189	self.set_model_param_sizer(self.model)
	3190	self._set_sizer_dispersion()
	3191	self._set_weight(is_2D=self.enable2D)
	3192	self._set_smear_buttons()
	3193	self.Show(True)
	3194	self.SetupScrolling()
	3195	self._draw_model()
	3196
	3197	self.state.enable2D = copy.deepcopy(self.enable2D)
	3198
	3199	def _set_smear_buttons(self):
	3200	"""
	3201	Set semarer radio buttons
	3202	"""
	3203	# more disables for 2D
	3204	if self.data.__class__.__name__ == "Data2D" or \
	3205	self.enable2D:
	3206	self.slit_smearer.Disable()
	3207	self.pinhole_smearer.Enable(True)
	3208	self.default_mask = copy.deepcopy(self.data.mask)
	3209	else:
	3210	self.slit_smearer.Enable(True)
	3211	self.pinhole_smearer.Enable(True)
	3212
	3213
	3214	class BGTextCtrl(wx.TextCtrl):
	3215	"""
	3216	Text control used to display outputs.
	3217	No editing allowed. The background is
	3218	grayed out. User can't select text.
	3219	"""
	3220	def __init__(self, args, *kwds):
	3221	wx.TextCtrl.__init__(self, args, *kwds)
	3222	self.SetEditable(False)
	3223	self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
	3224
	3225	# Bind to mouse event to avoid text highlighting
	3226	# The event will be skipped once the call-back
	3227	# is called.
	3228	self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
	3229
	3230	def _click(self, event):
	3231	"""
	3232	Prevent further handling of the mouse event
	3233	by not calling Skip().
	3234	"""
	3235	pass

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/fitpage.py @ 1a8e13f0

Download in other formats: