fitpage.py @ 9cc1f49

ticket-1094-headless

Last change on this file since 9cc1f49 was cb44d66, checked in by Paul Kienzle <pkienzle@…>, 6 years ago
Merge branch 'master' into ticket-1094-headless
Property mode set to `100644`
File size: 129.5 KB

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

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

SasView

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

Download in other formats: