Context Navigation

source: trunk/GSASIIpwdGUI.py @ 1547

Last change on this file since 1547 was 1547, checked in by vondreele, 9 years ago
change "Crystal size" to "Domain size" use lookups for allowed super symmetries for GSAS-II standard space groups as used in the indexing routine. supersymmetry for trigonal/rhomahedral & hexagonal all complete & checked supersylmmetry for monoclinic & tetragonal all complete but get errors orthorhombic not done yet min Nc/No? set to 2 (at 1 it failed) for indexing
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 201.9 KB

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