Context Navigation

source: trunk/GSASIIpwdGUI.py @ 1309

Last change on this file since 1309 was 1309, checked in by vondreele, 9 years ago
Implement structure factors for non-dilute small angle systems
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 179.7 KB

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

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

Download in other formats: