Context Navigation

source: trunk/GSASIIpwdGUI.py @ 2572

Last change on this file since 2572 was 2572, checked in by vondreele, 8 years ago
TextCtrl? -- ValidatedTextCtrl?
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 240.0 KB

Rev	Line
[904]	1	# -- coding: utf-8 --
[923]	2	#GSASIIpwdGUI - powder data display routines
[904]	3	########### SVN repository information ###################
	4	# $Date: 2016-12-12 15:41:08 +0000 (Mon, 12 Dec 2016) $
	5	# $Author: vondreele $
	6	# $Revision: 2572 $
	7	# $URL: trunk/GSASIIpwdGUI.py $
	8	# $Id: GSASIIpwdGUI.py 2572 2016-12-12 15:41:08Z vondreele $
	9	########### SVN repository information ###################
[923]	10	'''
	11	GSASIIpwdGUI: Powder Pattern GUI routines
	12	-------------------------------------------
	13
	14	Used to define GUI controls for the routines that interact
	15	with the powder histogram (PWDR) data tree items.
	16
	17	'''
[904]	18	import sys
	19	import os.path
	20	import wx
	21	import wx.grid as wg
[1208]	22	import wx.lib.scrolledpanel as wxscroll
[904]	23	import numpy as np
	24	import numpy.ma as ma
	25	import math
	26	import copy
	27	import random as ran
	28	import cPickle
[1893]	29	import scipy.interpolate as si
[904]	30	import GSASIIpath
	31	GSASIIpath.SetVersionNumber("$Revision: 2572 $")
	32	import GSASIImath as G2mth
	33	import GSASIIpwd as G2pwd
	34	import GSASIIIO as G2IO
	35	import GSASIIlattice as G2lat
	36	import GSASIIspc as G2spc
	37	import GSASIIindex as G2indx
	38	import GSASIIplot as G2plt
	39	import GSASIIgrid as G2gd
[1619]	40	import GSASIIctrls as G2G
[904]	41	import GSASIIElemGUI as G2elemGUI
	42	import GSASIIElem as G2elem
[1233]	43	import GSASIIsasd as G2sasd
[904]	44	VERY_LIGHT_GREY = wx.Colour(235,235,235)
[1233]	45	WACV = wx.ALIGN_CENTER_VERTICAL
[1263]	46	Pwr10 = unichr(0x0b9)+unichr(0x0b0)
	47	Pwr20 = unichr(0x0b2)+unichr(0x0b0)
	48	Pwrm1 = unichr(0x207b)+unichr(0x0b9)
	49	Pwrm2 = unichr(0x207b)+unichr(0x0b2)
	50	Pwrm4 = unichr(0x207b)+unichr(0x2074) #really -d but looks like -4 as a superscript
[904]	51	# trig functions in degrees
	52	sind = lambda x: math.sin(x*math.pi/180.)
	53	tand = lambda x: math.tan(x*math.pi/180.)
	54	cosd = lambda x: math.cos(x*math.pi/180.)
	55	asind = lambda x: 180.*math.asin(x)/math.pi
	56
[2355]	57	################################################################################
	58	###### class definitions
	59	################################################################################
	60
	61	class RDFDialog(wx.Dialog):
	62	def __init__(self,parent):
	63	wx.Dialog.__init__(self,parent,-1,'Background radial distribution function',
	64	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
	65	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
[2356]	66	self.result = {'UseObsCalc':True,'maxR':20.0,'Smooth':'linear'}
[2355]	67
	68	self.Draw()
	69
	70	def Draw(self):
	71
	72	def OnUseOC(event):
	73	self.result['UseObsCalc'] = not self.result['UseObsCalc']
	74
	75	def OnSmCombo(event):
	76	self.result['Smooth'] = smCombo.GetValue()
[2567]	77
[2355]	78	self.panel.Destroy()
	79	self.panel = wx.Panel(self)
	80	mainSizer = wx.BoxSizer(wx.VERTICAL)
	81	mainSizer.Add(wx.StaticText(self.panel,label='Background RDF controls:'),0,WACV)
[2356]	82	useOC = wx.CheckBox(self.panel,label=' Use obs - calc intensities?')
[2355]	83	useOC.SetValue(self.result['UseObsCalc'])
	84	useOC.Bind(wx.EVT_CHECKBOX,OnUseOC)
	85	mainSizer.Add(useOC,0,WACV)
	86	dataSizer = wx.BoxSizer(wx.HORIZONTAL)
	87	dataSizer.Add(wx.StaticText(self.panel,label=' Smoothing type: '),0,WACV)
[2356]	88	smChoice = ['linear','nearest',]
[2355]	89	smCombo = wx.ComboBox(self.panel,value=self.result['Smooth'],choices=smChoice,
	90	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	91	smCombo.Bind(wx.EVT_COMBOBOX, OnSmCombo)
	92	dataSizer.Add(smCombo,0,WACV)
	93	dataSizer.Add(wx.StaticText(self.panel,label=' Maximum radial dist.: '),0,WACV)
[2567]	94	maxR = G2G.ValidatedTxtCtrl(self.panel,self.result,'maxR',nDig=(10,1),min=10.,max=50.,
	95	typeHint=float)
[2355]	96	dataSizer.Add(maxR,0,WACV)
	97	mainSizer.Add(dataSizer,0,WACV)
	98
	99	OkBtn = wx.Button(self.panel,-1,"Ok")
	100	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
	101	cancelBtn = wx.Button(self.panel,-1,"Cancel")
	102	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
	103	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
	104	btnSizer.Add((20,20),1)
	105	btnSizer.Add(OkBtn)
	106	btnSizer.Add((20,20),1)
	107	btnSizer.Add(cancelBtn)
	108	btnSizer.Add((20,20),1)
	109
	110	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
	111	self.panel.SetSizer(mainSizer)
	112	self.panel.Fit()
	113	self.Fit()
	114
	115	def GetSelection(self):
	116	return self.result
	117
	118	def OnOk(self,event):
	119	parent = self.GetParent()
	120	parent.Raise()
	121	self.EndModal(wx.ID_OK)
	122
	123	def OnCancel(self,event):
	124	parent = self.GetParent()
	125	parent.Raise()
	126	self.EndModal(wx.ID_CANCEL)
	127
	128
	129	################################################################################
	130	##### Setup routines
	131	################################################################################
	132
[904]	133	def IsHistogramInAnyPhase(G2frame,histoName):
[923]	134	'Needs a doc string'
[904]	135	phases = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
	136	if phases:
	137	item, cookie = G2frame.PatternTree.GetFirstChild(phases)
	138	while item:
	139	data = G2frame.PatternTree.GetItemPyData(item)
	140	histoList = data['Histograms'].keys()
	141	if histoName in histoList:
[1506]	142	return G2frame.PatternTree.GetItemText(item)
[904]	143	item, cookie = G2frame.PatternTree.GetNextChild(phases, cookie)
	144	return False
	145	else:
	146	return False
	147
	148	def SetDefaultSample():
[1210]	149	'Fills in default items for the Sample dictionary'
[1143]	150	return {
[1203]	151	'InstrName':'',
[1143]	152	'ranId':ran.randint(0,sys.maxint),
[904]	153	'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],
	154	'DisplaceX':[0.0,False],'DisplaceY':[0.0,False],'Diffuse':[],
[1515]	155	'Temperature':300.,'Pressure':0.1,'Time':0.0,
[1143]	156	'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
	157	'Gonio. radius':200.0,
[1778]	158	'Omega':0.0,'Chi':0.0,'Phi':0.0,'Azimuth':0.0,
[1213]	159	#SASD items
	160	'Materials':[{'Name':'vacuum','VolFrac':1.0,},{'Name':'vacuum','VolFrac':0.0,}],
[1219]	161	'Thick':1.0,'Contrast':[0.0,0.0], #contrast & anomalous contrast
	162	'Trans':1.0, #measured transmission
[1339]	163	'SlitLen':0.0, #Slit length - in Q(A-1)
[1143]	164	}
[1459]	165	def SetupSampleLabels(histName,dataType,histType):
[1267]	166	'''Setup a list of labels and number formatting for use in
	167	labeling sample parameters.
	168	:param str histName: Name of histogram, ("PWDR ...")
	169	:param str dataType:
	170	'''
	171	parms = []
[1743]	172	parms.append(['Scale','Histogram scale factor: ',[10,7]])
[1459]	173	if 'C' in histType:
	174	parms.append(['Gonio. radius','Goniometer radius (mm): ',[10,3]])
[1267]	175	if 'PWDR' in histName:
	176	if dataType == 'Debye-Scherrer':
[1459]	177	if 'T' in histType:
[2156]	178	parms += [['Absorption',u'Sample absorption (\xb5\xb7r/l): ',[10,4]],]
	179	else:
	180	parms += [['DisplaceX',u'Sample X displ. perp. to beam (\xb5m): ',[10,3]],
	181	['DisplaceY',u'Sample Y displ. \|\| to beam (\xb5m): ',[10,3]],
	182	['Absorption',u'Sample absorption (\xb5\xb7r): ',[10,4]],]
[1267]	183	elif dataType == 'Bragg-Brentano':
	184	parms += [['Shift',u'Sample displacement(\xb5m): ',[10,4]],
	185	['Transparency',u'Sample transparency(1/\xb5eff, cm): ',[10,3]],
	186	['SurfRoughA','Surface roughness A: ',[10,4]],
	187	['SurfRoughB','Surface roughness B: ',[10,4]]]
	188	elif 'SASD' in histName:
	189	parms.append(['Thick','Sample thickness (mm)',[10,3]])
	190	parms.append(['Trans','Transmission (meas)',[10,3]])
[1339]	191	parms.append(['SlitLen',u'Slit length (Q,\xc5'+Pwrm1+')',[10,3]])
[1267]	192	parms.append(['Omega','Goniometer omega:',[10,3]])
	193	parms.append(['Chi','Goniometer chi:',[10,3]])
	194	parms.append(['Phi','Goniometer phi:',[10,3]])
[1834]	195	parms.append(['Azimuth','Detector azimuth:',[10,3]])
	196	parms.append(['Time','Clock time (s):',[12,3]])
[1267]	197	parms.append(['Temperature','Sample temperature (K): ',[10,3]])
	198	parms.append(['Pressure','Sample pressure (MPa): ',[10,3]])
	199	return parms
	200
[1210]	201	def SetDefaultSASDModel():
	202	'Fills in default items for the SASD Models dictionary'
[1323]	203	return {'Back':[0.0,False],'Size':{'MinDiam':50,'MaxDiam':10000,'Nbins':100,'logBins':True,'Method':'MaxEnt','Distribution':[],
[1250]	204	'Shape':['Spheroid',1.0],'MaxEnt':{'Niter':100,'Precision':0.01,'Sky':-3},
[1252]	205	'IPG':{'Niter':100,'Approach':0.8,'Power':-1},'Reg':{},},
[1263]	206	'Particle':{'Matrix':{'Name':'vacuum','VolFrac':[0.0,False]},'Levels':[],},
[1300]	207	'Current':'Size dist.','BackFile':'',
[1210]	208	}
	209
	210	def SetDefaultSubstances():
	211	'Fills in default items for the SASD Substances dictionary'
[1219]	212	return {'Substances':{'vacuum':{'Elements':{},'Volume':1.0,'Density':0.0,'Scatt density':0.0}}}
[1265]	213
	214	def GetHistsLikeSelected(G2frame):
	215	'''Get the histograms that match the current selected one:
	216	The histogram prefix and data type (PXC etc.), the number of
	217	wavelengths and the instrument geometry (Debye-Scherrer etc.)
	218	must all match. The current histogram is not included in the list.
	219
	220	:param wx.Frame G2frame: pointer to main GSAS-II data tree
	221	'''
	222	histList = []
	223	inst,inst2 = G2frame.PatternTree.GetItemPyData(
	224	G2gd.GetPatternTreeItemId(
	225	G2frame,G2frame.PatternId, 'Instrument Parameters')
	226	)
	227	hType = inst['Type'][0]
	228	if 'Lam1' in inst:
	229	hLam = 2
	230	elif 'Lam' in inst:
	231	hLam = 1
	232	else:
	233	hLam = 0
	234	sample = G2frame.PatternTree.GetItemPyData(
	235	G2gd.GetPatternTreeItemId(
	236	G2frame,G2frame.PatternId, 'Sample Parameters')
	237	)
	238	hGeom = sample.get('Type')
	239	hstName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	240	hPrefix = hstName.split()[0]+' '
	241	# cycle through tree looking for items that match the above
	242	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
	243	while item:
	244	name = G2frame.PatternTree.GetItemText(item)
	245	if name.startswith(hPrefix) and name != hstName:
	246	cGeom,cType,cLam, = '?','?',-1
	247	subitem, subcookie = G2frame.PatternTree.GetFirstChild(item)
	248	while subitem:
	249	subname = G2frame.PatternTree.GetItemText(subitem)
	250	if subname == 'Sample Parameters':
	251	sample = G2frame.PatternTree.GetItemPyData(subitem)
	252	cGeom = sample.get('Type')
	253	elif subname == 'Instrument Parameters':
	254	inst,inst2 = G2frame.PatternTree.GetItemPyData(subitem)
	255	cType = inst['Type'][0]
	256	if 'Lam1' in inst:
	257	cLam = 2
	258	elif 'Lam' in inst:
	259	cLam = 1
	260	else:
	261	cLam = 0
	262	subitem, subcookie = G2frame.PatternTree.GetNextChild(item, subcookie)
	263	if cLam == hLam and cType == hType and cGeom == hGeom:
	264	if name not in histList: histList.append(name)
	265	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
	266	return histList
	267
	268	def SetCopyNames(histName,dataType,addNames=[]):
	269	'''Determine the items in the sample parameters that should be copied,
	270	depending on the histogram type and the instrument type.
	271	'''
	272	copyNames = ['Scale',]
	273	histType = 'HKLF'
	274	if 'PWDR' in histName:
	275	histType = 'PWDR'
	276	if 'Debye' in dataType:
	277	copyNames += ['DisplaceX','DisplaceY','Absorption']
	278	else: #Bragg-Brentano
	279	copyNames += ['Shift','Transparency','SurfRoughA','SurfRoughB']
	280	elif 'SASD' in histName:
	281	histType = 'SASD'
	282	copyNames += ['Materials','Thick',]
	283	if len(addNames):
	284	copyNames += addNames
	285	return histType,copyNames
[1673]	286
	287	def CopyPlotCtrls(G2frame):
	288	'''Global copy: Copy plot controls from current histogram to others.
	289	'''
	290	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	291	histList = GetHistsLikeSelected(G2frame)
	292	if not histList:
	293	G2frame.ErrorDialog('No match','No other histograms match '+hst,G2frame.dataFrame)
	294	return
	295	sourceData = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
	296
	297	if 'Offset' not in sourceData[0]: #patch for old data
	298	sourceData[0].update({'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,
	299	'refDelt':0.01,'qPlot':False,'dPlot':False,'sqrtPlot':False})
	300	G2frame.PatternTree.SetItemPyData(G2frame.PatternId,sourceData)
	301
[1770]	302	dlg = G2G.G2MultiChoiceDialog(
[1673]	303	G2frame.dataFrame,
	304	'Copy plot controls from\n'+str(hst[5:])+' to...',
	305	'Copy plot controls', histList)
	306	results = []
	307	try:
	308	if dlg.ShowModal() == wx.ID_OK:
	309	results = dlg.GetSelections()
	310	finally:
	311	dlg.Destroy()
	312	copyList = []
	313	for i in results:
	314	copyList.append(histList[i])
[1265]	315
[1673]	316	keys = ['Offset','delOffset','refOffset','refDelt','qPlot','dPlot','sqrtPlot']
	317	source = dict(zip(keys,[sourceData[0][item] for item in keys]))
	318	for hist in copyList:
	319	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
	320	data = G2frame.PatternTree.GetItemPyData(Id)
	321	data[0].update(source)
	322	G2frame.PatternTree.SetItemPyData(Id,data)
	323	print 'Copy of plot controls successful'
	324
[1265]	325	def CopySelectedHistItems(G2frame):
	326	'''Global copy: Copy items from current histogram to others.
	327	'''
	328	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	329	histList = GetHistsLikeSelected(G2frame)
	330	if not histList:
[1673]	331	G2frame.ErrorDialog('No match','No other histograms match '+hst,G2frame.dataFrame)
[1265]	332	return
	333	choices = ['Limits','Background','Instrument Parameters','Sample Parameters']
[1770]	334	dlg = G2G.G2MultiChoiceDialog(
[1265]	335	G2frame.dataFrame,
	336	'Copy which histogram sections from\n'+str(hst[5:]),
	337	'Select copy sections', choices, filterBox=False)
	338	dlg.SetSelections(range(len(choices)))
[1267]	339	choiceList = []
[1265]	340	if dlg.ShowModal() == wx.ID_OK:
[1267]	341	choiceList = [choices[i] for i in dlg.GetSelections()]
	342	if not choiceList: return
[1265]	343
[1770]	344	dlg = G2G.G2MultiChoiceDialog(
[1265]	345	G2frame.dataFrame,
	346	'Copy parameters from\n'+str(hst[5:])+' to...',
	347	'Copy parameters', histList)
	348	results = []
	349	try:
	350	if dlg.ShowModal() == wx.ID_OK:
	351	results = dlg.GetSelections()
	352	finally:
	353	dlg.Destroy()
	354	copyList = []
	355	for i in results:
	356	copyList.append(histList[i])
	357
[1267]	358	if 'Limits' in choiceList: # Limits
[1265]	359	data = G2frame.PatternTree.GetItemPyData(
	360	G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Limits'))
	361	for item in copyList:
	362	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	363	G2frame.PatternTree.SetItemPyData(
	364	G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),
	365	copy.deepcopy(data))
[1267]	366	if 'Background' in choiceList: # Background
[1265]	367	data = G2frame.PatternTree.GetItemPyData(
	368	G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Background'))
	369	for item in copyList:
	370	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	371	G2frame.PatternTree.SetItemPyData(
	372	G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),
	373	copy.deepcopy(data))
[1267]	374	if 'Instrument Parameters' in choiceList: # Instrument Parameters
[1265]	375	# for now all items in Inst. parms are copied
	376	data,data1 = G2frame.PatternTree.GetItemPyData(
	377	G2gd.GetPatternTreeItemId(
	378	G2frame,G2frame.PatternId,'Instrument Parameters'))
	379	for item in copyList:
	380	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	381	G2frame.PatternTree.GetItemPyData(
	382	G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
	383	)[0].update(copy.deepcopy(data))
	384	G2frame.PatternTree.GetItemPyData(
	385	G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
	386	)[1].update(copy.deepcopy(data1))
[1267]	387	if 'Sample Parameters' in choiceList: # Sample Parameters
[1265]	388	data = G2frame.PatternTree.GetItemPyData(
	389	G2gd.GetPatternTreeItemId(
	390	G2frame,G2frame.PatternId,'Sample Parameters'))
	391	# selects items to be copied
	392	histType,copyNames = SetCopyNames(hst,data['Type'],
	393	addNames = ['Omega','Chi','Phi','Gonio. radius','InstrName'])
	394	copyDict = {parm:data[parm] for parm in copyNames}
	395	for item in copyList:
	396	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	397	G2frame.PatternTree.GetItemPyData(
	398	G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters')
	399	).update(copy.deepcopy(copyDict))
[904]	400
	401	################################################################################
	402	##### Powder Peaks
	403	################################################################################
	404
	405	def UpdatePeakGrid(G2frame, data):
[923]	406	'''respond to selection of PWDR powder peaks data tree item.
	407	'''
[904]	408	if G2frame.dataDisplay:
	409	G2frame.dataFrame.Clear()
	410
	411	def OnAutoSearch(event):
	412	PatternId = G2frame.PatternId
	413	limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
	414	inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
	415	profile = G2frame.PatternTree.GetItemPyData(PatternId)[1]
	416	x0 = profile[0]
	417	iBeg = np.searchsorted(x0,limits[0])
	418	iFin = np.searchsorted(x0,limits[1])
	419	x = x0[iBeg:iFin]
	420	y0 = profile[1][iBeg:iFin]
	421	y1 = copy.copy(y0)
[2365]	422	ysig = 0.5*np.std(y1)
[904]	423	offset = [-1,1]
	424	ymask = ma.array(y0,mask=(y0<ysig))
	425	for off in offset:
	426	ymask = ma.array(ymask,mask=(ymask-np.roll(y0,off)<=0.))
	427	indx = ymask.nonzero()
	428	mags = ymask[indx]
	429	poss = x[indx]
[1008]	430	refs = zip(poss,mags)
[1367]	431	if 'C' in Inst['Type'][0]:
	432	refs = G2mth.sortArray(refs,0,reverse=True) #small 2-Thetas first
	433	else: #'T'OF
	434	refs = G2mth.sortArray(refs,0,reverse=False) #big TOFs first
[2419]	435	for i,ref1 in enumerate(refs): #reject picks closer than 1 FWHM
[1008]	436	for ref2 in refs[i+1:]:
[2419]	437	if abs(ref2[0]-ref1[0]) < G2pwd.getFWHM(ref1[0],inst):
[1367]	438	del(refs[i])
	439	if 'C' in Inst['Type'][0]:
	440	refs = G2mth.sortArray(refs,1,reverse=True)
	441	else: #'T'OF
	442	refs = G2mth.sortArray(refs,1,reverse=False)
[1008]	443	for pos,mag in refs:
[1445]	444	data['peaks'].append(G2mth.setPeakparms(inst,inst2,pos,mag))
[904]	445	UpdatePeakGrid(G2frame,data)
[1496]	446	G2plt.PlotPatterns(G2frame,plotType='PWDR')
	447
	448	def OnCopyPeaks(event):
	449	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	450	histList = GetHistsLikeSelected(G2frame)
	451	if not histList:
	452	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	453	return
	454	copyList = []
[1770]	455	dlg = G2G.G2MultiChoiceDialog(
[1496]	456	G2frame.dataFrame,
	457	'Copy peak list from\n'+str(hst[5:])+' to...',
	458	'Copy peaks', histList)
	459	try:
	460	if dlg.ShowModal() == wx.ID_OK:
	461	for i in dlg.GetSelections():
	462	copyList.append(histList[i])
	463	finally:
	464	dlg.Destroy()
	465	for item in copyList:
	466	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	467	G2frame.PatternTree.SetItemPyData(
[1548]	468	G2gd.GetPatternTreeItemId(G2frame,Id,'Peak List'),copy.deepcopy(data))
[904]	469
	470	def OnUnDo(event):
	471	DoUnDo()
	472	G2frame.dataFrame.UnDo.Enable(False)
	473
	474	def DoUnDo():
	475	print 'Undo last refinement'
	476	file = open(G2frame.undofile,'rb')
	477	PatternId = G2frame.PatternId
	478	for item in ['Background','Instrument Parameters','Peak List']:
	479	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
	480	if G2frame.dataDisplay.GetName() == item:
	481	if item == 'Background':
	482	UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
	483	elif item == 'Instrument Parameters':
	484	UpdateInstrumentGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
	485	elif item == 'Peak List':
	486	UpdatePeakGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
	487	print item,' recovered'
	488	file.close()
	489
	490	def SaveState():
	491	G2frame.undofile = os.path.join(G2frame.dirname,'GSASII.save')
	492	file = open(G2frame.undofile,'wb')
	493	PatternId = G2frame.PatternId
	494	for item in ['Background','Instrument Parameters','Peak List']:
	495	cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
	496	file.close()
	497	G2frame.dataFrame.UnDo.Enable(True)
	498
	499	def OnLSQPeakFit(event):
[2049]	500	if not G2frame.GSASprojectfile: #force a save of the gpx file so SaveState can write in the same directory
[904]	501	G2frame.OnFileSaveas(event)
	502	OnPeakFit('LSQ')
	503
	504	def OnOneCycle(event):
	505	OnPeakFit('LSQ',oneCycle=True)
	506
[1496]	507	def OnSeqPeakFit(event):
	508	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	509	histList = GetHistsLikeSelected(G2frame)
	510	if not histList:
	511	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	512	return
	513	sel = []
[1770]	514	dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential peak fits',
[1496]	515	'Select dataset to include',histList)
	516	dlg.SetSelections(sel)
	517	names = []
	518	if dlg.ShowModal() == wx.ID_OK:
	519	for sel in dlg.GetSelections():
	520	names.append(histList[sel])
	521	dlg.Destroy()
[2421]	522	if not names:
	523	return
[1548]	524	SeqResult = {}
[1498]	525	Reverse = False
	526	CopyForward = False
[1515]	527	choice = ['Reverse sequence','Copy from prev.',]
[1498]	528	dlg = wx.MultiChoiceDialog(G2frame.dataFrame,'Sequential controls','Select controls',choice)
	529	if dlg.ShowModal() == wx.ID_OK:
	530	for sel in dlg.GetSelections():
	531	if sel:
	532	CopyForward = True
	533	else:
	534	Reverse = True
[1496]	535	dlg.Destroy()
	536	dlg = wx.ProgressDialog('Sequential peak fit','Data set name = '+names[0],len(names),
	537	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
[1498]	538	Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
[1496]	539	controls = {'deriv type':'analytic','min dM/M':0.0001,}
[1498]	540	Controls['ShowCell'] = False
[1496]	541	print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
	542	oneCycle = False
	543	FitPgm = 'LSQ'
[1515]	544	prevVaryList = []
[1548]	545	Names = []
[2546]	546	peaks = None
	547	varyList = None
[1515]	548	if Reverse:
	549	names.reverse()
[1496]	550	try:
[2505]	551	wx.BeginBusyCursor()
[1496]	552	for i,name in enumerate(names):
	553	print ' Sequential fit for ',name
	554	GoOn = dlg.Update(i,newmsg='Data set name = '+name)[0]
	555	if not GoOn:
	556	break
	557	PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
[1498]	558	if i and CopyForward:
[1548]	559	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
[1515]	560	prevVaryList = varyList[:]
[1496]	561	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
	562	background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
	563	limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
	564	inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
	565	data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
	566	dlg2 = wx.ProgressDialog('Residual','Peak fit Rwp = ',101.0,
	567	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
	568	screenSize = wx.ClientDisplayRect()
	569	Size = dlg.GetSize()
[1633]	570	if 50 < Size[0] < 500: # sanity check on size, since this fails w/Win & wx3.0
	571	dlg2.SetSize((int(Size[0]*1.2),Size[1])) # increase size a bit along x
	572	dlg2.SetPosition(wx.Point(screenSize[2]-Size[0]-305,screenSize[1]+5))
[1496]	573	try:
[1515]	574	peaks['sigDict'],result,sig,Rvals,varyList,parmDict,fullvaryList,badVary = G2pwd.DoPeakFit(FitPgm,peaks['peaks'],
	575	background,limits,inst,inst2,data,prevVaryList,oneCycle,controls,dlg2)
[1496]	576	finally:
[1548]	577	dlg2.Destroy()
	578	if len(result[0]) != len(fullvaryList):
	579	print ' *** Sequential peak fit stopped at '+name+' ***'
	580	break
	581	else:
	582	Names.append(name)
	583	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
	584	SeqResult[name] = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
	585	'covMatrix':np.eye(len(result[0])),'title':name,'parmDict':parmDict,
	586	'fullVary':fullvaryList,'badVary':badVary}
	587	print ' *** Sequential peak fit successful ***'
[1496]	588	finally:
[2506]	589	dlg.Destroy()
[1498]	590	wx.EndBusyCursor()
[2426]	591	if Reverse:
	592	Names.reverse()
[1548]	593	SeqResult['histNames'] = Names
[2421]	594	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential peak fit results')
[1496]	595	if Id:
	596	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
	597	else:
[2421]	598	Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential peak fit results')
[1496]	599	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
	600	G2frame.PatternTree.SelectItem(Id)
	601
[904]	602	def OnClearPeaks(event):
	603	dlg = wx.MessageDialog(G2frame,'Delete all peaks?','Clear peak list',wx.OK\|wx.CANCEL)
	604	try:
	605	if dlg.ShowModal() == wx.ID_OK:
[1445]	606	peaks = {'peaks':[],'sigDict':{}}
[904]	607	finally:
	608	dlg.Destroy()
	609	UpdatePeakGrid(G2frame,peaks)
[1221]	610	G2plt.PlotPatterns(G2frame,plotType='PWDR')
[904]	611
	612	def OnPeakFit(FitPgm,oneCycle=False):
	613	SaveState()
	614	controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
	615	if not controls:
	616	controls = {'deriv type':'analytic','min dM/M':0.0001,} #fill in defaults if needed
	617	print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
	618	PatternId = G2frame.PatternId
	619	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
	620	if not peaks:
	621	G2frame.ErrorDialog('No peaks!','Nothing to fit!')
	622	return
	623	background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
	624	limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
	625	inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
	626	data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
	627	wx.BeginBusyCursor()
	628	dlg = wx.ProgressDialog('Residual','Peak fit Rwp = ',101.0,
	629	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
	630	screenSize = wx.ClientDisplayRect()
	631	Size = dlg.GetSize()
[1633]	632	if 50 < Size[0] < 500: # sanity check on size, since this fails w/Win & wx3.0
	633	dlg.SetSize((int(Size[0]*1.2),Size[1])) # increase size a bit along x
	634	dlg.SetPosition(wx.Point(screenSize[2]-Size[0]-305,screenSize[1]+5))
[904]	635	try:
[1515]	636	peaks['sigDict'] = G2pwd.DoPeakFit(FitPgm,peaks['peaks'],background,limits,inst,inst2,data,[],oneCycle,controls,dlg)[0]
[904]	637	finally:
[2505]	638	print 'finished'
	639	wx.EndBusyCursor()
	640	dlg.Destroy()
[1515]	641	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),copy.copy(peaks))
	642	UpdatePeakGrid(G2frame,copy.copy(peaks))
[1221]	643	G2plt.PlotPatterns(G2frame,plotType='PWDR')
[904]	644	return
	645
	646	def OnResetSigGam(event):
	647	PatternId = G2frame.PatternId
	648	Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
	649	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
[1445]	650	if not peaks['peaks']:
[904]	651	G2frame.ErrorDialog('No peaks!','Nothing to do!')
	652	return
[1445]	653	newpeaks = {'peaks':[],'sigDict':{}}
	654	for peak in peaks['peaks']:
	655	newpeaks['peaks'].append(G2mth.setPeakparms(Inst,Inst2,peak[0],peak[2]))
[904]	656	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
	657	UpdatePeakGrid(G2frame,newpeaks)
	658
	659	def RefreshPeakGrid(event):
	660
	661	event.StopPropagation()
[1445]	662	data['peaks'] = G2frame.PeakTable.GetData()
[904]	663	T = []
[1445]	664	for peak in data['peaks']:T.append(peak[0])
	665	D = dict(zip(T,data['peaks']))
[904]	666	T.sort()
	667	X = []
	668	for key in T: X.append(D[key])
[1445]	669	data['peaks'] = X
[904]	670
	671	def setBackgroundColors():
	672	for r in range(G2frame.dataDisplay.GetNumberRows()):
	673	for c in range(G2frame.dataDisplay.GetNumberCols()):
	674	if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
	675	if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
	676	G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
	677	else:
	678	G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
	679
	680	def KeyEditPeakGrid(event):
	681	rowList = G2frame.dataDisplay.GetSelectedRows()
	682	colList = G2frame.dataDisplay.GetSelectedCols()
	683	selectList = G2frame.dataDisplay.GetSelectedCells()
	684	data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
	685	if event.GetKeyCode() == wx.WXK_RETURN:
	686	event.Skip(True)
	687	elif event.GetKeyCode() == wx.WXK_CONTROL:
	688	event.Skip(True)
	689	elif event.GetKeyCode() == wx.WXK_SHIFT:
	690	event.Skip(True)
	691	elif rowList:
	692	G2frame.dataDisplay.ClearSelection()
	693	if event.GetKeyCode() == wx.WXK_DELETE:
	694	G2frame.dataDisplay.ClearGrid()
	695	rowList.sort()
	696	rowList.reverse()
	697	nDel = 0
	698	for row in rowList:
	699	G2frame.PeakTable.DeleteRow(row)
	700	nDel += 1
	701	if nDel:
	702	msg = wg.GridTableMessage(G2frame.PeakTable,
	703	wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
	704	G2frame.dataDisplay.ProcessTableMessage(msg)
[2380]	705	data['peaks'] = G2frame.PeakTable.GetData()[:-nDel]
	706	G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
[904]	707	G2frame.dataDisplay.ForceRefresh()
	708	setBackgroundColors()
	709
	710	elif colList:
	711	G2frame.dataDisplay.ClearSelection()
	712	key = event.GetKeyCode()
	713	for col in colList:
	714	if G2frame.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
	715	if key == 89: #'Y'
[1445]	716	for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=True
[904]	717	elif key == 78: #'N'
[1445]	718	for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=False
[904]	719	elif selectList:
	720	G2frame.dataDisplay.ClearSelection()
	721	key = event.GetKeyCode()
	722	for row,col in selectList:
	723	if G2frame.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
	724	if key == 89: #'Y'
[1445]	725	data['peaks'][row][col]=True
[904]	726	elif key == 78: #'N'
[1445]	727	data['peaks'][row][col]=False
[1221]	728	G2plt.PlotPatterns(G2frame,plotType='PWDR')
[904]	729
[2521]	730	def SelectVars(rows):
	731	'''Set or clear peak refinement variables for peaks listed in rows
	732	'''
	733	refOpts = {G2frame.dataDisplay.GetColLabelValue(i):i+1 for i in range(G2frame.dataDisplay.GetNumberCols()) if G2frame.dataDisplay.GetColLabelValue(i) != "refine"}
	734	dlg = G2G.G2MultiChoiceDialog(
	735	G2frame.dataFrame,
	736	'Select columns to refine',
	737	'Refinement Selection', sorted(refOpts.keys()),
	738	filterBox=False,toggle=False)
	739	sels = []
	740	try:
	741	if dlg.ShowModal() == wx.ID_OK:
	742	sels = [sorted(refOpts.keys())[i] for i in dlg.GetSelections()]
	743	else:
	744	return
	745	finally:
	746	dlg.Destroy()
	747	for r in rows:
	748	for lbl,c in refOpts.iteritems():
	749	data['peaks'][r][c] = lbl in sels
	750	UpdatePeakGrid(G2frame,data)
	751
	752	def OnRefineSelected(event):
	753	'''set refinement flags for the selected peaks
	754	'''
	755	rows = list(set([row for row,col in G2frame.dataDisplay.GetSelectedCells()] +
	756	G2frame.dataDisplay.GetSelectedRows()))
	757	if not rows:
	758	wx.MessageBox('No selected rows. You must select rows or cells before using this command',
	759	caption='No selected peaks')
	760	return
	761	SelectVars(rows)
	762
	763	def OnRefineAll(event):
	764	'''set refinement flags for all peaks
	765	'''
	766	SelectVars(range(G2frame.dataDisplay.GetNumberRows()))
	767
	768	def onSelectedRow(event):
	769	'''Called when a peak is selected so that it can be highlighted in the plot
	770	'''
	771	event.Skip()
	772	wx.CallAfter(G2plt.PlotPatterns,G2frame,plotType='PWDR')
	773
	774	#======================================================================
	775	# beginning of UpdatePeakGrid init
	776	#======================================================================
[904]	777	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PeakMenu)
	778	if not G2frame.dataFrame.GetStatusBar():
	779	Status = G2frame.dataFrame.CreateStatusBar()
	780	Status.SetStatusText('Global refine: select refine column & press Y or N')
	781	G2frame.Bind(wx.EVT_MENU, OnAutoSearch, id=G2gd.wxID_AUTOSEARCH)
[1496]	782	G2frame.Bind(wx.EVT_MENU, OnCopyPeaks, id=G2gd.wxID_PEAKSCOPY)
[904]	783	G2frame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_UNDO)
[2521]	784	G2frame.Bind(wx.EVT_MENU, OnRefineSelected, id=G2frame.dataFrame.peaksSel.GetId())
	785	G2frame.Bind(wx.EVT_MENU, OnRefineAll, id=G2frame.dataFrame.peaksAll.GetId())
[904]	786	G2frame.Bind(wx.EVT_MENU, OnLSQPeakFit, id=G2gd.wxID_LSQPEAKFIT)
	787	G2frame.Bind(wx.EVT_MENU, OnOneCycle, id=G2gd.wxID_LSQONECYCLE)
[1496]	788	G2frame.Bind(wx.EVT_MENU, OnSeqPeakFit, id=G2gd.wxID_SEQPEAKFIT)
[904]	789	G2frame.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
	790	G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
[1445]	791	if data['peaks']:
	792	G2frame.dataFrame.AutoSearch.Enable(False)
[1496]	793	G2frame.dataFrame.PeakCopy.Enable(True)
[904]	794	G2frame.dataFrame.PeakFit.Enable(True)
	795	G2frame.dataFrame.PFOneCycle.Enable(True)
[1496]	796	G2frame.dataFrame.SeqPeakFit.Enable(True)
[1445]	797	else:
	798	G2frame.dataFrame.PeakFit.Enable(False)
[1496]	799	G2frame.dataFrame.PeakCopy.Enable(False)
[1445]	800	G2frame.dataFrame.PFOneCycle.Enable(False)
	801	G2frame.dataFrame.AutoSearch.Enable(True)
[1496]	802	G2frame.dataFrame.SeqPeakFit.Enable(False)
[904]	803	G2frame.PickTable = []
	804	rowLabels = []
	805	PatternId = G2frame.PatternId
	806	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))[0]
[1445]	807	for i in range(len(data['peaks'])): rowLabels.append(str(i+1))
[904]	808	if 'C' in Inst['Type'][0]:
	809	colLabels = ['position','refine','intensity','refine','sigma','refine','gamma','refine']
	810	Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
	811	wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
	812	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
	813	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
	814	else:
	815	colLabels = ['position','refine','intensity','refine','alpha','refine',
	816	'beta','refine','sigma','refine','gamma','refine']
	817	Types = [wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
	818	wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
	819	wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
	820	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
	821	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
	822	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
	823	T = []
[1445]	824	for peak in data['peaks']:
[904]	825	T.append(peak[0])
[1445]	826	D = dict(zip(T,data['peaks']))
[904]	827	T.sort()
[1367]	828	if 'T' in Inst['Type'][0]: #want big TOF's first
	829	T.reverse()
[904]	830	X = []
	831	for key in T: X.append(D[key])
[1445]	832	data['peaks'] = X
[904]	833	G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
[1831]	834	G2frame.PeakTable = G2G.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
[904]	835	G2frame.dataFrame.SetLabel('Peak List')
[1831]	836	G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
[904]	837	G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
	838	setBackgroundColors()
	839	G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
	840	G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
[2521]	841	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, onSelectedRow)
	842	G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, onSelectedRow)
[904]	843	G2frame.dataDisplay.SetMargins(0,0)
	844	G2frame.dataDisplay.AutoSizeColumns(False)
	845	G2frame.dataFrame.setSizePosLeft([535,350])
[1537]	846	G2frame.dataFrame.SendSizeEvent()
[2521]	847
[904]	848	################################################################################
	849	##### Background
	850	################################################################################
	851
	852	def UpdateBackground(G2frame,data):
[923]	853	'''respond to selection of PWDR background data tree item.
	854	'''
[904]	855	if len(data) < 2: #add Debye diffuse & peaks scattering here
	856	data.append({'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]})
	857	if 'nPeaks' not in data[1]:
	858	data[1].update({'nPeaks':0,'peaksList':[]})
	859
	860	def OnBackFlagCopy(event):
	861	flag = data[0][1]
	862	backDict = data[-1]
	863	if backDict['nDebye']:
	864	DBflags = []
	865	for term in backDict['debyeTerms']:
	866	DBflags.append(term[1::2])
	867	if backDict['nPeaks']:
	868	PKflags = []
	869	for term in backDict['peaksList']:
	870	PKflags.append(term[1::2])
[1265]	871	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	872	histList = GetHistsLikeSelected(G2frame)
	873	if not histList:
	874	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	875	return
[1770]	876	dlg = G2G.G2MultiChoiceDialog(
[1265]	877	G2frame.dataFrame,
	878	'Copy bkg ref. flags from\n'+str(hst[5:])+' to...',
[1267]	879	'Copy bkg flags', histList)
[904]	880	copyList = []
	881	try:
	882	if dlg.ShowModal() == wx.ID_OK:
[1265]	883	for i in dlg.GetSelections():
[904]	884	copyList.append(histList[i])
	885	finally:
	886	dlg.Destroy()
[1265]	887	for item in copyList:
	888	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	889	backData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'))
	890	backData[0][1] = copy.copy(flag)
	891	bkDict = backData[-1]
	892	if bkDict['nDebye'] == backDict['nDebye']:
	893	for i,term in enumerate(bkDict['debyeTerms']):
	894	term[1::2] = copy.copy(DBflags[i])
	895	if bkDict['nPeaks'] == backDict['nPeaks']:
	896	for i,term in enumerate(bkDict['peaksList']):
	897	term[1::2] = copy.copy(PKflags[i])
[904]	898
	899	def OnBackCopy(event):
[1265]	900	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	901	histList = GetHistsLikeSelected(G2frame)
	902	if not histList:
	903	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	904	return
[904]	905	copyList = []
[1770]	906	dlg = G2G.G2MultiChoiceDialog(
[1265]	907	G2frame.dataFrame,
	908	'Copy bkg params from\n'+str(hst[5:])+' to...',
	909	'Copy parameters', histList)
[904]	910	try:
	911	if dlg.ShowModal() == wx.ID_OK:
[1265]	912	for i in dlg.GetSelections():
[904]	913	copyList.append(histList[i])
	914	finally:
	915	dlg.Destroy()
[1265]	916	for item in copyList:
	917	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	918	G2frame.PatternTree.SetItemPyData(
	919	G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),copy.copy(data))
[1889]	920
	921	def OnBkgFit(event):
[1895]	922	def SetInstParms(Inst):
	923	dataType = Inst['Type'][0]
	924	insVary = []
	925	insNames = []
	926	insVals = []
	927	for parm in Inst:
	928	insNames.append(parm)
	929	insVals.append(Inst[parm][1])
	930	if parm in ['U','V','W','X','Y','SH/L','I(L2)/I(L1)','alpha',
	931	'beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q',] and Inst[parm][2]:
	932	insVary.append(parm)
	933	instDict = dict(zip(insNames,insVals))
	934	instDict['X'] = max(instDict['X'],0.01)
	935	instDict['Y'] = max(instDict['Y'],0.01)
	936	if 'SH/L' in instDict:
	937	instDict['SH/L'] = max(instDict['SH/L'],0.002)
	938	return dataType,instDict,insVary
[1889]	939
	940	PatternId = G2frame.PatternId
	941	controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
	942	background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
	943	limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
	944	inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
[1893]	945	# sort the points for convenience and then separate them; extend the range if needed
	946	background[1]['FixedPoints'] = sorted(background[1]['FixedPoints'],key=lambda pair:pair[0])
	947	X = [x for x,y in background[1]['FixedPoints']]
	948	Y = [y for x,y in background[1]['FixedPoints']]
	949	if X[0] > limits[0]:
	950	X = [limits[0]] + X
	951	Y = [Y[0]] + Y
	952	if X[-1] < limits[1]:
	953	X += [limits[1]]
	954	Y += [Y[-1]]
	955	# interpolate the fixed points onto the grid of data points within limits
	956	pwddata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
	957	xBeg = np.searchsorted(pwddata[0],limits[0])
	958	xFin = np.searchsorted(pwddata[0],limits[1])
	959	xdata = pwddata[0][xBeg:xFin]
[2334]	960	ydata = si.interp1d(X,Y)(ma.getdata(xdata))
[1893]	961	#GSASIIpath.IPyBreak()
	962	W = [1]*len(xdata)
	963	Z = [0]*len(xdata)
[1889]	964
	965	# load instrument and background params
[1895]	966	dataType,insDict,insVary = SetInstParms(inst)
[1889]	967	bakType,bakDict,bakVary = G2pwd.SetBackgroundParms(background)
	968	# how many background parameters are refined?
	969	if len(bakVary)*1.5 > len(X):
	970	msg = ("You are attempting to vary "+str(len(bakVary))+
	971	" background terms with only "+str(len(X))+" background points"+
	972	"\nAdd more points or reduce the number of terms")
	973	print msg
	974	G2frame.ErrorDialog('Too few points',msg)
	975	return
	976
	977	wx.BeginBusyCursor()
	978	try:
	979	G2pwd.DoPeakFit('LSQ',[],background,limits,inst,inst2,
[2355]	980	np.array((xdata,ydata,W,Z,Z,Z)),bakVary,False,controls)
[1889]	981	finally:
	982	wx.EndBusyCursor()
	983	# compute the background values and plot them
	984	parmDict = {}
	985	bakType,bakDict,bakVary = G2pwd.SetBackgroundParms(background)
	986	parmDict.update(bakDict)
	987	parmDict.update(insDict)
	988	pwddata[3] *= 0
	989	pwddata[5] *= 0
	990	pwddata[4][xBeg:xFin] = G2pwd.getBackground(
[1893]	991	'',parmDict,bakType,dataType,xdata)[0]
[1889]	992	G2plt.PlotPatterns(G2frame,plotType='PWDR')
	993	# show the updated background values
	994	wx.CallLater(100,UpdateBackground,G2frame,data)
[1894]	995
	996	def OnBkgClear(event):
	997	if 'FixedPoints' not in data[1]:
	998	return
	999	else:
	1000	del data[1]['FixedPoints']
	1001	G2plt.PlotPatterns(G2frame,plotType='PWDR')
[1889]	1002
[1820]	1003	def OnPeaksMove(event):
	1004	if not data[1]['nPeaks']:
	1005	G2frame.ErrorDialog('Error','No peaks to move')
	1006	return
	1007	Peaks = {'peaks':[],'sigDict':{}}
	1008	for peak in data[1]['peaksList']:
	1009	Peaks['peaks'].append([peak[0],0,peak[2],0,peak[4],0,peak[6],0])
	1010	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),Peaks)
[904]	1011
[2355]	1012	def OnMakeRDF(event):
	1013	dlg = RDFDialog(G2frame)
	1014	try:
	1015	if dlg.ShowModal() == wx.ID_OK:
	1016	RDFcontrols = dlg.GetSelection()
	1017	else:
	1018	return
	1019	finally:
	1020	dlg.Destroy()
	1021	PatternId = G2frame.PatternId
	1022	background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
	1023	inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
	1024	pwddata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
[2356]	1025	auxPlot = G2pwd.MakeRDF(RDFcontrols,background,inst,pwddata)
[2355]	1026	# GSASIIpath.IPyBreak()
	1027	superMinusOne = unichr(0xaf)+unichr(0xb9)
	1028	for plot in auxPlot:
	1029	XY = np.array(plot[:2])
[2356]	1030	if plot[2] == 'D(R)':
	1031	xlabel = r'$R, \AA$'
	1032	ylabel = r'$D(R), arb. units$'
	1033	else:
	1034	xlabel = r'$Q,\AA$'+superMinusOne
	1035	ylabel = r'$I(Q)$'
	1036	G2plt.PlotXY(G2frame,[XY,],Title=plot[2],labelX=xlabel,labelY=ylabel,lines=True)
[2355]	1037
[904]	1038	def BackSizer():
	1039
	1040	def OnNewType(event):
	1041	data[0][0] = bakType.GetValue()
	1042
	1043	def OnBakRef(event):
	1044	data[0][1] = bakRef.GetValue()
	1045
	1046	def OnBakTerms(event):
	1047	data[0][2] = int(bakTerms.GetValue())
	1048	M = len(data[0])
	1049	N = data[0][2]+3
	1050	item = data[0]
	1051	if N > M: #add terms
	1052	for i in range(M,N):
	1053	item.append(0.0)
	1054	elif N < M: #delete terms
	1055	for i in range(N,M):
	1056	del(item[-1])
	1057	G2frame.PatternTree.SetItemPyData(BackId,data)
[1525]	1058	#wx.CallAfter(UpdateBackground,G2frame,data)
	1059	wx.CallLater(100,UpdateBackground,G2frame,data)
[904]	1060
	1061	backSizer = wx.BoxSizer(wx.VERTICAL)
	1062	topSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	1063	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,WACV)
[904]	1064	bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
	1065	choices=Choices,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	1066	bakType.Bind(wx.EVT_COMBOBOX, OnNewType)
	1067	topSizer.Add(bakType)
	1068	topSizer.Add((5,0),0)
	1069	bakRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
	1070	bakRef.SetValue(bool(data[0][1]))
	1071	bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
[1233]	1072	topSizer.Add(bakRef,0,WACV)
	1073	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
[904]	1074	bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
	1075	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	1076	bakTerms.Bind(wx.EVT_COMBOBOX,OnBakTerms)
[1233]	1077	topSizer.Add(bakTerms,0,WACV)
[904]	1078	topSizer.Add((5,0),0)
	1079	backSizer.Add(topSizer)
[1233]	1080	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,WACV)
[1378]	1081	bakSizer = wx.FlexGridSizer(0,5,5,5)
[904]	1082	for i,value in enumerate(data[0][3:]):
[2567]	1083	bakVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[0],i+3,nDig=(10,4),typeHint=float)
[1233]	1084	bakSizer.Add(bakVal,0,WACV)
[904]	1085	backSizer.Add(bakSizer)
	1086	return backSizer
	1087
	1088	def DebyeSizer():
	1089
	1090	def OnDebTerms(event):
	1091	data[1]['nDebye'] = int(debTerms.GetValue())
	1092	M = len(data[1]['debyeTerms'])
	1093	N = data[1]['nDebye']
	1094	if N > M: #add terms
	1095	for i in range(M,N):
	1096	data[1]['debyeTerms'].append([1.0,False,1.0,False,0.010,False])
	1097	elif N < M: #delete terms
	1098	for i in range(N,M):
	1099	del(data[1]['debyeTerms'][-1])
[1541]	1100	#wx.CallAfter(UpdateBackground,G2frame,data)
	1101	wx.CallLater(100,UpdateBackground,G2frame,data)
	1102
[904]	1103	def KeyEditPeakGrid(event):
	1104	colList = debyeGrid.GetSelectedCols()
	1105	if event.GetKeyCode() == wx.WXK_RETURN:
	1106	event.Skip(True)
	1107	elif event.GetKeyCode() == wx.WXK_CONTROL:
	1108	event.Skip(True)
	1109	elif event.GetKeyCode() == wx.WXK_SHIFT:
	1110	event.Skip(True)
	1111	elif colList:
	1112	debyeGrid.ClearSelection()
	1113	key = event.GetKeyCode()
	1114	for col in colList:
	1115	if debyeTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
	1116	if key == 89: #'Y'
	1117	for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=True
	1118	elif key == 78: #'N'
	1119	for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=False
	1120
	1121
	1122	debSizer = wx.BoxSizer(wx.VERTICAL)
	1123	topSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	1124	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,WACV)
	1125	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
[904]	1126	debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
	1127	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	1128	debTerms.Bind(wx.EVT_COMBOBOX,OnDebTerms)
[1233]	1129	topSizer.Add(debTerms,0,WACV)
[904]	1130	topSizer.Add((5,0),0)
	1131	debSizer.Add(topSizer)
	1132	if data[1]['nDebye']:
[1233]	1133	debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,WACV)
[904]	1134	rowLabels = []
	1135	for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
	1136	colLabels = ['A','refine','R','refine','U','refine']
	1137	Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
	1138	wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
	1139	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
[1831]	1140	debyeTable = G2G.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
	1141	debyeGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
[904]	1142	debyeGrid.SetTable(debyeTable, True)
	1143	debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
	1144	debyeGrid.AutoSizeColumns(False)
	1145	debSizer.Add(debyeGrid)
	1146	return debSizer
	1147
	1148	def PeaksSizer():
	1149
	1150	def OnPeaks(event):
	1151	data[1]['nPeaks'] = int(peaks.GetValue())
	1152	M = len(data[1]['peaksList'])
	1153	N = data[1]['nPeaks']
	1154	if N > M: #add terms
	1155	for i in range(M,N):
	1156	data[1]['peaksList'].append([1.0,False,1.0,False,0.10,False,0.10,False])
	1157	elif N < M: #delete terms
	1158	for i in range(N,M):
	1159	del(data[1]['peaksList'][-1])
[1541]	1160	#wx.CallAfter(UpdateBackground,G2frame,data)
	1161	wx.CallLater(100,UpdateBackground,G2frame,data)
[904]	1162
	1163	def KeyEditPeakGrid(event):
	1164	colList = peaksGrid.GetSelectedCols()
	1165	if event.GetKeyCode() == wx.WXK_RETURN:
	1166	event.Skip(True)
	1167	elif event.GetKeyCode() == wx.WXK_CONTROL:
	1168	event.Skip(True)
	1169	elif event.GetKeyCode() == wx.WXK_SHIFT:
	1170	event.Skip(True)
	1171	elif colList:
	1172	peaksGrid.ClearSelection()
	1173	key = event.GetKeyCode()
	1174	for col in colList:
	1175	if peaksTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
	1176	if key == 89: #'Y'
	1177	for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=True
	1178	elif key == 78: #'N'
	1179	for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=False
	1180
	1181	peaksSizer = wx.BoxSizer(wx.VERTICAL)
	1182	topSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	1183	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,WACV)
	1184	topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,WACV)
[1820]	1185	peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(30)],
[904]	1186	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	1187	peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
[1233]	1188	topSizer.Add(peaks,0,WACV)
[904]	1189	topSizer.Add((5,0),0)
	1190	peaksSizer.Add(topSizer)
	1191	if data[1]['nPeaks']:
[1233]	1192	peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,WACV)
[904]	1193	rowLabels = []
	1194	for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
	1195	colLabels = ['pos','refine','int','refine','sig','refine','gam','refine']
	1196	Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
	1197	wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
	1198	wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
	1199	wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
[1831]	1200	peaksTable = G2G.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
	1201	peaksGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
[904]	1202	peaksGrid.SetTable(peaksTable, True)
	1203	peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
	1204	peaksGrid.AutoSizeColumns(False)
	1205	peaksSizer.Add(peaksGrid)
	1206	return peaksSizer
	1207
	1208	if G2frame.dataDisplay:
	1209	G2frame.dataFrame.DestroyChildren()
	1210	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
	1211	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.BackMenu)
	1212	G2frame.dataFrame.SetLabel('Background')
	1213	if not G2frame.dataFrame.GetStatusBar():
[2546]	1214	G2frame.dataFrame.CreateStatusBar()
[904]	1215	G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
	1216	G2frame.Bind(wx.EVT_MENU,OnBackFlagCopy,id=G2gd.wxID_BACKFLAGCOPY)
[1820]	1217	G2frame.Bind(wx.EVT_MENU,OnPeaksMove,id=G2gd.wxID_PEAKSMOVE)
[2355]	1218	G2frame.Bind(wx.EVT_MENU,OnMakeRDF,id=G2gd.wxID_MAKEBACKRDF)
[1889]	1219	G2frame.Bind(wx.EVT_MENU,OnBkgFit,id=G2frame.dataFrame.wxID_BackPts['Fit'])
[1894]	1220	G2frame.Bind(wx.EVT_MENU,OnBkgClear,id=G2frame.dataFrame.wxID_BackPts['Clear'])
[904]	1221	BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background')
[1911]	1222	Choices = ['chebyschev','cosine','Q^2 power series','Q^-2 power series','lin interpolate','inv interpolate','log interpolate']
[904]	1223	mainSizer = wx.BoxSizer(wx.VERTICAL)
	1224	mainSizer.Add(BackSizer())
	1225	mainSizer.Add((0,5),0)
	1226	mainSizer.Add(DebyeSizer())
	1227	mainSizer.Add((0,5),0)
	1228	mainSizer.Add(PeaksSizer())
	1229	mainSizer.Layout()
	1230	G2frame.dataDisplay.SetSizer(mainSizer)
[2202]	1231	Size = mainSizer.Fit(G2frame.dataFrame)
	1232	G2frame.dataDisplay.SetSize(Size)
	1233	G2frame.dataFrame.setSizePosLeft(Size)
[904]	1234
	1235	################################################################################
	1236	##### Limits
	1237	################################################################################
	1238
[1221]	1239	def UpdateLimitsGrid(G2frame, data,plottype):
[923]	1240	'''respond to selection of PWDR Limits data tree item.
	1241	'''
[2524]	1242	def LimitSizer():
	1243	limits = wx.FlexGridSizer(2,3,0,5)
	1244	labels = ['Tmin','Tmax']
	1245	for i in [0,1]:
	1246	limits.Add(wx.StaticText(G2frame.dataDisplay,label=' Original %s: %.4f'%(labels[0],data[0][i])),0,WACV)
	1247	limits.Add(wx.StaticText(G2frame.dataDisplay,label=' New: '),0,WACV)
	1248	limits.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[1],i, \
	1249	min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
	1250	return limits
[904]	1251
[2524]	1252	def AfterChange(invalid,value,tc):
	1253	if invalid: return
	1254	plottype = G2frame.PatternTree.GetItemText(G2frame.PatternId)[:4]
[2525]	1255	# print 'new plot'
	1256	wx.CallAfter(G2plt.PlotPatterns,G2frame,newPlot=False,plotType=plottype) #unfortunately this resets the plot width
[2524]	1257
	1258	def ExclSizer():
[904]	1259
[2524]	1260	def OnDelExcl(event):
	1261	Obj = event.GetEventObject()
	1262	item = Indx[Obj.GetId()]
	1263	del(data[item+2])
	1264	G2plt.PlotPatterns(G2frame,newPlot=False,plotType=plottype)
	1265	wx.CallAfter(UpdateLimitsGrid,G2frame,data,plottype)
	1266
	1267	Indx = {}
	1268	excl = wx.FlexGridSizer(0,3,0,5)
	1269	excl.Add(wx.StaticText(G2frame.dataDisplay,label=' From: '),0,WACV)
	1270	excl.Add(wx.StaticText(G2frame.dataDisplay,label=' To: '),0,WACV)
	1271	excl.Add(wx.StaticText(G2frame.dataDisplay,label=' Delete?: '),0,WACV)
	1272	for id,item in enumerate(data[2:]):
	1273	for i in [0,1]:
	1274	excl.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,i, \
	1275	min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
	1276	delExcl = wx.CheckBox(G2frame.dataDisplay,label='')
	1277	Indx[delExcl.GetId()] = id
	1278	delExcl.Bind(wx.EVT_CHECKBOX,OnDelExcl)
	1279	excl.Add(delExcl,0,WACV)
	1280	return excl
	1281
[904]	1282	def OnLimitCopy(event):
[1265]	1283	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	1284	histList = GetHistsLikeSelected(G2frame)
	1285	if not histList:
	1286	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	1287	return
[1770]	1288	dlg = G2G.G2MultiChoiceDialog(
[1265]	1289	G2frame.dataFrame,
	1290	'Copy limits from\n'+str(hst[5:])+' to...',
	1291	'Copy limits', histList)
[904]	1292	try:
	1293	if dlg.ShowModal() == wx.ID_OK:
[1265]	1294	for i in dlg.GetSelections():
	1295	item = histList[i]
	1296	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	1297	G2frame.PatternTree.SetItemPyData(
	1298	G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),copy.copy(data))
[904]	1299	finally:
	1300	dlg.Destroy()
[1017]	1301
	1302	def OnAddExcl(event):
	1303	G2frame.ifGetExclude = True
	1304	print 'Add excluded region'
[904]	1305
[2524]	1306	def Draw():
	1307	mainSizer = wx.BoxSizer(wx.VERTICAL)
	1308	mainSizer.Add(LimitSizer())
	1309	if len(data)>2:
	1310	mainSizer.Add((0,5),0)
	1311	mainSizer.Add(wx.StaticText(G2frame.dataFrame,label=' Excluded regions:'),0,WACV)
	1312	mainSizer.Add(ExclSizer())
	1313	mainSizer.Layout()
	1314	G2frame.dataDisplay.SetSizer(mainSizer)
	1315	Size = mainSizer.Fit(G2frame.dataFrame)
	1316	G2frame.dataDisplay.SetSize(Size)
	1317	G2frame.dataFrame.setSizePosLeft(Size)
	1318
	1319
	1320	if G2frame.dataDisplay:
	1321	G2frame.dataFrame.DestroyChildren()
	1322	G2frame.ifGetExclude = False
	1323	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
	1324	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LimitMenu)
[904]	1325	G2frame.dataFrame.SetLabel('Limits')
	1326	if not G2frame.dataFrame.GetStatusBar():
[2546]	1327	G2frame.dataFrame.CreateStatusBar()
[904]	1328	G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
[2524]	1329	G2frame.Bind(wx.EVT_MENU,OnAddExcl,id=G2gd.wxID_ADDEXCLREGION)
	1330	Draw()
[904]	1331
[2524]	1332
	1333
[904]	1334	################################################################################
	1335	##### Instrument parameters
	1336	################################################################################
	1337
	1338	def UpdateInstrumentGrid(G2frame,data):
[1199]	1339	'''respond to selection of PWDR/SASD Instrument Parameters
[923]	1340	data tree item.
	1341	'''
[2151]	1342	if 'Bank' not in data: #get it from name; absent for default parms selection
[2147]	1343	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	1344	if 'Bank' in hst:
[2151]	1345	bank = int(hst.split('Bank')[1].split('_')[0])
[2147]	1346	data['Bank'] = [bank,bank,0]
	1347	else:
	1348	data['Bank'] = [1,1,0]
[2151]	1349
[904]	1350	def keycheck(keys):
	1351	good = []
	1352	for key in keys:
[2050]	1353	if key in ['Type','Bank','U','V','W','X','Y','SH/L','I(L2)/I(L1)','alpha',
[1462]	1354	'beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q','Polariz.',
[1459]	1355	'Lam','Azimuth','2-theta','fltPath','difC','difA','difB','Zero','Lam1','Lam2']:
[904]	1356	good.append(key)
	1357	return good
	1358
[1881]	1359	def updateData(inst,ref):
	1360	data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
	1361	G2frame.PatternId,'Instrument Parameters'))[0]
[904]	1362	for item in data:
	1363	try:
	1364	data[item] = [data[item][0],inst[item],ref[item]]
	1365	except KeyError:
[1881]	1366	try:
	1367	data[item] = [data[item][0],inst[item]]
	1368	except KeyError:
	1369	pass #skip 'Polariz.' for N-data
[904]	1370
	1371	def RefreshInstrumentGrid(event,doAnyway=False):
	1372	if doAnyway or event.GetRow() == 1:
	1373	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
	1374	newpeaks = []
[1445]	1375	for peak in peaks['peaks']:
[904]	1376	newpeaks.append(G2mth.setPeakparms(data,Inst2,peak[0],peak[2]))
[1445]	1377	peaks['peaks'] = newpeaks
	1378	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),peaks)
[1443]	1379
	1380	def OnCalibrate(event):
[1493]	1381	Pattern = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
	1382	xye = ma.array(ma.getdata(Pattern[1]))
	1383	cw = np.diff(xye[0])
[1443]	1384	IndexPeaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
[1445]	1385	if not len(IndexPeaks[0]):
[1443]	1386	G2frame.ErrorDialog('Can not calibrate','Index Peak List empty')
	1387	return
[1955]	1388	if not np.any(IndexPeaks[1]):
	1389	G2frame.ErrorDialog('Can not calibrate','Peak positions not refined')
	1390	return False
[1445]	1391	Ok = False
	1392	for peak in IndexPeaks[0]:
	1393	if peak[2] and peak[3]:
	1394	Ok = True
	1395	if not Ok:
	1396	G2frame.ErrorDialog('Can not calibrate','Index Peak List not indexed')
	1397	return
[1493]	1398	if G2pwd.DoCalibInst(IndexPeaks,data):
	1399	UpdateInstrumentGrid(G2frame,data)
	1400	XY = []
	1401	Sigs = []
	1402	for ip,peak in enumerate(IndexPeaks[0]):
	1403	if peak[2] and peak[3]:
	1404	binwid = cw[np.searchsorted(xye[0],peak[0])]
[1571]	1405	XY.append([peak[-1],peak[0],binwid])
[1493]	1406	Sigs.append(IndexPeaks[1][ip])
	1407	if len(XY):
	1408	XY = np.array(XY)
	1409	G2plt.PlotCalib(G2frame,data,XY,Sigs,newPlot=True)
	1410	else:
	1411	G2frame.ErrorDialog('Can not calibrate','Nothing selected for refinement')
[1443]	1412
[904]	1413	def OnLoad(event):
	1414	'''Loads instrument parameters from a G2 .instprm file
	1415	in response to the Instrument Parameters-Operations/Load Profile menu
[2147]	1416	If instprm file has multiple banks each with header #Bank n: ..., this
	1417	finds matching bank no. to load - rejects nonmatches.
[904]	1418
	1419	Note that similar code is found in ReadPowderInstprm (GSASII.py)
	1420	'''
[2147]	1421	data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
	1422	G2frame.PatternId,'Instrument Parameters'))[0]
	1423	bank = data['Bank'][0]
[2109]	1424	pth = G2G.GetImportPath(G2frame)
	1425	if not pth: pth = '.'
	1426	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', pth, '',
	1427	'instrument parameter files (.instprm)\|.instprm',wx.OPEN)
[904]	1428	try:
	1429	if dlg.ShowModal() == wx.ID_OK:
	1430	filename = dlg.GetPath()
	1431	File = open(filename,'r')
	1432	S = File.readline()
	1433	newItems = []
	1434	newVals = []
[2147]	1435	Found = False
[904]	1436	while S:
	1437	if S[0] == '#':
[2147]	1438	if Found:
	1439	break
	1440	if 'Bank' in S:
	1441	if bank == int(S.split(':')[0].split()[1]):
	1442	S = File.readline()
	1443	continue
	1444	else:
	1445	S = File.readline()
	1446	while S and '#Bank' not in S:
	1447	S = File.readline()
	1448	continue
	1449	else: #a non #Bank file
	1450	S = File.readline()
	1451	continue
	1452	Found = True
[904]	1453	[item,val] = S[:-1].split(':')
	1454	newItems.append(item)
	1455	try:
	1456	newVals.append(float(val))
	1457	except ValueError:
	1458	newVals.append(val)
	1459	S = File.readline()
	1460	File.close()
[2147]	1461	if Found:
	1462	Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'))
	1463	if 'Bank' not in Inst: #patch for old .instprm files - may cause faults for TOF data
	1464	Inst['Bank'] = [1,1,0]
	1465	data = G2IO.makeInstDict(newItems,newVals,len(newVals)*[False,])
	1466	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),[data,Inst2])
	1467	RefreshInstrumentGrid(event,doAnyway=True) #to get peaks updated
	1468	else:
	1469	G2frame.ErrorDialog('No match','Bank %d not in %s'%(bank,filename),G2frame.dataFrame)
[904]	1470	UpdateInstrumentGrid(G2frame,data)
	1471	G2plt.PlotPeakWidths(G2frame)
	1472	finally:
	1473	dlg.Destroy()
	1474
	1475	def OnSave(event):
	1476	'''Respond to the Instrument Parameters Operations/Save Profile menu
	1477	item: writes current parameters to a .instprm file
[2147]	1478	It does not write Bank n: on # line & thus can be used any time w/o clash of bank nos.
[904]	1479	'''
[2109]	1480	pth = G2G.GetExportPath(G2frame)
	1481	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', pth, '',
	1482	'instrument parameter files (.instprm)\|.instprm',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
[904]	1483	try:
	1484	if dlg.ShowModal() == wx.ID_OK:
	1485	filename = dlg.GetPath()
	1486	# make sure extension is .instprm
	1487	filename = os.path.splitext(filename)[0]+'.instprm'
	1488	File = open(filename,'w')
[1507]	1489	File.write("#GSAS-II instrument parameter file; do not add/delete items!\n")
[904]	1490	for item in data:
	1491	File.write(item+':'+str(data[item][1])+'\n')
	1492	File.close()
[2554]	1493	print 'Instrument parameters saved to: '+filename
[904]	1494	finally:
	1495	dlg.Destroy()
[2147]	1496
	1497	def OnSaveAll(event):
	1498	'''Respond to the Instrument Parameters Operations/Save all Profile menu & writes
	1499	selected inst parms. across multiple banks into a single file
	1500	Each block starts with #Bank n: GSAS-II instrument... where n is bank no.
	1501	item: writes parameters from selected PWDR entries to a .instprm file
	1502	'''
	1503	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	1504	histList = GetHistsLikeSelected(G2frame)
	1505	histList.insert(0,hst)
	1506	saveList = []
	1507	dlg = G2G.G2MultiChoiceDialog(
	1508	G2frame.dataFrame,
	1509	'Save instrument parameters from',
	1510	'Save instrument parameters', histList)
	1511	try:
	1512	if dlg.ShowModal() == wx.ID_OK:
	1513	for i in dlg.GetSelections():
	1514	saveList.append(histList[i])
	1515	finally:
	1516	dlg.Destroy()
	1517	pth = G2G.GetExportPath(G2frame)
	1518	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', pth, '',
	1519	'instrument parameter files (.instprm)\|.instprm',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
	1520	try:
	1521	if dlg.ShowModal() == wx.ID_OK:
	1522	filename = dlg.GetPath()
	1523	# make sure extension is .instprm
	1524	filename = os.path.splitext(filename)[0]+'.instprm'
	1525	File = open(filename,'w')
	1526	for hist in saveList:
	1527	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
	1528	inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
	1529	if 'Bank' not in inst: #patch
	1530	bank = 1
	1531	if 'Bank' in hist:
	1532	bank = int(hist.split('Bank')[1])
	1533	inst['Bank'] = [bank,bank,0]
	1534	bank = inst['Bank'][0]
	1535	File.write("#Bank %d: GSAS-II instrument parameter file; do not add/delete items!\n"%(bank))
	1536	for item in inst:
	1537	File.write(item+':'+str(inst[item][1])+'\n')
	1538	File.close()
	1539	finally:
	1540	dlg.Destroy()
[904]	1541
	1542	def OnReset(event):
	1543	insVal.update(insDef)
[1404]	1544	updateData(insVal,insRef)
[904]	1545	RefreshInstrumentGrid(event,doAnyway=True) #to get peaks updated
	1546	UpdateInstrumentGrid(G2frame,data)
	1547	G2plt.PlotPeakWidths(G2frame)
	1548
	1549	def OnInstFlagCopy(event):
[1265]	1550	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	1551	histList = GetHistsLikeSelected(G2frame)
	1552	if not histList:
	1553	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	1554	return
[904]	1555	keys = data.keys()
[1898]	1556	try:
	1557	keys.remove('Source')
[1945]	1558	except ValueError:
[1898]	1559	pass
[904]	1560	flags = dict(zip(keys,[data[key][2] for key in keys]))
	1561	instType = data['Type'][0]
	1562	copyList = []
[1770]	1563	dlg = G2G.G2MultiChoiceDialog(
[1265]	1564	G2frame.dataFrame,
	1565	'Copy inst ref. flags from\n'+hst[5:],
	1566	'Copy refinement flags', histList)
[904]	1567	try:
	1568	if dlg.ShowModal() == wx.ID_OK:
[1265]	1569	for i in dlg.GetSelections():
[904]	1570	copyList.append(histList[i])
	1571	finally:
	1572	dlg.Destroy()
[1265]	1573	for item in copyList:
	1574	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	1575	instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
[2421]	1576	if 'Bank' not in instData:
	1577	instData['Bank'] = [1,1,0]
	1578	# GSASIIpath.IPyBreak()
[1265]	1579	if len(data) == len(instData) and instType == instData['Type'][0]: #don't mix data types or lam & lam1/lam2 parms!
	1580	for item in instData:
[1898]	1581	if item not in ['Source',]:
	1582	instData[item][2] = copy.copy(flags[item])
[1265]	1583	else:
	1584	print item+' not copied - instrument parameters not commensurate'
[904]	1585
	1586	def OnInstCopy(event):
	1587	#need fix for dictionary
[1265]	1588	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	1589	histList = GetHistsLikeSelected(G2frame)
	1590	if not histList:
	1591	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	1592	return
[904]	1593	copyList = []
	1594	instType = data['Type'][0]
[1770]	1595	dlg = G2G.G2MultiChoiceDialog(
[1265]	1596	G2frame.dataFrame,
	1597	'Copy inst params from\n'+hst,
	1598	'Copy parameters', histList)
[904]	1599	try:
	1600	if dlg.ShowModal() == wx.ID_OK:
[1265]	1601	for i in dlg.GetSelections():
[904]	1602	copyList.append(histList[i])
	1603	finally:
	1604	dlg.Destroy()
[1265]	1605	for item in copyList:
	1606	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	1607	instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
[2421]	1608	if 'Bank' not in instData:
	1609	instData['Bank'] = [1,1,0]
[1265]	1610	if len(data) == len(instData) and instType == instData['Type'][0]: #don't mix data types or lam & lam1/lam2 parms!
	1611	instData.update(data)
	1612	else:
	1613	print item+' not copied - instrument parameters not commensurate'
[1404]	1614
	1615	def AfterChange(invalid,value,tc):
	1616	if invalid: return
	1617	updateData(insVal,insRef)
[904]	1618
	1619	def OnItemRef(event):
	1620	Obj = event.GetEventObject()
	1621	item = RefObj[Obj.GetId()]
	1622	insRef[item] = Obj.GetValue()
[1404]	1623	updateData(insVal,insRef)
	1624
	1625	def OnCopy1Val(event):
	1626	'''Select one instrument parameter value to edit and copy to many histograms
	1627	optionally allow values to be edited in a table
	1628	'''
	1629	updateData(insVal,insRef)
[1619]	1630	G2G.SelectEdit1Var(G2frame,data,labelLst,elemKeysLst,dspLst,refFlgElem)
[1404]	1631	insVal.update({key:data[key][1] for key in instkeys})
	1632	insRef.update({key:data[key][2] for key in instkeys})
	1633	wx.CallAfter(MakeParameterWindow)
	1634
	1635	def lblWdef(lbl,dec,val):
	1636	'Label parameter showing the default value'
	1637	fmt = "%15."+str(dec)+"f"
	1638	return " " + lbl + " (" + (fmt % val).strip() + "): "
	1639
	1640	def RefineBox(item):
	1641	'Define a refine checkbox with binding'
	1642	wid = wx.CheckBox(G2frame.dataDisplay,label=' Refine? ')
	1643	wid.SetValue(bool(insRef[item]))
	1644	RefObj[wid.GetId()] = item
	1645	wid.Bind(wx.EVT_CHECKBOX, OnItemRef)
	1646	return wid
	1647
	1648	def OnLamPick(event):
	1649	data['Source'][1] = lamType = event.GetEventObject().GetValue()
[1880]	1650	if 'P' in insVal['Type']:
	1651	insVal['Lam1'] = waves[lamType][0]
	1652	insVal['Lam2'] = waves[lamType][1]
	1653	elif 'S' in insVal['Type'] and 'synch' not in lamType:
	1654	insVal['Lam'] = meanwaves[lamType]
[1404]	1655	updateData(insVal,insRef)
	1656	i,j= wx.__version__.split('.')[0:2]
	1657	if int(i)+int(j)/10. > 2.8:
	1658	pass # repaint crashes wxpython 2.9
	1659	wx.CallLater(100, MakeParameterWindow)
	1660	#wx.CallAfter(MakeParameterWindow)
	1661	else:
	1662	wx.CallAfter(MakeParameterWindow)
	1663
	1664	def MakeParameterWindow():
	1665	'Displays the Instrument parameters in the datadisplay frame'
	1666	if G2frame.dataDisplay:
	1667	G2frame.dataFrame.Clear()
	1668	G2frame.dataFrame.SetLabel('Instrument Parameters')
	1669	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
	1670	mainSizer = wx.BoxSizer(wx.VERTICAL)
	1671	instSizer = wx.FlexGridSizer(0,6,5,5)
	1672	subSizer = wx.BoxSizer(wx.HORIZONTAL)
[2514]	1673	if insVal['Bank'] == None: #patch
	1674	insVal['Bank'] = 1
[2050]	1675	text = ' Histogram Type: %s Bank: %d'%(insVal['Type'],insVal['Bank'])
	1676	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,text),0,WACV)
[1404]	1677	mainSizer.Add(subSizer)
	1678	labelLst[:],elemKeysLst[:],dspLst[:],refFlgElem[:] = [],[],[],[]
	1679	if 'P' in insVal['Type']: #powder data
	1680	if 'C' in insVal['Type']: #constant wavelength
	1681	labelLst.append('Azimuth angle')
	1682	elemKeysLst.append(['Azimuth',1])
	1683	dspLst.append([10,2])
	1684	refFlgElem.append(None)
	1685	if 'Lam1' in insVal:
	1686	subSizer = wx.BoxSizer(wx.HORIZONTAL)
	1687	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
	1688	txt = '%7.2f'%(insVal['Azimuth'])
	1689	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1690	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Ka1/Ka2: '),0,WACV)
	1691	txt = u' %8.6f/%8.6f\xc5'%(insVal['Lam1'],insVal['Lam2'])
	1692	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1693	waveSizer = wx.BoxSizer(wx.HORIZONTAL)
	1694	waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Source type: '),0,WACV)
	1695	# PATCH?: for now at least, Source is not saved anywhere before here
	1696	if 'Source' not in data: data['Source'] = ['CuKa','?']
	1697	choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
[1782]	1698	lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
[1404]	1699	lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
	1700	waveSizer.Add(lamPick,0)
	1701	subSizer.Add(waveSizer,0)
	1702	mainSizer.Add(subSizer)
	1703	instSizer.Add(wx.StaticText(
	1704	G2frame.dataDisplay,-1,
	1705	lblWdef('I(L2)/I(L1)',4,insDef['I(L2)/I(L1)'])),
	1706	0,WACV)
	1707	key = 'I(L2)/I(L1)'
	1708	labelLst.append(key)
	1709	elemKeysLst.append([key,1])
	1710	dspLst.append([10,4])
	1711	refFlgElem.append([key,2])
[1619]	1712	ratVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
[1404]	1713	instSizer.Add(ratVal,0)
	1714	instSizer.Add(RefineBox(key),0,WACV)
	1715	instSizer.Add((5,5),0)
	1716	instSizer.Add((5,5),0)
	1717	instSizer.Add((5,5),0)
	1718	else: # single wavelength
	1719	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
	1720	txt = '%7.2f'%(insVal['Azimuth'])
	1721	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1722	instSizer.Add((5,5),0)
	1723	key = 'Lam'
	1724	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
	1725	0,WACV)
[1619]	1726	waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
[1404]	1727	labelLst.append(u'Lam (\xc5)')
	1728	elemKeysLst.append([key,1])
	1729	dspLst.append([10,6])
	1730	instSizer.Add(waveVal,0,WACV)
[1443]	1731	refFlgElem.append([key,2])
	1732	instSizer.Add(RefineBox(key),0,WACV)
	1733	# if ifHisto:
	1734	# refFlgElem.append([key,2])
	1735	# instSizer.Add(RefineBox(key),0,WACV)
	1736	# else:
	1737	# refFlgElem.append(None)
	1738	# instSizer.Add((5,5),0)
[1404]	1739	for item in ['Zero','Polariz.']:
	1740	if item in insDef:
	1741	labelLst.append(item)
	1742	elemKeysLst.append([item,1])
	1743	dspLst.append([10,4])
	1744	instSizer.Add(
	1745	wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
	1746	0,WACV)
[1619]	1747	itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
[1404]	1748	instSizer.Add(itemVal,0,WACV)
[1443]	1749	refFlgElem.append([item,2])
	1750	instSizer.Add(RefineBox(item),0,WACV)
	1751	# if ifHisto:
	1752	# refFlgElem.append([item,2])
	1753	# instSizer.Add(RefineBox(item),0,WACV)
	1754	# else:
	1755	# refFlgElem.append(None)
	1756	# instSizer.Add((5,5),0)
[1404]	1757	else: #skip Polariz. for neutrons
	1758	instSizer.Add((5,5),0)
	1759	instSizer.Add((5,5),0)
	1760	instSizer.Add((5,5),0)
	1761	for item in ['U','V','W','','X','Y','SH/L']:
	1762	if item == '':
	1763	instSizer.Add((5,5),0)
	1764	instSizer.Add((5,5),0)
	1765	instSizer.Add((5,5),0)
	1766	continue
	1767	nDig = (10,3)
	1768	if item == 'SH/L':
	1769	nDig = (10,5)
	1770	labelLst.append(item)
	1771	elemKeysLst.append([item,1])
	1772	dspLst.append(nDig)
	1773	refFlgElem.append([item,2])
	1774	instSizer.Add(
	1775	wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
	1776	0,WACV)
[1619]	1777	itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
[1404]	1778	instSizer.Add(itemVal,0,WACV)
	1779	instSizer.Add(RefineBox(item),0,WACV)
[1820]	1780	elif 'T' in insVal['Type']: #time of flight (neutrons)
[1404]	1781	subSizer = wx.BoxSizer(wx.HORIZONTAL)
[1459]	1782	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Fligth path: '),0,WACV)
	1783	txt = '%8.3f'%(insVal['fltPath'])
	1784	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1785	labelLst.append('flight path')
	1786	elemKeysLst.append(['fltpath',1])
	1787	dspLst.append([10,2])
	1788	refFlgElem.append(None)
[1404]	1789	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' 2-theta: '),0,WACV)
	1790	txt = '%7.2f'%(insVal['2-theta'])
	1791	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1792	labelLst.append('2-theta')
	1793	elemKeysLst.append(['2-theta',1])
	1794	dspLst.append([10,2])
	1795	refFlgElem.append(None)
	1796	if 'Pdabc' in Inst2:
[1462]	1797	Items = ['sig-0','sig-1','sig-2','sig-q','X','Y']
[1404]	1798	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' difC: '),0,WACV)
	1799	txt = '%8.2f'%(insVal['difC'])
	1800	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
	1801	labelLst.append('difC')
	1802	elemKeysLst.append(['difC',1])
	1803	dspLst.append([10,2])
	1804	refFlgElem.append(None)
	1805	subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' alpha, beta: fixed by table'),0,WACV)
	1806	else:
[1462]	1807	Items = ['difC','difA','difB','Zero','alpha','beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q','X','Y']
[1459]	1808	mainSizer.Add((5,5),0)
[1404]	1809	mainSizer.Add(subSizer)
[1459]	1810	mainSizer.Add((5,5),0)
[1404]	1811	for item in Items:
[1459]	1812	if item == '':
	1813	instSizer.Add((5,5),0)
	1814	instSizer.Add((5,5),0)
	1815	instSizer.Add((5,5),0)
	1816	continue
[1404]	1817	nDig = (10,3)
	1818	if 'beta' in item:
[1759]	1819	nDig = (12,6)
[1404]	1820	instSizer.Add(
	1821	wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
	1822	0,WACV)
[1619]	1823	itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
[1404]	1824	instSizer.Add(itemVal,0,WACV)
	1825	labelLst.append(item)
	1826	elemKeysLst.append([item,1])
	1827	dspLst.append(nDig)
[1443]	1828	refFlgElem.append([item,2])
	1829	instSizer.Add(RefineBox(item),0,WACV)
[1820]	1830	elif 'PKS' in insVal['Type']: #peak positions only
	1831	key = 'Lam'
	1832	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
	1833	0,WACV)
	1834	waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
	1835	labelLst.append(u'Lam (\xc5)')
	1836	elemKeysLst.append([key,1])
	1837	dspLst.append([10,6])
	1838	instSizer.Add(waveVal,0,WACV)
	1839	refFlgElem.append([key,2])
	1840	# instSizer.Add(RefineBox(key),0,WACV)
	1841	for item in ['Zero',]:
	1842	if item in insDef:
	1843	labelLst.append(item)
	1844	elemKeysLst.append([item,1])
	1845	dspLst.append([10,4])
	1846	instSizer.Add(
	1847	wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
	1848	0,WACV)
	1849	itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
	1850	instSizer.Add(itemVal,0,WACV)
	1851	refFlgElem.append([item,2])
	1852	# instSizer.Add(RefineBox(item),0,WACV)
	1853
	1854
[1404]	1855	elif 'S' in insVal['Type']: #single crystal data
	1856	if 'C' in insVal['Type']: #constant wavelength
	1857	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
	1858	0,WACV)
[1619]	1859	waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
[1404]	1860	instSizer.Add(waveVal,0,WACV)
	1861	labelLst.append(u'Lam (\xc5)')
[1880]	1862	waveSizer = wx.BoxSizer(wx.HORIZONTAL)
	1863	waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Source type: '),0,WACV)
	1864	# PATCH?: for now at least, Source is not saved anywhere before here
	1865	if 'Source' not in data: data['Source'] = ['CuKa','?']
	1866	choice = ['synchrotron','TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
	1867	lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	1868	lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
	1869	waveSizer.Add(lamPick,0,WACV)
	1870	instSizer.Add(waveSizer,0,WACV)
[1404]	1871	elemKeysLst.append(['Lam',1])
	1872	dspLst.append([10,6])
	1873	refFlgElem.append(None)
	1874	else: #time of flight (neutrons)
	1875	pass #for now
	1876	elif 'L' in insVal['Type']:
	1877	if 'C' in insVal['Type']:
	1878	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
	1879	0,WACV)
[1619]	1880	waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
[1404]	1881	instSizer.Add(waveVal,0,WACV)
	1882	labelLst.append(u'Lam (\xc5)')
	1883	elemKeysLst.append(['Lam',1])
	1884	dspLst.append([10,6])
	1885	refFlgElem.append(None)
	1886	instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
	1887	labelLst.append('Azimuth angle')
	1888	elemKeysLst.append(['Azimuth',1])
	1889	dspLst.append([10,2])
	1890	refFlgElem.append(None)
	1891	else: #time of flight (neutrons)
	1892	pass #for now
	1893
	1894	mainSizer.Add(instSizer,0)
	1895	mainSizer.Layout()
	1896	G2frame.dataDisplay.SetSizer(mainSizer)
	1897	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
	1898	G2frame.dataFrame.SendSizeEvent() # this causes a frame repaint, even if the size does not change!
	1899	# end of MakeParameterWindow
[904]	1900
[1404]	1901	# beginning of UpdateInstrumentGrid code
[1406]	1902	#patch: make sure all parameter items are lists
	1903	patched = 0
	1904	for key in data:
	1905	if type(data[key]) is tuple:
	1906	data[key] = list(data[key])
	1907	patched += 1
	1908	if patched: print patched,' instrument parameters changed from tuples'
	1909	#end of patch
[1404]	1910	labelLst,elemKeysLst,dspLst,refFlgElem = [],[],[],[]
	1911	instkeys = keycheck(data.keys())
	1912	if 'P' in data['Type'][0]: #powder data
	1913	insVal = dict(zip(instkeys,[data[key][1] for key in instkeys]))
	1914	insDef = dict(zip(instkeys,[data[key][0] for key in instkeys]))
	1915	insRef = dict(zip(instkeys,[data[key][2] for key in instkeys]))
	1916	if 'NC' in data['Type'][0]:
	1917	del(insDef['Polariz.'])
	1918	del(insVal['Polariz.'])
	1919	del(insRef['Polariz.'])
	1920	elif 'S' in data['Type'][0]: #single crystal data
	1921	insVal = dict(zip(instkeys,[data[key][1] for key in instkeys]))
	1922	insDef = dict(zip(instkeys,[data[key][0] for key in instkeys]))
	1923	insRef = {}
	1924	elif 'L' in data['Type'][0]: #low angle data
	1925	insVal = dict(zip(instkeys,[data[key][1] for key in instkeys]))
	1926	insDef = dict(zip(instkeys,[data[key][0] for key in instkeys]))
	1927	insRef = {}
	1928	RefObj = {}
	1929	waves = {'CuKa':[1.54051,1.54433],'TiKa':[2.74841,2.75207],'CrKa':[2.28962,2.29351],
	1930	'FeKa':[1.93597,1.93991],'CoKa':[1.78892,1.79278],'MoKa':[0.70926,0.713543],
	1931	'AgKa':[0.559363,0.563775]}
[1880]	1932	meanwaves = {'CuKa':1.5418,'TiKa':2.7496,'CrKa':2.2909,'FeKa':1.9373,
	1933	'CoKa':1.7902,'MoKa':0.7107,'AgKa':0.5608}
[1404]	1934	Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
	1935	G2frame.PatternId,'Instrument Parameters'))[1]
[904]	1936	G2gd.SetDataMenuBar(G2frame)
[1404]	1937	#patch
[904]	1938	if 'P' in insVal['Type']: #powder data
[1404]	1939	if 'C' in insVal['Type']: #constant wavelength
	1940	if 'Azimuth' not in insVal:
	1941	insVal['Azimuth'] = 0.0
	1942	insDef['Azimuth'] = 0.0
	1943	insRef['Azimuth'] = False
[1462]	1944	# if 'T' in insVal['Type']:
	1945	# if 'difB' not in insVal:
	1946	# insVal['difB'] = 0.0
	1947	# insDef['difB'] = 0.0
	1948	# insRef['difB'] = False
[1404]	1949	#end of patch
	1950	if 'P' in insVal['Type']: #powder data menu commands
[904]	1951	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.InstMenu)
	1952	if not G2frame.dataFrame.GetStatusBar():
[1443]	1953	Status = G2frame.dataFrame.CreateStatusBar()
[1834]	1954	Status.SetStatusText('NB: Azimuth is used for polarization only')
[1443]	1955	G2frame.Bind(wx.EVT_MENU,OnCalibrate,id=G2gd.wxID_INSTCALIB)
[904]	1956	G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
	1957	G2frame.Bind(wx.EVT_MENU,OnSave,id=G2gd.wxID_INSTSAVE)
[2147]	1958	G2frame.Bind(wx.EVT_MENU,OnSaveAll,id=G2gd.wxID_INSTSAVEALL)
[904]	1959	G2frame.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
	1960	G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
	1961	G2frame.Bind(wx.EVT_MENU,OnInstFlagCopy,id=G2gd.wxID_INSTFLAGCOPY)
[1404]	1962	#G2frame.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)
	1963	G2frame.Bind(wx.EVT_MENU,OnCopy1Val,id=G2gd.wxID_INST1VAL)
[1571]	1964	elif 'L' in insVal['Type']: #SASD data menu commands
[2147]	1965	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SASDInstMenu)
[1571]	1966	if not G2frame.dataFrame.GetStatusBar():
[1834]	1967	Status = G2frame.dataFrame.CreateStatusBar()
[1571]	1968	G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
[1404]	1969	MakeParameterWindow()
[904]	1970
	1971
	1972	################################################################################
	1973	##### Sample parameters
	1974	################################################################################
	1975
	1976	def UpdateSampleGrid(G2frame,data):
[1199]	1977	'''respond to selection of PWDR/SASD Sample Parameters
[923]	1978	data tree item.
	1979	'''
[1265]	1980
[904]	1981	def OnSampleSave(event):
	1982	'''Respond to the Sample Parameters Operations/Save menu
	1983	item: writes current parameters to a .samprm file
	1984	'''
[2109]	1985	pth = G2G.GetExportPath(G2frame)
	1986	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', pth, '',
	1987	'sample parameter files (.samprm)\|.samprm',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
[904]	1988	try:
	1989	if dlg.ShowModal() == wx.ID_OK:
	1990	filename = dlg.GetPath()
	1991	# make sure extension is .samprm
	1992	filename = os.path.splitext(filename)[0]+'.samprm'
	1993	File = open(filename,'w')
[938]	1994	File.write("#GSAS-II sample parameter file\n")
[904]	1995	File.write("'Type':'"+str(data['Type'])+"'\n")
	1996	File.write("'Gonio. radius':"+str(data['Gonio. radius'])+"\n")
[938]	1997	if data.get('InstrName'):
	1998	File.write("'InstrName':'"+str(data['InstrName'])+"'\n")
[904]	1999	File.close()
	2000	finally:
	2001	dlg.Destroy()
[1248]	2002
[904]	2003	def OnSampleLoad(event):
	2004	'''Loads sample parameters from a G2 .samprm file
	2005	in response to the Sample Parameters-Operations/Load menu
	2006
	2007	Note that similar code is found in ReadPowderInstprm (GSASII.py)
	2008	'''
[2109]	2009	pth = G2G.GetImportPath(G2frame)
	2010	if not pth: pth = '.'
	2011	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', pth, '',
	2012	'sample parameter files (.samprm)\|.samprm',wx.OPEN)
[904]	2013	try:
	2014	if dlg.ShowModal() == wx.ID_OK:
	2015	filename = dlg.GetPath()
	2016	File = open(filename,'r')
	2017	S = File.readline()
	2018	newItems = {}
	2019	while S:
	2020	if S[0] == '#':
	2021	S = File.readline()
	2022	continue
	2023	[item,val] = S[:-1].split(':')
	2024	newItems[item.strip("'")] = eval(val)
	2025	S = File.readline()
	2026	File.close()
	2027	data.update(newItems)
	2028	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Sample Parameters'),data)
	2029	UpdateSampleGrid(G2frame,data)
	2030	finally:
	2031	dlg.Destroy()
[1515]	2032
	2033	def OnAllSampleLoad(event):
	2034	filename = ''
[2109]	2035	pth = G2G.GetImportPath(G2frame)
	2036	if not pth: pth = '.'
	2037	dlg = wx.FileDialog(G2frame, 'Choose multihistogram metadata text file', pth, '',
	2038	'metadata file (.)\|.',wx.OPEN)
[1515]	2039	try:
	2040	if dlg.ShowModal() == wx.ID_OK:
	2041	filename = dlg.GetPath()
	2042	File = open(filename,'r')
	2043	S = File.readline()
	2044	newItems = []
	2045	itemNames = []
	2046	Comments = []
	2047	while S:
	2048	if S[0] == '#':
	2049	Comments.append(S)
	2050	S = File.readline()
	2051	continue
[1518]	2052	S = S.replace(',',' ').replace('\t',' ')
	2053	Stuff = S[:-1].split()
[1515]	2054	itemNames.append(Stuff[0])
	2055	newItems.append(Stuff[1:])
	2056	S = File.readline()
	2057	File.close()
	2058	finally:
	2059	dlg.Destroy()
	2060	if not filename:
	2061	G2frame.ErrorDialog('Nothing to do','No file selected')
	2062	return
	2063	dataDict = dict(zip(itemNames,newItems))
	2064	ifany = False
	2065	Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
	2066	Names = [' ','Phi','Chi','Omega','Time','Temperature','Pressure']
	2067	freeNames = {}
	2068	for name in ['FreePrm1','FreePrm2','FreePrm3']:
	2069	freeNames[Controls[name]] = name
	2070	Names.append(Controls[name])
[1831]	2071	dlg = G2G.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
[1515]	2072	'Select columns',Comments,Names,np.array(newItems).T)
	2073	try:
	2074	if dlg.ShowModal() == wx.ID_OK:
	2075	colNames,newData = dlg.GetSelection()
	2076	dataDict = dict(zip(itemNames,newData.T))
	2077	for item in colNames:
	2078	if item != ' ':
	2079	ifany = True
	2080	finally:
	2081	dlg.Destroy()
	2082	if not ifany:
	2083	G2frame.ErrorDialog('Nothing to do','No columns identified')
	2084	return
	2085	histList = [G2frame.PatternTree.GetItemText(G2frame.PatternId),]
	2086	histList += GetHistsLikeSelected(G2frame)
	2087	colIds = {}
	2088	for i,name in enumerate(colNames):
	2089	if name != ' ':
	2090	colIds[name] = i
	2091	for hist in histList:
	2092	name = hist.split()[1] #this is file name
	2093	newItems = {}
	2094	for item in colIds:
	2095	key = freeNames.get(item,item)
	2096	newItems[key] = float(dataDict[name][colIds[item]])
	2097	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
	2098	sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
	2099	sampleData.update(newItems)
	2100	UpdateSampleGrid(G2frame,data)
[904]	2101
[1248]	2102	def OnSetScale(event):
	2103	histList = []
	2104	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
	2105	while item:
	2106	name = G2frame.PatternTree.GetItemText(item)
	2107	if 'SASD' in name and name != histName:
	2108	histList.append(name)
	2109	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
	2110	if not len(histList): #nothing to copy to!
	2111	return
	2112	dlg = wx.SingleChoiceDialog(G2frame,'Select reference histogram for scaling',
	2113	'Reference histogram',histList)
	2114	try:
	2115	if dlg.ShowModal() == wx.ID_OK:
	2116	sel = dlg.GetSelection()
	2117	refHist = histList[sel]
	2118	finally:
	2119	dlg.Destroy()
	2120	Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
	2121	Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
	2122	Data = [Profile,Limits,data]
	2123	refId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,refHist)
	2124	refSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Sample Parameters'))
	2125	refLimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Limits'))
	2126	refProfile = G2frame.PatternTree.GetItemPyData(refId)[1]
	2127	refData = [refProfile,refLimits,refSample]
	2128	G2sasd.SetScale(Data,refData)
[1349]	2129	G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=True)
[1248]	2130	UpdateSampleGrid(G2frame,data)
	2131
[904]	2132	def OnSampleCopy(event):
[1265]	2133	histType,copyNames = SetCopyNames(histName,data['Type'],
[1213]	2134	addNames = ['Omega','Chi','Phi','Gonio. radius','InstrName'])
[904]	2135	copyDict = {}
	2136	for parm in copyNames:
	2137	copyDict[parm] = data[parm]
[1265]	2138	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	2139	histList = GetHistsLikeSelected(G2frame)
	2140	if not histList:
	2141	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
[904]	2142	return
[1770]	2143	dlg = G2G.G2MultiChoiceDialog(
[1265]	2144	G2frame.dataFrame,
	2145	'Copy sample params from\n'+str(hst[5:])+' to...',
	2146	'Copy sample parameters', histList)
[904]	2147	try:
	2148	if dlg.ShowModal() == wx.ID_OK:
	2149	result = dlg.GetSelections()
	2150	for i in result:
[1265]	2151	item = histList[i]
	2152	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	2153	sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
	2154	sampleData.update(copy.deepcopy(copyDict))
[904]	2155	finally:
	2156	dlg.Destroy()
	2157
[1267]	2158	def OnSampleCopySelected(event):
	2159	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	2160	Controls = G2frame.PatternTree.GetItemPyData(
	2161	G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
	2162	histList = GetHistsLikeSelected(G2frame)
	2163	if not histList:
	2164	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	2165	return
	2166	# Assemble a list of item labels
	2167	TextTable = {key:label for key,label,dig in
[1459]	2168	SetupSampleLabels(hst,data.get('Type'),Inst['Type'][0])
[1267]	2169	}
	2170	# get flexible labels
	2171	TextTable.update({
	2172	key:Controls[key] for key in Controls if key.startswith('FreePrm')
	2173	})
	2174	# add a few extra
	2175	TextTable.update({
	2176	'Type':'Diffractometer type',
	2177	'InstrName':'Instrument Name',
	2178	})
	2179	# Assemble a list of dict entries that would be labeled in the Sample
	2180	# params data window (drop ranId and items not used).
	2181	keyList = [i for i in data.keys() if i in TextTable]
	2182	keyText = [TextTable[i] for i in keyList]
	2183	# sort both lists together, ordered by keyText
	2184	keyText, keyList = zip(*sorted(zip(keyText,keyList))) # sort lists
	2185	selectedKeys = []
[1770]	2186	dlg = G2G.G2MultiChoiceDialog(
[1267]	2187	G2frame.dataFrame,
	2188	'Select which sample parameters\nto copy',
	2189	'Select sample parameters', keyText)
	2190	try:
	2191	if dlg.ShowModal() == wx.ID_OK:
	2192	selectedKeys = [keyList[i] for i in dlg.GetSelections()]
	2193	finally:
	2194	dlg.Destroy()
	2195	if not selectedKeys: return # nothing to copy
	2196	copyDict = {}
	2197	for parm in selectedKeys:
	2198	copyDict[parm] = data[parm]
[1770]	2199	dlg = G2G.G2MultiChoiceDialog(
[1267]	2200	G2frame.dataFrame,
	2201	'Copy sample params from\n'+str(hst[5:])+' to...',
	2202	'Copy sample parameters', histList)
	2203	try:
	2204	if dlg.ShowModal() == wx.ID_OK:
	2205	result = dlg.GetSelections()
	2206	for i in result:
	2207	item = histList[i]
	2208	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	2209	sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
	2210	sampleData.update(copy.deepcopy(copyDict))
	2211	finally:
[1349]	2212	dlg.Destroy()
[1804]	2213	G2plt.PlotPatterns(G2frame,plotType=hst[:4],newPlot=False)
[1267]	2214
[904]	2215	def OnSampleFlagCopy(event):
[1265]	2216	histType,copyNames = SetCopyNames(histName,data['Type'])
[904]	2217	flagDict = {}
	2218	for parm in copyNames:
	2219	flagDict[parm] = data[parm][1]
[1265]	2220	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	2221	histList = GetHistsLikeSelected(G2frame)
	2222	if not histList:
	2223	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
[904]	2224	return
[1770]	2225	dlg = G2G.G2MultiChoiceDialog(
[1265]	2226	G2frame.dataFrame,
	2227	'Copy sample ref. flags from\n'+str(hst[5:])+' to...',
	2228	'Copy sample flags', histList)
[904]	2229	try:
	2230	if dlg.ShowModal() == wx.ID_OK:
	2231	result = dlg.GetSelections()
	2232	for i in result:
[1265]	2233	item = histList[i]
	2234	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	2235	sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
	2236	for name in copyNames:
	2237	sampleData[name][1] = copy.copy(flagDict[name])
[904]	2238	finally:
	2239	dlg.Destroy()
	2240
[1512]	2241	def OnHistoChange():
	2242	'''Called when the histogram type is changed to refresh the window
	2243	'''
[1959]	2244	#wx.CallAfter(UpdateSampleGrid,G2frame,data)
	2245	wx.CallLater(100,UpdateSampleGrid,G2frame,data)
[904]	2246
[938]	2247	def SetNameVal():
	2248	inst = instNameVal.GetValue()
	2249	data['InstrName'] = inst.strip()
[1021]	2250
[938]	2251	def OnNameVal(event):
	2252	event.Skip()
[1201]	2253	wx.CallAfter(SetNameVal)
	2254
	2255	def AfterChange(invalid,value,tc):
	2256	if invalid:
	2257	return
[1219]	2258	if tc.key == 0 and 'SASD' in histName: #a kluge for Scale!
[1201]	2259	G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=True)
[1219]	2260	elif tc.key == 'Thick':
	2261	wx.CallAfter(UpdateSampleGrid,G2frame,data)
[1217]	2262
	2263	def OnMaterial(event):
[2431]	2264	event.Skip()
[1217]	2265	Obj = event.GetEventObject()
	2266	id,key = Info[Obj.GetId()]
	2267	if key == 'Name':
	2268	data['Materials'][id][key] = Obj.GetValue()
	2269	elif key == 'VolFrac':
	2270	try:
	2271	value = min(max(0.,float(Obj.GetValue())),1.)
	2272	except ValueError:
	2273	value = data['Materials'][id][key]
	2274	data['Materials'][id][key] = value
	2275	data['Materials'][not id][key] = 1.-value
	2276	wx.CallAfter(UpdateSampleGrid,G2frame,data)
[1143]	2277
[1404]	2278	def OnCopy1Val(event):
	2279	'Select one value to copy to many histograms and optionally allow values to be edited in a table'
[1619]	2280	G2G.SelectEdit1Var(G2frame,data,labelLst,elemKeysLst,dspLst,refFlgElem)
[1404]	2281	wx.CallAfter(UpdateSampleGrid,G2frame,data)
	2282
[1143]	2283	######## DEBUG #######################################################
	2284	#import GSASIIpwdGUI
	2285	#reload(GSASIIpwdGUI)
	2286	#reload(G2gd)
	2287	######################################################################
[1459]	2288	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
	2289	G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
[1199]	2290	histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
[1143]	2291	if G2frame.dataDisplay:
	2292	G2frame.dataFrame.Clear()
	2293	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SampleMenu)
	2294	G2frame.dataFrame.SetLabel('Sample Parameters')
[1248]	2295	G2frame.Bind(wx.EVT_MENU, OnSetScale, id=G2gd.wxID_SETSCALE)
[1143]	2296	G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
[1267]	2297	G2frame.Bind(wx.EVT_MENU, OnSampleCopySelected, id=G2gd.wxID_SAMPLECOPYSOME)
[1143]	2298	G2frame.Bind(wx.EVT_MENU, OnSampleFlagCopy, id=G2gd.wxID_SAMPLEFLAGCOPY)
	2299	G2frame.Bind(wx.EVT_MENU, OnSampleSave, id=G2gd.wxID_SAMPLESAVE)
	2300	G2frame.Bind(wx.EVT_MENU, OnSampleLoad, id=G2gd.wxID_SAMPLELOAD)
[1404]	2301	G2frame.Bind(wx.EVT_MENU, OnCopy1Val, id=G2gd.wxID_SAMPLE1VAL)
[1515]	2302	G2frame.Bind(wx.EVT_MENU, OnAllSampleLoad, id=G2gd.wxID_ALLSAMPLELOAD)
[1248]	2303	if 'SASD' in histName:
	2304	G2frame.dataFrame.SetScale.Enable(True)
[1143]	2305	if not G2frame.dataFrame.GetStatusBar():
[2546]	2306	G2frame.dataFrame.CreateStatusBar()
[1143]	2307	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
	2308	Controls = G2frame.PatternTree.GetItemPyData(
	2309	G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
	2310	#patch
	2311	if 'ranId' not in data:
	2312	data['ranId'] = ran.randint(0,sys.maxint)
	2313	if not 'Gonio. radius' in data:
	2314	data['Gonio. radius'] = 200.0
	2315	if not 'Omega' in data:
	2316	data.update({'Omega':0.0,'Chi':0.0,'Phi':0.0})
[1783]	2317	if 'Azimuth' not in data:
	2318	data['Azimuth'] = 0.0
[1143]	2319	if type(data['Temperature']) is int:
	2320	data['Temperature'] = float(data['Temperature'])
[1515]	2321	if 'Time' not in data:
	2322	data['Time'] = 0.0
[1143]	2323	if 'FreePrm1' not in Controls:
	2324	Controls['FreePrm1'] = 'Sample humidity (%)'
	2325	if 'FreePrm2' not in Controls:
	2326	Controls['FreePrm2'] = 'Sample voltage (V)'
	2327	if 'FreePrm3' not in Controls:
	2328	Controls['FreePrm3'] = 'Applied load (MN)'
	2329	if 'FreePrm1' not in data:
	2330	data['FreePrm1'] = 0.
	2331	if 'FreePrm2' not in data:
	2332	data['FreePrm2'] = 0.
	2333	if 'FreePrm3' not in data:
	2334	data['FreePrm3'] = 0.
[1199]	2335	if 'SurfRoughA' not in data and 'PWDR' in histName:
[1175]	2336	data['SurfRoughA'] = [0.,False]
	2337	data['SurfRoughB'] = [0.,False]
[1219]	2338	if 'Trans' not in data and 'SASD' in histName:
	2339	data['Trans'] = 1.0
[1323]	2340	if 'SlitLen' not in data and 'SASD' in histName:
	2341	data['SlitLen'] = 0.0
[1512]	2342	if 'Shift' not in data:
	2343	data['Shift'] = [0.0,False]
	2344	if 'Transparency' not in data:
	2345	data['Transparency'] = [0.0,False]
[1404]	2346	data['InstrName'] = data.get('InstrName','')
[1143]	2347	#patch end
[1404]	2348	labelLst,elemKeysLst,dspLst,refFlgElem = [],[],[],[]
[1459]	2349	parms = SetupSampleLabels(histName,data.get('Type'),Inst['Type'][0])
[904]	2350	mainSizer = wx.BoxSizer(wx.VERTICAL)
[938]	2351	topSizer = wx.BoxSizer(wx.HORIZONTAL)
	2352	topSizer.Add((-1,-1),1,wx.EXPAND,1)
[1143]	2353	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Sample and Experimental Parameters'))
[938]	2354	topSizer.Add((-1,-1),1,wx.EXPAND,1)
	2355	mainSizer.Add(topSizer,0,wx.EXPAND,1)
	2356	nameSizer = wx.BoxSizer(wx.HORIZONTAL)
[1143]	2357	nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Instrument Name'),
[1233]	2358	0,WACV)
[938]	2359	nameSizer.Add((-1,-1),1,wx.EXPAND,1)
[1404]	2360	instNameVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,data['InstrName'],
[938]	2361	size=(200,-1),style=wx.TE_PROCESS_ENTER)
	2362	nameSizer.Add(instNameVal)
	2363	instNameVal.Bind(wx.EVT_CHAR,OnNameVal)
	2364	mainSizer.Add(nameSizer,0,wx.EXPAND,1)
[1143]	2365	mainSizer.Add((5,5),0)
[1404]	2366	labelLst.append('Instrument Name')
	2367	elemKeysLst.append(['InstrName'])
	2368	dspLst.append(None)
	2369	refFlgElem.append(None)
[938]	2370
[1199]	2371	if 'PWDR' in histName:
	2372	nameSizer = wx.BoxSizer(wx.HORIZONTAL)
	2373	nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Diffractometer type: '),
[1233]	2374	0,WACV)
[1459]	2375	if 'T' in Inst['Type'][0]:
	2376	choices = ['Debye-Scherrer',]
	2377	else:
	2378	choices = ['Debye-Scherrer','Bragg-Brentano',]
[1831]	2379	histoType = G2G.G2ChoiceButton(G2frame.dataDisplay,choices,
[1512]	2380	strLoc=data,strKey='Type',
	2381	onChoice=OnHistoChange)
[1199]	2382	nameSizer.Add(histoType)
	2383	mainSizer.Add(nameSizer,0,wx.EXPAND,1)
	2384	mainSizer.Add((5,5),0)
[1143]	2385
[1378]	2386	parmSizer = wx.FlexGridSizer(0,2,5,0)
[1177]	2387	for key,lbl,nDig in parms:
[1404]	2388	labelLst.append(lbl.strip().strip(':').strip())
	2389	dspLst.append(nDig)
[1143]	2390	if 'list' in str(type(data[key])):
[1619]	2391	parmRef = G2G.G2CheckBox(G2frame.dataDisplay,' '+lbl,data[key],1)
[1233]	2392	parmSizer.Add(parmRef,0,WACV\|wx.EXPAND)
[1619]	2393	parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[key],0,
[1201]	2394	nDig=nDig,typeHint=float,OnLeave=AfterChange)
[1404]	2395	elemKeysLst.append([key,0])
	2396	refFlgElem.append([key,1])
[904]	2397	else:
[1143]	2398	parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' '+lbl),
[1233]	2399	0,WACV\|wx.EXPAND)
[1619]	2400	parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,
[1219]	2401	typeHint=float,OnLeave=AfterChange)
[1404]	2402	elemKeysLst.append([key])
	2403	refFlgElem.append(None)
[904]	2404	parmSizer.Add(parmVal,1,wx.EXPAND)
[1217]	2405	Info = {}
[1219]	2406
	2407	for key in ('FreePrm1','FreePrm2','FreePrm3'):
[1619]	2408	parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Controls,key,typeHint=str,
[1219]	2409	notBlank=False)
	2410	parmSizer.Add(parmVal,1,wx.EXPAND)
[1619]	2411	parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,typeHint=float)
[1219]	2412	parmSizer.Add(parmVal,1,wx.EXPAND)
[1404]	2413	labelLst.append(Controls[key])
	2414	dspLst.append(None)
	2415	elemKeysLst.append([key])
	2416	refFlgElem.append(None)
	2417
[1219]	2418	mainSizer.Add(parmSizer,1,wx.EXPAND)
	2419	mainSizer.Add((0,5),0)
[1217]	2420	if 'SASD' in histName:
[1219]	2421	rho = [0.,0.]
	2422	anomrho = [0.,0.]
	2423	mu = 0.
[1378]	2424	subSizer = wx.FlexGridSizer(0,4,5,5)
[1217]	2425	Substances = G2frame.PatternTree.GetItemPyData(
	2426	G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
	2427	for id,item in enumerate(data['Materials']):
[1233]	2428	subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
[1217]	2429	matsel = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=Substances['Substances'].keys(),
	2430	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	2431	Info[matsel.GetId()] = [id,'Name']
	2432	matsel.Bind(wx.EVT_COMBOBOX,OnMaterial)
[1233]	2433	subSizer.Add(matsel,0,WACV)
	2434	subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
[2569]	2435	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1217]	2436	volfrac = wx.TextCtrl(G2frame.dataDisplay,value=str('%.3f'%(item['VolFrac'])),style=wx.TE_PROCESS_ENTER)
	2437	Info[volfrac.GetId()] = [id,'VolFrac']
	2438	volfrac.Bind(wx.EVT_TEXT_ENTER,OnMaterial)
	2439	volfrac.Bind(wx.EVT_KILL_FOCUS,OnMaterial)
[1233]	2440	subSizer.Add(volfrac,0,WACV)
[1219]	2441	material = Substances['Substances'][item['Name']]
	2442	mu += item['VolFrac']*material.get('XAbsorption',0.)
	2443	rho[id] = material['Scatt density']
	2444	anomrho[id] = material.get('XAnom density',0.)
	2445	data['Contrast'] = [(rho[1]-rho[0])2,(anomrho[1]-anomrho[0])2]
	2446	mainSizer.Add(subSizer,0)
	2447	conSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	2448	conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
	2449	conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
[1219]	2450	mut = mu*data['Thick']
[1233]	2451	conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Transmission (calc): %10.3f '%(np.exp(-mut))),0,WACV)
[1219]	2452	mainSizer.Add(conSizer,0)
[904]	2453
	2454	mainSizer.Layout()
	2455	G2frame.dataDisplay.SetSizer(mainSizer)
	2456	Size = mainSizer.Fit(G2frame.dataFrame)
	2457	G2frame.dataDisplay.SetSize(Size)
	2458	G2frame.dataFrame.setSizePosLeft(Size)
	2459
	2460	################################################################################
	2461	##### Indexing Peaks
	2462	################################################################################
	2463
	2464	def UpdateIndexPeaksGrid(G2frame, data):
[923]	2465	'''respond to selection of PWDR Index Peak List data
	2466	tree item.
	2467	'''
[1578]	2468	bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
	2469	'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
[904]	2470	IndexId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
	2471	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
[2056]	2472	limitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits')
	2473	Limits = G2frame.PatternTree.GetItemPyData(limitId)
[904]	2474	def RefreshIndexPeaksGrid(event):
	2475	r,c = event.GetRow(),event.GetCol()
[1445]	2476	peaks = G2frame.IndexPeaksTable.GetData()
[904]	2477	if c == 2:
[1445]	2478	if peaks[r][c]:
	2479	peaks[r][c] = False
[904]	2480	else:
[1445]	2481	peaks[r][c] = True
	2482	G2frame.IndexPeaksTable.SetData(peaks)
	2483	G2frame.PatternTree.SetItemPyData(IndexId,[peaks,data[1]])
[904]	2484	G2frame.dataDisplay.ForceRefresh()
[1586]	2485	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	2486	G2plt.PlotPowderLines(G2frame)
	2487	else:
	2488	G2plt.PlotPatterns(G2frame,plotType='PWDR')
[904]	2489
	2490	def OnReload(event):
[1445]	2491	peaks = []
	2492	sigs = []
	2493	Peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
	2494	for ip,peak in enumerate(Peaks['peaks']):
[1367]	2495	dsp = G2lat.Pos2dsp(Inst,peak[0])
[1571]	2496	peaks.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0]) #SS?
[1445]	2497	try:
	2498	sig = Peaks['sigDict']['pos'+str(ip)]
	2499	except KeyError:
	2500	sig = 0.
	2501	sigs.append(sig)
	2502	data = [peaks,sigs]
[904]	2503	G2frame.PatternTree.SetItemPyData(IndexId,data)
	2504	UpdateIndexPeaksGrid(G2frame,data)
	2505
	2506	def KeyEditPickGrid(event):
	2507	colList = G2frame.dataDisplay.GetSelectedCols()
	2508	data = G2frame.PatternTree.GetItemPyData(IndexId)
	2509	if event.GetKeyCode() == wx.WXK_RETURN:
	2510	event.Skip(True)
	2511	elif event.GetKeyCode() == wx.WXK_CONTROL:
	2512	event.Skip(True)
	2513	elif event.GetKeyCode() == wx.WXK_SHIFT:
	2514	event.Skip(True)
	2515	elif colList:
	2516	G2frame.dataDisplay.ClearSelection()
	2517	key = event.GetKeyCode()
	2518	for col in colList:
[1586]	2519	if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use',]:
[904]	2520	if key == 89: #'Y'
[1445]	2521	for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[0][row][col]=True
[904]	2522	elif key == 78: #'N'
[1445]	2523	for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[0][row][col]=False
[2124]	2524	elif key == 83: # 'S'
	2525	for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[0][row][col] = not data[0][row][col]
	2526
[904]	2527
	2528	if G2frame.dataDisplay:
	2529	G2frame.dataFrame.Clear()
	2530	if not G2frame.dataFrame.GetStatusBar():
[2546]	2531	G2frame.dataFrame.CreateStatusBar()
[904]	2532	if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	2533	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndPeaksMenu)
	2534	G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
	2535	G2frame.dataFrame.IndexPeaks.Enable(False)
	2536	G2frame.IndexPeaksTable = []
[1445]	2537	if len(data[0]):
[904]	2538	G2frame.dataFrame.IndexPeaks.Enable(True)
[1578]	2539	Unit = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
	2540	if Unit:
	2541	if len(Unit) == 4: #patch
	2542	Unit.append({})
	2543	controls,bravais,cellist,dmin,ssopt = Unit
[2056]	2544	if 'T' in Inst['Type'][0]: #TOF - use other limit!
	2545	dmin = G2lat.Pos2dsp(Inst,Limits[1][0])
	2546	else:
[2022]	2547	dmin = G2lat.Pos2dsp(Inst,Limits[1][1])
[904]	2548	G2frame.HKL = []
[1578]	2549	if ssopt.get('Use',False):
	2550	cell = controls[6:12]
	2551	A = G2lat.cell2A(cell)
	2552	ibrav = bravaisSymb.index(controls[5])
	2553	spc = controls[13]
	2554	SGData = G2spc.SpcGroup(spc)[1]
[1594]	2555	SSGData = G2spc.SSpcGroup(SGData,ssopt['ssSymb'])[1]
[1578]	2556	Vec = ssopt['ModVec']
	2557	maxH = ssopt['maxH']
	2558	G2frame.HKL = G2pwd.getHKLMpeak(dmin,Inst,SGData,SSGData,Vec,maxH,A)
[1933]	2559	G2frame.HKL = np.array(G2frame.HKL)
[1578]	2560	data[0] = G2indx.IndexSSPeaks(data[0],G2frame.HKL)[1]
	2561	else: #select cell from table - no SS
	2562	for i,cell in enumerate(cellist):
	2563	if cell[-2]:
	2564	ibrav = cell[2]
	2565	A = G2lat.cell2A(cell[3:9])
	2566	G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
	2567	for hkl in G2frame.HKL:
	2568	hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3]))
[1933]	2569	G2frame.HKL = np.array(G2frame.HKL)
[1578]	2570	data[0] = G2indx.IndexPeaks(data[0],G2frame.HKL)[1]
	2571	break
[904]	2572	rowLabels = []
[1445]	2573	for i in range(len(data[0])): rowLabels.append(str(i+1))
[904]	2574	colLabels = ['position','intensity','use','indexed','h','k','l','d-obs','d-calc']
[1571]	2575	Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',]+2*[wg.GRID_VALUE_BOOL,]+ \
	2576	3[wg.GRID_VALUE_LONG,]+2[wg.GRID_VALUE_FLOAT+':10,5',]
[1572]	2577	if len(data[0]) and len(data[0][0]) > 9:
[1571]	2578	colLabels = ['position','intensity','use','indexed','h','k','l','m','d-obs','d-calc']
	2579	Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',]+2*[wg.GRID_VALUE_BOOL,]+ \
	2580	4[wg.GRID_VALUE_LONG,]+2[wg.GRID_VALUE_FLOAT+':10,5',]
[904]	2581	G2frame.PatternTree.SetItemPyData(IndexId,data)
[1831]	2582	G2frame.IndexPeaksTable = G2G.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
[904]	2583	G2frame.dataFrame.SetLabel('Index Peak List')
[1831]	2584	G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
[904]	2585	G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
[1402]	2586	XY = []
[1445]	2587	Sigs = []
[904]	2588	for r in range(G2frame.dataDisplay.GetNumberRows()):
	2589	for c in range(G2frame.dataDisplay.GetNumberCols()):
	2590	if c == 2:
	2591	G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
	2592	else:
	2593	G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
[1445]	2594	if data[0][r][2] and data[0][r][3]:
[1571]	2595	XY.append([data[0][r][-1],data[0][r][0]])
[1445]	2596	try:
	2597	sig = data[1][r]
	2598	except IndexError:
	2599	sig = 0.
	2600	Sigs.append(sig)
[904]	2601	G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
	2602	G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)
	2603	G2frame.dataDisplay.SetMargins(0,0)
	2604	G2frame.dataDisplay.AutoSizeColumns(False)
	2605	G2frame.dataFrame.setSizePosLeft([490,300])
[1443]	2606	if len(XY):
[1445]	2607	XY = np.array(XY)
	2608	G2plt.PlotCalib(G2frame,Inst,XY,Sigs,newPlot=True)
[1537]	2609	G2frame.dataFrame.SendSizeEvent()
[1402]	2610
[904]	2611	################################################################################
	2612	##### Unit cells
	2613	################################################################################
	2614
	2615	def UpdateUnitCellsGrid(G2frame, data):
[923]	2616	'''respond to selection of PWDR Unit Cells data tree item.
	2617	'''
[904]	2618	UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
	2619	SPGlist = G2spc.spglist
[2158]	2620	bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm','P4/mmm',
	2621	'Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
[904]	2622	spaceGroups = ['F m 3 m','I m 3 m','P m 3 m','R 3 m','P 6/m m m','I 4/m m m',
	2623	'P 4/m m m','F m m m','I m m m','C m m m','P m m m','C 2/m','P 2/m','P -1']
	2624	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
[2024]	2625	Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))[1]
[1820]	2626	if 'C' in Inst['Type'][0] or 'PKS' in Inst['Type'][0]:
[1367]	2627	wave = G2mth.getWave(Inst)
[2024]	2628	dmin = G2lat.Pos2dsp(Inst,Limits[1])
[1367]	2629	else:
	2630	difC = Inst['difC'][1]
[2024]	2631	dmin = G2lat.Pos2dsp(Inst,Limits[0])
[904]	2632
	2633	def SetLattice(controls):
	2634	ibrav = bravaisSymb.index(controls[5])
[2158]	2635	if controls[5] in ['Fm3m','Im3m','Pm3m']:
[904]	2636	controls[7] = controls[8] = controls[6]
	2637	controls[9] = controls[10] = controls[11] = 90.
[2186]	2638	elif controls[5] in ['R3m','P6/mmm','I4/mmm','P4/mmm']:
[904]	2639	controls[7] = controls[6]
	2640	controls[9] = controls[10] = controls[11] = 90.
[2158]	2641	if controls[5] in ['R3-H','P6/mmm']:
[904]	2642	controls[11] = 120.
[2186]	2643	elif controls[5] in ['Fmmm','Immm','Cmmm','Pmmm']:
[904]	2644	controls[9] = controls[10] = controls[11] = 90.
[2186]	2645	elif controls[5] in ['C2/m','P2/m']:
[904]	2646	controls[9] = controls[11] = 90. # b unique
	2647	if len(controls) < 13: controls.append(0)
	2648	controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
	2649	return ibrav
	2650
	2651	def OnNcNo(event):
	2652	controls[2] = NcNo.GetValue()
	2653
[1592]	2654	def OnIfX20(event):
[1593]	2655	G2frame.ifX20 = x20.GetValue()
[1592]	2656
[904]	2657	def OnBravais(event):
	2658	Obj = event.GetEventObject()
	2659	bravais[bravList.index(Obj.GetId())] = Obj.GetValue()
[2570]	2660
[904]	2661	def OnZeroVar(event):
	2662	controls[0] = zeroVar.GetValue()
	2663
[1548]	2664	def OnSSopt(event):
[1559]	2665	if controls[5] in ['Fm3m','Im3m','Pm3m']:
	2666	SSopt.SetValue(False)
	2667	G2frame.ErrorDialog('Cubic lattice', 'Superlattice not allowed for a cubic lattice')
	2668	return
[1548]	2669	ssopt['Use'] = SSopt.GetValue()
[1593]	2670	if 'ssSymb' not in ssopt:
	2671	ssopt.update({'ssSymb':'(abg)','ModVec':[0.1,0.1,0.1],'maxH':1})
[1548]	2672	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2673
	2674	def OnSelMG(event):
	2675	ssopt['ssSymb'] = selMG.GetValue()
	2676	Vec = ssopt['ModVec']
	2677	modS = G2spc.splitSSsym(ssopt['ssSymb'])[0]
	2678	ssopt['ModVec'] = G2spc.SSGModCheck(Vec,modS)[0]
[1593]	2679	print ' Selecting: ',controls[13],ssopt['ssSymb'], 'maxH:',ssopt['maxH']
[1549]	2680	OnHklShow(event)
[1548]	2681	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2682
	2683	def OnModVal(event):
[2431]	2684	event.Skip()
[1549]	2685	Obj = event.GetEventObject()
	2686	ObjId = Obj.GetId()
	2687	Id = Indx[ObjId]
	2688	try:
[2111]	2689	value = min(0.98,max(-0.98,float(Obj.GetValue())))
[1549]	2690	except ValueError:
	2691	value = ssopt['ModVec'][Id]
[1571]	2692	Obj.SetValue('%.4f'%(value))
[1549]	2693	ssopt['ModVec'][Id] = value
	2694	OnHklShow(event)
[1548]	2695
	2696	def OnMoveMod(event):
	2697	Obj = event.GetEventObject()
[1549]	2698	ObjId = Obj.GetId()
	2699	Id,valObj = Indx[ObjId]
[2111]	2700	move = Obj.GetValue()*0.01
[1548]	2701	Obj.SetValue(0)
[2111]	2702	value = min(0.98,max(-0.98,float(valObj.GetValue())+move))
[1571]	2703	valObj.SetValue('%.4f'%(value))
[1549]	2704	ssopt['ModVec'][Id] = value
	2705	OnHklShow(event)
[1548]	2706
[1549]	2707	def OnMaxMH(event):
	2708	ssopt['maxH'] = int(maxMH.GetValue())
[1593]	2709	print ' Selecting: ',controls[13],ssopt['ssSymb'], 'maxH:',ssopt['maxH']
[1549]	2710	OnHklShow(event)
	2711
[1581]	2712	def OnFindMV(event):
[1592]	2713	Peaks = np.copy(peaks[0])
[2120]	2714	print ' Trying: ',controls[13],ssopt['ssSymb'], 'maxH:',1
[1593]	2715	dlg = wx.ProgressDialog('Elapsed time','Modulation vector search',
	2716	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
	2717	try:
[2120]	2718	ssopt['ModVec'],result = G2indx.findMV(Peaks,controls,ssopt,Inst,dlg)
	2719	if len(result[0]) == 2:
	2720	G2plt.PlotXYZ(G2frame,result[2],1./result[3],labelX='a',labelY='g',
	2721	newPlot=True,Title='Modulation vector search')
[1593]	2722	finally:
	2723	dlg.Destroy()
[1587]	2724	OnHklShow(event)
	2725	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
[1581]	2726
[904]	2727	def OnBravSel(event):
	2728	brav = bravSel.GetString(bravSel.GetSelection())
	2729	controls[5] = brav
	2730	controls[13] = SPGlist[brav][0]
	2731	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2732
	2733	def OnSpcSel(event):
[1461]	2734	controls[13] = spcSel.GetString(spcSel.GetSelection())
[1595]	2735	G2frame.dataFrame.RefineCell.Enable(True)
[1618]	2736	OnHklShow(event)
[904]	2737
[1461]	2738	def SetCellValue(Obj,ObjId,value):
[2158]	2739	if controls[5] in ['Fm3m','Im3m','Pm3m']:
[904]	2740	controls[6] = controls[7] = controls[8] = value
	2741	controls[9] = controls[10] = controls[11] = 90.0
	2742	Obj.SetValue("%.5f"%(controls[6]))
[2158]	2743	elif controls[5] in ['R3-H','P6/mmm','I4/mmm','P4/mmm']:
[904]	2744	if ObjId == 0:
	2745	controls[6] = controls[7] = value
	2746	Obj.SetValue("%.5f"%(controls[6]))
	2747	else:
	2748	controls[8] = value
	2749	Obj.SetValue("%.5f"%(controls[8]))
	2750	controls[9] = controls[10] = controls[11] = 90.0
[2158]	2751	if controls[5] in ['R3-H','P6/mmm']:
[904]	2752	controls[11] = 120.
[2186]	2753	elif controls[5] in ['Fmmm','Immm','Cmmm','Pmmm']:
[904]	2754	controls[6+ObjId] = value
	2755	Obj.SetValue("%.5f"%(controls[6+ObjId]))
	2756	controls[9] = controls[10] = controls[11] = 90.0
[2186]	2757	elif controls[5] in ['C2/m','P2/m']:
[904]	2758	controls[9] = controls[11] = 90.0
	2759	if ObjId != 3:
	2760	controls[6+ObjId] = value
	2761	Obj.SetValue("%.5f"%(controls[6+ObjId]))
	2762	else:
	2763	controls[10] = value
	2764	Obj.SetValue("%.3f"%(controls[10]))
	2765	else:
	2766	controls[6+ObjId] = value
	2767	if ObjId < 3:
	2768	Obj.SetValue("%.5f"%(controls[6+ObjId]))
	2769	else:
	2770	Obj.SetValue("%.3f"%(controls[6+ObjId]))
	2771	controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
	2772	volVal.SetValue("%.3f"%(controls[12]))
	2773
[1461]	2774	def OnMoveCell(event):
	2775	Obj = event.GetEventObject()
	2776	ObjId = cellList.index(Obj.GetId())
	2777	valObj = valDict[Obj.GetId()]
	2778	if ObjId/2 < 3:
	2779	move = Obj.GetValue()*0.01
	2780	else:
	2781	move = Obj.GetValue()*0.1
	2782	Obj.SetValue(0)
	2783	value = float(valObj.GetValue())+move
	2784	SetCellValue(valObj,ObjId/2,value)
	2785	OnHklShow(event)
	2786
[1840]	2787	def OnExportCells(event):
[2109]	2788	pth = G2G.GetExportPath(G2frame)
	2789	dlg = wx.FileDialog(G2frame, 'Choose Indexing Result csv file', pth, '',
	2790	'indexing result file (.csv)\|.csv',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
[1840]	2791	try:
	2792	if dlg.ShowModal() == wx.ID_OK:
	2793	filename = dlg.GetPath()
	2794	filename = os.path.splitext(filename)[0]+'.csv'
	2795	File = open(filename,'w')
	2796	names = 'M20,X20,Bravais,a,b,c,alpha,beta,gamma,volume\n'
	2797	File.write(names)
[1841]	2798	fmt = '%.2f,%d,%s,%.4f,%.4f,%.4f,%.2f,%.2f,%.2f,%.3f\n'
[1840]	2799	for cell in cells:
	2800	File.write(fmt%(cell[0],cell[1],bravaisSymb[cell[2]], cell[3],cell[4],cell[5], cell[6],cell[7],cell[8],cell[9]))
	2801	File.close()
	2802	finally:
	2803	dlg.Destroy()
	2804
[1461]	2805	def OnCellChange(event):
[2431]	2806	event.Skip()
[1461]	2807	Obj = event.GetEventObject()
	2808	ObjId = cellList.index(Obj.GetId())
	2809	try:
	2810	value = max(1.0,float(Obj.GetValue()))
	2811	except ValueError:
	2812	if ObjId/2 < 3: #bad cell edge - reset
	2813	value = controls[6+ObjId/2]
	2814	else: #bad angle
	2815	value = 90.
	2816	SetCellValue(Obj,ObjId/2,value)
[2186]	2817	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
[1461]	2818
[904]	2819	def OnHklShow(event):
	2820	PatternId = G2frame.PatternId
[1572]	2821	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
[2024]	2822	controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
[904]	2823	cell = controls[6:12]
	2824	A = G2lat.cell2A(cell)
[2158]	2825	# ibrav = bravaisSymb.index(controls[5])
[904]	2826	spc = controls[13]
	2827	SGData = G2spc.SpcGroup(spc)[1]
[1571]	2828	if ssopt.get('Use',False):
[1594]	2829	SSGData = G2spc.SSpcGroup(SGData,ssopt['ssSymb'])[1]
[1571]	2830	Vec = ssopt['ModVec']
	2831	maxH = ssopt['maxH']
[1578]	2832	G2frame.HKL = G2pwd.getHKLMpeak(dmin,Inst,SGData,SSGData,Vec,maxH,A)
	2833	peaks = [G2indx.IndexSSPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #keep esds from peak fit
[1581]	2834	M20,X20 = G2indx.calc_M20SS(peaks[0],G2frame.HKL)
[1571]	2835	else:
[1765]	2836	if len(peaks[0]):
[2024]	2837	# dmin = peaks[0][-1][7]
[1765]	2838	G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
	2839	peaks = [G2indx.IndexPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #keep esds from peak fit
	2840	M20,X20 = G2indx.calc_M20(peaks[0],G2frame.HKL)
	2841	else:
	2842	M20 = X20 = 0.
	2843	G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
[1933]	2844	G2frame.HKL = np.array(G2frame.HKL)
[1765]	2845	if len(G2frame.HKL):
	2846	print ' new M20,X20: %.2f %d fraction found: %.3f'%(M20,X20,float(len(peaks[0]))/len(G2frame.HKL))
[1572]	2847	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'),peaks)
[904]	2848	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	2849	G2plt.PlotPowderLines(G2frame)
	2850	else:
	2851	G2plt.PlotPatterns(G2frame)
	2852
	2853	def OnSortCells(event):
[2024]	2854	controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(UnitCellsId)
[904]	2855	c = event.GetCol()
	2856	if colLabels[c] == 'M20':
	2857	cells = G2indx.sortM20(cells)
[1592]	2858	elif colLabels[c] in ['X20','Bravais','a','b','c','alpha','beta','gamma','Volume']:
	2859	if c == 1:
	2860	c += 1 #X20 before Use
[1587]	2861	cells = G2indx.sortCells(cells,c-1) #an extra column (Use) not in cells
[904]	2862	else:
	2863	return
[1552]	2864	data = [controls,bravais,cells,dmin,ssopt]
[904]	2865	G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
	2866	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2867
	2868	def CopyUnitCell(event):
[2024]	2869	controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(UnitCellsId)
[904]	2870	for Cell in cells:
	2871	if Cell[-2]:
	2872	break
	2873	cell = Cell[2:9]
	2874	controls[4] = 1
	2875	controls[5] = bravaisSymb[cell[0]]
	2876	controls[6:12] = cell[1:8]
	2877	controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
	2878	controls[13] = spaceGroups[bravaisSymb.index(controls[5])]
[1552]	2879	G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin,ssopt])
[904]	2880	G2frame.dataFrame.RefineCell.Enable(True)
	2881	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2882
[1581]	2883	def RefineCell(event):
	2884
[904]	2885	def cellPrint(ibrav,A):
	2886	cell = G2lat.A2cell(A)
	2887	Vol = G2lat.calc_V(A)
[2158]	2888	if ibrav in ['Fm3m','Im3m','Pm3m']:
[1578]	2889	print " %s%10.6f" % ('a =',cell[0])
[2158]	2890	elif ibrav in ['R3-H','P6/mmm','I4/mmm','P4/mmm']:
[1578]	2891	print " %s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],' c =',cell[2],' volume =',Vol)
[2186]	2892	elif ibrav in ['P4/mmm','Fmmm','Immm','Cmmm','Pmmm']:
[1578]	2893	print " %s%10.6f %s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],' volume =',Vol)
[2186]	2894	elif ibrav in ['C2/m','P2/m']:
[1578]	2895	print " %s%10.6f %s%10.6f %s%10.6f %s%8.3f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],'beta =',cell[4],' volume =',Vol)
[904]	2896	else:
[1578]	2897	print " %s%10.6f %s%10.6f %s%10.6f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2])
	2898	print " %s%8.3f %s%8.3f %s%8.3f %s%12.3f" % ('alpha =',cell[3],'beta =',cell[4],'gamma =',cell[5],' volume =',Vol)
	2899
	2900	def vecPrint(Vec):
	2901	print ' %s %10.5f %10.5f %10.5f'%('Modulation vector:',Vec[0],Vec[1],Vec[2])
[904]	2902
	2903	PatternId = G2frame.PatternId
	2904	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
[1592]	2905	if not len(peaks[0]):
[904]	2906	G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
	2907	return
[1578]	2908	print ' Refine cell'
[2024]	2909	controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
[904]	2910	cell = controls[6:12]
	2911	A = G2lat.cell2A(cell)
	2912	ibrav = bravaisSymb.index(controls[5])
	2913	SGData = G2spc.SpcGroup(controls[13])[1]
[2056]	2914	if 'C' in Inst['Type'][0] or 'PKS' in Inst['Type'][0]:
[1578]	2915	if ssopt.get('Use',False):
	2916	vecFlags = [True if x in ssopt['ssSymb'] else False for x in ['a','b','g']]
[1594]	2917	SSGData = G2spc.SSpcGroup(SGData,ssopt['ssSymb'])[1]
[1578]	2918	G2frame.HKL = G2pwd.getHKLMpeak(dmin,Inst,SGData,SSGData,ssopt['ModVec'],ssopt['maxH'],A)
	2919	peaks = [G2indx.IndexSSPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #put peak fit esds back in peaks
	2920	Lhkl,M20,X20,Aref,Vec,Zero = \
	2921	G2indx.refinePeaksZSS(peaks[0],wave,Inst,SGData,SSGData,ssopt['maxH'],ibrav,A,ssopt['ModVec'],vecFlags,controls[1],controls[0])
	2922	else:
[1637]	2923	G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
[1578]	2924	peaks = [G2indx.IndexPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #put peak fit esds back in peaks
	2925	Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks[0],wave,ibrav,A,controls[1],controls[0])
[2158]	2926	else:
[2118]	2927	if ssopt.get('Use',False):
	2928	vecFlags = [True if x in ssopt['ssSymb'] else False for x in ['a','b','g']]
	2929	SSGData = G2spc.SSpcGroup(SGData,ssopt['ssSymb'])[1]
	2930	G2frame.HKL = G2pwd.getHKLMpeak(dmin,Inst,SGData,SSGData,ssopt['ModVec'],ssopt['maxH'],A)
	2931	peaks = [G2indx.IndexSSPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #put peak fit esds back in peaks
	2932	Lhkl,M20,X20,Aref,Vec,Zero = \
	2933	G2indx.refinePeaksTSS(peaks[0],difC,Inst,SGData,SSGData,ssopt['maxH'],ibrav,A,ssopt['ModVec'],vecFlags,controls[1],controls[0])
	2934	else:
	2935	G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
	2936	peaks = [G2indx.IndexPeaks(peaks[0],G2frame.HKL)[1],peaks[1]] #put peak fit esds back in peaks
	2937	Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksT(peaks[0],difC,ibrav,A,controls[1],controls[0])
[1933]	2938	G2frame.HKL = np.array(G2frame.HKL)
[904]	2939	controls[1] = Zero
	2940	controls[6:12] = G2lat.A2cell(Aref)
	2941	controls[12] = G2lat.calc_V(Aref)
	2942	cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
	2943	for cell in cells:
	2944	cell[-2] = False
	2945	cells.insert(0,[M20,X20,ibrav]+controls[6:13]+[True,False])
[1578]	2946	if ssopt.get('Use',False):
	2947	ssopt['ModVec'] = Vec
	2948	G2frame.HKL = G2pwd.getHKLMpeak(dmin,Inst,SGData,SSGData,ssopt['ModVec'],ssopt['maxH'],A)
	2949	else:
[1637]	2950	G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
[1578]	2951	data = [controls,bravais,cells,dmin,ssopt]
[904]	2952	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
[1578]	2953	print " %s%10.3f" % ('refinement M20 = ',M20)
	2954	print ' unindexed lines = ',X20
[2158]	2955	cellPrint(controls[5],Aref)
[1578]	2956	ip = 4
	2957	if ssopt.get('Use',False):
	2958	vecPrint(Vec)
	2959	ip = 5
[904]	2960	for hkl in G2frame.HKL:
[1578]	2961	hkl[ip] = G2lat.Dsp2pos(Inst,hkl[ip-1])+controls[1]
[1933]	2962	G2frame.HKL = np.array(G2frame.HKL)
[904]	2963	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	2964	G2plt.PlotPowderLines(G2frame)
	2965	else:
	2966	G2plt.PlotPatterns(G2frame)
	2967	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
	2968
[2124]	2969	def OnIndexPeaks(event):
[904]	2970	PatternId = G2frame.PatternId
	2971	print 'Peak Indexing'
	2972	keepcells = []
	2973	try:
[2024]	2974	controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
[904]	2975	for cell in cells:
	2976	if cell[11]:
[1592]	2977	cell[10] = False #clear selection flag on keepers
[904]	2978	keepcells.append(cell)
	2979	except IndexError:
	2980	pass
	2981	except ValueError:
	2982	G2frame.ErrorDialog('Error','Need to set controls in Unit Cell List first')
	2983	return
[1592]	2984	if ssopt.get('Use',False):
	2985	G2frame.ErrorDialog('Super lattice error','Indexing not available for super lattices')
	2986	return
[904]	2987	if True not in bravais:
	2988	G2frame.ErrorDialog('Error','No Bravais lattices selected')
	2989	return
[1593]	2990	if not len(peaks[0]):
[1582]	2991	G2frame.ErrorDialog('Error','Index Peak List is empty')
	2992	return
[1592]	2993	if len(peaks[0][0]) > 9:
	2994	G2frame.ErrorDialog('Error','You need to reload Index Peaks List first')
	2995	return
[904]	2996	G2frame.dataFrame.CopyCell.Enable(False)
	2997	G2frame.dataFrame.RefineCell.Enable(False)
[2117]	2998	dlg = wx.ProgressDialog("Generated reflections",'0 '+" cell search for "+bravaisNames[ibrav],101,
[2136]	2999	# style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_SKIP\|wx.PD_CAN_ABORT) #desn't work in 32 bit versions
	3000	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
[2506]	3001	try:
	3002	OK,dmin,newcells = G2indx.DoIndexPeaks(peaks[0],controls,bravais,dlg,G2frame.ifX20)
	3003	finally:
	3004	dlg.Destroy()
[904]	3005	cells = keepcells+newcells
	3006	cells = G2indx.sortM20(cells)
	3007	if OK:
[1593]	3008	cells[0][10] = True #select best M20
[1548]	3009	data = [controls,bravais,cells,dmin,ssopt]
[904]	3010	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
	3011	bestCell = cells[0]
	3012	if bestCell[0] > 10.:
	3013	G2frame.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
	3014	for hkl in G2frame.HKL:
[1578]	3015	hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
[1933]	3016	G2frame.HKL = np.array(G2frame.HKL)
[904]	3017	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	3018	G2plt.PlotPowderLines(G2frame)
	3019	else:
	3020	G2plt.PlotPatterns(G2frame)
	3021	G2frame.dataFrame.CopyCell.Enable(True)
	3022	G2frame.dataFrame.IndexPeaks.Enable(True)
	3023	G2frame.dataFrame.MakeNewPhase.Enable(True)
[1593]	3024	G2frame.ifX20 = True
	3025	wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
[904]	3026
	3027	def RefreshUnitCellsGrid(event):
[1592]	3028	data = G2frame.PatternTree.GetItemPyData(UnitCellsId)
[2024]	3029	cells,dminx = data[2:4]
[904]	3030	r,c = event.GetRow(),event.GetCol()
	3031	if cells:
	3032	if c == 2:
	3033	for i in range(len(cells)):
	3034	cells[i][-2] = False
	3035	UnitCellsTable.SetValue(i,c,False)
	3036	UnitCellsTable.SetValue(r,c,True)
[2090]	3037	gridDisplay.ForceRefresh()
[904]	3038	cells[r][-2] = True
	3039	ibrav = cells[r][2]
	3040	A = G2lat.cell2A(cells[r][3:9])
	3041	G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
	3042	for hkl in G2frame.HKL:
[1578]	3043	hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
[1933]	3044	G2frame.HKL = np.array(G2frame.HKL)
[904]	3045	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
	3046	G2plt.PlotPowderLines(G2frame)
	3047	else:
	3048	G2plt.PlotPatterns(G2frame)
	3049	elif c == 11:
	3050	if UnitCellsTable.GetValue(r,c):
	3051	UnitCellsTable.SetValue(r,c,False)
	3052	cells[r][c] = False
	3053	else:
	3054	cells[r][c] = True
	3055	UnitCellsTable.SetValue(r,c,True)
	3056	gridDisplay.ForceRefresh()
[1592]	3057	G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
[904]	3058
	3059	def MakeNewPhase(event):
	3060	if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
	3061	sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
	3062	else:
	3063	sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
	3064	PhaseName = ''
	3065	dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
	3066	style=wx.OK)
	3067	try:
	3068	if dlg.ShowModal() == wx.ID_OK:
	3069	PhaseName = dlg.GetValue()
	3070	cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
	3071	for Cell in cells:
	3072	if Cell[-2]:
	3073	break
	3074	cell = Cell[2:10]
	3075	sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
	3076	E,SGData = G2spc.SpcGroup(controls[13])
	3077	G2frame.PatternTree.SetItemPyData(sub, \
[1572]	3078	G2IO.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:],Super=ssopt))
[1147]	3079	Status.SetStatusText('Change space group from '+str(controls[13])+' if needed')
[904]	3080	finally:
	3081	dlg.Destroy()
[1594]	3082
[904]	3083	if G2frame.dataDisplay:
[1578]	3084	G2frame.dataFrame.DestroyChildren()
	3085	G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
[904]	3086	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndexMenu)
	3087	if not G2frame.dataFrame.GetStatusBar():
	3088	Status = G2frame.dataFrame.CreateStatusBar()
[2124]	3089	G2frame.Bind(wx.EVT_MENU, OnIndexPeaks, id=G2gd.wxID_INDEXPEAKS)
[904]	3090	G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
	3091	G2frame.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
[1840]	3092	G2frame.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
	3093	G2frame.Bind(wx.EVT_MENU, OnExportCells, id=G2gd.wxID_EXPORTCELLS)
	3094
[2024]	3095	controls,bravais,cells,dminx,ssopt = data
[904]	3096	if len(controls) < 13: #add cell volume if missing
	3097	controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
[2022]	3098	if len(controls) < 14: #add space group used in indexing
[904]	3099	controls.append(spaceGroups[bravaisSymb.index(controls[5])])
	3100	G2frame.PatternTree.SetItemPyData(UnitCellsId,data) #update with volume
	3101	bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
	3102	'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
	3103	'Orthorhombic-P','Monoclinic-C','Monoclinic-P','Triclinic']
	3104	cellGUIlist = [[[0,1,2],4,zip([" Unit cell: a = "," Vol = "],["%.5f","%.3f"],[True,False],[0,0])],
	3105	[[3,4,5,6],6,zip([" Unit cell: a = "," c = "," Vol = "],["%.5f","%.5f","%.3f"],[True,True,False],[0,2,0])],
	3106	[[7,8,9,10],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "],["%.5f","%.5f","%.5f","%.3f"],
	3107	[True,True,True,False],[0,1,2,0])],
	3108	[[11,12],10,zip([" Unit cell: a = "," b = "," c = "," beta = "," Vol = "],
	3109	["%.5f","%.5f","%.5f","%.3f","%.3f"],[True,True,True,True,False],[0,1,2,4,0])],
	3110	[[13,],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "," alpha = "," beta = "," gamma = "],
	3111	["%.5f","%.5f","%.5f","%.3f","%.3f","%.3f","%.3f"],
	3112	[True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
	3113
	3114	G2frame.dataFrame.SetLabel('Unit Cells List')
	3115	G2frame.dataFrame.IndexPeaks.Enable(False)
	3116	peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
	3117	if peaks:
	3118	G2frame.dataFrame.IndexPeaks.Enable(True)
	3119	G2frame.dataFrame.RefineCell.Enable(False)
	3120	if controls[12] > 1.0: #if a "real" volume (i.e. not default)
	3121	G2frame.dataFrame.RefineCell.Enable(True)
	3122	G2frame.dataFrame.CopyCell.Enable(False)
	3123	G2frame.dataFrame.MakeNewPhase.Enable(False)
[1840]	3124	G2frame.dataFrame.ExportCells.Enable(False)
[904]	3125	if cells:
	3126	G2frame.dataFrame.CopyCell.Enable(True)
[1840]	3127	G2frame.dataFrame.MakeNewPhase.Enable(True)
	3128	G2frame.dataFrame.ExportCells.Enable(True)
[904]	3129	mainSizer = wx.BoxSizer(wx.VERTICAL)
[1233]	3130	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,WACV)
[904]	3131	mainSizer.Add((5,5),0)
[1378]	3132	littleSizer = wx.FlexGridSizer(0,5,5,5)
[1233]	3133	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,WACV)
[904]	3134	NcNo = wx.SpinCtrl(G2frame.dataDisplay)
[2050]	3135	NcNo.SetRange(2,8)
[904]	3136	NcNo.SetValue(controls[2])
	3137	NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
[1233]	3138	littleSizer.Add(NcNo,0,WACV)
[2572]	3139	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Start Volume '),0,WACV)
	3140	startVol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,3,typeHint=int,min=25)
[1233]	3141	littleSizer.Add(startVol,0,WACV)
[1592]	3142	x20 = wx.CheckBox(G2frame.dataDisplay,label='Use M20/(X20+1)?')
[1593]	3143	x20.SetValue(G2frame.ifX20)
[1592]	3144	x20.Bind(wx.EVT_CHECKBOX,OnIfX20)
	3145	littleSizer.Add(x20,0,WACV)
[904]	3146	mainSizer.Add(littleSizer,0)
	3147	mainSizer.Add((5,5),0)
	3148	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
[1233]	3149	0,WACV)
[904]	3150	mainSizer.Add((5,5),0)
[1378]	3151	littleSizer = wx.FlexGridSizer(0,7,5,5)
[904]	3152	bravList = []
	3153	bravs = zip(bravais,bravaisNames)
	3154	for brav,bravName in bravs:
	3155	bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
	3156	bravList.append(bravCk.GetId())
	3157	bravCk.SetValue(brav)
	3158	bravCk.Bind(wx.EVT_CHECKBOX,OnBravais)
[1233]	3159	littleSizer.Add(bravCk,0,WACV)
[904]	3160	mainSizer.Add(littleSizer,0)
	3161	mainSizer.Add((5,5),0)
	3162
[2158]	3163	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Test & Refinement: '),0,WACV)
[904]	3164	mainSizer.Add((5,5),0)
	3165	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	3166	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,WACV)
[904]	3167	bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
	3168	bravSel.SetSelection(bravaisSymb.index(controls[5]))
	3169	bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
[1233]	3170	littleSizer.Add(bravSel,0,WACV)
	3171	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Space group "),0,WACV)
[904]	3172	spcSel = wx.Choice(G2frame.dataDisplay,choices=SPGlist[controls[5]])
	3173	spcSel.SetSelection(SPGlist[controls[5]].index(controls[13]))
	3174	spcSel.Bind(wx.EVT_CHOICE,OnSpcSel)
[1233]	3175	littleSizer.Add(spcSel,0,WACV)
[1585]	3176	if ssopt.get('Use',False): #zero for super lattice doesn't work!
	3177	controls[0] = False
	3178	else:
	3179	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,WACV)
[2570]	3180	zero = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,1,nDig=(10,4),typeHint=float,min=-5.,max=5.)
[1585]	3181	littleSizer.Add(zero,0,WACV)
	3182	zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
	3183	zeroVar.SetValue(controls[0])
	3184	zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
	3185	littleSizer.Add(zeroVar,0,WACV)
[1548]	3186	SSopt = wx.CheckBox(G2frame.dataDisplay,label="Super lattice?")
[1551]	3187	SSopt.SetValue(ssopt.get('Use',False))
[1548]	3188	SSopt.Bind(wx.EVT_CHECKBOX,OnSSopt)
	3189	littleSizer.Add(SSopt,0,WACV)
[904]	3190	hklShow = wx.Button(G2frame.dataDisplay,label="Show hkl positions")
	3191	hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
[1233]	3192	littleSizer.Add(hklShow,0,WACV)
[904]	3193	mainSizer.Add(littleSizer,0)
	3194
	3195	mainSizer.Add((5,5),0)
	3196	ibrav = SetLattice(controls)
	3197	for cellGUI in cellGUIlist:
	3198	if ibrav in cellGUI[0]:
	3199	useGUI = cellGUI
	3200	cellList = []
[1461]	3201	valDict = {}
[1378]	3202	littleSizer = wx.FlexGridSizer(0,useGUI[1],5,5)
[904]	3203	for txt,fmt,ifEdit,Id in useGUI[2]:
[1233]	3204	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,WACV)
[904]	3205	if ifEdit: #a,b,c,etc.
[2569]	3206	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[904]	3207	cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
	3208	cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)
	3209	cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
[1461]	3210	valSizer = wx.BoxSizer(wx.HORIZONTAL)
	3211	valSizer.Add(cellVal,0,WACV)
	3212	cellSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
	3213	cellSpin.SetValue(0)
	3214	cellSpin.SetRange(-1,1)
	3215	cellSpin.Bind(wx.EVT_SPIN, OnMoveCell)
	3216	valSizer.Add(cellSpin,0,WACV)
	3217	littleSizer.Add(valSizer,0,WACV)
[904]	3218	cellList.append(cellVal.GetId())
[1461]	3219	cellList.append(cellSpin.GetId())
	3220	valDict[cellSpin.GetId()] = cellVal
[904]	3221	else: #volume
	3222	volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
	3223	volVal.SetBackgroundColour(VERY_LIGHT_GREY)
[1233]	3224	littleSizer.Add(volVal,0,WACV)
[904]	3225	mainSizer.Add(littleSizer,0)
[1551]	3226	if ssopt.get('Use',False): #super lattice display
[1548]	3227	indChoice = ['1','2','3','4',]
	3228	SpSg = controls[13]
	3229	ssChoice = G2spc.ssdict[SpSg]
	3230	if ssopt['ssSymb'] not in ssChoice:
	3231	ssopt['ssSymb'] = ssChoice[0]
	3232	ssSizer = wx.BoxSizer(wx.HORIZONTAL)
	3233	ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Supersymmetry space group: '+SpSg+' '),0,WACV)
	3234	selMG = wx.ComboBox(G2frame.dataDisplay,value=ssopt['ssSymb'],
	3235	choices=ssChoice,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	3236	selMG.Bind(wx.EVT_COMBOBOX, OnSelMG)
	3237	ssSizer.Add(selMG,0,WACV)
[1549]	3238	ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Mod. vector: '),0,WACV)
[1548]	3239	modS = G2spc.splitSSsym(ssopt['ssSymb'])[0]
[1593]	3240	ssopt['ModVec'],ifShow = G2spc.SSGModCheck(ssopt['ModVec'],modS)
[1549]	3241	Indx = {}
[1593]	3242	for i,[val,show] in enumerate(zip(ssopt['ModVec'],ifShow)):
[1548]	3243	if show:
	3244	valSizer = wx.BoxSizer(wx.HORIZONTAL)
[2569]	3245	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1571]	3246	modVal = wx.TextCtrl(G2frame.dataDisplay,value=('%.4f'%(val)),
[1549]	3247	size=wx.Size(50,20),style=wx.TE_PROCESS_ENTER)
[1548]	3248	modVal.Bind(wx.EVT_TEXT_ENTER,OnModVal)
	3249	modVal.Bind(wx.EVT_KILL_FOCUS,OnModVal)
	3250	valSizer.Add(modVal,0,WACV)
	3251	modSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
	3252	modSpin.SetValue(0)
	3253	modSpin.SetRange(-1,1)
	3254	modSpin.Bind(wx.EVT_SPIN, OnMoveMod)
	3255	valSizer.Add(modSpin,0,WACV)
	3256	ssSizer.Add(valSizer,0,WACV)
[1549]	3257	Indx[modVal.GetId()] = i
	3258	Indx[modSpin.GetId()] = [i,modVal]
	3259	else:
	3260	modVal = wx.TextCtrl(G2frame.dataDisplay,value=('%.3f'%(val)),
	3261	size=wx.Size(50,20),style=wx.TE_READONLY)
	3262	modVal.SetBackgroundColour(VERY_LIGHT_GREY)
	3263	ssSizer.Add(modVal,0,WACV)
	3264	ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max. M: '),0,WACV)
	3265	maxMH = wx.ComboBox(G2frame.dataDisplay,value=str(ssopt['maxH']),
	3266	choices=indChoice,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	3267	maxMH.Bind(wx.EVT_COMBOBOX, OnMaxMH)
	3268	ssSizer.Add(maxMH,0,WACV)
[2120]	3269	findMV = wx.Button(G2frame.dataDisplay,label="Find mod. vec.?")
[1581]	3270	findMV.Bind(wx.EVT_BUTTON,OnFindMV)
	3271	ssSizer.Add(findMV,0,WACV)
[1549]	3272	mainSizer.Add(ssSizer,0)
[1548]	3273
[904]	3274	if cells:
[1578]	3275	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='\n Indexing Result:'),0,WACV)
[904]	3276	rowLabels = []
	3277	colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume','Keep']
	3278	Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_NUMBER,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_STRING,]+ \
	3279	3[wg.GRID_VALUE_FLOAT+':10,5',]+3[wg.GRID_VALUE_FLOAT+':10,3',]+ \
	3280	[wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL]
	3281	table = []
	3282	for cell in cells:
	3283	rowLabels.append('')
	3284	row = cell[0:2]+[cell[-2]]+[bravaisSymb[cell[2]]]+cell[3:10]+[cell[11],]
	3285	if cell[-2]:
	3286	A = G2lat.cell2A(cell[3:9])
	3287	G2frame.HKL = G2lat.GenHBravais(dmin,cell[2],A)
	3288	for hkl in G2frame.HKL:
[1578]	3289	hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
[1933]	3290	G2frame.HKL = np.array(G2frame.HKL)
[904]	3291	table.append(row)
[1831]	3292	UnitCellsTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
	3293	gridDisplay = G2G.GSGrid(G2frame.dataDisplay)
[904]	3294	gridDisplay.SetTable(UnitCellsTable, True)
	3295	G2frame.dataFrame.CopyCell.Enable(True)
	3296	gridDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshUnitCellsGrid)
	3297	gridDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK,OnSortCells)
	3298	gridDisplay.SetMargins(0,0)
	3299	gridDisplay.SetRowLabelSize(0)
	3300	gridDisplay.AutoSizeColumns(False)
	3301	for r in range(gridDisplay.GetNumberRows()):
	3302	for c in range(gridDisplay.GetNumberCols()):
	3303	if c == 2:
	3304	gridDisplay.SetReadOnly(r,c,isReadOnly=False)
	3305	else:
	3306	gridDisplay.SetReadOnly(r,c,isReadOnly=True)
[1578]	3307	mainSizer.Add(gridDisplay,0,WACV)
	3308	mainSizer.Layout()
	3309	G2frame.dataDisplay.SetSizer(mainSizer)
	3310	G2frame.dataDisplay.SetAutoLayout(1)
	3311	G2frame.dataDisplay.SetupScrolling()
	3312	Size = mainSizer.Fit(G2frame.dataFrame)
	3313	Size[0] += 25
	3314	G2frame.dataDisplay.SetSize(Size)
	3315	G2frame.dataFrame.setSizePosLeft(Size)
	3316
[904]	3317	################################################################################
	3318	##### Reflection list
	3319	################################################################################
	3320
	3321	def UpdateReflectionGrid(G2frame,data,HKLF=False,Name=''):
[1617]	3322	'''respond to selection of PWDR Reflections data tree item by displaying
	3323	a table of reflections in the data window.
[923]	3324	'''
[2136]	3325	Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
[2137]	3326	dMin = 0.05
	3327	if 'UsrReject' in Controls:
	3328	dMin = Controls['UsrReject'].get('MinD',0.05)
[1506]	3329	def OnPlotHKL(event):
[1617]	3330	'''Plots a layer of reflections
	3331	'''
[1622]	3332	phaseName = G2frame.RefList
[1909]	3333	if phaseName not in ['Unknown',]:
	3334	pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
	3335	phaseId = G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
	3336	General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
	3337	Super = General.get('Super',0)
	3338	SuperVec = General.get('SuperVec',[])
	3339	else:
	3340	Super = 0
	3341	SuperVec = []
[1643]	3342	if 'list' in str(type(data)): #single crystal data is 2 dict in list
	3343	refList = data[1]['RefList']
	3344	else: #powder data is a dict of dicts; each same structure as SC 2nd dict
[2211]	3345	if 'RefList' in data[phaseName]:
	3346	refList = np.array(data[phaseName]['RefList'])
	3347	else:
	3348	wx.MessageBox('No reflection list - do Refine first',caption='Reflection plotting')
	3349	return
[1506]	3350	FoMax = np.max(refList.T[8+Super])
	3351	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
	3352	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
	3353	controls = {'Type' : 'Fo','ifFc' : True,'HKLmax' : Hmax,'HKLmin' : Hmin,
	3354	'FoMax' : FoMax,'Zone' : '001','Layer' : 0,'Scale' : 1.0,'Super':Super,'SuperVec':SuperVec}
	3355	G2plt.PlotSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
	3356
	3357	def OnPlot3DHKL(event):
[1617]	3358	'''Plots the reflections in 3D
	3359	'''
[1622]	3360	phaseName = G2frame.RefList
[1909]	3361	if phaseName not in ['Unknown',]:
	3362	pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
	3363	phaseId = G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
	3364	General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
	3365	Super = General.get('Super',0)
	3366	SuperVec = General.get('SuperVec',[])
	3367	else:
	3368	Super = 0
	3369	SuperVec = []
[1643]	3370	if 'list' in str(type(data)): #single crystal data is 2 dict in list
	3371	refList = data[1]['RefList']
	3372	else: #powder data is a dict of dicts; each same structure as SC 2nd dict
[2211]	3373	if 'RefList' in data[phaseName]:
	3374	refList = np.array(data[phaseName]['RefList'])
	3375	else:
	3376	wx.MessageBox('No reflection list - do Refine first',caption='Reflection plotting')
	3377	return
[2136]	3378	refList.T[3+Super] = np.where(refList.T[4+Super]<dMin,-refList.T[3+Super],refList.T[3+Super])
[1506]	3379	FoMax = np.max(refList.T[8+Super])
	3380	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
	3381	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
[1969]	3382	Vpoint = np.array([int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))])
	3383	controls = {'Type':'Fosq','Iscale':False,'HKLmax':Hmax,'HKLmin':Hmin,'Zone':False,'viewKey':'L',
[1506]	3384	'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
[1966]	3385	'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
	3386	'Scale':1.0,'oldxy':[],'viewDir':[0,0,1]},'Super':Super,'SuperVec':SuperVec}
[1506]	3387	G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
	3388
[1617]	3389	def MakeReflectionTable(phaseName):
[1831]	3390	'''Returns a wx.grid table (G2G.Table) containing a list of all reflections
[1617]	3391	for a phase.
	3392	'''
[1909]	3393	if phaseName not in ['Unknown',]:
[1617]	3394	pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
	3395	phaseId = G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
[2491]	3396	if not phaseId: #phase deleted
	3397	return None
[1617]	3398	General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
	3399	Super = General.get('Super',0)
	3400	else:
	3401	Super = 0
	3402	rowLabels = []
	3403	if HKLF:
	3404	refList = data[1]['RefList']
	3405	refs = refList
	3406	else:
	3407	if len(data) > 1:
	3408	G2frame.dataFrame.SelectPhase.Enable(True)
	3409	try: #patch for old reflection lists
[1776]	3410	if not len(data[phaseName]):
	3411	return None
[1617]	3412	refList = np.array(data[phaseName]['RefList'])
	3413	I100 = refList.T[8+Super]*refList.T[11+Super]
	3414	except TypeError:
	3415	refList = np.array([refl[:11+Super] for refl in data[phaseName]])
	3416	I100 = refList.T[8+Super]*np.array([refl[11+Super] for refl in data[phaseName]])
	3417	Imax = np.max(I100)
	3418	if Imax:
	3419	I100 *= 100.0/Imax
	3420	if 'C' in Inst['Type'][0]:
	3421	refs = np.vstack((refList.T[:15+Super],I100)).T
	3422	elif 'T' in Inst['Type'][0]:
	3423	refs = np.vstack((refList.T[:18+Super],I100)).T
[1933]	3424	rowLabels = [str(i) for i in range(len(refs))]
[1617]	3425	Types = (4+Super)[wg.GRID_VALUE_LONG,]+4[wg.GRID_VALUE_FLOAT+':10,4',]+ \
	3426	2*[wg.GRID_VALUE_FLOAT+':10,2',]+[wg.GRID_VALUE_FLOAT+':10,3',]+ \
	3427	[wg.GRID_VALUE_FLOAT+':10,3',]
	3428	if HKLF:
[1912]	3429	colLabels = ['H','K','L','twin','d','Fosq','sig','Fcsq','FoTsq','FcTsq','phase','ExtC',]
[1617]	3430	if 'T' in Inst['Type'][0]:
[1912]	3431	colLabels = ['H','K','L','twin','d','Fosq','sig','Fcsq','FoTsq','FcTsq','phase','ExtC','wave','tbar']
[1617]	3432	Types += 2*[wg.GRID_VALUE_FLOAT+':10,3',]
	3433	if Super:
	3434	colLabels.insert(3,'M')
	3435	else:
	3436	if 'C' in Inst['Type'][0]:
	3437	colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase','Icorr','Prfo','Trans','ExtP','I100']
	3438	Types += 4*[wg.GRID_VALUE_FLOAT+':10,3',]
	3439	elif 'T' in Inst['Type'][0]:
	3440	colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase','Icorr','alp','bet','wave','Prfo','Abs','Ext','I100']
	3441	Types += 7*[wg.GRID_VALUE_FLOAT+':10,3',]
	3442	if Super:
	3443	colLabels.insert(3,'M')
[2136]	3444	refs.T[3+Super] = np.where(refs.T[4+Super]<dMin,-refs.T[3+Super],refs.T[3+Super])
[1831]	3445	return G2G.Table(refs,rowLabels=rowLabels,colLabels=colLabels,types=Types)
[1622]	3446
[1617]	3447	def ShowReflTable(phaseName):
	3448	'''Posts a table of reflections for a phase, creating the table
	3449	if needed using MakeReflectionTable
	3450	'''
[1781]	3451	def setBackgroundColors(im,it):
[1780]	3452	for r in range(G2frame.refTable[phaseName].GetNumberRows()):
[1781]	3453	if HKLF:
[1797]	3454	if float(G2frame.refTable[phaseName].GetCellValue(r,3+im)) <= 0.:
[1781]	3455	G2frame.refTable[phaseName].SetCellBackgroundColour(r,3+im,wx.RED)
	3456	Fosq = float(G2frame.refTable[phaseName].GetCellValue(r,5+im))
	3457	Fcsq = float(G2frame.refTable[phaseName].GetCellValue(r,7+im))
	3458	sig = float(G2frame.refTable[phaseName].GetCellValue(r,6+im))
[2310]	3459	rat = 11.
	3460	if sig:
	3461	rat = abs(Fosq-Fcsq)/sig
[1781]	3462	if rat > 10.:
	3463	G2frame.refTable[phaseName].SetCellBackgroundColour(r,7+im,wx.RED)
	3464	elif rat > 3.0:
	3465	G2frame.refTable[phaseName].SetCellBackgroundColour(r,7+im,wx.Colour(255,255,0))
	3466	else: #PWDR
[2130]	3467	if float(G2frame.refTable[phaseName].GetCellValue(r,12+im+itof)) < 0.:
	3468	G2frame.refTable[phaseName].SetCellBackgroundColour(r,12+im+itof,wx.RED)
	3469	if float(G2frame.refTable[phaseName].GetCellValue(r,3+im)) < 0:
	3470	G2frame.refTable[phaseName].SetCellBackgroundColour(r,8+im,wx.RED)
	3471
[1780]	3472
[2492]	3473	if not len(data[phaseName]):
	3474	return #deleted phase?
[1617]	3475	G2frame.RefList = phaseName
	3476	G2frame.dataFrame.SetLabel('Reflection List for '+phaseName)
[1781]	3477	if HKLF:
[1913]	3478	Status.SetStatusText('abs(DF)/sig > 10 red; > 3 yellow; twin < 0 (user rejected) red; twin=0 (sp. gp. absent) red')
[1781]	3479	else:
[2130]	3480	Status.SetStatusText('Prfo < 0. in red; if excluded Fosq in red & mul < 0')
	3481	itof = 0
[1781]	3482	if HKLF:
[1785]	3483	im = data[1].get('Super',0)
[1781]	3484	else:
[1945]	3485	if 'T' in data[phaseName].get('Type',''):
[2130]	3486	itof = 3
[1781]	3487	im = data[phaseName].get('Super',0)
[1617]	3488	# has this table already been displayed?
	3489	if G2frame.refTable[phaseName].GetTable() is None:
	3490	PeakTable = MakeReflectionTable(phaseName)
	3491	G2frame.refTable[phaseName].SetTable(PeakTable, True)
	3492	G2frame.refTable[phaseName].EnableEditing(False)
	3493	G2frame.refTable[phaseName].SetMargins(0,0)
	3494	G2frame.refTable[phaseName].AutoSizeColumns(False)
[2130]	3495	setBackgroundColors(im,itof)
[2499]	3496	# GSASIIpath.IPyBreak()
	3497	refList = np.array([refl[:6+im] for refl in data[phaseName]['RefList']])
	3498	G2frame.HKL = np.vstack((refList.T)).T #build for plots
[1617]	3499	# raise the tab (needed for 1st use and from OnSelectPhase)
	3500	for PageNum in range(G2frame.dataDisplay.GetPageCount()):
	3501	if phaseName == G2frame.dataDisplay.GetPageText(PageNum):
	3502	G2frame.dataDisplay.SetSelection(PageNum)
	3503	break
	3504	else:
	3505	print phaseName
	3506	print phases
	3507	raise Exception("how did we not find a phase name?")
	3508
	3509	def OnPageChanged(event):
	3510	'''Respond to a press on a phase tab by displaying the reflections. This
	3511	routine is needed because the reflection table may not have been created yet.
	3512	'''
	3513	page = event.GetSelection()
	3514	phaseName = G2frame.dataDisplay.GetPageText(page)
	3515	ShowReflTable(phaseName)
	3516
[1506]	3517	def OnSelectPhase(event):
[1617]	3518	'''For PWDR, selects a phase with a selection box. Called from menu.
	3519	'''
	3520	if len(phases) < 2: return
[1506]	3521	dlg = wx.SingleChoiceDialog(G2frame,'Select','Phase',phases)
	3522	try:
	3523	if dlg.ShowModal() == wx.ID_OK:
	3524	sel = dlg.GetSelection()
[1617]	3525	ShowReflTable(phases[sel])
[1506]	3526	finally:
	3527	dlg.Destroy()
	3528
[904]	3529	if not data:
	3530	print 'No phases, no reflections'
	3531	return
	3532	if HKLF:
	3533	G2frame.RefList = 1
[1506]	3534	phaseName = IsHistogramInAnyPhase(G2frame,Name)
[1909]	3535	if not phaseName:
	3536	phaseName = 'Unknown'
[1617]	3537	phases = [phaseName]
[904]	3538	else:
	3539	phaseName = G2frame.RefList
	3540	phases = data.keys()
	3541	if G2frame.dataDisplay:
	3542	G2frame.dataFrame.Clear()
[1459]	3543	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
[2559]	3544	if not G2frame.dataFrame.GetStatusBar():
	3545	Status = G2frame.dataFrame.CreateStatusBar()
[904]	3546	if HKLF:
	3547	G2gd.SetDataMenuBar(G2frame)
[1506]	3548	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
	3549	G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
	3550	G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
	3551	G2frame.dataFrame.SelectPhase.Enable(False)
[1503]	3552	else:
[904]	3553	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
	3554	G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
[1391]	3555	G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
[1442]	3556	G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
[904]	3557	G2frame.dataFrame.SelectPhase.Enable(False)
[1459]	3558
[1831]	3559	G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
[1617]	3560	G2frame.refTable = {}
	3561	for tabnum,phase in enumerate(phases):
[2492]	3562	if len(data[phase]):
	3563	G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
	3564	G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
	3565	else: #cleanup deleted phase reflection lists
	3566	del data[phase]
	3567	if len(data):
	3568	G2frame.RefList = data.keys()[0]
	3569	phaseName = G2frame.RefList
	3570	else:
	3571	G2frame.RefList = ''
	3572	phaseName = ''
[1909]	3573	# if phaseName not in G2frame.refTable:
	3574	# print phaseName
	3575	# print phases
	3576	# raise Exception("how did we get a invalid phase name?")
[2492]	3577	if phaseName:
	3578	ShowReflTable(phaseName)
[2136]	3579	# G2frame.refTable[phaseName].Fit() #slow!!
	3580	# size = G2frame.refTable[phaseName].GetSize()
	3581	# G2frame.dataFrame.setSizePosLeft([size[0]+32,350])
	3582	G2frame.dataFrame.setSizePosLeft([550,350])
[1617]	3583	G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
[1205]	3584
[904]	3585	################################################################################
[1210]	3586	##### SASD Substances
[1207]	3587	################################################################################
	3588
[1210]	3589	def UpdateSubstanceGrid(G2frame,data):
	3590	'''respond to selection of SASD Substance data tree item.
[1207]	3591	'''
[1208]	3592	import Substances as substFile
[1207]	3593
[1208]	3594	def OnLoadSubstance(event):
	3595	names = substFile.Substances.keys()
[1231]	3596	names.sort()
[1208]	3597	dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', names, wx.CHOICEDLG_STYLE)
	3598	try:
	3599	if dlg.ShowModal() == wx.ID_OK:
	3600	name = names[dlg.GetSelection()]
	3601	else:
	3602	return
	3603	finally:
	3604	dlg.Destroy()
	3605	data['Substances'][name] = {'Elements':{},'Volume':1.0,'Density':1.0,
[1210]	3606	'Scatt density':0.0,'XAnom density':0.0,'XAbsorption':0.0}
[1208]	3607	subst = substFile.Substances[name]
	3608	ElList = subst['Elements'].keys()
	3609	for El in ElList:
[1428]	3610	Info = G2elem.GetAtomInfo(El.strip().capitalize())
[1208]	3611	Info.update(subst['Elements'][El])
	3612	data['Substances'][name]['Elements'][El] = Info
	3613	if 'Volume' in subst:
	3614	data['Substances'][name]['Volume'] = subst['Volume']
	3615	data['Substances'][name]['Density'] = \
	3616	G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
	3617	elif 'Density' in subst:
	3618	data['Substances'][name]['Density'] = subst['Density']
	3619	data['Substances'][name]['Volume'] = \
	3620	G2mth.Den2Vol(data['Substances'][name]['Elements'],data['Substances'][name]['Density'])
	3621	else:
	3622	data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
	3623	data['Substances'][name]['Density'] = \
	3624	G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
	3625	data['Substances'][name]['Scatt density'] = \
[1210]	3626	G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
	3627	contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)
	3628	data['Substances'][name]['XAnom density'] = contrst
	3629	data['Substances'][name]['XAbsorption'] = absorb
	3630
	3631	UpdateSubstanceGrid(G2frame,data)
[1232]	3632
	3633	def OnCopySubstance(event):
[1265]	3634	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	3635	histList = GetHistsLikeSelected(G2frame)
	3636	if not histList:
	3637	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	3638	return
[1232]	3639	copyList = []
[1770]	3640	dlg = G2G.G2MultiChoiceDialog(
[1265]	3641	G2frame.dataFrame,
	3642	'Copy substances from\n'+hst[5:]+' to...',
	3643	'Copy substances', histList)
[1232]	3644	try:
	3645	if dlg.ShowModal() == wx.ID_OK:
[1265]	3646	for i in dlg.GetSelections():
[1232]	3647	copyList.append(histList[i])
	3648	finally:
	3649	dlg.Destroy()
[1265]	3650	for item in copyList:
	3651	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
[2334]	3652	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Instrument Parameters'))[0]
	3653	wave = G2mth.getWave(Inst)
	3654	ndata = copy.deepcopy(data)
	3655	for name in ndata['Substances'].keys():
	3656	contrst,absorb = G2mth.XScattDen(ndata['Substances'][name]['Elements'],ndata['Substances'][name]['Volume'],wave)
	3657	ndata['Substances'][name]['XAnom density'] = contrst
	3658	ndata['Substances'][name]['XAbsorption'] = absorb
	3659	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Substances'),ndata)
[1208]	3660
	3661	def OnAddSubstance(event):
	3662	dlg = wx.TextEntryDialog(None,'Enter a name for this substance','Substance Name Entry','New substance',
	3663	style=wx.OK)
	3664	if dlg.ShowModal() == wx.ID_OK:
	3665	Name = dlg.GetValue()
	3666	data['Substances'][Name] = {'Elements':{},'Volume':1.0,'Density':1.0,
[1210]	3667	'Scatt density':0.0,'XAnom density':0.,'XAbsorption':0.}
[1208]	3668	dlg.Destroy()
[1210]	3669	AddElement(Name)
	3670	UpdateSubstanceGrid(G2frame,data)
	3671
	3672	def OnDeleteSubstance(event):
	3673	TextList = []
	3674	for name in data['Substances']:
	3675	if name != 'vacuum':
	3676	TextList += [name,]
	3677	if not TextList:
	3678	return
	3679	dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance to delete', TextList, wx.CHOICEDLG_STYLE)
	3680	try:
	3681	if dlg.ShowModal() == wx.ID_OK:
	3682	name = TextList[dlg.GetSelection()]
	3683	else:
	3684	return
	3685	finally:
	3686	dlg.Destroy()
	3687	del(data['Substances'][name])
	3688	UpdateSubstanceGrid(G2frame,data)
[1208]	3689
	3690	def OnAddElement(event):
	3691	TextList = []
	3692	for name in data['Substances']:
	3693	if name != 'vacuum':
	3694	TextList += [name,]
	3695	if not TextList:
	3696	return
	3697	dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', TextList, wx.CHOICEDLG_STYLE)
	3698	try:
	3699	if dlg.ShowModal() == wx.ID_OK:
	3700	name = TextList[dlg.GetSelection()]
	3701	else:
	3702	return
	3703	finally:
	3704	dlg.Destroy()
[1210]	3705	AddElement(name)
	3706	UpdateSubstanceGrid(G2frame,data)
	3707
	3708	def AddElement(name):
[1208]	3709	ElList = data['Substances'][name]['Elements'].keys()
	3710	dlg = G2elemGUI.PickElements(G2frame,ElList)
	3711	if dlg.ShowModal() == wx.ID_OK:
	3712	for El in dlg.Elem:
[1428]	3713	El = El.strip().capitalize()
[1208]	3714	Info = G2elem.GetAtomInfo(El)
	3715	Info.update({'Num':1})
	3716	data['Substances'][name]['Elements'][El] = Info
[2334]	3717	data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
	3718	data['Substances'][name]['Density'] = \
	3719	G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
	3720	data['Substances'][name]['Scatt density'] = \
	3721	G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
	3722	contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)
	3723	data['Substances'][name]['XAnom density'] = contrst
	3724	data['Substances'][name]['XAbsorption'] = absorb
[1208]	3725	dlg.Destroy()
	3726
	3727	def OnDeleteElement(event):
	3728	TextList = []
	3729	for name in data['Substances']:
	3730	if name != 'vacuum':
	3731	TextList += [name,]
	3732	if not TextList:
	3733	return
	3734	dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', TextList, wx.CHOICEDLG_STYLE)
	3735	try:
	3736	if dlg.ShowModal() == wx.ID_OK:
	3737	name = TextList[dlg.GetSelection()]
	3738	else:
	3739	return
	3740	finally:
	3741	dlg.Destroy()
	3742	ElList = data['Substances'][name]['Elements'].keys()
	3743	if len(ElList):
	3744	DE = G2elemGUI.DeleteElement(G2frame,ElList)
	3745	if DE.ShowModal() == wx.ID_OK:
	3746	El = DE.GetDeleteElement().strip().upper()
	3747	del(data['Substances'][name]['Elements'][El])
	3748	data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
	3749	data['Substances'][name]['Density'] = \
	3750	G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
	3751	data['Substances'][name]['Scatt density'] = \
[1210]	3752	G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
	3753	contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)
	3754	data['Substances'][name]['XAnom density'] = contrst
	3755	data['Substances'][name]['XAbsorption'] = absorb
	3756	UpdateSubstanceGrid(G2frame,data)
[1208]	3757
	3758	def SubstSizer():
	3759
	3760	def OnValueChange(event):
[2431]	3761	event.Skip()
[1208]	3762	Obj = event.GetEventObject()
	3763	if len(Indx[Obj.GetId()]) == 3:
	3764	name,El,keyId = Indx[Obj.GetId()]
	3765	try:
[1213]	3766	value = max(0,float(Obj.GetValue()))
[1208]	3767	except ValueError:
	3768	value = 0
[1213]	3769	Obj.SetValue('%.2f'%(value))
[1208]	3770	data['Substances'][name]['Elements'][El][keyId] = value
	3771	data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
	3772	data['Substances'][name]['Density'] = \
	3773	G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
	3774	else:
	3775	name,keyId = Indx[Obj.GetId()]
	3776	try:
	3777	value = max(0,float(Obj.GetValue()))
	3778	except ValueError:
	3779	value = 1.0
	3780	data['Substances'][name][keyId] = value
	3781	if keyId in 'Volume':
	3782	data['Substances'][name]['Density'] = \
	3783	G2mth.Vol2Den(data['Substances'][name]['Elements'],value)
	3784	elif keyId in 'Density':
	3785	data['Substances'][name]['Volume'] = \
	3786	G2mth.Den2Vol(data['Substances'][name]['Elements'],value)
	3787	data['Substances'][name]['Scatt density'] = \
[1210]	3788	G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
	3789	contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)
	3790	data['Substances'][name]['XAnom density'] = contrst
	3791	data['Substances'][name]['XAbsorption'] = absorb
[1313]	3792	wx.CallAfter(UpdateSubstanceGrid,G2frame,data)
[1208]	3793
	3794	Indx = {}
	3795	substSizer = wx.BoxSizer(wx.VERTICAL)
[1210]	3796	substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Substance list: wavelength: %.5fA'%(wave)),
[1233]	3797	0,WACV)
[1208]	3798	for name in data['Substances']:
[1831]	3799	G2G.HorizontalLine(substSizer,G2frame.dataDisplay)
[1208]	3800	substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Data for '+name+':'),
[1233]	3801	0,WACV)
[1208]	3802	if name == 'vacuum':
	3803	substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Not applicable'),
[1233]	3804	0,WACV)
[1208]	3805	else:
[1378]	3806	elSizer = wx.FlexGridSizer(0,6,5,5)
[1208]	3807	Substance = data['Substances'][name]
	3808	Elems = Substance['Elements']
[1263]	3809	for El in Elems: #do elements as pull downs for isotopes for neutrons
[1208]	3810	elSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+El+': '),
[1233]	3811	0,WACV)
[2569]	3812	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1213]	3813	num = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(Elems[El]['Num']),style=wx.TE_PROCESS_ENTER)
[1208]	3814	Indx[num.GetId()] = [name,El,'Num']
	3815	num.Bind(wx.EVT_TEXT_ENTER,OnValueChange)
	3816	num.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
[1233]	3817	elSizer.Add(num,0,WACV)
[1208]	3818	substSizer.Add(elSizer,0)
[1378]	3819	vdsSizer = wx.FlexGridSizer(0,4,5,5)
[1208]	3820	vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Volume: '),
[1233]	3821	0,WACV)
[2569]	3822	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1208]	3823	vol = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(Substance['Volume']),style=wx.TE_PROCESS_ENTER)
	3824	Indx[vol.GetId()] = [name,'Volume']
	3825	vol.Bind(wx.EVT_TEXT_ENTER,OnValueChange)
	3826	vol.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
[1233]	3827	vdsSizer.Add(vol,0,WACV)
[1208]	3828	vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Density: '),
[1233]	3829	0,WACV)
[2569]	3830	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1208]	3831	den = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(Substance['Density']),style=wx.TE_PROCESS_ENTER)
	3832	Indx[den.GetId()] = [name,'Density']
	3833	den.Bind(wx.EVT_TEXT_ENTER,OnValueChange)
	3834	den.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
[1233]	3835	vdsSizer.Add(den,0,WACV)
[1208]	3836	substSizer.Add(vdsSizer,0)
	3837	substSizer.Add(wx.StaticText(G2frame.dataDisplay,
	3838	label=' Scattering density : %.2f *10%scm%s'%(Substance['Scatt density'],Pwr10,Pwrm2)),
[1233]	3839	0,WACV)
[1263]	3840	substSizer.Add(wx.StaticText(G2frame.dataDisplay, #allow neutrons here into NAnom density & NAbsorption
[1208]	3841	label=' Anomalous density : %.2f *10%scm%s'%(Substance['XAnom density'],Pwr10,Pwrm2)),
[1233]	3842	0,WACV)
[1210]	3843	substSizer.Add(wx.StaticText(G2frame.dataDisplay,
	3844	label=' X-ray absorption : %.2f cm%s'%(Substance['XAbsorption'],Pwrm1)),
[1233]	3845	0,WACV)
[1208]	3846	return substSizer
[1207]	3847
[1208]	3848	Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
	3849	wave = G2mth.getWave(Inst)
	3850	if G2frame.dataDisplay:
[1827]	3851	G2frame.dataFrame.DestroyChildren() # is this a ScrolledWindow? If so, bad!
[1210]	3852	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SubstanceMenu)
[1207]	3853	if not G2frame.dataFrame.GetStatusBar():
[2546]	3854	G2frame.dataFrame.CreateStatusBar()
[1208]	3855	G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
[1210]	3856	G2frame.dataFrame.SetLabel('Substances')
[1208]	3857	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadSubstance, id=G2gd.wxID_LOADSUBSTANCE)
[1232]	3858	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddSubstance, id=G2gd.wxID_ADDSUBSTANCE)
	3859	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopySubstance, id=G2gd.wxID_COPYSUBSTANCE)
[1210]	3860	G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteSubstance, id=G2gd.wxID_DELETESUBSTANCE)
	3861	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_ELEMENTADD)
	3862	G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_ELEMENTDELETE)
[1208]	3863	mainSizer = wx.BoxSizer(wx.VERTICAL)
	3864	mainSizer.Add(SubstSizer(),0)
	3865
	3866	mainSizer.Layout()
	3867	G2frame.dataDisplay.SetSizer(mainSizer)
	3868	G2frame.dataDisplay.SetAutoLayout(1)
	3869	G2frame.dataDisplay.SetupScrolling()
	3870	Size = mainSizer.Fit(G2frame.dataFrame)
	3871	Size[0] += 25
	3872	G2frame.dataDisplay.SetSize(Size)
	3873	G2frame.dataFrame.setSizePosLeft(Size)
[1207]	3874
	3875	################################################################################
[1205]	3876	##### SASD Models
	3877	################################################################################
	3878
	3879	def UpdateModelsGrid(G2frame,data):
	3880	'''respond to selection of SASD Models data tree item.
	3881	'''
[1233]	3882	#patches
	3883	if 'Current' not in data:
	3884	data['Current'] = 'Size dist.'
	3885	if 'logBins' not in data['Size']:
	3886	data['Size']['logBins'] = True
	3887	if 'MinMaxDiam' in data['Size']:
[1237]	3888	data['Size']['MinDiam'] = 50.
	3889	data['Size']['MaxDiam'] = 10000.
[1233]	3890	del data['Size']['MinMaxDiam']
[1249]	3891	if isinstance(data['Size']['MaxEnt']['Sky'],float):
	3892	data['Size']['MaxEnt']['Sky'] = -3
[1252]	3893	if 'Power' not in data['Size']['IPG']:
	3894	data['Size']['IPG']['Power'] = -1
[1263]	3895	if 'Matrix' not in data['Particle']:
	3896	data['Particle']['Matrix'] = {'Name':'vacuum','VolFrac':[0.0,False]}
[1300]	3897	if 'BackFile' not in data:
	3898	data['BackFile'] = ''
[1233]	3899	#end patches
[1205]	3900
[1283]	3901	def RefreshPlots(newPlot=False):
	3902	PlotText = G2frame.G2plotNB.nb.GetPageText(G2frame.G2plotNB.nb.GetSelection())
	3903	if 'Powder' in PlotText:
	3904	G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=newPlot)
	3905	elif 'Size' in PlotText:
	3906	G2plt.PlotSASDSizeDist(G2frame)
	3907
[1263]	3908	def OnAddModel(event):
	3909	if data['Current'] == 'Particle fit':
[1274]	3910	material = 'vacuum'
	3911	if len(data['Particle']['Levels']):
	3912	material = data['Particle']['Levels'][-1]['Controls']['Material']
	3913	data['Particle']['Levels'].append({
	3914	'Controls':{'FormFact':'Sphere','DistType':'LogNormal','Material':material,
[1315]	3915	'FFargs':{},'SFargs':{},'NumPoints':50,'Cutoff':0.01,'Contrast':0.0,
[1288]	3916	'SlitSmear':[0.0,False],'StrFact':'Dilute'}, #last 2 not used - future?
[1277]	3917	'LogNormal':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[0.5,False],'MinSize':[10.,False],},
[1269]	3918	'Gaussian':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[300.,False],},
	3919	'LSW':{'Volume':[0.05,False],'Mean':[1000.0,False],},
	3920	'Schulz-Zimm':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[300.,False],},
[1288]	3921	'Unified':{'G':[1.e3,False],'Rg':[100,False],'B':[1.e-5,False],'P':[4,False],'Cutoff':[1e-5,False],},
[1279]	3922	'Porod':{'B':[1.e-4,False],'P':[4,False],'Cutoff':[1e-5,False],},
[1274]	3923	'Monodisperse':{'Volume':[0.05,False],'Radius':[100,False],}, #OK for spheres
	3924	'Bragg':{'PkInt':[100,False],'PkPos':[0.2,False],
[1288]	3925	'PkSig':[10,False],'PkGam':[10,False],}, #reasonable 31A peak
[1263]	3926	})
[1315]	3927	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1283]	3928	RefreshPlots(True)
[1263]	3929
	3930	wx.CallAfter(UpdateModelsGrid,G2frame,data)
	3931
[1277]	3932	def OnCopyModel(event):
[1279]	3933	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	3934	histList = GetHistsLikeSelected(G2frame)
	3935	if not histList:
	3936	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	3937	return
	3938	copyList = []
[1770]	3939	dlg = G2G.G2MultiChoiceDialog(
[1279]	3940	G2frame.dataFrame,
	3941	'Copy models from\n'+hst[5:]+' to...',
	3942	'Copy models', histList)
	3943	try:
	3944	if dlg.ShowModal() == wx.ID_OK:
	3945	for i in dlg.GetSelections():
	3946	copyList.append(histList[i])
	3947	finally:
	3948	dlg.Destroy()
	3949	for item in copyList:
	3950	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
[1300]	3951	newdata = copy.deepcopy(data)
	3952	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Models'),newdata)
	3953	if newdata['BackFile']:
	3954	Profile = G2frame.PatternTree.GetItemPyData(Id)[1]
	3955	BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,newdata['BackFile'])
	3956	BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
	3957	Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
[2335]	3958	UpdateModelsGrid(G2frame,newdata)
	3959	wx.CallAfter(UpdateModelsGrid,G2frame,data)
[1300]	3960	RefreshPlots(True)
[1288]	3961
[1297]	3962	def OnCopyFlags(event):
	3963	thisModel = copy.deepcopy(data)
	3964	hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	3965	histList = GetHistsLikeSelected(G2frame)
	3966	if not histList:
	3967	G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
	3968	return
[1770]	3969	dlg = G2G.G2MultiChoiceDialog(
[1297]	3970	G2frame.dataFrame,
	3971	'Copy sample ref. flags from\n'+str(hst[5:])+' to...',
	3972	'Copy sample flags', histList)
	3973	distChoice = ['LogNormal','Gaussian','LSW','Schulz-Zimm','Bragg','Unified',
	3974	'Porod','Monodisperse',]
	3975	parmOrder = ['Volume','Radius','Mean','StdDev','G','Rg','B','P',
[1328]	3976	'Cutoff','PkInt','PkPos','PkSig','PkGam','VolFr','Dist',]
[1297]	3977	try:
	3978	if dlg.ShowModal() == wx.ID_OK:
	3979	result = dlg.GetSelections()
	3980	for i in result:
	3981	item = histList[i]
	3982	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	3983	newModel = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Models'))
	3984	newModel['Back'][1] = copy.copy(thisModel['Back'][1])
	3985	for ilev,level in enumerate(newModel['Particle']['Levels']):
	3986	for form in level:
	3987	if form in distChoice:
	3988	thisForm = thisModel['Particle']['Levels'][ilev][form]
	3989	for item in parmOrder:
	3990	if item in thisForm:
	3991	level[form][item][1] = copy.copy(thisForm[item][1])
[1328]	3992	elif form == 'Controls':
	3993	thisForm = thisModel['Particle']['Levels'][ilev][form]['SFargs']
	3994	for item in parmOrder:
	3995	if item in thisForm:
	3996	level[form]['SFargs'][item][1] = copy.copy(thisForm[item][1])
[1297]	3997	finally:
	3998	dlg.Destroy()
	3999
[1288]	4000	def OnFitModelAll(event):
[1297]	4001	choices = G2gd.GetPatternTreeDataNames(G2frame,['SASD',])
[1295]	4002	sel = []
[1770]	4003	dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential SASD refinement',
[1295]	4004	'Select dataset to include',choices)
	4005	dlg.SetSelections(sel)
	4006	names = []
	4007	if dlg.ShowModal() == wx.ID_OK:
	4008	for sel in dlg.GetSelections():
	4009	names.append(choices[sel])
	4010	dlg.Destroy()
[2426]	4011	SeqResult = {}
[1329]	4012	Reverse = False
	4013	CopyForward = False
	4014	choice = ['Reverse sequence','Copy from prev.']
	4015	dlg = wx.MultiChoiceDialog(G2frame.dataFrame,'Sequential controls','Select controls',choice)
	4016	if dlg.ShowModal() == wx.ID_OK:
	4017	for sel in dlg.GetSelections():
	4018	if sel:
	4019	CopyForward = True
	4020	else:
[1380]	4021	Reverse = True
[1329]	4022	dlg.Destroy()
[1297]	4023	dlg = wx.ProgressDialog('SASD Sequential fit','Data set name = '+names[0],len(names),
	4024	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
	4025	wx.BeginBusyCursor()
[1380]	4026	if Reverse:
[1329]	4027	names.reverse()
[2546]	4028	JModel = None
[1297]	4029	try:
	4030	for i,name in enumerate(names):
	4031	print ' Sequential fit for ',name
	4032	GoOn = dlg.Update(i,newmsg='Data set name = '+name)[0]
	4033	if not GoOn:
	4034	break
	4035	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
[1329]	4036	if i and CopyForward:
	4037	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Models'),JModel)
[1297]	4038	IProfDict,IProfile = G2frame.PatternTree.GetItemPyData(Id)[:2]
	4039	IModel = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Models'))
	4040	ISample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Sample Parameters'))
	4041	ILimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Limits'))
[1337]	4042	IfOK,result,varyList,sig,Rvals,covMatrix,parmDict,Msg = G2sasd.ModelFit(IProfile,IProfDict,ILimits,ISample,IModel)
[1380]	4043	JModel = copy.deepcopy(IModel)
[1297]	4044	if not IfOK:
	4045	G2frame.ErrorDialog('Failed sequential refinement for data '+name,
[1327]	4046	' Msg: '+Msg+'\nYou need to rethink your selection of parameters\n'+ \
[1297]	4047	' Model restored to previous version for'+name)
	4048	SeqResult['histNames'] = names[:i]
	4049	dlg.Destroy()
	4050	break
[1380]	4051	else:
	4052	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Models'),copy.deepcopy(IModel))
[1297]	4053
[1315]	4054	G2sasd.ModelFxn(IProfile,IProfDict,ILimits,ISample,IModel)
[1297]	4055	SeqResult[name] = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
[1337]	4056	'covMatrix':covMatrix,'title':name,'parmDict':parmDict}
[1297]	4057	else:
	4058	dlg.Destroy()
	4059	print ' *** Small angle sequential refinement successful ***'
	4060	finally:
	4061	wx.EndBusyCursor()
[2426]	4062	if Reverse:
	4063	names.reverse()
	4064	SeqResult['histNames'] = names
[2421]	4065	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential SASD results')
[1297]	4066	if Id:
	4067	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
	4068	else:
[2421]	4069	Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential SASD results')
[1297]	4070	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
	4071	G2frame.PatternTree.SelectItem(Id)
[1277]	4072
[1205]	4073	def OnFitModel(event):
[1233]	4074	if data['Current'] == 'Size dist.':
[1280]	4075	if not any(Sample['Contrast']):
	4076	G2frame.ErrorDialog('No contrast; your sample is a vacuum!',
	4077	'You need to define a scattering substance!\n'+ \
	4078	' Do Substances and then Sample parameters')
	4079	return
[1315]	4080	G2sasd.SizeDistribution(Profile,ProfDict,Limits,Sample,data)
[1300]	4081	G2plt.PlotSASDSizeDist(G2frame)
[1283]	4082	RefreshPlots(True)
[1263]	4083
	4084	elif data['Current'] == 'Particle fit':
[1277]	4085	SaveState()
[1327]	4086	Results = G2sasd.ModelFit(Profile,ProfDict,Limits,Sample,data)
	4087	if not Results[0]:
	4088	G2frame.ErrorDialog('Failed refinement',
	4089	' Msg: '+Results[-1]+'\nYou need to rethink your selection of parameters\n'+ \
	4090	' Model restored to previous version')
[1315]	4091	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1283]	4092	RefreshPlots(True)
[1277]	4093	wx.CallAfter(UpdateModelsGrid,G2frame,data)
[1263]	4094
[1277]	4095	def OnUnDo(event):
	4096	DoUnDo()
	4097	data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
	4098	G2frame.PatternId,'Models'))
	4099	G2frame.dataFrame.SasdUndo.Enable(False)
	4100	UpdateModelsGrid(G2frame,data)
[1315]	4101	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1283]	4102	RefreshPlots(True)
[1277]	4103
	4104	def DoUnDo():
	4105	print 'Undo last refinement'
	4106	file = open(G2frame.undosasd,'rb')
	4107	PatternId = G2frame.PatternId
[1283]	4108	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
	4109	print ' Models recovered'
[1277]	4110	file.close()
	4111
	4112	def SaveState():
	4113	G2frame.undosasd = os.path.join(G2frame.dirname,'GSASIIsasd.save')
	4114	file = open(G2frame.undosasd,'wb')
	4115	PatternId = G2frame.PatternId
	4116	for item in ['Models']:
	4117	cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
	4118	file.close()
	4119	G2frame.dataFrame.SasdUndo.Enable(True)
	4120
[1233]	4121	def OnSelectFit(event):
	4122	data['Current'] = fitSel.GetValue()
	4123	wx.CallAfter(UpdateModelsGrid,G2frame,data)
	4124
	4125	def OnCheckBox(event):
	4126	Obj = event.GetEventObject()
[1237]	4127	item,ind = Indx[Obj.GetId()]
	4128	item[ind] = Obj.GetValue()
[1233]	4129
	4130	def OnIntVal(event):
[2431]	4131	event.Skip()
[1233]	4132	Obj = event.GetEventObject()
[1249]	4133	item,ind,minVal = Indx[Obj.GetId()]
	4134	try:
	4135	value = int(Obj.GetValue())
	4136	if value <= minVal:
	4137	raise ValueError
	4138	except ValueError:
	4139	value = item[ind]
[1260]	4140	Obj.SetValue(str(value))
[1249]	4141	item[ind] = value
	4142
[1233]	4143	def SizeSizer():
	4144
	4145	def OnShape(event):
	4146	data['Size']['Shape'][0] = partsh.GetValue()
	4147	wx.CallAfter(UpdateModelsGrid,G2frame,data)
	4148
	4149	def OnMethod(event):
	4150	data['Size']['Method'] = method.GetValue()
	4151	wx.CallAfter(UpdateModelsGrid,G2frame,data)
	4152
	4153	sizeSizer = wx.BoxSizer(wx.VERTICAL)
	4154	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Size distribution parameters: '),0,WACV)
[1378]	4155	binSizer = wx.FlexGridSizer(0,7,5,5)
[1233]	4156	binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. size bins: '),0,WACV)
	4157	bins = ['50','100','150','200']
	4158	nbins = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Nbins']),choices=bins,
	4159	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
[1249]	4160	Indx[nbins.GetId()] = [data['Size'],'Nbins',0]
[1233]	4161	nbins.Bind(wx.EVT_COMBOBOX,OnIntVal)
	4162	binSizer.Add(nbins,0,WACV)
	4163	binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min diam.: '),0,WACV)
	4164	minDias = ['10','25','50','100','150','200']
	4165	mindiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MinDiam']),choices=minDias,
[1260]	4166	style=wx.CB_DROPDOWN)
[1263]	4167	mindiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
[1260]	4168	mindiam.Bind(wx.EVT_TEXT_ENTER,OnIntVal)
	4169	mindiam.Bind(wx.EVT_KILL_FOCUS,OnIntVal)
[1249]	4170	Indx[mindiam.GetId()] = [data['Size'],'MinDiam',0]
[1233]	4171	binSizer.Add(mindiam,0,WACV)
	4172	binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max diam.: '),0,WACV)
	4173	maxDias = [str(1000*(i+1)) for i in range(10)]
	4174	maxdiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxDiam']),choices=maxDias,
[1249]	4175	style=wx.CB_DROPDOWN)
[1263]	4176	maxdiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
[1260]	4177	maxdiam.Bind(wx.EVT_TEXT_ENTER,OnIntVal)
	4178	maxdiam.Bind(wx.EVT_KILL_FOCUS,OnIntVal)
[1249]	4179	Indx[maxdiam.GetId()] = [data['Size'],'MaxDiam',0]
[1233]	4180	binSizer.Add(maxdiam,0,WACV)
	4181	logbins = wx.CheckBox(G2frame.dataDisplay,label='Log bins?')
[1237]	4182	Indx[logbins.GetId()] = [data['Size'],'logBins']
[1233]	4183	logbins.SetValue(data['Size']['logBins'])
	4184	logbins.Bind(wx.EVT_CHECKBOX, OnCheckBox)
	4185	binSizer.Add(logbins,0,WACV)
	4186	sizeSizer.Add(binSizer,0)
	4187	sizeSizer.Add((5,5),0)
	4188	partSizer = wx.BoxSizer(wx.HORIZONTAL)
	4189	partSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Particle description: '),0,WACV)
[1237]	4190	shapes = {'Spheroid':' Aspect ratio: ','Cylinder':' Diameter ','Cylinder AR':' Aspect ratio: ',
[1233]	4191	'Unified sphere':'','Unified rod':' Diameter: ','Unified rod AR':' Aspect ratio: ',
[2308]	4192	'Unified disk':' Thickness: ', 'Spherical shell': ' Shell thickness'}
[1233]	4193	partsh = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Shape'][0]),choices=shapes.keys(),
	4194	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4195	partsh.Bind(wx.EVT_COMBOBOX,OnShape)
	4196	partSizer.Add(partsh,0,WACV)
	4197	if data['Size']['Shape'][0] not in ['Unified sphere',]:
	4198	partSizer.Add(wx.StaticText(G2frame.dataDisplay,label=shapes[data['Size']['Shape'][0]]),0,WACV)
[2572]	4199	partprm = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Size']['Shape'],1,
	4200	nDig=(10,3),typeHint=float,min=0.)
[1233]	4201	partSizer.Add(partprm,0,WACV)
	4202	sizeSizer.Add(partSizer,0)
	4203	sizeSizer.Add((5,5),0)
	4204	fitSizer = wx.BoxSizer(wx.HORIZONTAL)
[1253]	4205	methods = ['MaxEnt','IPG',]
[1233]	4206	fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Fitting method: '),0,WACV)
	4207	method = wx.ComboBox(G2frame.dataDisplay,value=data['Size']['Method'],choices=methods,
	4208	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4209	method.Bind(wx.EVT_COMBOBOX,OnMethod)
	4210	fitSizer.Add(method,0,WACV)
	4211	iters = ['10','25','50','100','150','200']
	4212	fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. iterations: '),0,WACV)
	4213	Method = data['Size']['Method']
	4214	iter = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size'][Method]['Niter']),choices=iters,
	4215	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
[1249]	4216	Indx[iter.GetId()] = [data['Size'][Method],'Niter',0]
[1233]	4217	iter.Bind(wx.EVT_COMBOBOX,OnIntVal)
	4218	fitSizer.Add(iter,0,WACV)
[1249]	4219	if 'MaxEnt' in data['Size']['Method']:
	4220	fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Log floor factor: '),0,WACV)
	4221	floors = [str(-i) for i in range(9)]
	4222	floor = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxEnt']['Sky']),choices=floors,
	4223	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4224	Indx[floor.GetId()] = [data['Size']['MaxEnt'],'Sky',-10]
	4225	floor.Bind(wx.EVT_COMBOBOX,OnIntVal)
	4226	fitSizer.Add(floor,0,WACV)
[1252]	4227	elif 'IPG' in data['Size']['Method']:
	4228	fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Q power weight (-1 for sigma): '),0,WACV)
	4229	choices = ['-1','0','1','2','3','4']
	4230	power = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['IPG']['Power']),choices=choices,
	4231	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4232	Indx[power.GetId()] = [data['Size']['IPG'],'Power',-2]
	4233	power.Bind(wx.EVT_COMBOBOX,OnIntVal)
	4234	fitSizer.Add(power,0,WACV)
[1233]	4235	sizeSizer.Add(fitSizer,0)
	4236
	4237	return sizeSizer
	4238
	4239	def PartSizer():
[1263]	4240
[1274]	4241	FormFactors = {'Sphere':{},'Spheroid':{'Aspect ratio':[1.0,False]},
[1273]	4242	'Cylinder':{'Length':[100.,False]},'Cylinder diam':{'Diameter':[100.,False]},
	4243	'Cylinder AR':{'Aspect ratio':[1.0,False]},'Unified sphere':{},
	4244	'Unified rod':{'Length':[100.,False]},'Unified rod AR':{'Aspect ratio':[1.0,False]},
	4245	'Unified disk':{'Thickness':[100.,False]},
[2308]	4246	'Unified tube':{'Length':[100.,False],'Thickness':[10.,False]},
	4247	'Spherical shell':{'Shell thickness':[1.5,False] }, }
[1269]	4248
[1309]	4249	StructureFactors = {'Dilute':{},'Hard sphere':{'VolFr':[0.1,False],'Dist':[100.,False]},
	4250	'Sticky hard sphere':{'VolFr':[0.1,False],'Dist':[100.,False],'epis':[0.05,False],'Sticky':[0.2,False]},
	4251	'Square well':{'VolFr':[0.1,False],'Dist':[100.,False],'Depth':[0.1,False],'Width':[1.,False]},
	4252	'InterPrecipitate':{'VolFr':[0.1,False],'Dist':[100.,False]},}
	4253
[1274]	4254	ffDistChoices = ['Sphere','Spheroid','Cylinder','Cylinder diam',
	4255	'Cylinder AR','Unified sphere','Unified rod','Unified rod AR',
[2308]	4256	'Unified disk','Unified tube','Spherical shell',]
[1274]	4257
[1309]	4258	ffMonoChoices = ['Sphere','Spheroid','Cylinder','Cylinder AR',]
	4259
	4260	sfChoices = ['Dilute','Hard sphere','Sticky hard sphere','Square well','InterPrecipitate',]
	4261
	4262	slMult = 1000.
[1274]	4263
[1263]	4264	def OnValue(event):
[2431]	4265	event.Skip()
[1263]	4266	Obj = event.GetEventObject()
[1309]	4267	item,key,sldrObj = Indx[Obj.GetId()]
[1263]	4268	try:
	4269	value = float(Obj.GetValue())
	4270	if value <= 0.:
	4271	raise ValueError
	4272	except ValueError:
[1309]	4273	value = item[key][0]
	4274	item[key][0] = value
[1263]	4275	Obj.SetValue('%.3g'%(value))
[1309]	4276	if key in ['P','epis','Sticky','Depth','Width','VolFr','Dist']:
	4277	sldrObj.SetValue(slMult*value)
[1277]	4278	else:
[1309]	4279	logv = np.log10(value)
	4280	valMinMax = [logv-1,logv+1]
	4281	sldrObj.SetRange(slMultvalMinMax[0],slMultvalMinMax[1])
	4282	sldrObj.SetValue(slMult*logv)
[1315]	4283	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1273]	4284	RefreshPlots()
[1263]	4285
	4286	def OnSelect(event):
	4287	Obj = event.GetEventObject()
	4288	item,key = Indx[Obj.GetId()]
	4289	item[key] = Obj.GetValue()
	4290	if 'Refine' not in Obj.GetLabel():
[1274]	4291	if 'FormFact' in key :
	4292	item['FFargs'] = FormFactors[Obj.GetValue()]
[1309]	4293	elif 'StrFact' in key:
	4294	item['SFargs'] = StructureFactors[Obj.GetValue()]
[1274]	4295	wx.CallAfter(UpdateModelsGrid,G2frame,data)
[1315]	4296	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1273]	4297	RefreshPlots()
[1274]	4298
[1263]	4299	def OnDelLevel(event):
	4300	Obj = event.GetEventObject()
	4301	item = Indx[Obj.GetId()]
	4302	del data['Particle']['Levels'][item]
	4303	wx.CallAfter(UpdateModelsGrid,G2frame,data)
[1315]	4304	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1273]	4305	RefreshPlots()
[1263]	4306
[1269]	4307	def OnParmSlider(event):
[1263]	4308	Obj = event.GetEventObject()
[1309]	4309	item,key,pvObj = Indx[Obj.GetId()]
[1274]	4310	slide = Obj.GetValue()
[1309]	4311	if key in ['P','epis','Sticky','Depth','Width','VolFr','Dist']:
	4312	value = float(slide/slMult)
[1277]	4313	else:
[1309]	4314	value = 10.**float(slide/slMult)
	4315	item[key][0] = value
	4316	pvObj.SetValue('%.3g'%(item[key][0]))
[1315]	4317	G2sasd.ModelFxn(Profile,ProfDict,Limits,Sample,data)
[1273]	4318	RefreshPlots()
[1263]	4319
[1269]	4320	def SizeSizer():
	4321	sizeSizer = wx.FlexGridSizer(0,4,5,5)
	4322	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Distribution: '),0,WACV)
[1274]	4323	Distchoice = ['LogNormal','Gaussian','LSW','Schulz-Zimm','Bragg','Unified','Porod','Monodisperse',]
[1269]	4324	distChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['DistType'],choices=Distchoice,
	4325	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4326	Indx[distChoice.GetId()] = [level['Controls'],'DistType']
	4327	distChoice.Bind(wx.EVT_COMBOBOX,OnSelect)
[1309]	4328	sizeSizer.Add(distChoice,0,WACV) #put structure factor choices here
[1274]	4329	if level['Controls']['DistType'] not in ['Bragg','Unified','Porod',]:
	4330	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Form Factor: '),0,WACV)
[1309]	4331	if 'Mono' in level['Controls']['DistType']:
	4332	ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffMonoChoices,
[1274]	4333	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4334	else:
[1309]	4335	ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffDistChoices,
[1274]	4336	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4337	Indx[ffChoice.GetId()] = [level['Controls'],'FormFact']
	4338	ffChoice.Bind(wx.EVT_COMBOBOX,OnSelect)
	4339	sizeSizer.Add(ffChoice,0,WACV)
[1309]	4340
[1274]	4341	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
	4342	matSel = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['Material'],
	4343	choices=Substances['Substances'].keys(),style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4344	Indx[matSel.GetId()] = [level['Controls'],'Material']
	4345	matSel.Bind(wx.EVT_COMBOBOX,OnSelect)
	4346	sizeSizer.Add(matSel,0,WACV) #do neutron test here?
	4347	rho = Substances['Substances'][level['Controls']['Material']].get('XAnom density',0.0)
[1315]	4348	level['Controls']['Contrast'] = contrast = (rho-rhoMat)**2
[1274]	4349	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Resonant X-ray contrast: '),0,WACV)
	4350	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' %.2f 10%scm%s'%(contrast,Pwr20,Pwrm4)),0,WACV)
[1309]	4351	if 'Mono' not in level['Controls']['DistType']:
	4352	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Num. radii: '),0,WACV)
	4353	radii = ['25','50','75','100','200']
	4354	nRadii = wx.ComboBox(G2frame.dataDisplay,value=str(level['Controls']['NumPoints']),choices=radii,
	4355	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4356	Indx[nRadii.GetId()] = [level['Controls'],'NumPoints']
	4357	nRadii.Bind(wx.EVT_COMBOBOX,OnSelect)
	4358	sizeSizer.Add(nRadii,0,WACV)
	4359	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' R dist. cutoff: '),0,WACV)
[1619]	4360	rCutoff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,level['Controls'],'Cutoff',
[1309]	4361	min=0.001,max=0.1,typeHint=float)
	4362	sizeSizer.Add(rCutoff,0,WACV)
[1278]	4363	elif level['Controls']['DistType'] in ['Unified',]:
	4364	Parms = level['Unified']
	4365	Best = G2sasd.Bestimate(Parms['G'][0],Parms['Rg'][0],Parms['P'][0])
	4366	sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Estimated Dist B: %12.4g'%(Best)),0,WACV)
[1269]	4367	return sizeSizer
	4368
[1309]	4369	def ParmSizer():
[1378]	4370	parmSizer = wx.FlexGridSizer(0,3,5,5)
[1309]	4371	parmSizer.AddGrowableCol(2,1)
	4372	parmSizer.SetFlexibleDirection(wx.HORIZONTAL)
	4373	Parms = level[level['Controls']['DistType']]
	4374	FFargs = level['Controls']['FFargs']
	4375	SFargs = level['Controls'].get('SFargs',{})
	4376	parmOrder = ['Volume','Radius','Mean','StdDev','MinSize','G','Rg','B','P','Cutoff',
	4377	'PkInt','PkPos','PkSig','PkGam',]
	4378	for parm in parmOrder:
	4379	if parm in Parms:
	4380	if parm == 'MinSize':
	4381	parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Dist '+parm),0,wx.ALIGN_CENTER)
	4382	else:
	4383	parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? Dist '+parm)
	4384	parmVar.SetValue(Parms[parm][1])
	4385	parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
	4386	parmSizer.Add(parmVar,0,WACV)
	4387	Indx[parmVar.GetId()] = [Parms[parm],1]
[2569]	4388	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1309]	4389	parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(Parms[parm][0]),
	4390	style=wx.TE_PROCESS_ENTER)
	4391	parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)
	4392	parmValue.Bind(wx.EVT_KILL_FOCUS,OnValue)
	4393	parmSizer.Add(parmValue,0,WACV)
	4394	if parm == 'P':
	4395	value = Parms[parm][0]
	4396	valMinMax = [0.1,4.2]
	4397	else:
	4398	value = np.log10(Parms[parm][0])
	4399	valMinMax = [value-1,value+1]
	4400	parmSldr = wx.Slider(G2frame.dataDisplay,minValue=slMult*valMinMax[0],
	4401	maxValue=slMultvalMinMax[1],value=slMultvalue)
	4402	Indx[parmValue.GetId()] = [Parms,parm,parmSldr]
	4403	Indx[parmSldr.GetId()] = [Parms,parm,parmValue]
	4404	parmSldr.Bind(wx.EVT_SLIDER,OnParmSlider)
	4405	parmSizer.Add(parmSldr,1,wx.EXPAND)
	4406	if level['Controls']['DistType'] not in ['Bragg']:
[2308]	4407	parmOrder = ['Aspect ratio','Length','Diameter','Thickness','VolFr','Dist','epis','Sticky','Depth','Width','Shell thickness',]
[1309]	4408	fTypes = ['FF ','SF ']
	4409	for iarg,Args in enumerate([FFargs,SFargs]):
	4410	for parm in parmOrder:
	4411	if parm in Args:
	4412	parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? '+fTypes[iarg]+parm)
	4413	parmVar.SetValue(Args[parm][1])
	4414	Indx[parmVar.GetId()] = [Args[parm],1]
	4415	parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
	4416	parmSizer.Add(parmVar,0,WACV)
[2569]	4417	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1309]	4418	parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(Args[parm][0]),
	4419	style=wx.TE_PROCESS_ENTER)
	4420	parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)
	4421	parmValue.Bind(wx.EVT_KILL_FOCUS,OnValue)
	4422	parmSizer.Add(parmValue,0,WACV)
	4423	value = Args[parm][0]
	4424	if parm == 'epis':
	4425	valMinMax = [0,.1]
	4426	elif parm in ['Sticky','Width',]:
	4427	valMinMax = [0,1.]
	4428	elif parm == 'Depth':
	4429	valMinMax = [-2.,2.]
	4430	elif parm == 'Dist':
	4431	valMinMax = [100.,1000.]
	4432	elif parm == 'VolFr':
	4433	valMinMax = [1.e-4,1.]
	4434	else:
	4435	value = np.log10(Args[parm][0])
	4436	valMinMax = [value-1,value+1]
	4437	parmSldr = wx.Slider(G2frame.dataDisplay,minValue=slMult*valMinMax[0],
	4438	maxValue=slMultvalMinMax[1],value=slMultvalue)
	4439	Indx[parmVar.GetId()] = [Args[parm],1]
	4440	Indx[parmValue.GetId()] = [Args,parm,parmSldr]
	4441	Indx[parmSldr.GetId()] = [Args,parm,parmValue]
	4442	parmSldr.Bind(wx.EVT_SLIDER,OnParmSlider)
	4443	parmSizer.Add(parmSldr,1,wx.EXPAND)
	4444	return parmSizer
	4445
[1263]	4446	Indx = {}
[1233]	4447	partSizer = wx.BoxSizer(wx.VERTICAL)
[1263]	4448	topSizer = wx.BoxSizer(wx.HORIZONTAL)
	4449	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Particle fit parameters: '),0,WACV)
	4450	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Matrix: '),0,WACV)
	4451	matsel = wx.ComboBox(G2frame.dataDisplay,value=data['Particle']['Matrix']['Name'],
	4452	choices=Substances['Substances'].keys(),style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4453	Indx[matsel.GetId()] = [data['Particle']['Matrix'],'Name']
	4454	matsel.Bind(wx.EVT_COMBOBOX,OnSelect) #Do neutron test here?
	4455	rhoMat = Substances['Substances'][data['Particle']['Matrix']['Name']].get('XAnom density',0.0)
	4456	topSizer.Add(matsel,0,WACV)
	4457	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
[1619]	4458	volfrac = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Particle']['Matrix']['VolFrac'],0,
[1269]	4459	typeHint=float)
[1263]	4460	topSizer.Add(volfrac,0,WACV)
	4461	volVar = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
	4462	volVar.SetValue(data['Particle']['Matrix']['VolFrac'][1])
	4463	Indx[volVar.GetId()] = [data['Particle']['Matrix']['VolFrac'],1]
	4464	volVar.Bind(wx.EVT_CHECKBOX, OnSelect)
	4465	topSizer.Add(volVar,0,WACV)
	4466	partSizer.Add(topSizer,0,)
	4467	for ilev,level in enumerate(data['Particle']['Levels']):
[1831]	4468	G2G.HorizontalLine(partSizer,G2frame.dataDisplay)
[1263]	4469	topLevel = wx.BoxSizer(wx.HORIZONTAL)
[1274]	4470	topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Model component %d: '%(ilev)),0,WACV)
[1263]	4471	delBtn = wx.Button(G2frame.dataDisplay,label=' Delete?')
	4472	Indx[delBtn.GetId()] = ilev
	4473	delBtn.Bind(wx.EVT_BUTTON,OnDelLevel)
	4474	topLevel.Add(delBtn,0,WACV)
	4475	partSizer.Add(topLevel,0)
[1274]	4476	partSizer.Add(SizeSizer())
[1309]	4477	if level['Controls']['DistType'] not in ['Bragg','Unified','Porod',]:
	4478	topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Structure factor: '),0,WACV)
	4479	strfctr = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['StrFact'],
	4480	choices=sfChoices,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4481	Indx[strfctr.GetId()] = [level['Controls'],'StrFact']
	4482	strfctr.Bind(wx.EVT_COMBOBOX,OnSelect)
	4483	topLevel.Add(strfctr,0,WACV)
[1317]	4484	partSizer.Add(ParmSizer(),0,wx.EXPAND)
[1233]	4485	return partSizer
	4486
[1237]	4487	def OnEsdScale(event):
[2431]	4488	event.Skip()
[1237]	4489	try:
	4490	value = float(esdScale.GetValue())
	4491	if value <= 0.:
	4492	raise ValueError
	4493	except ValueError:
	4494	value = 1./np.sqrt(ProfDict['wtFactor'])
	4495	ProfDict['wtFactor'] = 1./value**2
	4496	esdScale.SetValue('%.3f'%(value))
[1283]	4497	RefreshPlots(True)
[1237]	4498
[2572]	4499	def OnBackChange(invalid,value,tc):
[1300]	4500	Profile[4][:] = value
	4501	RefreshPlots()
	4502
[1571]	4503	def OnBackFile(event): #multiple backgrounds?
[1300]	4504	data['BackFile'] = backFile.GetValue()
	4505	if data['BackFile']:
	4506	BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['BackFile'])
	4507	BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
	4508	Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
[1571]	4509	else:
	4510	Profile[5] = np.zeros(len(Profile[5]))
	4511	RefreshPlots(True)
[1300]	4512
[1233]	4513	Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
	4514	Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
	4515	Substances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
[1237]	4516	ProfDict,Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[:2]
[1300]	4517	if data['BackFile']:
	4518	BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['BackFile'])
	4519	BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
	4520	Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
[1233]	4521	if G2frame.dataDisplay:
[1827]	4522	G2frame.dataFrame.DestroyChildren() # is this a ScrolledWindow? If so, bad!
[1205]	4523	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ModelMenu)
	4524	if not G2frame.dataFrame.GetStatusBar():
	4525	Status = G2frame.dataFrame.CreateStatusBar()
[1208]	4526	G2frame.dataFrame.SetLabel('Modelling')
	4527	G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
[1205]	4528	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyModel, id=G2gd.wxID_MODELCOPY)
[1297]	4529	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyFlags, id=G2gd.wxID_MODELCOPYFLAGS)
[1205]	4530	G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitModel, id=G2gd.wxID_MODELFIT)
[1288]	4531	G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitModelAll, id=G2gd.wxID_MODELFITALL)
[1277]	4532	G2frame.dataFrame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_MODELUNDO)
[1263]	4533	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddModel, id=G2gd.wxID_MODELADD)
[1233]	4534	Indx = {}
[1210]	4535	mainSizer = wx.BoxSizer(wx.VERTICAL)
[1233]	4536	topSizer = wx.BoxSizer(wx.HORIZONTAL)
[1274]	4537	models = ['Size dist.','Particle fit']
[1233]	4538	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Modeling by: '),0,WACV)
	4539	fitSel = wx.ComboBox(G2frame.dataDisplay,value=data['Current'],choices=models,
	4540	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4541	fitSel.Bind(wx.EVT_COMBOBOX,OnSelectFit)
	4542	topSizer.Add(fitSel,0,WACV)
[1237]	4543	topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Error multiplier: '),0,WACV)
[2569]	4544	# azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
[1237]	4545	esdScale = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(1./np.sqrt(ProfDict['wtFactor'])),style=wx.TE_PROCESS_ENTER)
	4546	esdScale.Bind(wx.EVT_TEXT_ENTER,OnEsdScale)
	4547	esdScale.Bind(wx.EVT_KILL_FOCUS,OnEsdScale)
	4548	topSizer.Add(esdScale,0,WACV)
[1233]	4549	mainSizer.Add(topSizer)
[1831]	4550	G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
[1233]	4551	if 'Size' in data['Current']:
[1252]	4552	if 'MaxEnt' in data['Size']['Method']:
	4553	Status.SetStatusText('Size distribution by Maximum entropy')
	4554	elif 'IPG' in data['Size']['Method']:
	4555	Status.SetStatusText('Size distribution by Interior-Point Gradient')
[1233]	4556	mainSizer.Add(SizeSizer())
	4557	elif 'Particle' in data['Current']:
[1269]	4558	mainSizer.Add(PartSizer(),1,wx.ALIGN_LEFT\|wx.EXPAND)
[1831]	4559	G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
[1233]	4560	backSizer = wx.BoxSizer(wx.HORIZONTAL)
	4561	backSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Background:'),0,WACV)
[2572]	4562	backVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Back'],0,
	4563	nDig=(10,3),typeHint=float,OnLeave=OnBackChange)
[1233]	4564	backSizer.Add(backVal,0,WACV)
[1252]	4565	backVar = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
[1244]	4566	Indx[backVar.GetId()] = [data['Back'],1]
[1233]	4567	backVar.SetValue(data['Back'][1])
	4568	backVar.Bind(wx.EVT_CHECKBOX, OnCheckBox)
[1571]	4569	backSizer.Add(backVar,0,WACV)
	4570	#multiple background files?
[1300]	4571	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background file: '),0,WACV)
	4572	Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['SASD',])
	4573	backFile = wx.ComboBox(parent=G2frame.dataDisplay,value=data['BackFile'],choices=Choices,
	4574	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4575	backFile.Bind(wx.EVT_COMBOBOX,OnBackFile)
	4576	backSizer.Add(backFile)
[1233]	4577	mainSizer.Add(backSizer)
[1208]	4578
	4579	mainSizer.Layout()
	4580	G2frame.dataDisplay.SetSizer(mainSizer)
	4581	G2frame.dataDisplay.SetAutoLayout(1)
	4582	G2frame.dataDisplay.SetupScrolling()
	4583	Size = mainSizer.Fit(G2frame.dataFrame)
	4584	Size[0] += 25
	4585	G2frame.dataDisplay.SetSize(Size)
	4586	G2frame.dataFrame.setSizePosLeft(Size)
[1205]	4587
	4588	################################################################################
[904]	4589	##### PDF controls
	4590	################################################################################
	4591
	4592	def UpdatePDFGrid(G2frame,data):
[923]	4593	'''respond to selection of PWDR PDF data tree item.
	4594	'''
[904]	4595	global inst
	4596	tth2q = lambda t,w:4.0math.pisind(t/2.0)/w
[1878]	4597	tof2q = lambda t,C:2.0math.piC/t
[904]	4598	dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
	4599	powName = 'PWDR'+dataFile[4:]
	4600	powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
[1017]	4601	fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))[:2]
[904]	4602	inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))[0]
[1878]	4603	if 'C' in inst['Type'][0]:
[2563]	4604	wave = G2mth.getWave(inst)
	4605	keV = 12.397639/wave
[1878]	4606	qLimits = [tth2q(fullLimits[0],wave),tth2q(fullLimits[1],wave)]
	4607	polariz = inst['Polariz.'][1]
	4608	else: #'T'of
	4609	qLimits = [tof2q(fullLimits[1],inst['difC'][1]),tof2q(fullLimits[0],inst['difC'][1])]
	4610	polariz = 1.0
[904]	4611	data['QScaleLim'][1] = min(qLimits[1],data['QScaleLim'][1])
	4612	if data['QScaleLim'][0]:
	4613	data['QScaleLim'][0] = max(qLimits[0],data['QScaleLim'][0])
	4614	else: #initial setting at 90% of max Q
	4615	data['QScaleLim'][0] = 0.90*data['QScaleLim'][1]
	4616	itemDict = {}
[2355]	4617	#patch
	4618	if 'BackRatio' not in data:
	4619	data['BackRatio'] = 0.
[2519]	4620	if 'noRing' not in data:
	4621	data['noRing'] = False
[2561]	4622	if 'Rmax' not in data:
	4623	data['Rmax'] = 100.
[904]	4624
	4625	def FillFileSizer(fileSizer,key):
	4626	#fileSizer is a FlexGridSizer(3,6)
	4627
	4628	def OnSelectFile(event):
	4629	Obj = event.GetEventObject()
	4630	fileKey,itemKey,fmt = itemDict[Obj.GetId()]
	4631	if itemKey == 'Name':
	4632	value = Obj.GetValue()
	4633	Obj.SetValue(fmt%(value))
	4634	data[fileKey][itemKey] = value
	4635	UpdatePDFGrid(G2frame,data)
[2560]	4636
	4637	def OnMoveMult(event):
	4638	data[key]['Mult'] += multSpin.GetValue()*0.01
[2567]	4639	mult.SetValue(data[key]['Mult'])
[2560]	4640	wx.CallAfter(OnComputePDF,None)
[904]	4641
[2567]	4642	def AfterChange(invalid,value,tc):
	4643	if invalid: return
	4644	wx.CallAfter(OnComputePDF,None)
	4645
[904]	4646	item = data[key]
[2412]	4647	fileList = GetFileList('PWDR')
[1233]	4648	fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,WACV)
[904]	4649	fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
	4650	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4651	itemDict[fileName.GetId()] = [key,'Name','%s']
	4652	fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)
	4653	fileSizer.Add(fileName,0,)
[1233]	4654	fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,WACV)
[2560]	4655	mulBox = wx.BoxSizer(wx.HORIZONTAL)
[2567]	4656	mult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,'Mult',nDig=(10,3),
	4657	typeHint=float,OnLeave=AfterChange)
[2560]	4658	mulBox.Add(mult,0,)
	4659	multSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
	4660	multSpin.SetValue(0)
	4661	multSpin.SetRange(-1,1)
	4662	multSpin.Bind(wx.EVT_SPIN, OnMoveMult)
	4663	mulBox.Add(multSpin,0,WACV)
	4664	fileSizer.Add(mulBox,0,WACV)
[1233]	4665	fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Add:'),0,WACV)
[2567]	4666	fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,'Add',nDig=(10,0),
	4667	typeHint=float,OnLeave=AfterChange),0,)
[904]	4668
	4669	def SumElementVolumes():
	4670	sumVol = 0.
	4671	ElList = data['ElList']
	4672	for El in ElList:
	4673	Avol = (4.math.pi/3.)ElList[El]['Drad']**3
	4674	sumVol += Avol*ElList[El]['FormulaNo']
	4675	return sumVol
[2558]	4676	wx.CallAfter(OnComputePDF,None)
[904]	4677
	4678	def FillElemSizer(elemSizer,ElData):
	4679
[2567]	4680	def AfterChange(invalid,value,tc):
	4681	if invalid: return
[904]	4682	data['Form Vol'] = max(10.0,SumElementVolumes())
[961]	4683	wx.CallAfter(UpdatePDFGrid,G2frame,data)
[2558]	4684	wx.CallAfter(OnComputePDF,None)
[2567]	4685
[904]	4686	elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
[1233]	4687	label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,WACV)
[2567]	4688	num = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,ElData,'FormulaNo',nDig=(10,3),min=0.0,
	4689	typeHint=float,OnLeave=AfterChange)
[1233]	4690	elemSizer.Add(num,0,WACV)
[904]	4691	elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
	4692	label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
[1233]	4693	0,WACV)
[904]	4694
	4695	def OnGeometry(event):
	4696	data['Geometry'] = geometry.GetValue()
	4697	UpdatePDFGrid(G2frame,data)
[2558]	4698	wx.CallAfter(OnComputePDF,None)
[904]	4699
	4700	def OnDetType(event):
	4701	data['DetType'] = detType.GetValue()
	4702	UpdatePDFGrid(G2frame,data)
[2558]	4703	wx.CallAfter(OnComputePDF,None)
[904]	4704
[2567]	4705	def AfterChange(invalid,value,tc):
	4706	if invalid: return
	4707	wx.CallAfter(UpdatePDFGrid,G2frame,data)
[2558]	4708	wx.CallAfter(OnComputePDF,None)
[904]	4709
[2567]	4710	def AfterChangeNoRefresh(invalid,value,tc):
	4711	if invalid: return
[2558]	4712	wx.CallAfter(OnComputePDF,None)
[904]	4713
[2567]	4714	def NewQmax(invalid,value,tc):
	4715	if invalid: return
	4716	data['QScaleLim'][0] = 0.9*value
	4717	SQmin.SetValue(data['QScaleLim'][0])
[2558]	4718	wx.CallAfter(OnComputePDF,None)
[904]	4719
[2355]	4720	def OnBackSlider(event):
	4721	value = int(backSldr.GetValue())/100.
	4722	data['BackRatio'] = value
[2567]	4723	backVal.SetValue(data['BackRatio'])
[2558]	4724	wx.CallAfter(OnComputePDF,None)
[2355]	4725
[904]	4726	def OnRulSlider(event):
	4727	value = int(rulandSldr.GetValue())/1000.
	4728	data['Ruland'] = max(0.001,value)
[2567]	4729	rulandWdt.SetValue(data['Ruland'])
[2558]	4730	wx.CallAfter(OnComputePDF,None)
[904]	4731
	4732	def OnLorch(event):
	4733	data['Lorch'] = lorch.GetValue()
[2558]	4734	wx.CallAfter(OnComputePDF,None)
[904]	4735
	4736	def OnResetQ(event):
	4737	resetQ.SetValue(False)
	4738	data['QScaleLim'][1] = qLimits[1]
[2567]	4739	SQmax.SetValue(data['QScaleLim'][1])
[904]	4740	data['QScaleLim'][0] = 0.9*qLimits[1]
[2567]	4741	SQmin.SetValue(data['QScaleLim'][0])
[2558]	4742	wx.CallAfter(OnComputePDF,None)
[2519]	4743
	4744	def OnNoRing(event):
	4745	data['noRing'] = not data['noRing']
[2558]	4746	wx.CallAfter(OnComputePDF,None)
[904]	4747
[2412]	4748	def GetFileList(fileType):
	4749	fileList = []
[904]	4750	id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
	4751	while id:
	4752	name = G2frame.PatternTree.GetItemText(id)
[2417]	4753	if fileType in name.split()[0]:
[2412]	4754	fileList.append(name)
[904]	4755	id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
[2412]	4756	return fileList
[904]	4757
	4758	def OnCopyPDFControls(event):
	4759	import copy
[2412]	4760	TextList = GetFileList('PDF')
	4761	Source = G2frame.PatternTree.GetItemText(G2frame.PatternId)
[904]	4762	if len(TextList) == 1:
	4763	G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
	4764	return
[2412]	4765	dlg = G2G.G2MultiChoiceDialog(G2frame,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
[904]	4766	try:
	4767	if dlg.ShowModal() == wx.ID_OK:
[2412]	4768	PDFlist = [TextList[i] for i in dlg.GetSelections()]
	4769	for item in PDFlist:
	4770	id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
	4771	olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
	4772	sample = olddata['Sample']
	4773	olddata.update(copy.deepcopy(data))
	4774	olddata['Sample'] = sample
	4775	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
[904]	4776	Status.SetStatusText('PDF controls copied')
	4777	finally:
	4778	dlg.Destroy()
	4779
	4780	def OnSavePDFControls(event):
[2554]	4781	pth = G2G.GetExportPath(G2frame)
	4782	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II PDF controls file', pth, '',
	4783	'PDF controls files (.pdfprm)\|.pdfprm',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
	4784	try:
	4785	if dlg.ShowModal() == wx.ID_OK:
	4786	filename = dlg.GetPath()
	4787	# make sure extension is .pdfprm
	4788	filename = os.path.splitext(filename)[0]+'.pdfprm'
	4789	File = open(filename,'w')
	4790	File.write("#GSAS-II PDF controls file; do not add/delete items!\n")
	4791	for item in data:
	4792	File.write(item+':'+unicode(data[item])+'\n')
	4793	File.close()
	4794	print 'PDF controls saved to: '+filename
	4795	finally:
	4796	dlg.Destroy()
	4797
[904]	4798	def OnLoadPDFControls(event):
[2554]	4799	pth = G2G.GetExportPath(G2frame)
	4800	dlg = wx.FileDialog(G2frame, 'Choose GSAS-II PDF controls file', pth, '',
	4801	'PDF controls files (.pdfprm)\|.pdfprm',wx.OPEN)
	4802	try:
	4803	if dlg.ShowModal() == wx.ID_OK:
	4804	filename = dlg.GetPath()
	4805	File = open(filename,'r')
	4806	newdata = {}
	4807	S = File.readline()
	4808	while S:
	4809	if '#' in S:
	4810	S = File.readline()
	4811	continue
	4812	key,val = S.split(':',1)
	4813	try:
	4814	newdata[key] = eval(val)
	4815	except SyntaxError:
	4816	newdata[key] = val
	4817	S = File.readline()
	4818	data.update(newdata)
	4819	finally:
	4820	dlg.Destroy()
	4821	OnComputePDF(event)
	4822	UpdatePDFGrid(G2frame,data)
[904]	4823
	4824	def OnAddElement(event):
	4825	ElList = data['ElList']
	4826	PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
	4827	if PE.ShowModal() == wx.ID_OK:
	4828	El = PE.Elem
	4829	if El not in ElList and El != 'None':
[2564]	4830	data['ElList'][El] = G2elem.GetElInfo(El,inst)
[904]	4831	data['Form Vol'] = max(10.0,SumElementVolumes())
	4832	PE.Destroy()
	4833	UpdatePDFGrid(G2frame,data)
	4834
	4835	def OnDeleteElement(event):
	4836	ElList = data['ElList']
	4837	choice = ElList.keys()
	4838	dlg = G2elemGUI.DeleteElement(G2frame,choice=choice)
	4839	if dlg.ShowModal() == wx.ID_OK:
	4840	del ElList[dlg.GetDeleteElement()]
	4841	dlg.Destroy()
	4842	UpdatePDFGrid(G2frame,data)
	4843
	4844	def ComputePDF(Data):
	4845	xydata = {}
	4846	for key in ['Sample','Sample Bkg.','Container','Container Bkg.']:
	4847	name = Data[key]['Name']
	4848	if name:
	4849	xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
[2336]	4850	powName = Data['Sample']['Name']
[904]	4851	powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
[2412]	4852	limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Limits'))[1]
[904]	4853	inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))[0]
[2412]	4854	auxPlot = G2pwd.CalcPDF(Data,inst,limits,xydata)
[904]	4855	PDFId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PDF '+powName[4:])
	4856	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
	4857	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
	4858	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
	4859	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
	4860	return auxPlot
	4861
	4862	def OnComputePDF(event):
[2561]	4863	if not data['ElList']:
	4864	G2frame.ErrorDialog('PDF error','Chemical formula not defined')
	4865	return
[904]	4866	auxPlot = ComputePDF(data)
[2559]	4867	if not G2frame.dataFrame.GetStatusBar():
	4868	Status = G2frame.dataFrame.CreateStatusBar()
[2560]	4869	Status.SetStatusText('PDF computed')
[904]	4870	for plot in auxPlot:
[2356]	4871	XY = np.array(plot[:2])
	4872	G2plt.PlotXY(G2frame,[XY,],Title=plot[2])
[2546]	4873	if event is not None:
	4874	G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
	4875	G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
	4876	G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
[2553]	4877	G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
	4878	else:
	4879	G2plt.PlotISFG(G2frame,newPlot=False)
[904]	4880
	4881	def OnComputeAllPDF(event):
	4882	print 'Calculating PDFs:'
	4883	if G2frame.PatternTree.GetCount():
	4884	id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
	4885	while id:
	4886	Name = G2frame.PatternTree.GetItemText(id)
[2417]	4887	if 'PDF' in Name.split()[0]:
[904]	4888	Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
[2561]	4889	if not Data['ElList']:
	4890	G2frame.ErrorDialog('PDF error','Chemical formula not defined for \n'+Name)
	4891	return
[2546]	4892	ComputePDF(Data)
[904]	4893	id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
[2559]	4894	if not G2frame.dataFrame.GetStatusBar():
	4895	Status = G2frame.dataFrame.CreateStatusBar()
[2560]	4896	Status.SetStatusText('All PDFs computed')
[2412]	4897	G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
	4898	G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
	4899	G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
[904]	4900	G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
	4901	print ' Done calculating PDFs:'
	4902
	4903	if G2frame.dataDisplay:
	4904	G2frame.dataFrame.Clear()
	4905	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PDFMenu)
	4906	if not G2frame.dataFrame.GetStatusBar():
	4907	Status = G2frame.dataFrame.CreateStatusBar()
	4908	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
	4909	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
	4910	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
	4911	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
	4912	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
	4913	G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
	4914	G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
	4915	G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
	4916	mainSizer = wx.BoxSizer(wx.VERTICAL)
[2556]	4917
	4918	ElList = data['ElList']
[2567]	4919	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,WACV)
	4920	mainSizer.Add((5,5),0)
	4921	if 'C' in inst['Type'][0]:
	4922	str = ' Sample file: PWDR %s Wavelength, A: %.5f Energy, keV: %.3f Polariz.: %.2f '%(dataFile[3:],wave,keV,polariz)
	4923	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,WACV)
[904]	4924	mainSizer.Add((5,5),0)
[2567]	4925	fileSizer = wx.FlexGridSizer(0,6,5,1)
	4926	select = ['Sample Bkg.','Container']
	4927	if data['Container']['Name']:
	4928	select.append('Container Bkg.')
	4929	for key in select:
	4930	FillFileSizer(fileSizer,key)
	4931	mainSizer.Add(fileSizer,0)
	4932	G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
[2556]	4933	if not ElList:
	4934	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: fill in this 1st'),0,WACV)
	4935	else:
	4936	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,WACV)
[904]	4937	mainSizer.Add((5,5),0)
	4938	Abs = G2lat.CellAbsorption(ElList,data['Form Vol'])
	4939	Trans = G2pwd.Transmission(data['Geometry'],Abs*data['Pack'],data['Diam'])
[1378]	4940	elemSizer = wx.FlexGridSizer(0,3,5,1)
[904]	4941	for El in ElList:
	4942	FillElemSizer(elemSizer,ElList[El])
	4943	mainSizer.Add(elemSizer,0)
	4944	mainSizer.Add((5,5),0)
	4945	midSizer = wx.BoxSizer(wx.HORIZONTAL)
[1233]	4946	midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,WACV)
[2567]	4947	formVol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Form Vol',nDig=(10,3),min=10.0,
	4948	typeHint=float,OnLeave=AfterChange)
[904]	4949	midSizer.Add(formVol,0)
	4950	midSizer.Add(wx.StaticText(G2frame.dataDisplay,
	4951	label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
[1233]	4952	0,WACV)
[904]	4953	mainSizer.Add(midSizer,0)
[2556]	4954	mainSizer.Add((5,5),0)
[904]	4955	geoBox = wx.BoxSizer(wx.HORIZONTAL)
[1233]	4956	geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,WACV)
[904]	4957	choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
	4958	geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
	4959	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4960	geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
	4961	geoBox.Add(geometry,0)
[1233]	4962	geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,WACV)
[2567]	4963	diam = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Diam',nDig=(10,3),min=0.01,
	4964	typeHint=float,OnLeave=AfterChange)
[904]	4965	geoBox.Add(diam,0)
	4966	mainSizer.Add(geoBox,0)
	4967	mainSizer.Add((5,5),0)
	4968	geoBox = wx.BoxSizer(wx.HORIZONTAL)
[1233]	4969	geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,WACV)
[2567]	4970	pack = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Pack',nDig=(10,2),min=0.01,
	4971	typeHint=float,OnLeave=AfterChange)
[904]	4972	geoBox.Add(pack,0)
[1233]	4973	geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,WACV)
[904]	4974	mainSizer.Add(geoBox,0)
	4975
[2567]	4976	G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
[1233]	4977	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,WACV)
[904]	4978	mainSizer.Add((5,5),0)
	4979	sqBox = wx.BoxSizer(wx.HORIZONTAL)
[1233]	4980	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,WACV)
[904]	4981	choice = ['Image plate','Point detector']
	4982	detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
	4983	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
	4984	detType.Bind(wx.EVT_COMBOBOX, OnDetType)
	4985	sqBox.Add(detType,0)
	4986	if data['DetType'] == 'Image plate':
[1233]	4987	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,WACV)
[2567]	4988	obliqCoeff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'ObliqCoeff',nDig=(10,3),min=0.0,max=1.0,
	4989	typeHint=float,OnLeave=AfterChangeNoRefresh)
[904]	4990	sqBox.Add(obliqCoeff,0)
	4991	mainSizer.Add(sqBox,0)
	4992
[2355]	4993	bkBox = wx.BoxSizer(wx.HORIZONTAL)
	4994	bkBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Background ratio: '),0,WACV)
	4995	backSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
	4996	value=int(100*data['BackRatio']))
	4997	bkBox.Add(backSldr,1,wx.EXPAND)
	4998	backSldr.Bind(wx.EVT_SLIDER, OnBackSlider)
[2567]	4999	backVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'BackRatio',nDig=(10,3),min=0.0,max=1.0,
	5000	typeHint=float,OnLeave=AfterChangeNoRefresh)
[2355]	5001	bkBox.Add(backVal,0,WACV)
	5002	mainSizer.Add(bkBox,0,wx.ALIGN_LEFT\|wx.EXPAND)
	5003
[904]	5004	sqBox = wx.BoxSizer(wx.HORIZONTAL)
[1233]	5005	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,WACV)
[904]	5006	rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
	5007	value=int(1000*data['Ruland']))
	5008	sqBox.Add(rulandSldr,1,wx.EXPAND)
	5009	rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
[2567]	5010	rulandWdt = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Ruland',nDig=(10,3),min=0.001,max=1.0,
	5011	typeHint=float,OnLeave=AfterChangeNoRefresh)
[1233]	5012	sqBox.Add(rulandWdt,0,WACV)
[904]	5013	mainSizer.Add(sqBox,0,wx.ALIGN_LEFT\|wx.EXPAND)
	5014
	5015	sqBox = wx.BoxSizer(wx.HORIZONTAL)
[1233]	5016	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling q-range: '),0,WACV)
[2567]	5017	SQmin = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['QScaleLim'],0,nDig=(10,3),min=qLimits[0],max=.95*data['QScaleLim'][1],
	5018	typeHint=float,OnLeave=AfterChangeNoRefresh)
[2561]	5019	sqBox.Add(SQmin,0,WACV)
[2560]	5020	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to Qmax '),0,WACV)
[2567]	5021	SQmax = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['QScaleLim'],1,nDig=(10,3),min=qLimits[0],max=qLimits[1],
	5022	typeHint=float,OnLeave=NewQmax)
[2561]	5023	sqBox.Add(SQmax,0,WACV)
[904]	5024	resetQ = wx.CheckBox(parent=G2frame.dataDisplay,label='Reset?')
[2561]	5025	sqBox.Add(resetQ,0,WACV)
[904]	5026	resetQ.Bind(wx.EVT_CHECKBOX, OnResetQ)
[2561]	5027	sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Rmax: '),0,WACV)
[2567]	5028	rmax = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Rmax',nDig=(10,1),min=10.,max=200.,
	5029	typeHint=float,OnLeave=AfterChangeNoRefresh,size=wx.Size(50,20))
[2561]	5030	sqBox.Add(rmax,0,WACV)
	5031	lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
	5032	lorch.SetValue(data['Lorch'])
	5033	lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
	5034	sqBox.Add(lorch,0,WACV)
[2519]	5035	noRing = wx.CheckBox(parent=G2frame.dataDisplay,label='Suppress G(0) ringing?')
	5036	noRing.SetValue(data['noRing'])
	5037	noRing.Bind(wx.EVT_CHECKBOX, OnNoRing)
	5038	sqBox.Add(noRing,0)
[904]	5039	mainSizer.Add(sqBox,0)
[2519]	5040	#Rmax
[904]	5041
	5042	mainSizer.Layout()
	5043	G2frame.dataDisplay.SetSizer(mainSizer)
	5044	Size = mainSizer.Fit(G2frame.dataFrame)
	5045	G2frame.dataDisplay.SetSize(Size)
	5046	G2frame.dataFrame.setSizePosLeft(Size)
	5047

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

Download in other formats: