Context Navigation

source: trunk/GSASIIpwdGUI.py @ 1459

Last change on this file since 1459 was 1459, checked in by vondreele, 9 years ago
add instrument parameters (flight path & detector 2-theta) needed for TOF rework reflection list for TOF change default diff curve & reflection marker offsets change weighting to instrument constants calibration to be 1/esd2 from peak fit positions - works a lot better 1st shot at TOF Rietveld refinement with derivatives - need to be checked for correctness (some are wrong)
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 190.2 KB

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

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

Download in other formats: