fitpage.py @ e4fe091

Last change on this file since e4fe091 was bf44249e, checked in by wojciech, 8 years ago
Fixed a few pylint issues
Property mode set to `100644`
File size: 128.2 KB

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

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

SasView

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

Download in other formats: