Context Navigation

source: trunk/GSASIIpwdGUI.py @ 1453

Last change on this file since 1453 was 1453, checked in by vondreele, 9 years ago
get HKLF data type into RefDict? create a SetDefaultDData routine in GSASII.py fix copyflags for sc extinction coeff fix neutron resonant ff for TOF fix error in making Hessian v-cov matrix - now matches the Jabobian one put names in the Es, Ep & Eg sc extinction coeff fix errors in SCExtinction - still problem with derivatives
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 188.9 KB

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

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

Download in other formats: