fitpage.py @ 0ea31ca

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

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

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

SasView

source: sasview/src/sas/perspectives/fitting/fitpage.py @ 0ea31ca

Download in other formats: