fitpage.py @ 42585bf

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

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/fitpage.py @ 42585bf

Download in other formats: