Context Navigation

source: trunk/GSASIIpwdGUI.py @ 2335

Last change on this file since 2335 was 2335, checked in by vondreele, 9 years ago
fix to contrast in copy models for SASD
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 235.6 KB

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

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

Download in other formats: