Context Navigation

source: trunk/GSASIIgrid.py @ 2340

Last change on this file since 2340 was 2340, checked in by toby, 7 years ago
write multiple control files
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 201.6 KB

Line
1	# -- coding: utf-8 --
2	#GSASIIgrid - data display routines
3	########### SVN repository information ###################
4	# $Date: 2016-06-23 19:54:24 +0000 (Thu, 23 Jun 2016) $
5	# $Author: toby $
6	# $Revision: 2340 $
7	# $URL: trunk/GSASIIgrid.py $
8	# $Id: GSASIIgrid.py 2340 2016-06-23 19:54:24Z toby $
9	########### SVN repository information ###################
10	'''
11	GSASIIgrid: Basic GUI routines
12	--------------------------------
13
14	'''
15	import wx
16	import wx.grid as wg
17	#import wx.wizard as wz
18	#import wx.aui
19	import wx.lib.scrolledpanel as wxscroll
20	import time
21	import copy
22	import cPickle
23	import sys
24	import os
25	import random as ran
26	import numpy as np
27	import numpy.ma as ma
28	import scipy.optimize as so
29	import GSASIIpath
30	GSASIIpath.SetVersionNumber("$Revision: 2340 $")
31	import GSASIImath as G2mth
32	import GSASIIIO as G2IO
33	import GSASIIstrIO as G2stIO
34	import GSASIIlattice as G2lat
35	import GSASIIplot as G2plt
36	import GSASIIpwdGUI as G2pdG
37	import GSASIIimgGUI as G2imG
38	import GSASIIphsGUI as G2phG
39	import GSASIIspc as G2spc
40	import GSASIImapvars as G2mv
41	import GSASIIconstrGUI as G2cnstG
42	import GSASIIrestrGUI as G2restG
43	import GSASIIpy3 as G2py3
44	import GSASIIobj as G2obj
45	import GSASIIexprGUI as G2exG
46	import GSASIIlog as log
47	import GSASIIctrls as G2G
48
49	# trig functions in degrees
50	sind = lambda x: np.sin(x*np.pi/180.)
51	tand = lambda x: np.tan(x*np.pi/180.)
52	cosd = lambda x: np.cos(x*np.pi/180.)
53
54	# Define a short name for convenience
55	WACV = wx.ALIGN_CENTER_VERTICAL
56
57	[ wxID_FOURCALC, wxID_FOURSEARCH, wxID_FOURCLEAR, wxID_PEAKSMOVE, wxID_PEAKSCLEAR,
58	wxID_CHARGEFLIP, wxID_PEAKSUNIQUE, wxID_PEAKSDELETE, wxID_PEAKSDA,
59	wxID_PEAKSDISTVP, wxID_PEAKSVIEWPT, wxID_FINDEQVPEAKS,wxID_SHOWBONDS,wxID_MULTIMCSA,
60	wxID_SINGLEMCSA,wxID_4DCHARGEFLIP,wxID_TRANSFORMSTRUCTURE,
61	] = [wx.NewId() for item in range(17)]
62
63	[ wxID_PWDRADD, wxID_HKLFADD, wxID_PWDANALYSIS, wxID_PWDCOPY, wxID_PLOTCTRLCOPY,
64	wxID_DATADELETE,wxID_DATACOPY,wxID_DATACOPYFLAGS,wxID_DATASELCOPY,wxID_DATAUSE,
65	] = [wx.NewId() for item in range(10)]
66
67	[ wxID_ATOMSEDITADD, wxID_ATOMSEDITINSERT, wxID_ATOMSEDITDELETE, wxID_ATOMSREFINE,
68	wxID_ATOMSMODIFY, wxID_ATOMSTRANSFORM, wxID_ATOMSVIEWADD, wxID_ATOMVIEWINSERT,
69	wxID_RELOADDRAWATOMS,wxID_ATOMSDISAGL,wxID_ATOMMOVE,wxID_MAKEMOLECULE,
70	wxID_ASSIGNATMS2RB,wxID_ATOMSPDISAGL, wxID_ISODISP,wxID_ADDHATOM,wxID_UPDATEHATOM,
71	wxID_WAVEVARY,wxID_ATOMSROTATE,
72	] = [wx.NewId() for item in range(19)]
73
74	[ wxID_DRAWATOMSTYLE, wxID_DRAWATOMLABEL, wxID_DRAWATOMCOLOR, wxID_DRAWATOMRESETCOLOR,
75	wxID_DRAWVIEWPOINT, wxID_DRAWTRANSFORM, wxID_DRAWDELETE, wxID_DRAWFILLCELL,
76	wxID_DRAWADDEQUIV, wxID_DRAWFILLCOORD, wxID_DRAWDISAGLTOR, wxID_DRAWPLANE,
77	wxID_DRAWDISTVP,
78	] = [wx.NewId() for item in range(13)]
79
80	[ wxID_DRAWRESTRBOND, wxID_DRAWRESTRANGLE, wxID_DRAWRESTRPLANE, wxID_DRAWRESTRCHIRAL,
81	] = [wx.NewId() for item in range(4)]
82
83	[ wxID_ADDMCSAATOM,wxID_ADDMCSARB,wxID_CLEARMCSARB,wxID_MOVEMCSA,wxID_MCSACLEARRESULTS,
84	] = [wx.NewId() for item in range(5)]
85
86	[ wxID_CLEARTEXTURE,wxID_REFINETEXTURE,
87	] = [wx.NewId() for item in range(2)]
88
89	[ wxID_LOADDIFFAX,wxID_LAYERSIMULATE,wxID_SEQUENCESIMULATE, wxID_COPYPHASE,
90	] = [wx.NewId() for item in range(4)]
91
92	[ wxID_PAWLEYLOAD, wxID_PAWLEYESTIMATE, wxID_PAWLEYUPDATE,
93	] = [wx.NewId() for item in range(3)]
94
95	[ wxID_IMCALIBRATE,wxID_IMRECALIBRATE,wxID_IMINTEGRATE, wxID_IMCLEARCALIB,wxID_IMRECALIBALL,
96	wxID_IMCOPYCONTROLS, wxID_INTEGRATEALL, wxID_IMSAVECONTROLS, wxID_IMLOADCONTROLS, wxID_IMAUTOINTEG,
97	wxID_IMCOPYSELECTED, wxID_SAVESELECTEDCONTROLS,
98	] = [wx.NewId() for item in range(12)]
99
100	[ wxID_MASKCOPY, wxID_MASKSAVE, wxID_MASKLOAD, wxID_NEWMASKSPOT,wxID_NEWMASKARC,wxID_NEWMASKRING,
101	wxID_NEWMASKFRAME, wxID_NEWMASKPOLY, wxID_MASKLOADNOT,
102	] = [wx.NewId() for item in range(9)]
103
104	[ wxID_STRSTACOPY, wxID_STRSTAFIT, wxID_STRSTASAVE, wxID_STRSTALOAD,wxID_STRSTSAMPLE,
105	wxID_APPENDDZERO,wxID_STRSTAALLFIT,wxID_UPDATEDZERO,
106	] = [wx.NewId() for item in range(8)]
107
108	[ wxID_BACKCOPY,wxID_LIMITCOPY, wxID_SAMPLECOPY, wxID_SAMPLECOPYSOME, wxID_BACKFLAGCOPY, wxID_SAMPLEFLAGCOPY,
109	wxID_SAMPLESAVE, wxID_SAMPLELOAD,wxID_ADDEXCLREGION,wxID_SETSCALE,wxID_SAMPLE1VAL,wxID_ALLSAMPLELOAD,
110	] = [wx.NewId() for item in range(12)]
111
112	[ wxID_INSTPRMRESET,wxID_CHANGEWAVETYPE,wxID_INSTCOPY, wxID_INSTFLAGCOPY, wxID_INSTLOAD,
113	wxID_INSTSAVE, wxID_INST1VAL, wxID_INSTCALIB,wxID_INSTSAVEALL,
114	] = [wx.NewId() for item in range(9)]
115
116	[ wxID_UNDO,wxID_LSQPEAKFIT,wxID_LSQONECYCLE,wxID_RESETSIGGAM,wxID_CLEARPEAKS,wxID_AUTOSEARCH,
117	wxID_PEAKSCOPY, wxID_SEQPEAKFIT,
118	] = [wx.NewId() for item in range(8)]
119
120	[ wxID_INDXRELOAD, wxID_INDEXPEAKS, wxID_REFINECELL, wxID_COPYCELL, wxID_MAKENEWPHASE,
121	wxID_EXPORTCELLS,
122	] = [wx.NewId() for item in range(6)]
123
124	[ wxID_CONSTRAINTADD,wxID_EQUIVADD,wxID_HOLDADD,wxID_FUNCTADD,wxID_ADDRIDING,
125	wxID_CONSPHASE, wxID_CONSHIST, wxID_CONSHAP, wxID_CONSGLOBAL,wxID_EQUIVALANCEATOMS,
126	] = [wx.NewId() for item in range(10)]
127
128	[ wxID_RESTRAINTADD, wxID_RESTSELPHASE,wxID_RESTDELETE, wxID_RESRCHANGEVAL,
129	wxID_RESTCHANGEESD,wxID_AARESTRAINTADD,wxID_AARESTRAINTPLOT,
130	] = [wx.NewId() for item in range(7)]
131
132	[ wxID_RIGIDBODYADD,wxID_DRAWDEFINERB,wxID_RIGIDBODYIMPORT,wxID_RESIDUETORSSEQ,
133	wxID_AUTOFINDRESRB,wxID_GLOBALRESREFINE,wxID_RBREMOVEALL,wxID_COPYRBPARMS,
134	wxID_GLOBALTHERM,wxID_VECTORBODYADD
135	] = [wx.NewId() for item in range(10)]
136
137	[ wxID_RENAMESEQSEL,wxID_SAVESEQSEL,wxID_SAVESEQSELCSV,wxID_SAVESEQCSV,wxID_PLOTSEQSEL,
138	wxID_ORGSEQSEL,wxADDSEQVAR,wxDELSEQVAR,wxEDITSEQVAR,wxCOPYPARFIT,wxID_AVESEQSEL,
139	wxADDPARFIT,wxDELPARFIT,wxEDITPARFIT,wxDOPARFIT,wxADDSEQDIST,wxADDSEQANGLE
140	] = [wx.NewId() for item in range(17)]
141
142	[ wxID_MODELCOPY,wxID_MODELFIT,wxID_MODELADD,wxID_ELEMENTADD,wxID_ELEMENTDELETE,
143	wxID_ADDSUBSTANCE,wxID_LOADSUBSTANCE,wxID_DELETESUBSTANCE,wxID_COPYSUBSTANCE,
144	wxID_MODELUNDO,wxID_MODELFITALL,wxID_MODELCOPYFLAGS,
145	] = [wx.NewId() for item in range(12)]
146
147	[ wxID_SELECTPHASE,wxID_PWDHKLPLOT,wxID_PWD3DHKLPLOT,wxID_3DALLHKLPLOT,wxID_MERGEHKL,
148	] = [wx.NewId() for item in range(5)]
149
150	[ wxID_PDFCOPYCONTROLS, wxID_PDFSAVECONTROLS, wxID_PDFLOADCONTROLS,
151	wxID_PDFCOMPUTE, wxID_PDFCOMPUTEALL, wxID_PDFADDELEMENT, wxID_PDFDELELEMENT,
152	] = [wx.NewId() for item in range(7)]
153
154	[ wxID_MCRON,wxID_MCRLIST,wxID_MCRSAVE,wxID_MCRPLAY,
155	] = [wx.NewId() for item in range(4)]
156
157	VERY_LIGHT_GREY = wx.Colour(235,235,235)
158
159	commonTrans = {'abc':np.eye(3),'a-cb':np.array([[1,0,0],[0,0,-1],[0,1,0]]),
160	'ba-c':np.array([[0,1,0],[1,0,0],[0,0,-1]]),'-cba':np.array([[0,0,-1],[0,1,0],[1,0,0]]),
161	'bca':np.array([[0,1,0],[0,0,1],[1,0,0]]),'cab':np.array([[0,0,1],[1,0,0],[0,1,0]]),
162	'P->R':np.array([[1,-1,0],[0,1,-1],[1,1,1]]),'R->P':np.array([[2./3,1./3,1./3],[-1./3,1./3,1./3],[-1./3,-2./3,1./3]]),
163	'P->A':np.array([[-1,0,0],[0,-1,1],[0,1,1]]),'R->O':np.array([[-1,0,0],[0,-1,0],[0,0,1]]),
164	'P->B':np.array([[-1,0,1],[0,-1,0],[1,0,1]]),'B->P':np.array([[-.5,0,.5],[0,-1,0],[.5,0,.5]]),
165	'P->C':np.array([[1,1,0],[1,-1,0],[0,0,-1]]),'C->P':np.array([[.5,.5,0],[.5,-.5,0],[0,0,-1]]),
166	'P->F':np.array([[-1,1,1],[1,-1,1],[1,1,-1]]),'F->P':np.array([[0,.5,.5],[.5,0,.5],[.5,.5,0]]),
167	'P->I':np.array([[0,1,1],[1,0,1],[1,1,0]]),'I->P':np.array([[-.5,.5,.5],[.5,-.5,.5],[.5,.5,-.5]]),
168	'A->P':np.array([[-1,0,0],[0,-.5,.5],[0,.5,.5]]),'O->R':np.array([[-1,0,0],[0,-1,0],[0,0,1]]),
169	'abc*':np.eye(3), }
170	commonNames = ['abc','bca','cab','a-cb','ba-c','-cba','P->A','A->P','P->B','B->P','P->C','C->P',
171	'P->I','I->P','P->F','F->P','P->R','R->P','R->O','O->R','abc*',]
172
173	# Should SGMessageBox, SymOpDialog, DisAglDialog be moved?
174
175	################################################################################
176	#### GSAS-II class definitions
177	################################################################################
178
179	class SGMessageBox(wx.Dialog):
180	''' Special version of MessageBox that displays space group & super space group text
181	in two blocks
182	'''
183	def __init__(self,parent,title,text,table,):
184	wx.Dialog.__init__(self,parent,wx.ID_ANY,title,pos=wx.DefaultPosition,
185	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
186	self.text=text
187	self.table = table
188	self.panel = wx.Panel(self)
189	mainSizer = wx.BoxSizer(wx.VERTICAL)
190	mainSizer.Add((0,10))
191	for line in text:
192	mainSizer.Add(wx.StaticText(self.panel,label=' %s '%(line)),0,WACV)
193	ncol = self.table[0].count(',')+1
194	tableSizer = wx.FlexGridSizer(0,2*ncol+3,0,0)
195	for j,item in enumerate(self.table):
196	num,flds = item.split(')')
197	tableSizer.Add(wx.StaticText(self.panel,label=' %s '%(num+')')),0,WACV\|wx.ALIGN_LEFT)
198	flds = flds.replace(' ','').split(',')
199	for i,fld in enumerate(flds):
200	if i < ncol-1:
201	tableSizer.Add(wx.StaticText(self.panel,label='%s, '%(fld)),0,WACV\|wx.ALIGN_RIGHT)
202	else:
203	tableSizer.Add(wx.StaticText(self.panel,label='%s'%(fld)),0,WACV\|wx.ALIGN_RIGHT)
204	if not j%2:
205	tableSizer.Add((20,0))
206	mainSizer.Add(tableSizer,0,wx.ALIGN_LEFT)
207	btnsizer = wx.StdDialogButtonSizer()
208	OKbtn = wx.Button(self.panel, wx.ID_OK)
209	OKbtn.SetDefault()
210	btnsizer.AddButton(OKbtn)
211	btnsizer.Realize()
212	mainSizer.Add((0,10))
213	mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
214	self.panel.SetSizer(mainSizer)
215	self.panel.Fit()
216	self.Fit()
217	size = self.GetSize()
218	self.SetSize([size[0]+20,size[1]])
219
220	def Show(self):
221	'''Use this method after creating the dialog to post it
222	'''
223	self.ShowModal()
224	return
225
226	################################################################################
227	class SymOpDialog(wx.Dialog):
228	'''Class to select a symmetry operator
229	'''
230	def __init__(self,parent,SGData,New=True,ForceUnit=False):
231	wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
232	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
233	panel = wx.Panel(self)
234	self.SGData = SGData
235	self.New = New
236	self.Force = ForceUnit
237	self.OpSelected = [0,0,0,[0,0,0],False,False]
238	mainSizer = wx.BoxSizer(wx.VERTICAL)
239	if ForceUnit:
240	choice = ['No','Yes']
241	self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
242	self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
243	mainSizer.Add(self.force,0,WACV\|wx.TOP,5)
244	# if SGData['SGInv']:
245	choice = ['No','Yes']
246	self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
247	self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
248	mainSizer.Add(self.inv,0,WACV)
249	if SGData['SGLatt'] != 'P':
250	LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
251	self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
252	self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
253	mainSizer.Add(self.latt,0,WACV)
254	if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
255	Ncol = 2
256	else:
257	Ncol = 3
258	OpList = []
259	for Opr in SGData['SGOps']:
260	OpList.append(G2spc.MT2text(Opr))
261	self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
262	majorDimension=Ncol)
263	self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
264	mainSizer.Add(self.oprs,0,WACV\|wx.BOTTOM,5)
265	mainSizer.Add(wx.StaticText(panel,-1," Choose unit cell?"),0,WACV)
266	cellSizer = wx.BoxSizer(wx.HORIZONTAL)
267	cellName = ['X','Y','Z']
268	self.cell = []
269	for i in range(3):
270	self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
271	self.cell[-1].SetRange(-3,3)
272	self.cell[-1].SetValue(0)
273	self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
274	cellSizer.Add(self.cell[-1],0,WACV)
275	mainSizer.Add(cellSizer,0,WACV\|wx.BOTTOM,5)
276	if self.New:
277	choice = ['No','Yes']
278	self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
279	self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
280	mainSizer.Add(self.new,0,WACV)
281
282	OkBtn = wx.Button(panel,-1,"Ok")
283	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
284	cancelBtn = wx.Button(panel,-1,"Cancel")
285	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
286	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
287	btnSizer.Add((20,20),1)
288	btnSizer.Add(OkBtn)
289	btnSizer.Add((20,20),1)
290	btnSizer.Add(cancelBtn)
291	btnSizer.Add((20,20),1)
292
293	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
294	panel.SetSizer(mainSizer)
295	panel.Fit()
296	self.Fit()
297
298	def OnOpSelect(self,event):
299	# if self.SGData['SGInv']:
300	self.OpSelected[0] = self.inv.GetSelection()
301	if self.SGData['SGLatt'] != 'P':
302	self.OpSelected[1] = self.latt.GetSelection()
303	self.OpSelected[2] = self.oprs.GetSelection()
304	for i in range(3):
305	self.OpSelected[3][i] = float(self.cell[i].GetValue())
306	if self.New:
307	self.OpSelected[4] = self.new.GetSelection()
308	if self.Force:
309	self.OpSelected[5] = self.force.GetSelection()
310
311	def GetSelection(self):
312	return self.OpSelected
313
314	def OnOk(self,event):
315	parent = self.GetParent()
316	parent.Raise()
317	self.EndModal(wx.ID_OK)
318
319	def OnCancel(self,event):
320	parent = self.GetParent()
321	parent.Raise()
322	self.EndModal(wx.ID_CANCEL)
323
324	################################################################################
325	class TransformDialog(wx.Dialog):
326	''' Phaae transformation
327
328	:param wx.Frame parent: reference to parent frame (or None)
329	:param phase: phase data
330
331	#NB: commonNames & commonTrans defined at top of this file
332	'''
333	def __init__(self,parent,phase):
334	wx.Dialog.__init__(self,parent,wx.ID_ANY,'Setup phase transformation',
335	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
336	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
337	self.Phase = copy.deepcopy(phase) #will be a new phase!
338	# self.Super = phase['General']['Super']
339	# if self.Super:
340	# self.Trans = np.eye(4)
341	# self.Vec = np.zeros(4)
342	# else:
343	self.Trans = np.eye(3)
344	self.Vec = np.zeros(3)
345	self.oldSpGrp = phase['General']['SGData']['SpGrp']
346	self.oldSGdata = phase['General']['SGData']
347	self.newSpGrp = self.Phase['General']['SGData']['SpGrp']
348	self.oldCell = phase['General']['Cell'][1:8]
349	self.newCell = self.Phase['General']['Cell'][1:8]
350	self.Common = 'abc'
351	self.Draw()
352
353	def Draw(self):
354
355	def OnMatValue(event):
356	Obj = event.GetEventObject()
357	ix,iy = Ind[Obj.GetId()]
358	val = Obj.GetValue()
359	try:
360	if '/' in val:
361	vals = val.split('/')
362	self.Trans[iy,ix] = float(vals[0])/float(vals[1])
363	else:
364	self.Trans[iy,ix] = float(Obj.GetValue())
365	except ValueError:
366	pass
367	Obj.SetValue('%5.3f'%(self.Trans[iy,ix]))
368
369	def OnVecValue(event):
370	Obj = event.GetEventObject()
371	iy = Ind[Obj.GetId()]
372	val = Obj.GetValue()
373	try:
374	if '/' in val:
375	vals = val.split('/')
376	self.Vec[iy] = float(vals[0])/float(vals[1])
377	else:
378	self.Vec[iy] = float(Obj.GetValue())
379	except ValueError:
380	pass
381	Obj.SetValue('%5.3f'%(self.Vec[iy]))
382
383	def OnCommon(event):
384	Obj = event.GetEventObject()
385	self.Common = Obj.GetValue()
386	if '*' in self.Common:
387	A,B = G2lat.cell2AB(self.oldCell[:6])
388	self.newCell[2:5] = [A[2,2],90.,90.]
389	a,b = G2lat.cell2AB(self.newCell[:6])
390	self.Trans = np.inner(a.T,B) #correct!
391	self.newSpGrp = 'P 1'
392	SGErr,SGData = G2spc.SpcGroup(self.newSpGrp)
393	self.Phase['General']['SGData'] = SGData
394	else:
395	self.Trans = commonTrans[self.Common]
396	OnTest(event)
397
398	def OnSpaceGroup(event):
399	Flds = SGTxt.GetValue().split()
400	#get rid of extra spaces between fields first
401	for fld in Flds: fld = fld.strip()
402	SpcGp = ' '.join(Flds)
403	if SpcGp == self.newSpGrp: #didn't change it!
404	return
405	# try a lookup on the user-supplied name
406	SpGrpNorm = G2spc.StandardizeSpcName(SpcGp)
407	if SpGrpNorm:
408	SGErr,SGData = G2spc.SpcGroup(SpGrpNorm)
409	else:
410	SGErr,SGData = G2spc.SpcGroup(SpcGp)
411	if SGErr:
412	text = [G2spc.SGErrors(SGErr)+'\nSpace Group set to previous']
413	SGTxt.SetValue(self.newSpGrp)
414	msg = 'Space Group Error'
415	Style = wx.ICON_EXCLAMATION
416	Text = '\n'.join(text)
417	wx.MessageBox(Text,caption=msg,style=Style)
418	else:
419	text,table = G2spc.SGPrint(SGData)
420	self.Phase['General']['SGData'] = SGData
421	self.newSpGrp = SpcGp
422	SGTxt.SetValue(self.Phase['General']['SGData']['SpGrp'])
423	msg = 'Space Group Information'
424	dlg = SGMessageBox(self.panel,msg,text,table)
425	dlg.Show()
426	dlg.Destroy()
427	# if self.Phase['General']['Type'] in ['modulated',]:
428	# self.Phase['General']['SuperSg'] = SetDefaultSSsymbol()
429	# self.Phase['General']['SSGData'] = G2spc.SSpcGroup(generalData['SGData'],generalData['SuperSg'])[1]
430
431	def OnTest(event):
432	self.newCell = G2lat.TransformCell(self.oldCell[:6],self.Trans)
433	wx.CallAfter(self.Draw)
434
435	self.panel.Destroy()
436	self.panel = wx.Panel(self)
437	Ind = {}
438	mainSizer = wx.BoxSizer(wx.VERTICAL)
439	MatSizer = wx.BoxSizer(wx.HORIZONTAL)
440	transSizer = wx.BoxSizer(wx.VERTICAL)
441	transSizer.Add(wx.StaticText(self.panel,label=" XYZ Transformation matrix & vector: M*X+V = X'"))
442	# if self.Super:
443	# Trmat = wx.FlexGridSizer(4,4,0,0)
444	# else:
445	commonSizer = wx.BoxSizer(wx.HORIZONTAL)
446	commonSizer.Add(wx.StaticText(self.panel,label=' Common transformations: '),0,WACV)
447	common = wx.ComboBox(self.panel,value=self.Common,choices=commonNames,
448	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
449	common.Bind(wx.EVT_COMBOBOX,OnCommon)
450	commonSizer.Add(common,0,WACV)
451	transSizer.Add(commonSizer)
452	Trmat = wx.FlexGridSizer(3,5,0,0)
453	for iy,line in enumerate(self.Trans):
454	for ix,val in enumerate(line):
455	item = wx.TextCtrl(self.panel,value='%5.3f'%(val),
456	size=(50,25),style=wx.TE_PROCESS_ENTER)
457	Ind[item.GetId()] = [ix,iy]
458	item.Bind(wx.EVT_TEXT_ENTER,OnMatValue)
459	item.Bind(wx.EVT_KILL_FOCUS,OnMatValue)
460	Trmat.Add(item)
461	Trmat.Add((25,0),0)
462	vec = wx.TextCtrl(self.panel,value='%5.3f'%(self.Vec[iy]),
463	size=(50,25),style=wx.TE_PROCESS_ENTER)
464	Ind[vec.GetId()] = [iy]
465	vec.Bind(wx.EVT_TEXT_ENTER,OnVecValue)
466	vec.Bind(wx.EVT_KILL_FOCUS,OnVecValue)
467	Trmat.Add(vec)
468	transSizer.Add(Trmat)
469	MatSizer.Add((10,0),0)
470	MatSizer.Add(transSizer)
471	mainSizer.Add(MatSizer)
472	mainSizer.Add(wx.StaticText(self.panel,label=' Old lattice parameters:'),0,WACV)
473	mainSizer.Add(wx.StaticText(self.panel,label=
474	' a = %.5f b = %.5f c = %.5f'%(self.oldCell[0],self.oldCell[1],self.oldCell[2])),0,WACV)
475	mainSizer.Add(wx.StaticText(self.panel,label=' alpha = %.3f beta = %.3f gamma = %.3f'%
476	(self.oldCell[3],self.oldCell[4],self.oldCell[5])),0,WACV)
477	mainSizer.Add(wx.StaticText(self.panel,label=' volume = %.3f'%(self.oldCell[6])),0,WACV)
478	mainSizer.Add(wx.StaticText(self.panel,label=' New lattice parameters:'),0,WACV)
479	mainSizer.Add(wx.StaticText(self.panel,label=
480	' a = %.5f b = %.5f c = %.5f'%(self.newCell[0],self.newCell[1],self.newCell[2])),0,WACV)
481	mainSizer.Add(wx.StaticText(self.panel,label=' alpha = %.3f beta = %.3f gamma = %.3f'%
482	(self.newCell[3],self.newCell[4],self.newCell[5])),0,WACV)
483	mainSizer.Add(wx.StaticText(self.panel,label=' volume = %.3f'%(self.newCell[6])),0,WACV)
484	sgSizer = wx.BoxSizer(wx.HORIZONTAL)
485	sgSizer.Add(wx.StaticText(self.panel,label=' Space group: '),0,WACV)
486	SGTxt = wx.TextCtrl(self.panel,value=self.newSpGrp,style=wx.TE_PROCESS_ENTER)
487	SGTxt.Bind(wx.EVT_TEXT_ENTER,OnSpaceGroup)
488	SGTxt.Bind(wx.EVT_KILL_FOCUS,OnSpaceGroup)
489	sgSizer.Add(SGTxt,0,WACV)
490	mainSizer.Add(sgSizer,0,WACV)
491
492	TestBtn = wx.Button(self.panel,-1,"Test")
493	TestBtn.Bind(wx.EVT_BUTTON, OnTest)
494	OkBtn = wx.Button(self.panel,-1,"Ok")
495	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
496	cancelBtn = wx.Button(self.panel,-1,"Cancel")
497	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
498	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
499	btnSizer.Add((20,20),1)
500	btnSizer.Add(TestBtn)
501	btnSizer.Add((20,20),1)
502	btnSizer.Add(OkBtn)
503	btnSizer.Add((20,20),1)
504	btnSizer.Add(cancelBtn)
505	btnSizer.Add((20,20),1)
506
507	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
508	self.panel.SetSizer(mainSizer)
509	self.panel.Fit()
510	self.Fit()
511
512	def GetSelection(self):
513	self.Phase['General']['Name'] += ' %s'%(self.Common)
514	self.Phase['General']['Cell'][1:] = G2lat.TransformCell(self.oldCell[:6],self.Trans)
515	return self.Phase,self.Trans,self.Vec
516
517	def OnOk(self,event):
518	parent = self.GetParent()
519	parent.Raise()
520	self.EndModal(wx.ID_OK)
521
522	def OnCancel(self,event):
523	parent = self.GetParent()
524	parent.Raise()
525	self.EndModal(wx.ID_CANCEL)
526
527	################################################################################
528	class RotationDialog(wx.Dialog):
529	''' Get Rotate & translate matrix & vector - currently not used
530	needs rethinking - possible use to rotate a group of atoms about some
531	vector/origin + translation
532
533	'''
534	def __init__(self,parent):
535	wx.Dialog.__init__(self,parent,wx.ID_ANY,'Atom group rotation/translation',
536	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
537	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
538	self.Trans = np.eye(3)
539	self.Vec = np.zeros(3)
540	self.rotAngle = 0.
541	self.rotVec = np.array([0.,0.,1.])
542	self.Expand = ''
543	self.Draw()
544
545	def Draw(self):
546
547	def OnMatValue(event):
548	Obj = event.GetEventObject()
549	ix,iy = Ind[Obj.GetId()]
550	val = Obj.GetValue()
551	if '/' in val:
552	vals = val.split('/')
553	self.Trans[iy,ix] = float(vals[0])/float(vals[1])
554	else:
555	self.Trans[iy,ix] = float(Obj.GetValue())
556	Obj.SetValue('%5.3f'%(self.Trans[iy,ix]))
557
558
559	def OnVecValue(event):
560	Obj = event.GetEventObject()
561	iy = Ind[Obj.GetId()]
562	val = Obj.GetValue()
563	if '/' in val:
564	vals = val.split('/')
565	self.Vec[iy] = float(vals[0])/float(vals[1])
566	else:
567	self.Vec[iy] = float(Obj.GetValue())
568	Obj.SetValue('%5.3f'%(self.Vec[iy]))
569
570	def OnExpand(event):
571	self.Expand = expand.GetValue()
572
573	def OnRotAngle(event):
574	self.rotAngle = float(rotangle.GetValue())
575	rotangle.SetValue('%5.3f'%(self.rotAngle))
576	Q = G2mth.AVdeg2Q(self.rotAngle,self.rotVec)
577	self.Trans = G2mth.Q2Mat(Q)
578	self.Draw()
579
580	def OnRotVec(event):
581	vals = rotvec.GetValue()
582	vals = vals.split()
583	self.rotVec = np.array([float(val) for val in vals])
584	rotvec.SetValue('%5.3f %5.3f %5.3f'%(self.rotVec[0],self.rotVec[1],self.rotVec[2]))
585	Q = G2mth.AVdeg2Q(self.rotAngle,self.rotVec)
586	self.Trans = G2mth.Q2Mat(Q)
587	self.Draw()
588
589	self.panel.Destroy()
590	self.panel = wx.Panel(self)
591	Ind = {}
592	mainSizer = wx.BoxSizer(wx.VERTICAL)
593	MatSizer = wx.BoxSizer(wx.HORIZONTAL)
594	transSizer = wx.BoxSizer(wx.VERTICAL)
595	transSizer.Add(wx.StaticText(self.panel,label=" XYZ Transformation matrix && vector: "+ \
596	"\n BMA*(X-V)+V = X'\n A,B: Cartesian transformation matrices"))
597	Trmat = wx.FlexGridSizer(3,5,0,0)
598	for iy,line in enumerate(self.Trans):
599	for ix,val in enumerate(line):
600	item = wx.TextCtrl(self.panel,value='%5.3f'%(val),
601	size=(50,25),style=wx.TE_PROCESS_ENTER)
602	Ind[item.GetId()] = [ix,iy]
603	item.Bind(wx.EVT_TEXT_ENTER,OnMatValue)
604	item.Bind(wx.EVT_KILL_FOCUS,OnMatValue)
605	Trmat.Add(item)
606	Trmat.Add((25,0),0)
607	vec = wx.TextCtrl(self.panel,value='%5.3f'%(self.Vec[iy]),
608	size=(50,25),style=wx.TE_PROCESS_ENTER)
609	Ind[vec.GetId()] = [iy]
610	vec.Bind(wx.EVT_TEXT_ENTER,OnVecValue)
611	vec.Bind(wx.EVT_KILL_FOCUS,OnVecValue)
612	Trmat.Add(vec)
613	transSizer.Add(Trmat)
614	MatSizer.Add((10,0),0)
615	MatSizer.Add(transSizer)
616	mainSizer.Add(MatSizer)
617	rotationBox = wx.BoxSizer(wx.HORIZONTAL)
618	rotationBox.Add(wx.StaticText(self.panel,label=' Rotation angle: '),0,WACV)
619	rotangle = wx.TextCtrl(self.panel,value='%5.3f'%(self.rotAngle),
620	size=(50,25),style=wx.TE_PROCESS_ENTER)
621	rotangle.Bind(wx.EVT_TEXT_ENTER,OnRotAngle)
622	rotangle.Bind(wx.EVT_KILL_FOCUS,OnRotAngle)
623	rotationBox.Add(rotangle,0,WACV)
624	rotationBox.Add(wx.StaticText(self.panel,label=' about vector: '),0,WACV)
625	rotvec = wx.TextCtrl(self.panel,value='%5.3f %5.3f %5.3f'%(self.rotVec[0],self.rotVec[1],self.rotVec[2]),
626	size=(100,25),style=wx.TE_PROCESS_ENTER)
627	rotvec.Bind(wx.EVT_TEXT_ENTER,OnRotVec)
628	rotvec.Bind(wx.EVT_KILL_FOCUS,OnRotVec)
629	rotationBox.Add(rotvec,0,WACV)
630	mainSizer.Add(rotationBox,0,WACV)
631	expandChoice = ['','xy','xz','yz','xyz']
632	expandBox = wx.BoxSizer(wx.HORIZONTAL)
633	expandBox.Add(wx.StaticText(self.panel,label=' Expand -1 to +1 on: '),0,WACV)
634	expand = wx.ComboBox(self.panel,value=self.Expand,choices=expandChoice,
635	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
636	expand.Bind(wx.EVT_COMBOBOX,OnExpand)
637	expandBox.Add(expand,0,WACV)
638	expandBox.Add(wx.StaticText(self.panel,label=' and find unique atoms '),0,WACV)
639	mainSizer.Add(expandBox)
640
641	OkBtn = wx.Button(self.panel,-1,"Ok")
642	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
643	cancelBtn = wx.Button(self.panel,-1,"Cancel")
644	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
645	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
646	btnSizer.Add((20,20),1)
647	btnSizer.Add(OkBtn)
648	btnSizer.Add((20,20),1)
649	btnSizer.Add(cancelBtn)
650	btnSizer.Add((20,20),1)
651
652	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
653	self.panel.SetSizer(mainSizer)
654	self.panel.Fit()
655	self.Fit()
656
657	def GetSelection(self):
658	return self.Trans,self.Vec,self.Expand
659
660	def OnOk(self,event):
661	parent = self.GetParent()
662	parent.Raise()
663	self.EndModal(wx.ID_OK)
664
665	def OnCancel(self,event):
666	parent = self.GetParent()
667	parent.Raise()
668	self.EndModal(wx.ID_CANCEL)
669
670	################################################################################
671	class DIFFaXcontrols(wx.Dialog):
672	''' Solicit items needed to prepare DIFFaX control.dif file
673	'''
674	def __init__(self,parent,ctrls,parms=None):
675	wx.Dialog.__init__(self,parent,wx.ID_ANY,'DIFFaX controls',
676	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
677	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
678	self.ctrls = ctrls
679	self.calcType = 'powder pattern'
680	self.plane = 'h0l'
681	self.planeChoice = ['h0l','0kl','hhl','h-hl',]
682	self.lmax = '2'
683	self.lmaxChoice = [str(i+1) for i in range(6)]
684	self.Parms = parms
685	self.Parm = None
686	if self.Parms != None:
687	self.Parm = self.Parms[0]
688	self.parmRange = [0.,1.]
689	self.parmStep = 2
690	self.Inst = 'Gaussian'
691	self.Draw()
692
693	def Draw(self):
694
695	def OnCalcType(event):
696	self.calcType = calcType.GetValue()
697	wx.CallAfter(self.Draw)
698
699	def OnPlane(event):
700	self.plane = plane.GetValue()
701
702	def OnMaxL(event):
703	self.lmax = lmax.GetValue()
704
705	def OnParmSel(event):
706	self.Parm = parmsel.GetValue()
707
708	def OnNumStep(event):
709	self.parmStep = int(numStep.GetValue())
710
711	def OnParmRange(event):
712	vals = parmrange.GetValue().split()
713	try:
714	vals = [float(vals[0]),float(vals[1])]
715	except ValueError:
716	vals = self.parmRange
717	parmrange.SetValue('%.3f %.3f'%(vals[0],vals[1]))
718	self.parmRange = vals
719
720	def OnInstSel(event):
721	self.Inst = instsel.GetValue()
722
723	self.panel.Destroy()
724	self.panel = wx.Panel(self)
725	mainSizer = wx.BoxSizer(wx.VERTICAL)
726	mainSizer.Add(wx.StaticText(self.panel,label=' Controls for DIFFaX'),0,WACV)
727	if self.Parms:
728	mainSizer.Add(wx.StaticText(self.panel,label=' Sequential powder pattern simulation'),0,WACV)
729	else:
730	calcChoice = ['powder pattern','selected area']
731	calcSizer = wx.BoxSizer(wx.HORIZONTAL)
732	calcSizer.Add(wx.StaticText(self.panel,label=' Select calculation type: '),0,WACV)
733	calcType = wx.ComboBox(self.panel,value=self.calcType,choices=calcChoice,
734	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
735	calcType.Bind(wx.EVT_COMBOBOX,OnCalcType)
736	calcSizer.Add(calcType,0,WACV)
737	mainSizer.Add(calcSizer)
738	if self.Parms:
739	parmSel = wx.BoxSizer(wx.HORIZONTAL)
740	parmSel.Add(wx.StaticText(self.panel,label=' Select parameter to vary: '),0,WACV)
741	parmsel = wx.ComboBox(self.panel,value=self.Parm,choices=self.Parms,
742	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
743	parmsel.Bind(wx.EVT_COMBOBOX,OnParmSel)
744	parmSel.Add(parmsel,0,WACV)
745	mainSizer.Add(parmSel)
746	mainSizer.Add(wx.StaticText(self.panel,label=' Enter parameter range & no. steps: '),0,WACV)
747	parmRange = wx.BoxSizer(wx.HORIZONTAL)
748	numChoice = [str(i+1) for i in range(10)]
749	parmrange = wx.TextCtrl(self.panel,value='%.3f %.3f'%(self.parmRange[0],self.parmRange[1]),
750	style=wx.TE_PROCESS_ENTER)
751	parmrange.Bind(wx.EVT_TEXT_ENTER,OnParmRange)
752	parmrange.Bind(wx.EVT_KILL_FOCUS,OnParmRange)
753	parmRange.Add(parmrange,0,WACV)
754	numStep = wx.ComboBox(self.panel,value=str(self.parmStep),choices=numChoice,
755	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
756	numStep.Bind(wx.EVT_COMBOBOX,OnNumStep)
757	parmRange.Add(numStep,0,WACV)
758	mainSizer.Add(parmRange)
759	if 'selected' in self.calcType:
760	planeSizer = wx.BoxSizer(wx.HORIZONTAL)
761	planeSizer.Add(wx.StaticText(self.panel,label=' Select plane: '),0,WACV)
762	plane = wx.ComboBox(self.panel,value=self.plane,choices=self.planeChoice,
763	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
764	plane.Bind(wx.EVT_COMBOBOX,OnPlane)
765	planeSizer.Add(plane,0,WACV)
766	planeSizer.Add(wx.StaticText(self.panel,label=' Max. l index: '),0,WACV)
767	lmax = wx.ComboBox(self.panel,value=self.lmax,choices=self.lmaxChoice,
768	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
769	lmax.Bind(wx.EVT_COMBOBOX,OnMaxL)
770	planeSizer.Add(lmax,0,WACV)
771	mainSizer.Add(planeSizer)
772	else:
773	instChoice = ['None','Mean Gaussian','Gaussian',]
774	instSizer = wx.BoxSizer(wx.HORIZONTAL)
775	instSizer.Add(wx.StaticText(self.panel,label=' Select instrument broadening: '),0,WACV)
776	instsel = wx.ComboBox(self.panel,value=self.Inst,choices=instChoice,
777	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
778	instsel.Bind(wx.EVT_COMBOBOX,OnInstSel)
779	instSizer.Add(instsel,0,WACV)
780	mainSizer.Add(instSizer)
781	OkBtn = wx.Button(self.panel,-1,"Ok")
782	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
783	cancelBtn = wx.Button(self.panel,-1,"Cancel")
784	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
785	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
786	btnSizer.Add((20,20),1)
787	btnSizer.Add(OkBtn)
788	btnSizer.Add((20,20),1)
789	btnSizer.Add(cancelBtn)
790	btnSizer.Add((20,20),1)
791
792	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
793	self.panel.SetSizer(mainSizer)
794	self.panel.Fit()
795	self.Fit()
796
797	def GetSelection(self):
798	if 'powder' in self.calcType:
799	return 'PWDR',self.Inst,self.Parm,self.parmRange,self.parmStep
800	elif 'selected' in self.calcType:
801	return 'SADP',self.plane,self.lmax
802
803	def OnOk(self,event):
804	parent = self.GetParent()
805	parent.Raise()
806	self.EndModal(wx.ID_OK)
807
808	def OnCancel(self,event):
809	parent = self.GetParent()
810	parent.Raise()
811	self.EndModal(wx.ID_CANCEL)
812
813
814	################################################################################
815	class MergeDialog(wx.Dialog):
816	''' HKL transformation & merge dialog
817
818	:param wx.Frame parent: reference to parent frame (or None)
819	:param data: HKLF data
820
821	#NB: commonNames & commonTrans defined at top of this file
822	'''
823	def __init__(self,parent,data):
824	wx.Dialog.__init__(self,parent,wx.ID_ANY,'Setup HKLF merge',
825	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
826	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
827	self.data = data
828	self.Super = data[1]['Super']
829	if self.Super:
830	self.Trans = np.eye(4)
831	else:
832	self.Trans = np.eye(3)
833	self.Cent = 'noncentrosymmetric'
834	self.Laue = '1'
835	self.Class = 'triclinic'
836	self.Common = 'abc'
837	self.Draw()
838
839	def Draw(self):
840
841	def OnMatValue(event):
842	Obj = event.GetEventObject()
843	ix,iy = Ind[Obj.GetId()]
844	self.Trans[ix,iy] = float(Obj.GetValue())
845
846	def OnCent(event):
847	Obj = event.GetEventObject()
848	self.Cent = Obj.GetValue()
849	self.Laue = ''
850	wx.CallAfter(self.Draw)
851
852	def OnLaue(event):
853	Obj = event.GetEventObject()
854	self.Laue = Obj.GetValue()
855	wx.CallAfter(self.Draw)
856
857	def OnClass(event):
858	Obj = event.GetEventObject()
859	self.Class = Obj.GetValue()
860	self.Laue = ''
861	wx.CallAfter(self.Draw)
862
863	def OnCommon(event):
864	Obj = event.GetEventObject()
865	self.Common = Obj.GetValue()
866	self.Trans = commonTrans[self.Common]
867	wx.CallAfter(self.Draw)
868
869	self.panel.Destroy()
870	self.panel = wx.Panel(self)
871	Ind = {}
872	mainSizer = wx.BoxSizer(wx.VERTICAL)
873	MatSizer = wx.BoxSizer(wx.HORIZONTAL)
874	transSizer = wx.BoxSizer(wx.VERTICAL)
875	transSizer.Add(wx.StaticText(self.panel,label=" HKL Transformation matrix: M*H = H'"))
876	if self.Super:
877	Trmat = wx.FlexGridSizer(4,4,0,0)
878	else:
879	commonSizer = wx.BoxSizer(wx.HORIZONTAL)
880	commonSizer.Add(wx.StaticText(self.panel,label=' Common transformations: '),0,WACV)
881	common = wx.ComboBox(self.panel,value=self.Common,choices=commonNames[:-1], #not the last one!
882	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
883	common.Bind(wx.EVT_COMBOBOX,OnCommon)
884	commonSizer.Add(common,0,WACV)
885	transSizer.Add(commonSizer)
886	Trmat = wx.FlexGridSizer(3,3,0,0)
887	for iy,line in enumerate(self.Trans):
888	for ix,val in enumerate(line):
889	item = wx.TextCtrl(self.panel,value='%5.3f'%(val),
890	size=(50,25),style=wx.TE_PROCESS_ENTER)
891	Ind[item.GetId()] = [ix,iy]
892	item.Bind(wx.EVT_TEXT_ENTER,OnMatValue)
893	item.Bind(wx.EVT_KILL_FOCUS,OnMatValue)
894	Trmat.Add(item)
895	transSizer.Add(Trmat)
896	MatSizer.Add((10,0),0)
897	MatSizer.Add(transSizer)
898	mainSizer.Add(MatSizer)
899	laueClass = ['triclinic','monoclinic','orthorhombic','trigonal(H)','tetragonal','hexagonal','cubic']
900	centroLaue = {'triclinic':['-1',],'monoclinic':['2/m','1 1 2/m','2/m 1 1',],
901	'orthorhombic':['m m m',],'trigonal(H)':['-3','-3 m 1','-3 1 m',], \
902	'tetragonal':['4/m','4/m m m',],'hexagonal':['6/m','6/m m m',],'cubic':['m 3','m 3 m']}
903	noncentroLaue = {'triclinic':['1',],'monoclinic':['2','2 1 1','1 1 2','m','m 1 1','1 1 m',],
904	'orthorhombic':['2 2 2','m m 2','m 2 m','2 m m',],
905	'trigonal(H)':['3','3 1 2','3 2 1','3 m 1','3 1 m',],
906	'tetragonal':['4','-4','4 2 2','4 m m','-4 2 m','-4 m 2',], \
907	'hexagonal':['6','-6','6 2 2','6 m m','-6 m 2','-6 2 m',],'cubic':['2 3','4 3 2','-4 3 m']}
908	centChoice = ['noncentrosymmetric','centrosymmetric']
909	mainSizer.Add(wx.StaticText(self.panel,label=' Select Laue class for new lattice:'),0,WACV)
910	Class = wx.ComboBox(self.panel,value=self.Class,choices=laueClass,
911	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
912	Class.Bind(wx.EVT_COMBOBOX,OnClass)
913	mainSizer.Add(Class,0,WACV)
914	mainSizer.Add(wx.StaticText(self.panel,label=' Target Laue symmetry:'),0,WACV)
915	Cent = wx.ComboBox(self.panel,value=self.Cent,choices=centChoice,
916	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
917	Cent.Bind(wx.EVT_COMBOBOX,OnCent)
918	mergeSizer = wx.BoxSizer(wx.HORIZONTAL)
919	mergeSizer.Add(Cent,0,WACV)
920	mergeSizer.Add((10,0),0)
921	Choice = centroLaue[self.Class]
922	if 'non' in self.Cent:
923	Choice = noncentroLaue[self.Class]
924	Laue = wx.ComboBox(self.panel,value=self.Laue,choices=Choice,
925	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
926	Laue.Bind(wx.EVT_COMBOBOX,OnLaue)
927	mergeSizer.Add(Laue,0,WACV)
928	mainSizer.Add(mergeSizer)
929
930	OkBtn = wx.Button(self.panel,-1,"Ok")
931	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
932	cancelBtn = wx.Button(self.panel,-1,"Cancel")
933	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
934	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
935	btnSizer.Add((20,20),1)
936	if self.Laue:
937	btnSizer.Add(OkBtn)
938	btnSizer.Add((20,20),1)
939	btnSizer.Add(cancelBtn)
940	btnSizer.Add((20,20),1)
941
942	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
943	self.panel.SetSizer(mainSizer)
944	self.panel.Fit()
945	self.Fit()
946
947	def GetSelection(self):
948	return self.Trans,self.Cent,self.Laue
949
950	def OnOk(self,event):
951	parent = self.GetParent()
952	parent.Raise()
953	self.EndModal(wx.ID_OK)
954
955	def OnCancel(self,event):
956	parent = self.GetParent()
957	parent.Raise()
958	self.EndModal(wx.ID_CANCEL)
959
960
961	################################################################################
962	class AddHatomDialog(wx.Dialog):
963	'''H atom addition dialog. After :meth:`ShowModal` returns, the results
964	are found in dict :attr:`self.data`, which is accessed using :meth:`GetData`.
965
966	:param wx.Frame parent: reference to parent frame (or None)
967	:param dict Neigh: a dict of atom names with list of atom name, dist pairs for neighboring atoms
968	:param dict phase: a dict containing the phase as defined by
969	:ref:`Phase Tree Item <Phase_table>`
970	'''
971	def __init__(self,parent,Neigh,phase):
972	wx.Dialog.__init__(self,parent,wx.ID_ANY,'H atom add',
973	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
974	self.panel = wxscroll.ScrolledPanel(self) #just a dummy - gets destroyed in Draw!
975	self.Neigh = Neigh
976	self.phase = phase
977	self.Hatoms = []
978	self.Draw(self.Neigh,self.phase)
979
980	def Draw(self,Neigh,phase):
981	'''Creates the contents of the dialog. Normally called
982	by :meth:`__init__`.
983	'''
984	def OnHSelect(event):
985	Obj = event.GetEventObject()
986	item,i = Indx[Obj.GetId()]
987	for obj in Indx[item]:
988	obj.SetValue(False)
989	Obj.SetValue(True)
990	self.Neigh[item][2] = i
991
992	def OnBond(event):
993	Obj = event.GetEventObject()
994	inei,ibond = Indx[Obj.GetId()]
995	self.Neigh[inei][1][0][ibond][2] = Obj.GetValue()
996
997	self.panel.Destroy()
998	self.panel = wxscroll.ScrolledPanel(self,style = wx.DEFAULT_DIALOG_STYLE)
999	mainSizer = wx.BoxSizer(wx.VERTICAL)
1000	mainSizer.Add(wx.StaticText(self.panel,-1,'H atom add controls for phase %s:'%(phase['General']['Name'])),
1001	0,wx.LEFT\|wx.TOP,10)
1002	mainSizer.Add(wx.StaticText(self.panel,-1,'NB: Check selections as they may not be correct'),0,WACV\|wx.LEFT,10)
1003	mainSizer.Add(wx.StaticText(self.panel,-1," Atom: Add # H's Use: Neighbors, dist"),0,wx.TOP\|wx.LEFT,5)
1004	nHatms = ['0','1','2','3']
1005	dataSizer = wx.FlexGridSizer(0,3,0,0)
1006	Indx = {}
1007	for inei,neigh in enumerate(Neigh):
1008	dataSizer.Add(wx.StaticText(self.panel,-1,' %s: '%(neigh[0])),0,WACV)
1009	nH = 1 #for O atom
1010	if 'C' in neigh[0] or 'N' in neigh[0]:
1011	nH = 4-len(neigh[1][0])
1012	checks = wx.BoxSizer(wx.HORIZONTAL)
1013	Ids = []
1014	for i in range(nH+1):
1015	nHs = wx.CheckBox(self.panel,-1,label=nHatms[i])
1016	if i == neigh[2]:
1017	nHs.SetValue(True)
1018	Indx[nHs.GetId()] = [inei,i]
1019	Ids.append(nHs)
1020	nHs.Bind(wx.EVT_CHECKBOX, OnHSelect)
1021	checks.Add(nHs,0,WACV)
1022	Indx[inei] = Ids
1023	dataSizer.Add(checks,0,WACV)
1024	lineSizer = wx.BoxSizer(wx.HORIZONTAL)
1025	for ib,bond in enumerate(neigh[1][0]):
1026	Bond = wx.CheckBox(self.panel,-1,label=': %s, %.3f'%(bond[0],bond[1]))
1027	Bond.SetValue(bond[2])
1028	Indx[Bond.GetId()] = [inei,ib]
1029	Bond.Bind(wx.EVT_CHECKBOX,OnBond)
1030	lineSizer.Add(Bond,0,WACV)
1031	dataSizer.Add(lineSizer,0,WACV\|wx.RIGHT,10)
1032	mainSizer.Add(dataSizer,0,wx.LEFT,5)
1033
1034	CancelBtn = wx.Button(self.panel,-1,'Cancel')
1035	CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
1036	OkBtn = wx.Button(self.panel,-1,'Ok')
1037	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1038	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1039	btnSizer.Add((20,20),1)
1040	btnSizer.Add(OkBtn)
1041	btnSizer.Add((20,20),1)
1042	btnSizer.Add(CancelBtn)
1043	btnSizer.Add((20,20),1)
1044	mainSizer.Add(btnSizer,0,wx.BOTTOM\|wx.TOP, 10)
1045	size = np.array(self.GetSize())
1046	self.panel.SetupScrolling()
1047	self.panel.SetSizer(mainSizer)
1048	self.panel.SetAutoLayout(1)
1049	size = [size[0]-5,size[1]-20] #this fiddling is needed for older wx!
1050	self.panel.SetSize(size)
1051
1052	def GetData(self):
1053	'Returns the values from the dialog'
1054	for neigh in self.Neigh:
1055	for ibond,bond in enumerate(neigh[1][0]):
1056	if not bond[2]:
1057	neigh[1][1][1][ibond] = 0 #deselected bond
1058	neigh[1][1][1] = [a for a in neigh[1][1][1] if a]
1059	return self.Neigh #has #Hs to add for each entry
1060
1061	def OnOk(self,event):
1062	'Called when the OK button is pressed'
1063	parent = self.GetParent()
1064	parent.Raise()
1065	self.EndModal(wx.ID_OK)
1066
1067	def OnCancel(self,event):
1068	parent = self.GetParent()
1069	parent.Raise()
1070	self.EndModal(wx.ID_CANCEL)
1071
1072	################################################################################
1073	class DisAglDialog(wx.Dialog):
1074	'''Distance/Angle Controls input dialog. After
1075	:meth:`ShowModal` returns, the results are found in
1076	dict :attr:`self.data`, which is accessed using :meth:`GetData`.
1077
1078	:param wx.Frame parent: reference to parent frame (or None)
1079	:param dict data: a dict containing the current
1080	search ranges or an empty dict, which causes default values
1081	to be used.
1082	Will be used to set element `DisAglCtls` in
1083	:ref:`Phase Tree Item <Phase_table>`
1084	:param dict default: A dict containing the default
1085	search ranges for each element.
1086	'''
1087	def __init__(self,parent,data,default,Reset=True):
1088	wx.Dialog.__init__(self,parent,wx.ID_ANY,
1089	'Distance Angle Controls',
1090	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
1091	self.default = default
1092	self.Reset = Reset
1093	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
1094	self._default(data,self.default)
1095	self.Draw(self.data)
1096
1097	def _default(self,data,default):
1098	'''Set starting values for the search values, either from
1099	the input array or from defaults, if input is null
1100	'''
1101	if data:
1102	self.data = copy.deepcopy(data) # don't mess with originals
1103	else:
1104	self.data = {}
1105	self.data['Name'] = default['Name']
1106	self.data['Factors'] = [0.85,0.85]
1107	self.data['AtomTypes'] = default['AtomTypes']
1108	self.data['BondRadii'] = default['BondRadii'][:]
1109	self.data['AngleRadii'] = default['AngleRadii'][:]
1110
1111	def Draw(self,data):
1112	'''Creates the contents of the dialog. Normally called
1113	by :meth:`__init__`.
1114	'''
1115	self.panel.Destroy()
1116	self.panel = wx.Panel(self)
1117	mainSizer = wx.BoxSizer(wx.VERTICAL)
1118	mainSizer.Add(wx.StaticText(self.panel,-1,'Controls for phase '+data['Name']),
1119	0,WACV\|wx.LEFT,10)
1120	mainSizer.Add((10,10),1)
1121
1122	radiiSizer = wx.FlexGridSizer(0,3,5,5)
1123	radiiSizer.Add(wx.StaticText(self.panel,-1,' Type'),0,WACV)
1124	radiiSizer.Add(wx.StaticText(self.panel,-1,'Bond radii'),0,WACV)
1125	radiiSizer.Add(wx.StaticText(self.panel,-1,'Angle radii'),0,WACV)
1126	self.objList = {}
1127	for id,item in enumerate(self.data['AtomTypes']):
1128	radiiSizer.Add(wx.StaticText(self.panel,-1,' '+item),0,WACV)
1129	bRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['BondRadii'][id]),style=wx.TE_PROCESS_ENTER)
1130	self.objList[bRadii.GetId()] = ['BondRadii',id]
1131	bRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1132	bRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1133	radiiSizer.Add(bRadii,0,WACV)
1134	aRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['AngleRadii'][id]),style=wx.TE_PROCESS_ENTER)
1135	self.objList[aRadii.GetId()] = ['AngleRadii',id]
1136	aRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1137	aRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1138	radiiSizer.Add(aRadii,0,WACV)
1139	mainSizer.Add(radiiSizer,0,wx.EXPAND)
1140	factorSizer = wx.FlexGridSizer(0,2,5,5)
1141	Names = ['Bond','Angle']
1142	for i,name in enumerate(Names):
1143	factorSizer.Add(wx.StaticText(self.panel,-1,name+' search factor'),0,WACV)
1144	bondFact = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['Factors'][i]),style=wx.TE_PROCESS_ENTER)
1145	self.objList[bondFact.GetId()] = ['Factors',i]
1146	bondFact.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1147	bondFact.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1148	factorSizer.Add(bondFact)
1149	mainSizer.Add(factorSizer,0,wx.EXPAND)
1150
1151	OkBtn = wx.Button(self.panel,-1,"Ok")
1152	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1153	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1154	btnSizer.Add((20,20),1)
1155	btnSizer.Add(OkBtn)
1156	if self.Reset:
1157	ResetBtn = wx.Button(self.panel,-1,'Reset')
1158	ResetBtn.Bind(wx.EVT_BUTTON, self.OnReset)
1159	btnSizer.Add(ResetBtn)
1160	btnSizer.Add((20,20),1)
1161	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
1162	self.panel.SetSizer(mainSizer)
1163	self.panel.Fit()
1164	self.Fit()
1165
1166	def OnRadiiVal(self,event):
1167	Obj = event.GetEventObject()
1168	item = self.objList[Obj.GetId()]
1169	try:
1170	self.data[item[0]][item[1]] = float(Obj.GetValue())
1171	except ValueError:
1172	pass
1173	Obj.SetValue("%.3f"%(self.data[item[0]][item[1]])) #reset in case of error
1174
1175	def GetData(self):
1176	'Returns the values from the dialog'
1177	return self.data
1178
1179	def OnOk(self,event):
1180	'Called when the OK button is pressed'
1181	parent = self.GetParent()
1182	parent.Raise()
1183	self.EndModal(wx.ID_OK)
1184
1185	def OnReset(self,event):
1186	'Called when the Reset button is pressed'
1187	data = {}
1188	self._default(data,self.default)
1189	self.Draw(self.data)
1190
1191	################################################################################
1192	class ShowLSParms(wx.Dialog):
1193	'''Create frame to show least-squares parameters
1194	'''
1195	def __init__(self,parent,title,parmDict,varyList,fullVaryList,
1196	size=(300,430)):
1197	wx.Dialog.__init__(self,parent,wx.ID_ANY,title,size=size,
1198	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
1199	mainSizer = wx.BoxSizer(wx.VERTICAL)
1200
1201	panel = wxscroll.ScrolledPanel(
1202	self, wx.ID_ANY,
1203	#size=size,
1204	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
1205	num = len(varyList)
1206	mainSizer.Add(wx.StaticText(self,wx.ID_ANY,'Number of refined variables: '+str(num)))
1207	if len(varyList) != len(fullVaryList):
1208	num = len(fullVaryList) - len(varyList)
1209	mainSizer.Add(wx.StaticText(self,wx.ID_ANY,' + '+str(num)+' parameters are varied via constraints'))
1210	subSizer = wx.FlexGridSizer(cols=4,hgap=2,vgap=2)
1211	parmNames = parmDict.keys()
1212	parmNames.sort()
1213	subSizer.Add((-1,-1))
1214	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'Parameter name '))
1215	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'refine?'))
1216	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'value'),0,wx.ALIGN_RIGHT)
1217	explainRefine = False
1218	for name in parmNames:
1219	# skip entries without numerical values
1220	if isinstance(parmDict[name],basestring): continue
1221	try:
1222	value = G2py3.FormatSigFigs(parmDict[name])
1223	except TypeError:
1224	value = str(parmDict[name])+' -?' # unexpected
1225	#continue
1226	v = G2obj.getVarDescr(name)
1227	if v is None or v[-1] is None:
1228	subSizer.Add((-1,-1))
1229	else:
1230	ch = G2G.HelpButton(panel,G2obj.fmtVarDescr(name))
1231	subSizer.Add(ch,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1)
1232	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(name)))
1233	if name in varyList:
1234	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'R'))
1235	elif name in fullVaryList:
1236	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'C'))
1237	explainRefine = True
1238	else:
1239	subSizer.Add((-1,-1))
1240	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
1241
1242	# finish up ScrolledPanel
1243	panel.SetSizer(subSizer)
1244	panel.SetAutoLayout(1)
1245	panel.SetupScrolling()
1246	mainSizer.Add(panel,1, wx.ALL\|wx.EXPAND,1)
1247
1248	if explainRefine:
1249	mainSizer.Add(
1250	wx.StaticText(self,wx.ID_ANY,
1251	'"R" indicates a refined variable\n'+
1252	'"C" indicates generated from a constraint'
1253	),
1254	0, wx.ALL,0)
1255	# make OK button
1256	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
1257	btn = wx.Button(self, wx.ID_CLOSE,"Close")
1258	btn.Bind(wx.EVT_BUTTON,self._onClose)
1259	btnsizer.Add(btn)
1260	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
1261	# Allow window to be enlarged but not made smaller
1262	self.SetSizer(mainSizer)
1263	self.SetMinSize(self.GetSize())
1264
1265	def _onClose(self,event):
1266	self.EndModal(wx.ID_CANCEL)
1267
1268	################################################################################
1269	class DataFrame(wx.Frame):
1270	'''Create the data item window and all the entries in menus used in
1271	that window. For Linux and windows, the menu entries are created for the
1272	current data item window, but in the Mac the menu is accessed from all
1273	windows. This means that a different menu is posted depending on which
1274	data item is posted. On the Mac, all the menus contain the data tree menu
1275	items, but additional menus are added specific to the data item.
1276
1277	Note that while the menus are created here,
1278	the binding for the menus is done later in various GSASII*GUI modules,
1279	where the functions to be called are defined.
1280	'''
1281	def Bind(self,eventtype,handler,args,*kwargs):
1282	'''Override the Bind() function: on the Mac the binding is to
1283	the main window, so that menus operate with any window on top.
1284	For other platforms, either wrap calls that will be logged
1285	or call the default wx.Frame Bind() to bind to the menu item directly.
1286
1287	Note that bindings can be made to objects by Id or by direct reference to the
1288	object. As a convention, when bindings are to objects, they are not logged
1289	but when bindings are by Id, they are logged.
1290	'''
1291	if sys.platform == "darwin": # mac
1292	self.G2frame.Bind(eventtype,handler,args,*kwargs)
1293	return
1294	if eventtype == wx.EVT_MENU and 'id' in kwargs:
1295	menulabels = log.SaveMenuCommand(kwargs['id'],self.G2frame,handler)
1296	if menulabels:
1297	#print 'intercepting bind for',handler,menulabels,kwargs['id']
1298	wx.Frame.Bind(self,eventtype,self.G2frame.MenuBinding,args,*kwargs)
1299	return
1300	wx.Frame.Bind(self,eventtype,handler,args,*kwargs)
1301
1302	def PrefillDataMenu(self,menu,helpType,helpLbl=None,empty=False):
1303	'''Create the "standard" part of data frame menus. Note that on Linux and
1304	Windows nothing happens here. On Mac, this menu duplicates the
1305	tree menu, but adds an extra help command for the data item and a separator.
1306	'''
1307	self.datamenu = menu
1308	self.G2frame.dataMenuBars.append(menu)
1309	self.helpType = helpType
1310	self.helpLbl = helpLbl
1311	if sys.platform == "darwin": # mac
1312	self.G2frame.FillMainMenu(menu) # add the data tree menu items
1313	if not empty:
1314	menu.Append(wx.Menu(title=''),title='\|') # add a separator
1315
1316	def PostfillDataMenu(self,empty=False):
1317	'''Create the "standard" part of data frame menus. Note that on Linux and
1318	Windows, this is the standard help Menu. On Mac, this menu duplicates the
1319	tree menu, but adds an extra help command for the data item and a separator.
1320	'''
1321	menu = self.datamenu
1322	helpType = self.helpType
1323	helpLbl = self.helpLbl
1324	if sys.platform == "darwin": # mac
1325	if not empty:
1326	menu.Append(wx.Menu(title=''),title='\|') # add another separator
1327	menu.Append(G2G.AddHelp(self.G2frame,helpType=helpType, helpLbl=helpLbl),
1328	title='&Help')
1329	else: # other
1330	menu.Append(menu=G2G.MyHelp(self,helpType=helpType, helpLbl=helpLbl),
1331	title='&Help')
1332
1333	def _init_menus(self):
1334	'define all GSAS-II data frame menus'
1335
1336	# for use where no menu or data frame help is provided
1337	self.BlankMenu = wx.MenuBar()
1338
1339	# Controls
1340	self.ControlsMenu = wx.MenuBar()
1341	self.PrefillDataMenu(self.ControlsMenu,helpType='Controls',empty=True)
1342	self.PostfillDataMenu(empty=True)
1343
1344	# Notebook
1345	self.DataNotebookMenu = wx.MenuBar()
1346	self.PrefillDataMenu(self.DataNotebookMenu,helpType='Notebook',empty=True)
1347	self.PostfillDataMenu(empty=True)
1348
1349	# Comments
1350	self.DataCommentsMenu = wx.MenuBar()
1351	self.PrefillDataMenu(self.DataCommentsMenu,helpType='Comments',empty=True)
1352	self.PostfillDataMenu(empty=True)
1353
1354	# Constraints - something amiss here - get weird wx C++ error after refine!
1355	self.ConstraintMenu = wx.MenuBar()
1356	self.PrefillDataMenu(self.ConstraintMenu,helpType='Constraints')
1357	self.ConstraintTab = wx.Menu(title='')
1358	self.ConstraintMenu.Append(menu=self.ConstraintTab, title='Select tab')
1359	for id,txt in (
1360	(wxID_CONSPHASE,'Phase'),
1361	(wxID_CONSHAP,'Histogram/Phase'),
1362	(wxID_CONSHIST,'Histogram'),
1363	(wxID_CONSGLOBAL,'Global')):
1364	self.ConstraintTab.Append(
1365	id=id, kind=wx.ITEM_NORMAL,text=txt,
1366	help='Select '+txt+' constraint editing tab')
1367	self.ConstraintEdit = wx.Menu(title='')
1368	self.ConstraintMenu.Append(menu=self.ConstraintEdit, title='Edit')
1369	self.ConstraintEdit.Append(id=wxID_HOLDADD, kind=wx.ITEM_NORMAL,text='Add hold',
1370	help='Add hold on a parameter value')
1371	self.ConstraintEdit.Append(id=wxID_EQUIVADD, kind=wx.ITEM_NORMAL,text='Add equivalence',
1372	help='Add equivalence between parameter values')
1373	self.ConstraintEdit.Append(id=wxID_CONSTRAINTADD, kind=wx.ITEM_NORMAL,text='Add constraint',
1374	help='Add constraint on parameter values')
1375	self.ConstraintEdit.Append(id=wxID_FUNCTADD, kind=wx.ITEM_NORMAL,text='Add New Var',
1376	help='Add variable composed of existing parameter')
1377	self.ConstraintEdit.Append(id=wxID_EQUIVALANCEATOMS, kind=wx.ITEM_NORMAL,text='Add atom equivalence',
1378	help='Add equivalences between atom parameter values')
1379	self.ConstraintEdit.Enable(wxID_EQUIVALANCEATOMS,False)
1380	# self.ConstraintEdit.Append(id=wxID_ADDRIDING, kind=wx.ITEM_NORMAL,text='Add H riding constraints',
1381	# help='Add H atom riding constraints between atom parameter values')
1382	# self.ConstraintEdit.Enable(wxID_ADDRIDING,False)
1383	self.PostfillDataMenu()
1384
1385	# item = self.ConstraintEdit.Append(id=wx.ID_ANY,kind=wx.ITEM_NORMAL,text='Update GUI')
1386	# def UpdateGSASIIconstrGUI(event):
1387	# import GSASIIconstrGUI
1388	# reload(GSASIIconstrGUI)
1389	# import GSASIIobj
1390	# reload(GSASIIobj)
1391	# self.Bind(wx.EVT_MENU,UpdateGSASIIconstrGUI,id=item.GetId())
1392
1393	# Rigid bodies
1394	self.RigidBodyMenu = wx.MenuBar()
1395	self.PrefillDataMenu(self.RigidBodyMenu,helpType='Rigid bodies')
1396	self.ResidueRBMenu = wx.Menu(title='')
1397	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYIMPORT, kind=wx.ITEM_NORMAL,text='Import XYZ',
1398	help='Import rigid body XYZ from file')
1399	self.ResidueRBMenu.Append(id=wxID_RESIDUETORSSEQ, kind=wx.ITEM_NORMAL,text='Define sequence',
1400	help='Define torsion sequence')
1401	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYADD, kind=wx.ITEM_NORMAL,text='Import residues',
1402	help='Import residue rigid bodies from macro file')
1403	self.RigidBodyMenu.Append(menu=self.ResidueRBMenu, title='Edit Body')
1404	self.PostfillDataMenu()
1405
1406	self.VectorBodyMenu = wx.MenuBar()
1407	self.PrefillDataMenu(self.VectorBodyMenu,helpType='Vector rigid bodies')
1408	self.VectorRBEdit = wx.Menu(title='')
1409	self.VectorRBEdit.Append(id=wxID_VECTORBODYADD, kind=wx.ITEM_NORMAL,text='Add rigid body',
1410	help='Add vector rigid body')
1411	self.VectorBodyMenu.Append(menu=self.VectorRBEdit, title='Edit Vector Body')
1412	self.PostfillDataMenu()
1413
1414
1415	# Restraints
1416	self.RestraintTab = wx.Menu(title='')
1417	self.RestraintEdit = wx.Menu(title='')
1418	self.RestraintEdit.Append(id=wxID_RESTSELPHASE, kind=wx.ITEM_NORMAL,text='Select phase',
1419	help='Select phase')
1420	self.RestraintEdit.Append(id=wxID_RESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add restraints',
1421	help='Add restraints')
1422	self.RestraintEdit.Enable(wxID_RESTRAINTADD,True) #gets disabled if macromolecule phase
1423	self.RestraintEdit.Append(id=wxID_AARESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add residue restraints',
1424	help='Add residue based restraints for macromolecules from macro file')
1425	self.RestraintEdit.Enable(wxID_AARESTRAINTADD,False) #gets enabled if macromolecule phase
1426	self.RestraintEdit.Append(id=wxID_AARESTRAINTPLOT, kind=wx.ITEM_NORMAL,text='Plot residue restraints',
1427	help='Plot selected residue based restraints for macromolecules from macro file')
1428	self.RestraintEdit.Enable(wxID_AARESTRAINTPLOT,False) #gets enabled if macromolecule phase
1429	self.RestraintEdit.Append(id=wxID_RESRCHANGEVAL, kind=wx.ITEM_NORMAL,text='Change value',
1430	help='Change observed value')
1431	self.RestraintEdit.Append(id=wxID_RESTCHANGEESD, kind=wx.ITEM_NORMAL,text='Change esd',
1432	help='Change esd in observed value')
1433	self.RestraintEdit.Append(id=wxID_RESTDELETE, kind=wx.ITEM_NORMAL,text='Delete restraints',
1434	help='Delete selected restraints')
1435
1436	self.RestraintMenu = wx.MenuBar()
1437	self.PrefillDataMenu(self.RestraintMenu,helpType='Restraints')
1438	self.RestraintMenu.Append(menu=self.RestraintTab, title='Select tab')
1439	self.RestraintMenu.Append(menu=self.RestraintEdit, title='Edit')
1440	self.PostfillDataMenu()
1441
1442	# Sequential results
1443	self.SequentialMenu = wx.MenuBar()
1444	self.PrefillDataMenu(self.SequentialMenu,helpType='Sequential',helpLbl='Sequential Refinement')
1445	self.SequentialFile = wx.Menu(title='')
1446	self.SequentialMenu.Append(menu=self.SequentialFile, title='Columns')
1447	self.SequentialFile.Append(id=wxID_RENAMESEQSEL, kind=wx.ITEM_NORMAL,text='Rename selected',
1448	help='Rename selected sequential refinement columns')
1449	self.SequentialFile.Append(id=wxID_SAVESEQSEL, kind=wx.ITEM_NORMAL,text='Save selected as text',
1450	help='Save selected sequential refinement results as a text file')
1451	self.SequentialFile.Append(id=wxID_SAVESEQCSV, kind=wx.ITEM_NORMAL,text='Save all as CSV',
1452	help='Save all sequential refinement results as a CSV spreadsheet file')
1453	self.SequentialFile.Append(id=wxID_SAVESEQSELCSV, kind=wx.ITEM_NORMAL,text='Save selected as CSV',
1454	help='Save selected sequential refinement results as a CSV spreadsheet file')
1455	self.SequentialFile.Append(id=wxID_PLOTSEQSEL, kind=wx.ITEM_NORMAL,text='Plot selected',
1456	help='Plot selected sequential refinement results')
1457	self.SequentialFile.Append(id=wxID_AVESEQSEL, kind=wx.ITEM_NORMAL,text='Compute average',
1458	help='Compute average for selected parameter')
1459	self.SequentialFile.Append(id=wxID_ORGSEQSEL, kind=wx.ITEM_NORMAL,text='Reorganize',
1460	help='Reorganize variables where variables change')
1461	self.SequentialPvars = wx.Menu(title='')
1462	self.SequentialMenu.Append(menu=self.SequentialPvars, title='Pseudo Vars')
1463	self.SequentialPvars.Append(
1464	id=wxADDSEQVAR, kind=wx.ITEM_NORMAL,text='Add Formula',
1465	help='Add a new custom pseudo-variable')
1466	self.SequentialPvars.Append(
1467	id=wxADDSEQDIST, kind=wx.ITEM_NORMAL,text='Add Distance',
1468	help='Add a new bond distance pseudo-variable')
1469	self.SequentialPvars.Append(
1470	id=wxADDSEQANGLE, kind=wx.ITEM_NORMAL,text='Add Angle',
1471	help='Add a new bond angle pseudo-variable')
1472	self.SequentialPvars.Append(
1473	id=wxDELSEQVAR, kind=wx.ITEM_NORMAL,text='Delete',
1474	help='Delete an existing pseudo-variable')
1475	self.SequentialPvars.Append(
1476	id=wxEDITSEQVAR, kind=wx.ITEM_NORMAL,text='Edit',
1477	help='Edit an existing pseudo-variable')
1478
1479	self.SequentialPfit = wx.Menu(title='')
1480	self.SequentialMenu.Append(menu=self.SequentialPfit, title='Parametric Fit')
1481	self.SequentialPfit.Append(
1482	id=wxADDPARFIT, kind=wx.ITEM_NORMAL,text='Add equation',
1483	help='Add a new equation to minimize')
1484	self.SequentialPfit.Append(
1485	id=wxCOPYPARFIT, kind=wx.ITEM_NORMAL,text='Copy equation',
1486	help='Copy an equation to minimize - edit it next')
1487	self.SequentialPfit.Append(
1488	id=wxDELPARFIT, kind=wx.ITEM_NORMAL,text='Delete equation',
1489	help='Delete an equation for parametric minimization')
1490	self.SequentialPfit.Append(
1491	id=wxEDITPARFIT, kind=wx.ITEM_NORMAL,text='Edit equation',
1492	help='Edit an existing parametric minimization equation')
1493	self.SequentialPfit.Append(
1494	id=wxDOPARFIT, kind=wx.ITEM_NORMAL,text='Fit to equation(s)',
1495	help='Perform a parametric minimization')
1496	self.PostfillDataMenu()
1497
1498	# PWDR & SASD
1499	self.PWDRMenu = wx.MenuBar()
1500	self.PrefillDataMenu(self.PWDRMenu,helpType='PWDR Analysis',helpLbl='Powder Fit Error Analysis')
1501	self.ErrorAnal = wx.Menu(title='')
1502	self.PWDRMenu.Append(menu=self.ErrorAnal,title='Commands')
1503	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Error Analysis',
1504	help='Error analysis on powder pattern')
1505	self.ErrorAnal.Append(id=wxID_PWDCOPY,kind=wx.ITEM_NORMAL,text='Copy params',
1506	help='Copy of PWDR parameters')
1507	self.ErrorAnal.Append(id=wxID_PLOTCTRLCOPY,kind=wx.ITEM_NORMAL,text='Copy plot controls',
1508	help='Copy of PWDR plot controls')
1509
1510	self.PostfillDataMenu()
1511
1512	# HKLF
1513	self.HKLFMenu = wx.MenuBar()
1514	self.PrefillDataMenu(self.HKLFMenu,helpType='HKLF Analysis',helpLbl='HKLF Fit Error Analysis')
1515	self.ErrorAnal = wx.Menu(title='')
1516	self.HKLFMenu.Append(menu=self.ErrorAnal,title='Commands')
1517	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Error Analysis',
1518	help='Error analysis on single crystal data')
1519	self.ErrorAnal.Append(id=wxID_MERGEHKL,kind=wx.ITEM_NORMAL,text='Merge HKLs',
1520	help='Transform & merge HKLF data to new histogram')
1521	self.ErrorAnal.Append(id=wxID_PWD3DHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot 3D HKLs',
1522	help='Plot HKLs from single crystal data in 3D')
1523	self.ErrorAnal.Append(id=wxID_3DALLHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot all 3D HKLs',
1524	help='Plot HKLs from all single crystal data in 3D')
1525	self.ErrorAnal.Append(id=wxID_PWDCOPY,kind=wx.ITEM_NORMAL,text='Copy params',
1526	help='Copy of HKLF parameters')
1527	self.PostfillDataMenu()
1528
1529	# PDR / Limits
1530	self.LimitMenu = wx.MenuBar()
1531	self.PrefillDataMenu(self.LimitMenu,helpType='Limits')
1532	self.LimitEdit = wx.Menu(title='')
1533	self.LimitMenu.Append(menu=self.LimitEdit, title='Edit')
1534	self.LimitEdit.Append(id=wxID_LIMITCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1535	help='Copy limits to other histograms')
1536	self.LimitEdit.Append(id=wxID_ADDEXCLREGION, kind=wx.ITEM_NORMAL,text='Add exclude',
1537	help='Add excluded region - select a point on plot; drag to adjust')
1538	self.PostfillDataMenu()
1539
1540	# PDR / Background
1541	self.BackMenu = wx.MenuBar()
1542	self.PrefillDataMenu(self.BackMenu,helpType='Background')
1543	self.BackEdit = wx.Menu(title='')
1544	self.BackMenu.Append(menu=self.BackEdit, title='File')
1545	self.BackEdit.Append(id=wxID_BACKCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1546	help='Copy background parameters to other histograms')
1547	self.BackEdit.Append(id=wxID_BACKFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1548	help='Copy background refinement flags to other histograms')
1549	self.BackEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks',
1550	help='Move background peaks to Peak List')
1551	self.BackFixed = wx.Menu(title='') # fixed background point menu
1552	self.BackMenu.Append(menu=self.BackFixed, title='Fixed Points')
1553	self.wxID_BackPts = {}
1554	self.wxID_BackPts['Add'] = wx.NewId() # N.B. not using wxID_ global as for other menu items
1555	self.BackFixed.Append(id=self.wxID_BackPts['Add'], kind=wx.ITEM_RADIO,text='Add',
1556	help='Add fixed background points with mouse clicks')
1557	self.wxID_BackPts['Move'] = wx.NewId()
1558	item = self.BackFixed.Append(id=self.wxID_BackPts['Move'], kind=wx.ITEM_RADIO,text='Move',
1559	help='Move selected fixed background points with mouse drags')
1560	item.Check(True)
1561	self.wxID_BackPts['Del'] = wx.NewId()
1562	self.BackFixed.Append(id=self.wxID_BackPts['Del'], kind=wx.ITEM_RADIO,text='Delete',
1563	help='Delete fixed background points with mouse clicks')
1564	self.wxID_BackPts['Clear'] = wx.NewId()
1565	self.BackFixed.Append(id=self.wxID_BackPts['Clear'], kind=wx.ITEM_NORMAL,text='Clear',
1566	help='Clear fixed background points')
1567	self.wxID_BackPts['Fit'] = wx.NewId()
1568	self.BackFixed.Append(id=self.wxID_BackPts['Fit'], kind=wx.ITEM_NORMAL,text='Fit background',
1569	help='Fit background function to fixed background points')
1570	self.PostfillDataMenu()
1571
1572	# PDR / Instrument Parameters
1573	self.InstMenu = wx.MenuBar()
1574	self.PrefillDataMenu(self.InstMenu,helpType='Instrument Parameters')
1575	self.InstEdit = wx.Menu(title='')
1576	self.InstMenu.Append(menu=self.InstEdit, title='Operations')
1577	self.InstEdit.Append(help='Calibrate from indexed peaks',
1578	id=wxID_INSTCALIB, kind=wx.ITEM_NORMAL,text='Calibrate')
1579	self.InstEdit.Append(help='Reset instrument profile parameters to default',
1580	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
1581	self.InstEdit.Append(help='Load instrument profile parameters from file',
1582	id=wxID_INSTLOAD, kind=wx.ITEM_NORMAL,text='Load profile...')
1583	self.InstEdit.Append(help='Save all instrument profile parameters to one file',
1584	id=wxID_INSTSAVE, kind=wx.ITEM_NORMAL,text='Save profile...')
1585	self.InstEdit.Append(help='Save instrument profile parameters to file',
1586	id=wxID_INSTSAVEALL, kind=wx.ITEM_NORMAL,text='Save all profile...')
1587	self.InstEdit.Append(help='Copy instrument profile parameters to other histograms',
1588	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
1589	self.InstEdit.Append(id=wxID_INSTFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1590	help='Copy instrument parameter refinement flags to other histograms')
1591	# self.InstEdit.Append(help='Change radiation type (Ka12 - synch)',
1592	# id=wxID_CHANGEWAVETYPE, kind=wx.ITEM_NORMAL,text='Change radiation')
1593	self.InstEdit.Append(id=wxID_INST1VAL, kind=wx.ITEM_NORMAL,text='Set one value',
1594	help='Set one instrument parameter value across multiple histograms')
1595
1596	self.PostfillDataMenu()
1597
1598	# PDR / Sample Parameters
1599	self.SampleMenu = wx.MenuBar()
1600	self.PrefillDataMenu(self.SampleMenu,helpType='Sample Parameters')
1601	self.SampleEdit = wx.Menu(title='')
1602	self.SampleMenu.Append(menu=self.SampleEdit, title='Command')
1603	self.SetScale = self.SampleEdit.Append(id=wxID_SETSCALE, kind=wx.ITEM_NORMAL,text='Set scale',
1604	help='Set scale by matching to another histogram')
1605	self.SampleEdit.Append(id=wxID_SAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load',
1606	help='Load sample parameters from file')
1607	self.SampleEdit.Append(id=wxID_SAMPLESAVE, kind=wx.ITEM_NORMAL,text='Save',
1608	help='Save sample parameters to file')
1609	self.SampleEdit.Append(id=wxID_SAMPLECOPY, kind=wx.ITEM_NORMAL,text='Copy',
1610	help='Copy refinable and most other sample parameters to other histograms')
1611	self.SampleEdit.Append(id=wxID_SAMPLECOPYSOME, kind=wx.ITEM_NORMAL,text='Copy selected...',
1612	help='Copy selected sample parameters to other histograms')
1613	self.SampleEdit.Append(id=wxID_SAMPLEFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1614	help='Copy sample parameter refinement flags to other histograms')
1615	self.SampleEdit.Append(id=wxID_SAMPLE1VAL, kind=wx.ITEM_NORMAL,text='Set one value',
1616	help='Set one sample parameter value across multiple histograms')
1617	self.SampleEdit.Append(id=wxID_ALLSAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load all',
1618	help='Load sample parmameters over multiple histograms')
1619
1620	self.PostfillDataMenu()
1621	self.SetScale.Enable(False)
1622
1623	# PDR / Peak List
1624	self.PeakMenu = wx.MenuBar()
1625	self.PrefillDataMenu(self.PeakMenu,helpType='Peak List')
1626	self.PeakEdit = wx.Menu(title='')
1627	self.PeakMenu.Append(menu=self.PeakEdit, title='Peak Fitting')
1628	self.AutoSearch = self.PeakEdit.Append(help='Automatic peak search',
1629	id=wxID_AUTOSEARCH, kind=wx.ITEM_NORMAL,text='Auto search')
1630	self.UnDo = self.PeakEdit.Append(help='Undo last least squares refinement',
1631	id=wxID_UNDO, kind=wx.ITEM_NORMAL,text='UnDo')
1632	self.PeakFit = self.PeakEdit.Append(id=wxID_LSQPEAKFIT, kind=wx.ITEM_NORMAL,text='Peakfit',
1633	help='Peak fitting' )
1634	self.PFOneCycle = self.PeakEdit.Append(id=wxID_LSQONECYCLE, kind=wx.ITEM_NORMAL,text='Peakfit one cycle',
1635	help='One cycle of Peak fitting' )
1636	self.PeakEdit.Append(id=wxID_RESETSIGGAM, kind=wx.ITEM_NORMAL,
1637	text='Reset sig and gam',help='Reset sigma and gamma to global fit' )
1638	self.PeakCopy = self.PeakEdit.Append(help='Copy peaks to other histograms',
1639	id=wxID_PEAKSCOPY, kind=wx.ITEM_NORMAL,text='Peak copy')
1640	self.SeqPeakFit = self.PeakEdit.Append(id=wxID_SEQPEAKFIT, kind=wx.ITEM_NORMAL,text='Seq PeakFit',
1641	help='Sequential Peak fitting for all histograms' )
1642	self.PeakEdit.Append(id=wxID_CLEARPEAKS, kind=wx.ITEM_NORMAL,text='Clear peaks',
1643	help='Clear the peak list' )
1644	self.PostfillDataMenu()
1645	self.UnDo.Enable(False)
1646	self.PeakFit.Enable(False)
1647	self.PFOneCycle.Enable(False)
1648	self.AutoSearch.Enable(True)
1649
1650	# PDR / Index Peak List
1651	self.IndPeaksMenu = wx.MenuBar()
1652	self.PrefillDataMenu(self.IndPeaksMenu,helpType='Index Peak List')
1653	self.IndPeaksEdit = wx.Menu(title='')
1654	self.IndPeaksMenu.Append(menu=self.IndPeaksEdit,title='Operations')
1655	self.IndPeaksEdit.Append(help='Load/Reload index peaks from peak list',id=wxID_INDXRELOAD,
1656	kind=wx.ITEM_NORMAL,text='Load/Reload')
1657	self.PostfillDataMenu()
1658
1659	# PDR / Unit Cells List
1660	self.IndexMenu = wx.MenuBar()
1661	self.PrefillDataMenu(self.IndexMenu,helpType='Unit Cells List')
1662	self.IndexEdit = wx.Menu(title='')
1663	self.IndexMenu.Append(menu=self.IndexEdit, title='Cell Index/Refine')
1664	self.IndexPeaks = self.IndexEdit.Append(help='', id=wxID_INDEXPEAKS, kind=wx.ITEM_NORMAL,
1665	text='Index Cell')
1666	self.CopyCell = self.IndexEdit.Append( id=wxID_COPYCELL, kind=wx.ITEM_NORMAL,text='Copy Cell',
1667	help='Copy selected unit cell from indexing to cell refinement fields')
1668	self.RefineCell = self.IndexEdit.Append( id=wxID_REFINECELL, kind=wx.ITEM_NORMAL,
1669	text='Refine Cell',help='Refine unit cell parameters from indexed peaks')
1670	self.MakeNewPhase = self.IndexEdit.Append( id=wxID_MAKENEWPHASE, kind=wx.ITEM_NORMAL,
1671	text='Make new phase',help='Make new phase from selected unit cell')
1672	self.ExportCells = self.IndexEdit.Append( id=wxID_EXPORTCELLS, kind=wx.ITEM_NORMAL,
1673	text='Export cell list',help='Export cell list to csv file')
1674	self.PostfillDataMenu()
1675	self.IndexPeaks.Enable(False)
1676	self.CopyCell.Enable(False)
1677	self.RefineCell.Enable(False)
1678	self.MakeNewPhase.Enable(False)
1679
1680	# PDR / Reflection Lists
1681	self.ReflMenu = wx.MenuBar()
1682	self.PrefillDataMenu(self.ReflMenu,helpType='Reflection List')
1683	self.ReflEdit = wx.Menu(title='')
1684	self.ReflMenu.Append(menu=self.ReflEdit, title='Reflection List')
1685	self.SelectPhase = self.ReflEdit.Append(help='Select phase for reflection list',id=wxID_SELECTPHASE,
1686	kind=wx.ITEM_NORMAL,text='Select phase')
1687	self.ReflEdit.Append(id=wxID_PWDHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot HKLs',
1688	help='Plot HKLs from powder pattern')
1689	self.ReflEdit.Append(id=wxID_PWD3DHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot 3D HKLs',
1690	help='Plot HKLs from powder pattern in 3D')
1691	self.PostfillDataMenu()
1692
1693	# SASD / Instrument Parameters
1694	self.SASDInstMenu = wx.MenuBar()
1695	self.PrefillDataMenu(self.SASDInstMenu,helpType='Instrument Parameters')
1696	self.SASDInstEdit = wx.Menu(title='')
1697	self.SASDInstMenu.Append(menu=self.SASDInstEdit, title='Operations')
1698	self.InstEdit.Append(help='Reset instrument profile parameters to default',
1699	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
1700	self.SASDInstEdit.Append(help='Copy instrument profile parameters to other histograms',
1701	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
1702	self.PostfillDataMenu()
1703
1704	#SASD & REFL/ Substance editor
1705	self.SubstanceMenu = wx.MenuBar()
1706	self.PrefillDataMenu(self.SubstanceMenu,helpType='Substances')
1707	self.SubstanceEdit = wx.Menu(title='')
1708	self.SubstanceMenu.Append(menu=self.SubstanceEdit, title='Edit')
1709	self.SubstanceEdit.Append(id=wxID_LOADSUBSTANCE, kind=wx.ITEM_NORMAL,text='Load substance',
1710	help='Load substance from file')
1711	self.SubstanceEdit.Append(id=wxID_ADDSUBSTANCE, kind=wx.ITEM_NORMAL,text='Add substance',
1712	help='Add new substance to list')
1713	self.SubstanceEdit.Append(id=wxID_COPYSUBSTANCE, kind=wx.ITEM_NORMAL,text='Copy substances',
1714	help='Copy substances')
1715	self.SubstanceEdit.Append(id=wxID_DELETESUBSTANCE, kind=wx.ITEM_NORMAL,text='Delete substance',
1716	help='Delete substance from list')
1717	self.SubstanceEdit.Append(id=wxID_ELEMENTADD, kind=wx.ITEM_NORMAL,text='Add elements',
1718	help='Add elements to substance')
1719	self.SubstanceEdit.Append(id=wxID_ELEMENTDELETE, kind=wx.ITEM_NORMAL,text='Delete elements',
1720	help='Delete elements from substance')
1721	self.PostfillDataMenu()
1722
1723	# SASD/ Models
1724	self.ModelMenu = wx.MenuBar()
1725	self.PrefillDataMenu(self.ModelMenu,helpType='Models')
1726	self.ModelEdit = wx.Menu(title='')
1727	self.ModelMenu.Append(menu=self.ModelEdit, title='Models')
1728	self.ModelEdit.Append(id=wxID_MODELADD,kind=wx.ITEM_NORMAL,text='Add',
1729	help='Add new term to model')
1730	self.ModelEdit.Append(id=wxID_MODELFIT, kind=wx.ITEM_NORMAL,text='Fit',
1731	help='Fit model parameters to data')
1732	self.SasdUndo = self.ModelEdit.Append(id=wxID_MODELUNDO, kind=wx.ITEM_NORMAL,text='Undo',
1733	help='Undo model fit')
1734	self.SasdUndo.Enable(False)
1735	self.ModelEdit.Append(id=wxID_MODELFITALL, kind=wx.ITEM_NORMAL,text='Sequential fit',
1736	help='Sequential fit of model parameters to all SASD data')
1737	self.ModelEdit.Append(id=wxID_MODELCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1738	help='Copy model parameters to other histograms')
1739	self.ModelEdit.Append(id=wxID_MODELCOPYFLAGS, kind=wx.ITEM_NORMAL,text='Copy flags',
1740	help='Copy model refinement flags to other histograms')
1741	self.PostfillDataMenu()
1742
1743	# IMG / Image Controls
1744	self.ImageMenu = wx.MenuBar()
1745	self.PrefillDataMenu(self.ImageMenu,helpType='Image Controls')
1746	self.ImageEdit = wx.Menu(title='')
1747	self.ImageMenu.Append(menu=self.ImageEdit, title='Operations')
1748	self.ImageEdit.Append(help='Calibrate detector by fitting to calibrant lines',
1749	id=wxID_IMCALIBRATE, kind=wx.ITEM_NORMAL,text='Calibrate')
1750	self.ImageEdit.Append(help='Recalibrate detector by fitting to calibrant lines',
1751	id=wxID_IMRECALIBRATE, kind=wx.ITEM_NORMAL,text='Recalibrate')
1752	self.ImageEdit.Append(help='Recalibrate all images by fitting to calibrant lines',
1753	id=wxID_IMRECALIBALL, kind=wx.ITEM_NORMAL,text='Recalibrate all')
1754	self.ImageEdit.Append(help='Clear calibration data points and rings',id=wxID_IMCLEARCALIB,
1755	kind=wx.ITEM_NORMAL,text='Clear calibration')
1756	self.ImageEdit.Append(help='Integrate selected image',id=wxID_IMINTEGRATE,
1757	kind=wx.ITEM_NORMAL,text='Integrate')
1758	self.ImageEdit.Append(help='Integrate all images selected from list',id=wxID_INTEGRATEALL,
1759	kind=wx.ITEM_NORMAL,text='Integrate all')
1760	self.ImageEdit.Append(help='Copy image controls to other images',
1761	id=wxID_IMCOPYCONTROLS, kind=wx.ITEM_NORMAL,text='Copy Controls')
1762	self.ImageEdit.Append(help='Copy selected image controls to other images',
1763	id=wxID_IMCOPYSELECTED, kind=wx.ITEM_NORMAL,text='Copy Selected')
1764	self.ImageEdit.Append(help='Save image controls to file',
1765	id=wxID_IMSAVECONTROLS, kind=wx.ITEM_NORMAL,text='Save Controls')
1766	self.ImageEdit.Append(help='Save controls from selected images to file',
1767	id=wxID_SAVESELECTEDCONTROLS, kind=wx.ITEM_NORMAL,text='Save Multiple Controls')
1768	self.ImageEdit.Append(help='Load image controls from file',
1769	id=wxID_IMLOADCONTROLS, kind=wx.ITEM_NORMAL,text='Load Controls')
1770	self.ImageEdit.Append(help='Open Auto-integration window to integrate a series of images',
1771	id=wxID_IMAUTOINTEG, kind=wx.ITEM_NORMAL,text='Auto Integrate')
1772	self.PostfillDataMenu()
1773
1774	# IMG / Masks
1775	self.MaskMenu = wx.MenuBar()
1776	self.PrefillDataMenu(self.MaskMenu,helpType='Image Masks')
1777	self.MaskEdit = wx.Menu(title='')
1778	self.MaskMenu.Append(menu=self.MaskEdit, title='Operations')
1779	submenu = wx.Menu()
1780	self.MaskEdit.AppendMenu(
1781	wx.ID_ANY,'Create new', submenu,
1782	help=''
1783	)
1784	self.MaskEdit.Append(help='Copy mask to other images',
1785	id=wxID_MASKCOPY, kind=wx.ITEM_NORMAL,text='Copy mask')
1786	self.MaskEdit.Append(help='Save mask to file',
1787	id=wxID_MASKSAVE, kind=wx.ITEM_NORMAL,text='Save mask')
1788	self.MaskEdit.Append(help='Load mask from file',
1789	id=wxID_MASKLOAD, kind=wx.ITEM_NORMAL,text='Load mask')
1790	self.MaskEdit.Append(help='Load mask from file; ignore threshold',
1791	id=wxID_MASKLOADNOT, kind=wx.ITEM_NORMAL,text='Load mask w/o threshold')
1792	submenu.Append(help='Create an arc mask with mouse input',
1793	id=wxID_NEWMASKARC, kind=wx.ITEM_NORMAL,text='Arc mask')
1794	submenu.Append(help='Create a frame mask with mouse input',
1795	id=wxID_NEWMASKFRAME, kind=wx.ITEM_NORMAL,text='Frame mask')
1796	submenu.Append(help='Create a polygon mask with mouse input',
1797	id=wxID_NEWMASKPOLY, kind=wx.ITEM_NORMAL,text='Polygon mask')
1798	submenu.Append(help='Create a ring mask with mouse input',
1799	id=wxID_NEWMASKRING, kind=wx.ITEM_NORMAL,text='Ring mask')
1800	submenu.Append(help='Create a spot mask with mouse input',
1801	id=wxID_NEWMASKSPOT, kind=wx.ITEM_NORMAL,text='Spot mask')
1802	self.PostfillDataMenu()
1803
1804	# IMG / Stress/Strain
1805	self.StrStaMenu = wx.MenuBar()
1806	self.PrefillDataMenu(self.StrStaMenu,helpType='Stress/Strain')
1807	self.StrStaEdit = wx.Menu(title='')
1808	self.StrStaMenu.Append(menu=self.StrStaEdit, title='Operations')
1809	self.StrStaEdit.Append(help='Append d-zero for one ring',
1810	id=wxID_APPENDDZERO, kind=wx.ITEM_NORMAL,text='Append d-zero')
1811	self.StrStaEdit.Append(help='Fit stress/strain data',
1812	id=wxID_STRSTAFIT, kind=wx.ITEM_NORMAL,text='Fit stress/strain')
1813	self.StrStaEdit.Append(help='Update d-zero from ave d-zero',
1814	id=wxID_UPDATEDZERO, kind=wx.ITEM_NORMAL,text='Update d-zero')
1815	self.StrStaEdit.Append(help='Fit stress/strain data for all images',
1816	id=wxID_STRSTAALLFIT, kind=wx.ITEM_NORMAL,text='All image fit')
1817	self.StrStaEdit.Append(help='Copy stress/strain data to other images',
1818	id=wxID_STRSTACOPY, kind=wx.ITEM_NORMAL,text='Copy stress/strain')
1819	self.StrStaEdit.Append(help='Save stress/strain data to file',
1820	id=wxID_STRSTASAVE, kind=wx.ITEM_NORMAL,text='Save stress/strain')
1821	self.StrStaEdit.Append(help='Load stress/strain data from file',
1822	id=wxID_STRSTALOAD, kind=wx.ITEM_NORMAL,text='Load stress/strain')
1823	self.StrStaEdit.Append(help='Load sample data from file',
1824	id=wxID_STRSTSAMPLE, kind=wx.ITEM_NORMAL,text='Load sample data')
1825	self.PostfillDataMenu()
1826
1827	# PDF / PDF Controls
1828	self.PDFMenu = wx.MenuBar()
1829	self.PrefillDataMenu(self.PDFMenu,helpType='PDF Controls')
1830	self.PDFEdit = wx.Menu(title='')
1831	self.PDFMenu.Append(menu=self.PDFEdit, title='PDF Controls')
1832	self.PDFEdit.Append(help='Add element to sample composition',id=wxID_PDFADDELEMENT, kind=wx.ITEM_NORMAL,
1833	text='Add element')
1834	self.PDFEdit.Append(help='Delete element from sample composition',id=wxID_PDFDELELEMENT, kind=wx.ITEM_NORMAL,
1835	text='Delete element')
1836	self.PDFEdit.Append(help='Copy PDF controls', id=wxID_PDFCOPYCONTROLS, kind=wx.ITEM_NORMAL,
1837	text='Copy controls')
1838	self.PDFEdit.Append(help='Load PDF controls from file',id=wxID_PDFLOADCONTROLS, kind=wx.ITEM_NORMAL,
1839	text='Load Controls')
1840	self.PDFEdit.Append(help='Save PDF controls to file', id=wxID_PDFSAVECONTROLS, kind=wx.ITEM_NORMAL,
1841	text='Save controls')
1842	self.PDFEdit.Append(help='Compute PDF', id=wxID_PDFCOMPUTE, kind=wx.ITEM_NORMAL,
1843	text='Compute PDF')
1844	self.PDFEdit.Append(help='Compute all PDFs', id=wxID_PDFCOMPUTEALL, kind=wx.ITEM_NORMAL,
1845	text='Compute all PDFs')
1846	self.PostfillDataMenu()
1847
1848	# Phase / General tab
1849	self.DataGeneral = wx.MenuBar()
1850	self.PrefillDataMenu(self.DataGeneral,helpType='General', helpLbl='Phase/General')
1851	self.DataGeneral.Append(menu=wx.Menu(title=''),title='Select tab')
1852	self.GeneralCalc = wx.Menu(title='')
1853	self.DataGeneral.Append(menu=self.GeneralCalc,title='Compute')
1854	self.GeneralCalc.Append(help='Compute Fourier map',id=wxID_FOURCALC, kind=wx.ITEM_NORMAL,
1855	text='Fourier map')
1856	self.GeneralCalc.Append(help='Search Fourier map',id=wxID_FOURSEARCH, kind=wx.ITEM_NORMAL,
1857	text='Search map')
1858	self.GeneralCalc.Append(help='Run charge flipping',id=wxID_CHARGEFLIP, kind=wx.ITEM_NORMAL,
1859	text='Charge flipping')
1860	self.GeneralCalc.Append(help='Run 4D charge flipping',id=wxID_4DCHARGEFLIP, kind=wx.ITEM_NORMAL,
1861	text='4D Charge flipping')
1862	self.GeneralCalc.Enable(wxID_4DCHARGEFLIP,False)
1863	self.GeneralCalc.Append(help='Clear map',id=wxID_FOURCLEAR, kind=wx.ITEM_NORMAL,
1864	text='Clear map')
1865	self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing',id=wxID_SINGLEMCSA, kind=wx.ITEM_NORMAL,
1866	text='MC/SA')
1867	self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing on multiprocessors',id=wxID_MULTIMCSA, kind=wx.ITEM_NORMAL,
1868	text='Multi MC/SA') #currently not useful
1869	self.GeneralCalc.Append(help='Transform crystal structure',id=wxID_TRANSFORMSTRUCTURE, kind=wx.ITEM_NORMAL,
1870	text='Transform')
1871	self.PostfillDataMenu()
1872
1873	# Phase / Data tab
1874	self.DataMenu = wx.MenuBar()
1875	self.PrefillDataMenu(self.DataMenu,helpType='Data', helpLbl='Phase/Data')
1876	self.DataMenu.Append(menu=wx.Menu(title=''),title='Select tab')
1877	self.DataEdit = wx.Menu(title='')
1878	self.DataMenu.Append(menu=self.DataEdit, title='Edit')
1879	self.DataEdit.Append(id=wxID_DATACOPY, kind=wx.ITEM_NORMAL,text='Copy data',
1880	help='Copy phase data to other histograms')
1881	self.DataEdit.Append(id=wxID_DATACOPYFLAGS, kind=wx.ITEM_NORMAL,text='Copy flags',
1882	help='Copy phase data flags to other histograms')
1883	self.DataEdit.Append(id=wxID_DATASELCOPY, kind=wx.ITEM_NORMAL,text='Copy selected data',
1884	help='Copy selected phase data to other histograms')
1885	self.DataEdit.Append(id=wxID_DATAUSE, kind=wx.ITEM_NORMAL,text='Select used data',
1886	help='Select all histograms to use')
1887	self.DataEdit.Append(id=wxID_PWDRADD, kind=wx.ITEM_NORMAL,text='Add powder histograms',
1888	help='Select new powder histograms to be used for this phase')
1889	self.DataEdit.Append(id=wxID_HKLFADD, kind=wx.ITEM_NORMAL,text='Add single crystal histograms',
1890	help='Select new single crystal histograms to be used for this phase')
1891	self.DataEdit.Append(id=wxID_DATADELETE, kind=wx.ITEM_NORMAL,text='Remove histograms',
1892	help='Remove histograms from use for this phase')
1893	self.PostfillDataMenu()
1894
1895	# Phase / Atoms tab
1896	self.AtomsMenu = wx.MenuBar()
1897	self.PrefillDataMenu(self.AtomsMenu,helpType='Atoms')
1898	self.AtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
1899	self.AtomEdit = wx.Menu(title='')
1900	self.AtomCompute = wx.Menu(title='')
1901	self.AtomsMenu.Append(menu=self.AtomEdit, title='Edit')
1902	self.AtomsMenu.Append(menu=self.AtomCompute, title='Compute')
1903	self.AtomEdit.Append(id=wxID_ATOMSEDITADD, kind=wx.ITEM_NORMAL,text='Append atom',
1904	help='Appended as an H atom')
1905	self.AtomEdit.Append(id=wxID_ATOMSVIEWADD, kind=wx.ITEM_NORMAL,text='Append view point',
1906	help='Appended as an H atom')
1907	self.AtomEdit.Append(id=wxID_ATOMSEDITINSERT, kind=wx.ITEM_NORMAL,text='Insert atom',
1908	help='Select atom row to insert before; inserted as an H atom')
1909	self.AtomEdit.Append(id=wxID_ATOMVIEWINSERT, kind=wx.ITEM_NORMAL,text='Insert view point',
1910	help='Select atom row to insert before; inserted as an H atom')
1911	self.AtomEdit.Append(id=wxID_ADDHATOM, kind=wx.ITEM_NORMAL,text='Insert H atoms',
1912	help='Insert H atoms in standard positions bonded to selected atoms')
1913	self.AtomEdit.Append(id=wxID_UPDATEHATOM, kind=wx.ITEM_NORMAL,text='Update H atoms',
1914	help='Update H atoms in standard positions')
1915	self.AtomEdit.Append(id=wxID_ATOMMOVE, kind=wx.ITEM_NORMAL,text='Move atom to view point',
1916	help='Select single atom to move')
1917	self.AtomEdit.Append(id=wxID_ATOMSEDITDELETE, kind=wx.ITEM_NORMAL,text='Delete atom',
1918	help='Select atoms to delete first')
1919	self.AtomEdit.Append(id=wxID_ATOMSREFINE, kind=wx.ITEM_NORMAL,text='Set atom refinement flags',
1920	help='Select atoms to refine first')
1921	self.AtomEdit.Append(id=wxID_ATOMSMODIFY, kind=wx.ITEM_NORMAL,text='Modify atom parameters',
1922	help='Select atoms to modify first')
1923	self.AtomEdit.Append(id=wxID_ATOMSTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
1924	help='Select atoms to transform first')
1925	# self.AtomEdit.Append(id=wxID_ATOMSROTATE, kind=wx.ITEM_NORMAL,text='Rotate atoms',
1926	# help='Select atoms to rotate first')
1927	self.AtomEdit.Append(id=wxID_MAKEMOLECULE, kind=wx.ITEM_NORMAL,text='Assemble molecule',
1928	help='Assemble molecule from scatterd atom positions')
1929	self.AtomEdit.Append(id=wxID_RELOADDRAWATOMS, kind=wx.ITEM_NORMAL,text='Reload draw atoms',
1930	help='Reload atom drawing list')
1931	submenu = wx.Menu()
1932	self.AtomEdit.AppendMenu(wx.ID_ANY, 'Reimport atoms', submenu,
1933	help='Reimport atoms from file; sequence must match')
1934	# setup a cascade menu for the formats that have been defined
1935	self.ReImportMenuId = {} # points to readers for each menu entry
1936	for reader in self.G2frame.ImportPhaseReaderlist:
1937	item = submenu.Append(
1938	wx.ID_ANY,help=reader.longFormatName,
1939	kind=wx.ITEM_NORMAL,text='reimport coordinates from '+reader.formatName+' file')
1940	self.ReImportMenuId[item.GetId()] = reader
1941	item = submenu.Append(
1942	wx.ID_ANY,
1943	help='Reimport coordinates, try to determine format from file',
1944	kind=wx.ITEM_NORMAL,
1945	text='guess format from file')
1946	self.ReImportMenuId[item.GetId()] = None # try all readers
1947
1948	self.AtomCompute.Append(id=wxID_ATOMSDISAGL, kind=wx.ITEM_NORMAL,text='Show Distances && Angles',
1949	help='Compute distances & angles for selected atoms')
1950	self.AtomCompute.Append(id=wxID_ATOMSPDISAGL, kind=wx.ITEM_NORMAL,text='Save Distances && Angles',
1951	help='Compute distances & angles for selected atoms')
1952	self.AtomCompute.ISOcalc = self.AtomCompute.Append(
1953	id=wxID_ISODISP, kind=wx.ITEM_NORMAL,
1954	text='Compute ISODISTORT mode values',
1955	help='Compute values of ISODISTORT modes from atom parameters')
1956	self.PostfillDataMenu()
1957
1958	# Phase / Imcommensurate "waves" tab
1959	self.WavesData = wx.MenuBar()
1960	self.PrefillDataMenu(self.WavesData,helpType='Wave Data', helpLbl='Imcommensurate wave data')
1961	self.WavesData.Append(menu=wx.Menu(title=''),title='Select tab')
1962	self.WavesDataEdit = wx.Menu(title='')
1963	self.WavesData.Append(menu=self.WavesDataEdit, title='Edit')
1964	self.WavesDataEdit.Append(id=wxID_WAVEVARY, kind=wx.ITEM_NORMAL,text='Global wave vary',
1965	help='Global setting of wave vary flags')
1966	self.PostfillDataMenu()
1967
1968	# Phase / Layer tab
1969	self.LayerData = wx.MenuBar()
1970	self.PrefillDataMenu(self.LayerData,helpType='Layer Data', helpLbl='Stacking fault layers')
1971	self.LayerData.Append(menu=wx.Menu(title=''),title='Select tab')
1972	self.LayerDataEdit = wx.Menu(title='')
1973	self.LayerData.Append(menu=self.LayerDataEdit, title='Operations')
1974	self.LayerDataEdit.Append(id=wxID_LOADDIFFAX, kind=wx.ITEM_NORMAL,text='Load from DIFFaX file',
1975	help='Load layer info from DIFFaX file')
1976	self.LayerDataEdit.Append(id=wxID_COPYPHASE, kind=wx.ITEM_NORMAL,text='Copy phase cell',
1977	help='Copy phase cell from another project')
1978	self.LayerDataEdit.Append(id=wxID_LAYERSIMULATE, kind=wx.ITEM_NORMAL,text='Simulate pattern',
1979	help='Simulate diffraction pattern from layer stacking')
1980	self.LayerDataEdit.Append(id=wxID_SEQUENCESIMULATE, kind=wx.ITEM_NORMAL,text='Sequence simulations',
1981	help='Sequence simulation changing one parameter')
1982	self.PostfillDataMenu()
1983
1984	# Phase / Draw Options tab
1985	self.DataDrawOptions = wx.MenuBar()
1986	self.PrefillDataMenu(self.DataDrawOptions,helpType='Draw Options', helpLbl='Phase/Draw Options')
1987	self.DataDrawOptions.Append(menu=wx.Menu(title=''),title='Select tab')
1988	self.PostfillDataMenu()
1989
1990	# Phase / Draw Atoms tab
1991	self.DrawAtomsMenu = wx.MenuBar()
1992	self.PrefillDataMenu(self.DrawAtomsMenu,helpType='Draw Atoms')
1993	self.DrawAtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
1994	self.DrawAtomEdit = wx.Menu(title='')
1995	self.DrawAtomCompute = wx.Menu(title='')
1996	self.DrawAtomRestraint = wx.Menu(title='')
1997	self.DrawAtomRigidBody = wx.Menu(title='')
1998	self.DrawAtomsMenu.Append(menu=self.DrawAtomEdit, title='Edit')
1999	self.DrawAtomsMenu.Append(menu=self.DrawAtomCompute,title='Compute')
2000	self.DrawAtomsMenu.Append(menu=self.DrawAtomRestraint, title='Restraints')
2001	self.DrawAtomsMenu.Append(menu=self.DrawAtomRigidBody, title='Rigid body')
2002	self.DrawAtomEdit.Append(id=wxID_DRAWATOMSTYLE, kind=wx.ITEM_NORMAL,text='Atom style',
2003	help='Select atoms first')
2004	self.DrawAtomEdit.Append(id=wxID_DRAWATOMLABEL, kind=wx.ITEM_NORMAL,text='Atom label',
2005	help='Select atoms first')
2006	self.DrawAtomEdit.Append(id=wxID_DRAWATOMCOLOR, kind=wx.ITEM_NORMAL,text='Atom color',
2007	help='Select atoms first')
2008	self.DrawAtomEdit.Append(id=wxID_DRAWATOMRESETCOLOR, kind=wx.ITEM_NORMAL,text='Reset atom colors',
2009	help='Resets all atom colors to defaults')
2010	self.DrawAtomEdit.Append(id=wxID_DRAWVIEWPOINT, kind=wx.ITEM_NORMAL,text='View point',
2011	help='View point is 1st atom selected')
2012	self.DrawAtomEdit.Append(id=wxID_DRAWADDEQUIV, kind=wx.ITEM_NORMAL,text='Add atoms',
2013	help='Add symmetry & cell equivalents to drawing set from selected atoms')
2014	self.DrawAtomEdit.Append(id=wxID_DRAWTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform draw atoms',
2015	help='Transform selected atoms by symmetry & cell translations')
2016	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCOORD, kind=wx.ITEM_NORMAL,text='Fill CN-sphere',
2017	help='Fill coordination sphere for selected atoms')
2018	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCELL, kind=wx.ITEM_NORMAL,text='Fill unit cell',
2019	help='Fill unit cell with selected atoms')
2020	self.DrawAtomEdit.Append(id=wxID_DRAWDELETE, kind=wx.ITEM_NORMAL,text='Delete atoms',
2021	help='Delete atoms from drawing set')
2022	self.DrawAtomCompute.Append(id=wxID_DRAWDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2023	help='Compute distance of selected atoms from view point')
2024	self.DrawAtomCompute.Append(id=wxID_DRAWDISAGLTOR, kind=wx.ITEM_NORMAL,text='Dist. Ang. Tors.',
2025	help='Compute distance, angle or torsion for 2-4 selected atoms')
2026	self.DrawAtomCompute.Append(id=wxID_DRAWPLANE, kind=wx.ITEM_NORMAL,text='Best plane',
2027	help='Compute best plane for 4+ selected atoms')
2028	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRBOND, kind=wx.ITEM_NORMAL,text='Add bond restraint',
2029	help='Add bond restraint for selected atoms (2)')
2030	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRANGLE, kind=wx.ITEM_NORMAL,text='Add angle restraint',
2031	help='Add angle restraint for selected atoms (3: one end 1st)')
2032	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRPLANE, kind=wx.ITEM_NORMAL,text='Add plane restraint',
2033	help='Add plane restraint for selected atoms (4+)')
2034	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRCHIRAL, kind=wx.ITEM_NORMAL,text='Add chiral restraint',
2035	help='Add chiral restraint for selected atoms (4: center atom 1st)')
2036	self.DrawAtomRigidBody.Append(id=wxID_DRAWDEFINERB, kind=wx.ITEM_NORMAL,text='Define rigid body',
2037	help='Define rigid body with selected atoms')
2038	self.PostfillDataMenu()
2039
2040	# Phase / MCSA tab
2041	self.MCSAMenu = wx.MenuBar()
2042	self.PrefillDataMenu(self.MCSAMenu,helpType='MC/SA')
2043	self.MCSAMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2044	self.MCSAEdit = wx.Menu(title='')
2045	self.MCSAMenu.Append(menu=self.MCSAEdit, title='MC/SA')
2046	self.MCSAEdit.Append(id=wxID_ADDMCSAATOM, kind=wx.ITEM_NORMAL,text='Add atom',
2047	help='Add single atom to MC/SA model')
2048	self.MCSAEdit.Append(id=wxID_ADDMCSARB, kind=wx.ITEM_NORMAL,text='Add rigid body',
2049	help='Add rigid body to MC/SA model' )
2050	self.MCSAEdit.Append(id=wxID_CLEARMCSARB, kind=wx.ITEM_NORMAL,text='Clear rigid bodies',
2051	help='Clear all atoms & rigid bodies from MC/SA model' )
2052	self.MCSAEdit.Append(id=wxID_MOVEMCSA, kind=wx.ITEM_NORMAL,text='Move MC/SA solution',
2053	help='Move MC/SA solution to atom list' )
2054	self.MCSAEdit.Append(id=wxID_MCSACLEARRESULTS, kind=wx.ITEM_NORMAL,text='Clear results',
2055	help='Clear table of MC/SA results' )
2056	self.PostfillDataMenu()
2057
2058	# Phase / Texture tab
2059	self.TextureMenu = wx.MenuBar()
2060	self.PrefillDataMenu(self.TextureMenu,helpType='Texture')
2061	self.TextureMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2062	self.TextureEdit = wx.Menu(title='')
2063	self.TextureMenu.Append(menu=self.TextureEdit, title='Texture')
2064	self.TextureEdit.Append(id=wxID_REFINETEXTURE, kind=wx.ITEM_NORMAL,text='Refine texture',
2065	help='Refine the texture coefficients from sequential results')
2066	# self.TextureEdit.Append(id=wxID_CLEARTEXTURE, kind=wx.ITEM_NORMAL,text='Clear texture',
2067	# help='Clear the texture coefficients' )
2068	self.PostfillDataMenu()
2069
2070	# Phase / Pawley tab
2071	self.PawleyMenu = wx.MenuBar()
2072	self.PrefillDataMenu(self.PawleyMenu,helpType='Pawley')
2073	self.PawleyMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2074	self.PawleyEdit = wx.Menu(title='')
2075	self.PawleyMenu.Append(menu=self.PawleyEdit,title='Operations')
2076	self.PawleyEdit.Append(id=wxID_PAWLEYLOAD, kind=wx.ITEM_NORMAL,text='Pawley create',
2077	help='Initialize Pawley reflection list')
2078	self.PawleyEdit.Append(id=wxID_PAWLEYESTIMATE, kind=wx.ITEM_NORMAL,text='Pawley estimate',
2079	help='Estimate initial Pawley intensities')
2080	self.PawleyEdit.Append(id=wxID_PAWLEYUPDATE, kind=wx.ITEM_NORMAL,text='Pawley update',
2081	help='Update negative Pawley intensities with -0.5*Fobs and turn off refinemnt')
2082	self.PostfillDataMenu()
2083
2084	# Phase / Map peaks tab
2085	self.MapPeaksMenu = wx.MenuBar()
2086	self.PrefillDataMenu(self.MapPeaksMenu,helpType='Map peaks')
2087	self.MapPeaksMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2088	self.MapPeaksEdit = wx.Menu(title='')
2089	self.MapPeaksMenu.Append(menu=self.MapPeaksEdit, title='Map peaks')
2090	self.MapPeaksEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks',
2091	help='Move selected peaks to atom list')
2092	self.MapPeaksEdit.Append(id=wxID_PEAKSVIEWPT, kind=wx.ITEM_NORMAL,text='View point',
2093	help='View point is 1st peak selected')
2094	self.MapPeaksEdit.Append(id=wxID_PEAKSDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2095	help='Compute distance of selected peaks from view point')
2096	self.MapPeaksEdit.Append(id=wxID_SHOWBONDS, kind=wx.ITEM_NORMAL,text='Hide bonds',
2097	help='Hide or show bonds between peak positions')
2098	self.MapPeaksEdit.Append(id=wxID_PEAKSDA, kind=wx.ITEM_NORMAL,text='Calc dist/ang',
2099	help='Calculate distance or angle for selection')
2100	self.MapPeaksEdit.Append(id=wxID_FINDEQVPEAKS, kind=wx.ITEM_NORMAL,text='Equivalent peaks',
2101	help='Find equivalent peaks')
2102	self.MapPeaksEdit.Append(id=wxID_PEAKSUNIQUE, kind=wx.ITEM_NORMAL,text='Unique peaks',
2103	help='Select unique set')
2104	self.MapPeaksEdit.Append(id=wxID_PEAKSDELETE, kind=wx.ITEM_NORMAL,text='Delete peaks',
2105	help='Delete selected peaks')
2106	self.MapPeaksEdit.Append(id=wxID_PEAKSCLEAR, kind=wx.ITEM_NORMAL,text='Clear peaks',
2107	help='Clear the map peak list')
2108	self.PostfillDataMenu()
2109
2110	# Phase / Rigid bodies tab
2111	self.RigidBodiesMenu = wx.MenuBar()
2112	self.PrefillDataMenu(self.RigidBodiesMenu,helpType='Rigid bodies')
2113	self.RigidBodiesMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2114	self.RigidBodiesEdit = wx.Menu(title='')
2115	self.RigidBodiesMenu.Append(menu=self.RigidBodiesEdit, title='Edit')
2116	self.RigidBodiesEdit.Append(id=wxID_ASSIGNATMS2RB, kind=wx.ITEM_NORMAL,text='Assign atoms to rigid body',
2117	help='Select & position rigid body in structure of existing atoms')
2118	self.RigidBodiesEdit.Append(id=wxID_AUTOFINDRESRB, kind=wx.ITEM_NORMAL,text='Auto find residues',
2119	help='Auto find of residue RBs in macromolecule')
2120	self.RigidBodiesEdit.Append(id=wxID_COPYRBPARMS, kind=wx.ITEM_NORMAL,text='Copy rigid body parms',
2121	help='Copy rigid body location & TLS parameters')
2122	self.RigidBodiesEdit.Append(id=wxID_GLOBALTHERM, kind=wx.ITEM_NORMAL,text='Global thermal motion',
2123	help='Global setting of residue thermal motion models')
2124	self.RigidBodiesEdit.Append(id=wxID_GLOBALRESREFINE, kind=wx.ITEM_NORMAL,text='Global residue refine',
2125	help='Global setting of residue RB refinement flags')
2126	self.RigidBodiesEdit.Append(id=wxID_RBREMOVEALL, kind=wx.ITEM_NORMAL,text='Remove all rigid bodies',
2127	help='Remove all rigid body assignment for atoms')
2128	self.PostfillDataMenu()
2129	# end of GSAS-II menu definitions
2130
2131	def _init_ctrls(self, parent,name=None,size=None,pos=None):
2132	wx.Frame.__init__(
2133	self,parent=parent,
2134	#style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX \| wx.FRAME_FLOAT_ON_PARENT ,
2135	style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
2136	size=size,pos=pos,title='GSAS-II data display')
2137	self._init_menus()
2138	if name:
2139	self.SetLabel(name)
2140	self.Show()
2141
2142	def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
2143	self.G2frame = frame
2144	self._init_ctrls(parent,name,size,pos)
2145	self.data = data
2146	clientSize = wx.ClientDisplayRect()
2147	Size = self.GetSize()
2148	xPos = clientSize[2]-Size[0]
2149	self.SetPosition(wx.Point(xPos,clientSize[1]+250))
2150	self.AtomGrid = []
2151	self.selectedRow = 0
2152
2153	def setSizePosLeft(self,Width):
2154	clientSize = wx.ClientDisplayRect()
2155	Width[1] = min(Width[1],clientSize[2]-300)
2156	Width[0] = max(Width[0],300)
2157	self.SetSize(Width)
2158	# self.SetPosition(wx.Point(clientSize[2]-Width[0],clientSize[1]+250))
2159
2160	def Clear(self):
2161	self.ClearBackground()
2162	self.DestroyChildren()
2163
2164
2165	################################################################################
2166	##### Notebook Tree Item editor
2167	################################################################################
2168	def UpdateNotebook(G2frame,data):
2169	'''Called when the data tree notebook entry is selected. Allows for
2170	editing of the text in that tree entry
2171	'''
2172	def OnNoteBook(event):
2173	data = G2frame.dataDisplay.GetValue().split('\n')
2174	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
2175	if 'nt' not in os.name:
2176	G2frame.dataDisplay.AppendText('\n')
2177
2178	if G2frame.dataDisplay:
2179	G2frame.dataDisplay.Destroy()
2180	G2frame.dataFrame.SetLabel('Notebook')
2181	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2182	style=wx.TE_MULTILINE\|wx.TE_PROCESS_ENTER \| wx.TE_DONTWRAP)
2183	G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
2184	G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
2185	for line in data:
2186	G2frame.dataDisplay.AppendText(line+"\n")
2187	G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
2188	G2frame.dataFrame.setSizePosLeft([400,250])
2189
2190	################################################################################
2191	##### Controls Tree Item editor
2192	################################################################################
2193	def UpdateControls(G2frame,data):
2194	'''Edit overall GSAS-II controls in main Controls data tree entry
2195	'''
2196	#patch
2197	if 'deriv type' not in data:
2198	data = {}
2199	data['deriv type'] = 'analytic Hessian'
2200	data['min dM/M'] = 0.0001
2201	data['shift factor'] = 1.
2202	data['max cyc'] = 3
2203	data['F**2'] = False
2204	if 'shift factor' not in data:
2205	data['shift factor'] = 1.
2206	if 'max cyc' not in data:
2207	data['max cyc'] = 3
2208	if 'F**2' not in data:
2209	data['F**2'] = False
2210	if 'Author' not in data:
2211	data['Author'] = 'no name'
2212	if 'FreePrm1' not in data:
2213	data['FreePrm1'] = 'Sample humidity (%)'
2214	if 'FreePrm2' not in data:
2215	data['FreePrm2'] = 'Sample voltage (V)'
2216	if 'FreePrm3' not in data:
2217	data['FreePrm3'] = 'Applied load (MN)'
2218	if 'Copy2Next' not in data:
2219	data['Copy2Next'] = False
2220	if 'Reverse Seq' not in data:
2221	data['Reverse Seq'] = False
2222	if 'UsrReject' not in data:
2223	data['UsrReject'] = {'minF/sig':0,'MinExt':0.01,'MaxDF/F':20.,'MaxD':500.,'MinD':0.05}
2224	if 'HatomFix' not in data:
2225	data['HatomFix'] = False
2226
2227	#end patch
2228
2229	def SeqSizer():
2230
2231	def OnSelectData(event):
2232	choices = GetPatternTreeDataNames(G2frame,['PWDR','HKLF',])
2233	sel = []
2234	try:
2235	if 'Seq Data' in data:
2236	for item in data['Seq Data']:
2237	sel.append(choices.index(item))
2238	sel = [choices.index(item) for item in data['Seq Data']]
2239	except ValueError: #data changed somehow - start fresh
2240	sel = []
2241	dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential refinement',
2242	'Select dataset to include',choices)
2243	dlg.SetSelections(sel)
2244	names = []
2245	if dlg.ShowModal() == wx.ID_OK:
2246	for sel in dlg.GetSelections():
2247	names.append(choices[sel])
2248	data['Seq Data'] = names
2249	G2frame.EnableSeqRefineMenu()
2250	dlg.Destroy()
2251	wx.CallAfter(UpdateControls,G2frame,data)
2252
2253	def OnReverse(event):
2254	data['Reverse Seq'] = reverseSel.GetValue()
2255
2256	def OnCopySel(event):
2257	data['Copy2Next'] = copySel.GetValue()
2258
2259	seqSizer = wx.BoxSizer(wx.VERTICAL)
2260	dataSizer = wx.BoxSizer(wx.HORIZONTAL)
2261	dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement: '),0,WACV)
2262	selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
2263	selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
2264	dataSizer.Add(selSeqData,0,WACV)
2265	SeqData = data.get('Seq Data',[])
2266	if not SeqData:
2267	lbl = ' (no data selected)'
2268	else:
2269	lbl = ' ('+str(len(SeqData))+' dataset(s) selected)'
2270
2271	dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=lbl),0,WACV)
2272	seqSizer.Add(dataSizer,0)
2273	if SeqData:
2274	selSizer = wx.BoxSizer(wx.HORIZONTAL)
2275	reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
2276	reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
2277	reverseSel.SetValue(data['Reverse Seq'])
2278	selSizer.Add(reverseSel,0,WACV)
2279	copySel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Copy results to next histogram?')
2280	copySel.Bind(wx.EVT_CHECKBOX,OnCopySel)
2281	copySel.SetValue(data['Copy2Next'])
2282	selSizer.Add(copySel,0,WACV)
2283	seqSizer.Add(selSizer,0)
2284	return seqSizer
2285
2286	def LSSizer():
2287
2288	def OnDerivType(event):
2289	data['deriv type'] = derivSel.GetValue()
2290	derivSel.SetValue(data['deriv type'])
2291	wx.CallAfter(UpdateControls,G2frame,data)
2292
2293	def OnConvergence(event):
2294	try:
2295	value = max(1.e-9,min(1.0,float(Cnvrg.GetValue())))
2296	except ValueError:
2297	value = 0.0001
2298	data['min dM/M'] = value
2299	Cnvrg.SetValue('%.2g'%(value))
2300
2301	def OnMaxCycles(event):
2302	data['max cyc'] = int(maxCyc.GetValue())
2303	maxCyc.SetValue(str(data['max cyc']))
2304
2305	def OnFactor(event):
2306	try:
2307	value = min(max(float(Factr.GetValue()),0.00001),100.)
2308	except ValueError:
2309	value = 1.0
2310	data['shift factor'] = value
2311	Factr.SetValue('%.5f'%(value))
2312
2313	def OnFsqRef(event):
2314	data['F**2'] = fsqRef.GetValue()
2315
2316	def OnHatomFix(event):
2317	data['HatomFix'] = Hfix.GetValue()
2318
2319	def OnUsrRej(event):
2320	Obj = event.GetEventObject()
2321	item,limits = Indx[Obj]
2322	try:
2323	value = min(max(float(Obj.GetValue()),limits[0]),limits[1])
2324	except ValueError:
2325	value = data['UsrReject'][item]
2326	data['UsrReject'][item] = value
2327	Obj.SetValue('%.2f'%(value))
2328
2329	LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
2330	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,WACV)
2331	Choice=['analytic Jacobian','numeric','analytic Hessian']
2332	derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
2333	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2334	derivSel.SetValue(data['deriv type'])
2335	derivSel.Bind(wx.EVT_COMBOBOX, OnDerivType)
2336
2337	LSSizer.Add(derivSel,0,WACV)
2338	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,WACV)
2339	Cnvrg = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
2340	Cnvrg.Bind(wx.EVT_TEXT_ENTER,OnConvergence)
2341	Cnvrg.Bind(wx.EVT_KILL_FOCUS,OnConvergence)
2342	LSSizer.Add(Cnvrg,0,WACV)
2343	Indx = {}
2344	if 'Hessian' in data['deriv type']:
2345	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,WACV)
2346	Choice = ['0','1','2','3','5','10','15','20']
2347	maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
2348	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2349	maxCyc.SetValue(str(data['max cyc']))
2350	maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
2351	LSSizer.Add(maxCyc,0,WACV)
2352	else:
2353	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,WACV)
2354	Factr = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
2355	Factr.Bind(wx.EVT_TEXT_ENTER,OnFactor)
2356	Factr.Bind(wx.EVT_KILL_FOCUS,OnFactor)
2357	LSSizer.Add(Factr,0,WACV)
2358	if G2frame.Sngl:
2359	userReject = data['UsrReject']
2360	usrRej = {'minF/sig':[' Min obs/sig (0-5): ',[0,5], ],'MinExt':[' Min extinct. (0-.9): ',[0,.9],],
2361	'MaxDF/F':[' Max delt-F/sig (3-1000): ',[3.,1000.],],'MaxD':[' Max d-spacing (3-500): ',[3,500],],
2362	'MinD':[' Min d-spacing (0.1-2.0): ',[0.1,2.0],]}
2363
2364	fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
2365	fsqRef.SetValue(data['F**2'])
2366	fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
2367	LSSizer.Add(fsqRef,0,WACV)
2368	LSSizer.Add((1,0),)
2369	for item in usrRej:
2370	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=usrRej[item][0]),0,WACV)
2371	usrrej = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(userReject[item]),style=wx.TE_PROCESS_ENTER)
2372	Indx[usrrej] = [item,usrRej[item][1]]
2373	usrrej.Bind(wx.EVT_TEXT_ENTER,OnUsrRej)
2374	usrrej.Bind(wx.EVT_KILL_FOCUS,OnUsrRej)
2375	LSSizer.Add(usrrej,0,WACV)
2376	# Hfix = wx.CheckBox(G2frame.dataDisplay,-1,label='Regularize H atoms? ')
2377	# Hfix.SetValue(data['HatomFix'])
2378	# Hfix.Bind(wx.EVT_CHECKBOX,OnHatomFix)
2379	# LSSizer.Add(Hfix,0,WACV) #for now
2380	return LSSizer
2381
2382	def AuthSizer():
2383
2384	def OnAuthor(event):
2385	data['Author'] = auth.GetValue()
2386
2387	Author = data['Author']
2388	authSizer = wx.BoxSizer(wx.HORIZONTAL)
2389	authSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' CIF Author (last, first):'),0,WACV)
2390	auth = wx.TextCtrl(G2frame.dataDisplay,-1,value=Author,style=wx.TE_PROCESS_ENTER)
2391	auth.Bind(wx.EVT_TEXT_ENTER,OnAuthor)
2392	auth.Bind(wx.EVT_KILL_FOCUS,OnAuthor)
2393	authSizer.Add(auth,0,WACV)
2394	return authSizer
2395
2396
2397	if G2frame.dataDisplay:
2398	G2frame.dataDisplay.Destroy()
2399	if not G2frame.dataFrame.GetStatusBar():
2400	Status = G2frame.dataFrame.CreateStatusBar()
2401	Status.SetStatusText('')
2402	G2frame.dataFrame.SetLabel('Controls')
2403	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2404	SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
2405	mainSizer = wx.BoxSizer(wx.VERTICAL)
2406	mainSizer.Add((5,5),0)
2407	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,WACV)
2408	mainSizer.Add(LSSizer())
2409	mainSizer.Add((5,5),0)
2410	mainSizer.Add(SeqSizer())
2411	mainSizer.Add((5,5),0)
2412	mainSizer.Add(AuthSizer())
2413	mainSizer.Add((5,5),0)
2414
2415	mainSizer.Layout()
2416	G2frame.dataDisplay.SetSizer(mainSizer)
2417	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
2418	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
2419
2420	################################################################################
2421	##### Comments
2422	################################################################################
2423
2424	def UpdateComments(G2frame,data):
2425
2426	if G2frame.dataDisplay:
2427	G2frame.dataDisplay.Destroy()
2428	G2frame.dataFrame.SetLabel('Comments')
2429	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2430	style=wx.TE_MULTILINE\|wx.TE_READONLY\|wx.TE_DONTWRAP)
2431	for line in data:
2432	G2frame.dataDisplay.AppendText(line+'\n')
2433	G2frame.dataFrame.setSizePosLeft([400,250])
2434
2435	################################################################################
2436	##### Display of Sequential Results
2437	################################################################################
2438
2439	def UpdateSeqResults(G2frame,data,prevSize=None):
2440	"""
2441	Called when the Sequential Results data tree entry is selected
2442	to show results from a sequential refinement.
2443
2444	:param wx.Frame G2frame: main GSAS-II data tree windows
2445
2446	:param dict data: a dictionary containing the following items:
2447
2448	* 'histNames' - list of histogram names in order as processed by Sequential Refinement
2449	* 'varyList' - list of variables - identical over all refinements in sequence
2450	note that this is the original list of variables, prior to processing
2451	constraints.
2452	* 'variableLabels' -- a dict of labels to be applied to each parameter
2453	(this is created as an empty dict if not present in data).
2454	* keyed by histName - dictionaries for all data sets processed, which contains:
2455
2456	* 'variables'- result[0] from leastsq call
2457	* 'varyList' - list of variables passed to leastsq call (not same as above)
2458	* 'sig' - esds for variables
2459	* 'covMatrix' - covariance matrix from individual refinement
2460	* 'title' - histogram name; same as dict item name
2461	* 'newAtomDict' - new atom parameters after shifts applied
2462	* 'newCellDict' - refined cell parameters after shifts to A0-A5 from Dij terms applied'
2463	"""
2464
2465	def GetSampleParms():
2466	'''Make a dictionary of the sample parameters are not the same over the
2467	refinement series.
2468	'''
2469	if 'IMG' in histNames[0]:
2470	sampleParmDict = {'Sample load':[],}
2471	else:
2472	sampleParmDict = {'Temperature':[],'Pressure':[],'Time':[],
2473	'FreePrm1':[],'FreePrm2':[],'FreePrm3':[],'Omega':[],
2474	'Chi':[],'Phi':[],'Azimuth':[],}
2475	Controls = G2frame.PatternTree.GetItemPyData(
2476	GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
2477	sampleParm = {}
2478	for name in histNames:
2479	if 'IMG' in name:
2480	for item in sampleParmDict:
2481	sampleParmDict[item].append(data[name]['parmDict'].get(item,0))
2482	else:
2483	Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
2484	sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
2485	for item in sampleParmDict:
2486	sampleParmDict[item].append(sampleData.get(item,0))
2487	for item in sampleParmDict:
2488	frstValue = sampleParmDict[item][0]
2489	if np.any(np.array(sampleParmDict[item])-frstValue):
2490	if item.startswith('FreePrm'):
2491	sampleParm[Controls[item]] = sampleParmDict[item]
2492	else:
2493	sampleParm[item] = sampleParmDict[item]
2494	return sampleParm
2495
2496	def GetColumnInfo(col):
2497	'''returns column label, lists of values and errors (or None) for each column in the table
2498	for plotting. The column label is reformatted from Unicode to MatPlotLib encoding
2499	'''
2500	colName = G2frame.SeqTable.GetColLabelValue(col)
2501	plotName = variableLabels.get(colName,colName)
2502	plotName = plotSpCharFix(plotName)
2503	return plotName,colList[col],colSigs[col]
2504
2505	def PlotSelect(event):
2506	'Plots a row (covariance) or column on double-click'
2507	cols = G2frame.dataDisplay.GetSelectedCols()
2508	rows = G2frame.dataDisplay.GetSelectedRows()
2509	if cols:
2510	G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
2511	elif rows:
2512	name = histNames[rows[0]] #only does 1st one selected
2513	G2plt.PlotCovariance(G2frame,data[name])
2514	else:
2515	G2frame.ErrorDialog(
2516	'Select row or columns',
2517	'Nothing selected in table. Click on column or row label(s) to plot. N.B. Grid selection can be a bit funky.'
2518	)
2519
2520	def OnPlotSelSeq(event):
2521	'plot the selected columns or row from menu command'
2522	cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2523	rows = G2frame.dataDisplay.GetSelectedRows()
2524	if cols:
2525	G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
2526	elif rows:
2527	name = histNames[rows[0]] #only does 1st one selected
2528	G2plt.PlotCovariance(G2frame,data[name])
2529	else:
2530	G2frame.ErrorDialog(
2531	'Select columns',
2532	'No columns or rows selected in table. Click on row or column labels to select fields for plotting.'
2533	)
2534
2535	def OnAveSelSeq(event):
2536	'average the selected columns from menu command'
2537	cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2538	if cols:
2539	for col in cols:
2540	ave = np.mean(GetColumnInfo(col)[1])
2541	sig = np.std(GetColumnInfo(col)[1])
2542	print ' Average for '+G2frame.SeqTable.GetColLabelValue(col)+': '+'%.6g'%(ave)+' +/- '+'%.6g'%(sig)
2543	else:
2544	G2frame.ErrorDialog(
2545	'Select columns',
2546	'No columns selected in table. Click on column labels to select fields for averaging.'
2547	)
2548
2549	def OnRenameSelSeq(event):
2550	cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2551	colNames = [G2frame.SeqTable.GetColLabelValue(c) for c in cols]
2552	newNames = colNames[:]
2553	for i,name in enumerate(colNames):
2554	if name in variableLabels:
2555	newNames[i] = variableLabels[name]
2556	if not cols:
2557	G2frame.ErrorDialog('Select columns',
2558	'No columns selected in table. Click on column labels to select fields for rename.')
2559	return
2560	dlg = G2G.MultiStringDialog(G2frame.dataDisplay,'Set column names',colNames,newNames)
2561	if dlg.Show():
2562	newNames = dlg.GetValues()
2563	variableLabels.update(dict(zip(colNames,newNames)))
2564	data['variableLabels'] = variableLabels
2565	dlg.Destroy()
2566	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2567	G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
2568
2569	def OnReOrgSelSeq(event):
2570	'Reorder the columns'
2571	G2G.GetItemOrder(G2frame,VaryListChanges,vallookup,posdict)
2572	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2573
2574	def OnSaveSelSeqCSV(event):
2575	'export the selected columns to a .csv file from menu command'
2576	OnSaveSelSeq(event,csv=True)
2577
2578	def OnSaveSeqCSV(event):
2579	'export all columns to a .csv file from menu command'
2580	OnSaveSelSeq(event,csv=True,allcols=True)
2581
2582	def OnSaveSelSeq(event,csv=False,allcols=False):
2583	'export the selected columns to a .txt or .csv file from menu command'
2584	def WriteCSV():
2585	def WriteList(headerItems):
2586	line = ''
2587	for lbl in headerItems:
2588	if line: line += ','
2589	line += '"'+lbl+'"'
2590	return line
2591	head = ['name']
2592	for col in cols:
2593	item = G2frame.SeqTable.GetColLabelValue(col)
2594	# get rid of labels that have Unicode characters
2595	if not all([ord(c) < 128 and ord(c) != 0 for c in item]): item = '?'
2596	if col in havesig:
2597	head += [item,'esd-'+item]
2598	else:
2599	head += [item]
2600	SeqFile.write(WriteList(head)+'\n')
2601	for row,name in enumerate(saveNames):
2602	line = '"'+saveNames[row]+'"'
2603	for col in cols:
2604	if col in havesig:
2605	line += ','+str(saveData[col][row])+','+str(saveSigs[col][row])
2606	else:
2607	line += ','+str(saveData[col][row])
2608	SeqFile.write(line+'\n')
2609	def WriteSeq():
2610	lenName = len(saveNames[0])
2611	line = ' %s '%('name'.center(lenName))
2612	for col in cols:
2613	item = G2frame.SeqTable.GetColLabelValue(col)
2614	if col in havesig:
2615	line += ' %12s %12s '%(item.center(12),'esd'.center(12))
2616	else:
2617	line += ' %12s '%(item.center(12))
2618	SeqFile.write(line+'\n')
2619	for row,name in enumerate(saveNames):
2620	line = " '%s' "%(saveNames[row])
2621	for col in cols:
2622	if col in havesig:
2623	line += ' %12.6f %12.6f '%(saveData[col][row],saveSigs[col][row])
2624	else:
2625	line += ' %12.6f '%saveData[col][row]
2626	SeqFile.write(line+'\n')
2627
2628	# start of OnSaveSelSeq code
2629	if allcols:
2630	cols = range(G2frame.SeqTable.GetNumberCols())
2631	else:
2632	cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2633	nrows = G2frame.SeqTable.GetNumberRows()
2634	if not cols:
2635	G2frame.ErrorDialog('Select columns',
2636	'No columns selected in table. Click on column labels to select fields for output.')
2637	return
2638	saveNames = [G2frame.SeqTable.GetRowLabelValue(r) for r in range(nrows)]
2639	saveData = {}
2640	saveSigs = {}
2641	havesig = []
2642	for col in cols:
2643	name,vals,sigs = GetColumnInfo(col)
2644	saveData[col] = vals
2645	if sigs:
2646	havesig.append(col)
2647	saveSigs[col] = sigs
2648	if csv:
2649	wild = 'CSV output file (.csv)\|.csv'
2650	else:
2651	wild = 'Text output file (.txt)\|.txt'
2652	pth = G2G.GetExportPath(G2frame)
2653	dlg = wx.FileDialog(
2654	G2frame,
2655	'Choose text output file for your selection', pth, '',
2656	wild,wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
2657	try:
2658	if dlg.ShowModal() == wx.ID_OK:
2659	SeqTextFile = dlg.GetPath()
2660	SeqTextFile = G2IO.FileDlgFixExt(dlg,SeqTextFile)
2661	SeqFile = open(SeqTextFile,'w')
2662	if csv:
2663	WriteCSV()
2664	else:
2665	WriteSeq()
2666	SeqFile.close()
2667	finally:
2668	dlg.Destroy()
2669
2670	def striphist(var,insChar=''):
2671	'strip a histogram number from a var name'
2672	sv = var.split(':')
2673	if len(sv) <= 1: return var
2674	if sv[1]:
2675	sv[1] = insChar
2676	return ':'.join(sv)
2677
2678	def plotSpCharFix(lbl):
2679	'Change selected unicode characters to their matplotlib equivalent'
2680	for u,p in [
2681	(u'\u03B1',r'$\alpha$'),
2682	(u'\u03B2',r'$\beta$'),
2683	(u'\u03B3',r'$\gamma$'),
2684	(u'\u0394\u03C7',r'$\Delta\chi$'),
2685	]:
2686	lbl = lbl.replace(u,p)
2687	return lbl
2688
2689	def SelectXaxis():
2690	'returns a selected column number (or None) as the X-axis selection'
2691	ncols = G2frame.SeqTable.GetNumberCols()
2692	colNames = [G2frame.SeqTable.GetColLabelValue(r) for r in range(ncols)]
2693	dlg = G2G.G2SingleChoiceDialog(
2694	G2frame.dataDisplay,
2695	'Select x-axis parameter for plot or Cancel for sequence number',
2696	'Select X-axis',
2697	colNames)
2698	try:
2699	if dlg.ShowModal() == wx.ID_OK:
2700	col = dlg.GetSelection()
2701	else:
2702	col = None
2703	finally:
2704	dlg.Destroy()
2705	return col
2706
2707	def EnablePseudoVarMenus():
2708	'Enables or disables the PseudoVar menu items that require existing defs'
2709	if Controls['SeqPseudoVars']:
2710	val = True
2711	else:
2712	val = False
2713	G2frame.dataFrame.SequentialPvars.Enable(wxDELSEQVAR,val)
2714	G2frame.dataFrame.SequentialPvars.Enable(wxEDITSEQVAR,val)
2715
2716	def DelPseudoVar(event):
2717	'Ask the user to select a pseudo var expression to delete'
2718	choices = Controls['SeqPseudoVars'].keys()
2719	selected = G2G.ItemSelector(
2720	choices,G2frame.dataFrame,
2721	multiple=True,
2722	title='Select expressions to remove',
2723	header='Delete expression')
2724	if selected is None: return
2725	for item in selected:
2726	del Controls['SeqPseudoVars'][choices[item]]
2727	if selected:
2728	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2729
2730	def EditPseudoVar(event):
2731	'Edit an existing pseudo var expression'
2732	choices = Controls['SeqPseudoVars'].keys()
2733	if len(choices) == 1:
2734	selected = 0
2735	else:
2736	selected = G2G.ItemSelector(
2737	choices,G2frame.dataFrame,
2738	multiple=False,
2739	title='Select an expression to edit',
2740	header='Edit expression')
2741	if selected is not None:
2742	dlg = G2exG.ExpressionDialog(
2743	G2frame.dataDisplay,PSvarDict,
2744	Controls['SeqPseudoVars'][choices[selected]],
2745	header="Edit the PseudoVar expression",
2746	VarLabel="PseudoVar #"+str(selected+1),
2747	fit=False)
2748	newobj = dlg.Show(True)
2749	if newobj:
2750	calcobj = G2obj.ExpressionCalcObj(newobj)
2751	del Controls['SeqPseudoVars'][choices[selected]]
2752	Controls['SeqPseudoVars'][calcobj.eObj.expression] = newobj
2753	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2754
2755	def AddNewPseudoVar(event):
2756	'Create a new pseudo var expression'
2757	dlg = G2exG.ExpressionDialog(
2758	G2frame.dataDisplay,PSvarDict,
2759	header='Enter an expression for a PseudoVar here',
2760	VarLabel = "New PseudoVar",
2761	fit=False)
2762	obj = dlg.Show(True)
2763	dlg.Destroy()
2764	if obj:
2765	calcobj = G2obj.ExpressionCalcObj(obj)
2766	Controls['SeqPseudoVars'][calcobj.eObj.expression] = obj
2767	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2768
2769	def AddNewDistPseudoVar(event):
2770	obj = None
2771	dlg = G2exG.BondDialog(
2772	G2frame.dataDisplay,Phases,PSvarDict,
2773	header='Select a Bond here',
2774	VarLabel = "New Bond")
2775	if dlg.ShowModal() == wx.ID_OK:
2776	pName,Oatom,Tatom = dlg.GetSelection()
2777	if Tatom:
2778	Phase = Phases[pName]
2779	General = Phase['General']
2780	cx,ct = General['AtomPtrs'][:2]
2781	pId = Phase['pId']
2782	SGData = General['SGData']
2783	sB = Tatom.find('(')+1
2784	symNo = 0
2785	if sB:
2786	sF = Tatom.find(')')
2787	symNo = int(Tatom[sB:sF])
2788	cellNo = [0,0,0]
2789	cB = Tatom.find('[')
2790	if cB>0:
2791	cF = Tatom.find(']')+1
2792	cellNo = eval(Tatom[cB:cF])
2793	Atoms = Phase['Atoms']
2794	aNames = [atom[ct-1] for atom in Atoms]
2795	oId = aNames.index(Oatom)
2796	tId = aNames.index(Tatom.split(' +')[0])
2797	# create an expression object
2798	obj = G2obj.ExpressionObj()
2799	obj.expression = 'Dist(%s,\n%s)'%(Oatom,Tatom.split(' d=')[0].replace(' ',''))
2800	obj.distance_dict = {'pId':pId,'SGData':SGData,'symNo':symNo,'cellNo':cellNo}
2801	obj.distance_atoms = [oId,tId]
2802	else:
2803	dlg.Destroy()
2804	return
2805	dlg.Destroy()
2806	if obj:
2807	Controls['SeqPseudoVars'][obj.expression] = obj
2808	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2809
2810	def AddNewAnglePseudoVar(event):
2811	obj = None
2812	dlg = G2exG.AngleDialog(
2813	G2frame.dataDisplay,Phases,PSvarDict,
2814	header='Enter an Angle here',
2815	VarLabel = "New Angle")
2816	if dlg.ShowModal() == wx.ID_OK:
2817	pName,Oatom,Tatoms = dlg.GetSelection()
2818	if Tatoms:
2819	Phase = Phases[pName]
2820	General = Phase['General']
2821	cx,ct = General['AtomPtrs'][:2]
2822	pId = Phase['pId']
2823	SGData = General['SGData']
2824	Atoms = Phase['Atoms']
2825	aNames = [atom[ct-1] for atom in Atoms]
2826	tIds = []
2827	symNos = []
2828	cellNos = []
2829	oId = aNames.index(Oatom)
2830	Tatoms = Tatoms.split(';')
2831	for Tatom in Tatoms:
2832	sB = Tatom.find('(')+1
2833	symNo = 0
2834	if sB:
2835	sF = Tatom.find(')')
2836	symNo = int(Tatom[sB:sF])
2837	symNos.append(symNo)
2838	cellNo = [0,0,0]
2839	cB = Tatom.find('[')
2840	if cB>0:
2841	cF = Tatom.find(']')+1
2842	cellNo = eval(Tatom[cB:cF])
2843	cellNos.append(cellNo)
2844	tIds.append(aNames.index(Tatom.split('+')[0]))
2845	# create an expression object
2846	obj = G2obj.ExpressionObj()
2847	obj.expression = 'Angle(%s,%s,\n%s)'%(Tatoms[0],Oatom,Tatoms[1])
2848	obj.angle_dict = {'pId':pId,'SGData':SGData,'symNo':symNos,'cellNo':cellNos}
2849	obj.angle_atoms = [oId,tIds]
2850	else:
2851	dlg.Destroy()
2852	return
2853	dlg.Destroy()
2854	if obj:
2855	Controls['SeqPseudoVars'][obj.expression] = obj
2856	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2857
2858	def UpdateParmDict(parmDict):
2859	'''generate the atom positions and the direct & reciprocal cell values,
2860	because they might be needed to evaluate the pseudovar
2861	'''
2862	Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
2863	['A'+str(i) for i in range(6)])
2864	)
2865	delList = []
2866	phaselist = []
2867	for item in parmDict:
2868	if ':' not in item: continue
2869	key = item.split(':')
2870	if len(key) < 3: continue
2871	# remove the dA[xyz] terms, they would only bring confusion
2872	if key[2].startswith('dA'):
2873	delList.append(item)
2874	# compute and update the corrected reciprocal cell terms using the Dij values
2875	elif key[2] in Ddict:
2876	if key[0] not in phaselist: phaselist.append(key[0])
2877	akey = key[0]+'::'+Ddict[key[2]]
2878	parmDict[akey] -= parmDict[item]
2879	delList.append(item)
2880	for item in delList:
2881	del parmDict[item]
2882	for i in phaselist:
2883	pId = int(i)
2884	# apply cell symmetry
2885	A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],parmDict,zeroDict[pId])
2886	# convert to direct cell & add the unique terms to the dictionary
2887	for i,val in enumerate(G2lat.A2cell(A)):
2888	if i in uniqCellIndx[pId]:
2889	lbl = str(pId)+'::'+cellUlbl[i]
2890	parmDict[lbl] = val
2891	lbl = str(pId)+'::'+'vol'
2892	parmDict[lbl] = G2lat.calc_V(A)
2893	return parmDict
2894
2895	def EvalPSvarDeriv(calcobj,parmDict,sampleDict,var,ESD):
2896	'''Evaluate an expression derivative with respect to a
2897	GSAS-II variable name.
2898
2899	Note this likely could be faster if the loop over calcobjs were done
2900	inside after the Dict was created.
2901	'''
2902	step = ESD/10
2903	Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
2904	['A'+str(i) for i in range(6)])
2905	)
2906	results = []
2907	phaselist = []
2908	VparmDict = sampleDict.copy()
2909	for incr in step,-step:
2910	VparmDict.update(parmDict.copy())
2911	# as saved, the parmDict has updated 'A[xyz]' values, but 'dA[xyz]'
2912	# values are not zeroed: fix that!
2913	VparmDict.update({item:0.0 for item in parmDict if 'dA' in item})
2914	VparmDict[var] += incr
2915	G2mv.Dict2Map(VparmDict,[]) # apply constraints
2916	# generate the atom positions and the direct & reciprocal cell values now, because they might
2917	# needed to evaluate the pseudovar
2918	for item in VparmDict:
2919	if item in sampleDict:
2920	continue
2921	if ':' not in item: continue
2922	key = item.split(':')
2923	if len(key) < 3: continue
2924	# apply any new shifts to atom positions
2925	if key[2].startswith('dA'):
2926	VparmDict[''.join(item.split('d'))] += VparmDict[item]
2927	VparmDict[item] = 0.0
2928	# compute and update the corrected reciprocal cell terms using the Dij values
2929	if key[2] in Ddict:
2930	if key[0] not in phaselist: phaselist.append(key[0])
2931	akey = key[0]+'::'+Ddict[key[2]]
2932	VparmDict[akey] -= VparmDict[item]
2933	for i in phaselist:
2934	pId = int(i)
2935	# apply cell symmetry
2936	A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],VparmDict,zeroDict[pId])
2937	# convert to direct cell & add the unique terms to the dictionary
2938	for i,val in enumerate(G2lat.A2cell(A)):
2939	if i in uniqCellIndx[pId]:
2940	lbl = str(pId)+'::'+cellUlbl[i]
2941	VparmDict[lbl] = val
2942	lbl = str(pId)+'::'+'vol'
2943	VparmDict[lbl] = G2lat.calc_V(A)
2944	# dict should be fully updated, use it & calculate
2945	calcobj.SetupCalc(VparmDict)
2946	results.append(calcobj.EvalExpression())
2947	return (results[0] - results[1]) / (2.*step)
2948
2949	def EnableParFitEqMenus():
2950	'Enables or disables the Parametric Fit menu items that require existing defs'
2951	if Controls['SeqParFitEqList']:
2952	val = True
2953	else:
2954	val = False
2955	G2frame.dataFrame.SequentialPfit.Enable(wxDELPARFIT,val)
2956	G2frame.dataFrame.SequentialPfit.Enable(wxEDITPARFIT,val)
2957	G2frame.dataFrame.SequentialPfit.Enable(wxDOPARFIT,val)
2958
2959	def ParEqEval(Values,calcObjList,varyList):
2960	'''Evaluate the parametric expression(s)
2961	:param list Values: a list of values for each variable parameter
2962	:param list calcObjList: a list of :class:`GSASIIobj.ExpressionCalcObj`
2963	expression objects to evaluate
2964	:param list varyList: a list of variable names for each value in Values
2965	'''
2966	result = []
2967	for calcobj in calcObjList:
2968	calcobj.UpdateVars(varyList,Values)
2969	result.append((calcobj.depVal-calcobj.EvalExpression())/calcobj.depSig)
2970	return result
2971
2972	def DoParEqFit(event,eqObj=None):
2973	'Parametric fit minimizer'
2974	varyValueDict = {} # dict of variables and their initial values
2975	calcObjList = [] # expression objects, ready to go for each data point
2976	if eqObj is not None:
2977	eqObjList = [eqObj,]
2978	else:
2979	eqObjList = Controls['SeqParFitEqList']
2980	UseFlags = G2frame.SeqTable.GetColValues(0)
2981	for obj in eqObjList:
2982	expr = obj.expression
2983	# assemble refined vars for this equation
2984	varyValueDict.update({var:val for var,val in obj.GetVariedVarVal()})
2985	# lookup dependent var position
2986	depVar = obj.GetDepVar()
2987	if depVar in colLabels:
2988	indx = colLabels.index(depVar)
2989	else:
2990	raise Exception('Dependent variable '+depVar+' not found')
2991	# assemble a list of the independent variables
2992	indepVars = obj.GetIndependentVars()
2993	# loop over each datapoint
2994	for j,row in enumerate(zip(*colList)):
2995	if not UseFlags[j]: continue
2996	# assemble equations to fit
2997	calcobj = G2obj.ExpressionCalcObj(obj)
2998	# prepare a dict of needed independent vars for this expression
2999	indepVarDict = {var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
3000	calcobj.SetupCalc(indepVarDict)
3001	# values and sigs for current value of dependent var
3002	calcobj.depVal = row[indx]
3003	calcobj.depSig = colSigs[indx][j]
3004	calcObjList.append(calcobj)
3005	# varied parameters
3006	varyList = varyValueDict.keys()
3007	values = varyValues = [varyValueDict[key] for key in varyList]
3008	if not varyList:
3009	print 'no variables to refine!'
3010	return
3011	try:
3012	result = so.leastsq(ParEqEval,varyValues,full_output=True, #ftol=Ftol,
3013	args=(calcObjList,varyList)
3014	)
3015	values = result[0]
3016	covar = result[1]
3017	if covar is None:
3018	raise Exception
3019	esdDict = {}
3020	for i,avar in enumerate(varyList):
3021	esdDict[avar] = np.sqrt(covar[i,i])
3022	except:
3023	print('====> Fit failed')
3024	return
3025	print('==== Fit Results ====')
3026	for obj in eqObjList:
3027	obj.UpdateVariedVars(varyList,values)
3028	ind = ' '
3029	print(' '+obj.GetDepVar()+' = '+obj.expression)
3030	for var in obj.assgnVars:
3031	print(ind+var+' = '+obj.assgnVars[var])
3032	for var in obj.freeVars:
3033	avar = "::"+obj.freeVars[var][0]
3034	val = obj.freeVars[var][1]
3035	if obj.freeVars[var][2]:
3036	print(ind+var+' = '+avar + " = " + G2mth.ValEsd(val,esdDict[avar]))
3037	else:
3038	print(ind+var+' = '+avar + " =" + G2mth.ValEsd(val,0))
3039	# create a plot for each parametric variable
3040	for fitnum,obj in enumerate(eqObjList):
3041	calcobj = G2obj.ExpressionCalcObj(obj)
3042	# lookup dependent var position
3043	indx = colLabels.index(obj.GetDepVar())
3044	# assemble a list of the independent variables
3045	indepVars = obj.GetIndependentVars()
3046	# loop over each datapoint
3047	fitvals = []
3048	for j,row in enumerate(zip(*colList)):
3049	calcobj.SetupCalc(
3050	{var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
3051	)
3052	fitvals.append(calcobj.EvalExpression())
3053	G2plt.PlotSelectedSequence(
3054	G2frame,[indx],GetColumnInfo,SelectXaxis,
3055	fitnum,fitvals)
3056
3057	def SingleParEqFit(eqObj):
3058	DoParEqFit(None,eqObj)
3059
3060	def DelParFitEq(event):
3061	'Ask the user to select function to delete'
3062	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3063	selected = G2G.ItemSelector(
3064	txtlst,G2frame.dataFrame,
3065	multiple=True,
3066	title='Select a parametric equation(s) to remove',
3067	header='Delete equation')
3068	if selected is None: return
3069	Controls['SeqParFitEqList'] = [obj for i,obj in enumerate(Controls['SeqParFitEqList']) if i not in selected]
3070	EnableParFitEqMenus()
3071	if Controls['SeqParFitEqList']: DoParEqFit(event)
3072
3073	def EditParFitEq(event):
3074	'Edit an existing parametric equation'
3075	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3076	if len(txtlst) == 1:
3077	selected = 0
3078	else:
3079	selected = G2G.ItemSelector(
3080	txtlst,G2frame.dataFrame,
3081	multiple=False,
3082	title='Select a parametric equation to edit',
3083	header='Edit equation')
3084	if selected is not None:
3085	dlg = G2exG.ExpressionDialog(
3086	G2frame.dataDisplay,indepVarDict,
3087	Controls['SeqParFitEqList'][selected],
3088	depVarDict=depVarDict,
3089	header="Edit the formula for this minimization function",
3090	ExtraButton=['Fit',SingleParEqFit])
3091	newobj = dlg.Show(True)
3092	if newobj:
3093	calcobj = G2obj.ExpressionCalcObj(newobj)
3094	Controls['SeqParFitEqList'][selected] = newobj
3095	EnableParFitEqMenus()
3096	if Controls['SeqParFitEqList']: DoParEqFit(event)
3097
3098	def AddNewParFitEq(event):
3099	'Create a new parametric equation to be fit to sequential results'
3100
3101	# compile the variable names used in previous freevars to avoid accidental name collisions
3102	usedvarlist = []
3103	for obj in Controls['SeqParFitEqList']:
3104	for var in obj.freeVars:
3105	if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3106
3107	dlg = G2exG.ExpressionDialog(
3108	G2frame.dataDisplay,indepVarDict,
3109	depVarDict=depVarDict,
3110	header='Define an equation to minimize in the parametric fit',
3111	ExtraButton=['Fit',SingleParEqFit],
3112	usedVars=usedvarlist)
3113	obj = dlg.Show(True)
3114	dlg.Destroy()
3115	if obj:
3116	Controls['SeqParFitEqList'].append(obj)
3117	EnableParFitEqMenus()
3118	if Controls['SeqParFitEqList']: DoParEqFit(event)
3119
3120	def CopyParFitEq(event):
3121	'Copy an existing parametric equation to be fit to sequential results'
3122	# compile the variable names used in previous freevars to avoid accidental name collisions
3123	usedvarlist = []
3124	for obj in Controls['SeqParFitEqList']:
3125	for var in obj.freeVars:
3126	if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3127	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3128	if len(txtlst) == 1:
3129	selected = 0
3130	else:
3131	selected = G2G.ItemSelector(
3132	txtlst,G2frame.dataFrame,
3133	multiple=False,
3134	title='Select a parametric equation to copy',
3135	header='Copy equation')
3136	if selected is not None:
3137	newEqn = copy.deepcopy(Controls['SeqParFitEqList'][selected])
3138	for var in newEqn.freeVars:
3139	newEqn.freeVars[var][0] = G2obj.MakeUniqueLabel(newEqn.freeVars[var][0],usedvarlist)
3140	dlg = G2exG.ExpressionDialog(
3141	G2frame.dataDisplay,indepVarDict,
3142	newEqn,
3143	depVarDict=depVarDict,
3144	header="Edit the formula for this minimization function",
3145	ExtraButton=['Fit',SingleParEqFit])
3146	newobj = dlg.Show(True)
3147	if newobj:
3148	calcobj = G2obj.ExpressionCalcObj(newobj)
3149	Controls['SeqParFitEqList'].append(newobj)
3150	EnableParFitEqMenus()
3151	if Controls['SeqParFitEqList']: DoParEqFit(event)
3152
3153	def GridSetToolTip(row,col):
3154	'''Routine to show standard uncertainties for each element in table
3155	as a tooltip
3156	'''
3157	if colSigs[col]:
3158	return u'\u03c3 = '+str(colSigs[col][row])
3159	return ''
3160
3161	def GridColLblToolTip(col):
3162	'''Define a tooltip for a column. This will be the user-entered value
3163	(from data['variableLabels']) or the default name
3164	'''
3165	if col < 0 or col > len(colLabels):
3166	print 'Illegal column #',col
3167	return
3168	var = colLabels[col]
3169	return variableLabels.get(var,G2obj.fmtVarDescr(var))
3170
3171	def SetLabelString(event):
3172	'''Define or edit the label for a column in the table, to be used
3173	as a tooltip and for plotting
3174	'''
3175	col = event.GetCol()
3176	if col < 0 or col > len(colLabels):
3177	return
3178	var = colLabels[col]
3179	lbl = variableLabels.get(var,G2obj.fmtVarDescr(var))
3180	dlg = G2G.SingleStringDialog(G2frame.dataFrame,'Set variable label',
3181	'Set a new name for variable '+var,lbl,size=(400,-1))
3182	if dlg.Show():
3183	variableLabels[var] = dlg.GetValue()
3184	dlg.Destroy()
3185
3186	#def GridRowLblToolTip(row): return 'Row ='+str(row)
3187
3188	# lookup table for unique cell parameters by symmetry
3189	cellGUIlist = [
3190	[['m3','m3m'],(0,)],
3191	[['3R','3mR'],(0,3)],
3192	[['3','3m1','31m','6/m','6/mmm','4/m','4/mmm'],(0,2)],
3193	[['mmm'],(0,1,2)],
3194	[['2/m'+'a'],(0,1,2,3)],
3195	[['2/m'+'b'],(0,1,2,4)],
3196	[['2/m'+'c'],(0,1,2,5)],
3197	[['-1'],(0,1,2,3,4,5)],
3198	]
3199	# cell labels
3200	cellUlbl = ('a','b','c',u'\u03B1',u'\u03B2',u'\u03B3') # unicode a,b,c,alpha,beta,gamma
3201
3202	#======================================================================
3203	# start processing sequential results here (UpdateSeqResults)
3204	#======================================================================
3205	if not data:
3206	print 'No sequential refinement results'
3207	return
3208	variableLabels = data.get('variableLabels',{})
3209	data['variableLabels'] = variableLabels
3210	Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
3211	Controls = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
3212	# create a place to store Pseudo Vars & Parametric Fit functions, if not present
3213	if 'SeqPseudoVars' not in Controls: Controls['SeqPseudoVars'] = {}
3214	if 'SeqParFitEqList' not in Controls: Controls['SeqParFitEqList'] = []
3215	histNames = data['histNames']
3216	if G2frame.dataDisplay:
3217	G2frame.dataDisplay.Destroy()
3218	if not G2frame.dataFrame.GetStatusBar():
3219	Status = G2frame.dataFrame.CreateStatusBar()
3220	Status.SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
3221	sampleParms = GetSampleParms()
3222
3223	# make dict of varied atom coords keyed by absolute position
3224	newAtomDict = data[histNames[0]].get('newAtomDict',{}) # dict with atom positions; relative & absolute
3225	# Possible error: the next might need to be data[histNames[0]]['varyList']
3226	# error will arise if there constraints on coordinates?
3227	atomLookup = {newAtomDict[item][0]:item for item in newAtomDict if item in data['varyList']}
3228
3229	# make dict of varied cell parameters equivalents
3230	ESDlookup = {} # provides the Dij term for each Ak term (where terms are refined)
3231	Dlookup = {} # provides the Ak term for each Dij term (where terms are refined)
3232	# N.B. These Dij vars are missing a histogram #
3233	newCellDict = data[histNames[0]].get('newCellDict',{})
3234	for item in newCellDict:
3235	if item in data['varyList']:
3236	ESDlookup[newCellDict[item][0]] = item
3237	Dlookup[item] = newCellDict[item][0]
3238	# add coordinate equivalents to lookup table
3239	for parm in atomLookup:
3240	Dlookup[atomLookup[parm]] = parm
3241	ESDlookup[parm] = atomLookup[parm]
3242
3243	# get unit cell & symmetry for all phases & initial stuff for later use
3244	RecpCellTerms = {}
3245	SGdata = {}
3246	uniqCellIndx = {}
3247	initialCell = {}
3248	RcellLbls = {}
3249	zeroDict = {}
3250	Rcelldict = {}
3251	for phase in Phases:
3252	phasedict = Phases[phase]
3253	pId = phasedict['pId']
3254	pfx = str(pId)+'::' # prefix for A values from phase
3255	RcellLbls[pId] = [pfx+'A'+str(i) for i in range(6)]
3256	RecpCellTerms[pId] = G2lat.cell2A(phasedict['General']['Cell'][1:7])
3257	zeroDict[pId] = dict(zip(RcellLbls[pId],6*[0.,]))
3258	SGdata[pId] = phasedict['General']['SGData']
3259	Rcelldict.update({lbl:val for lbl,val in zip(RcellLbls[pId],RecpCellTerms[pId])})
3260	laue = SGdata[pId]['SGLaue']
3261	if laue == '2/m':
3262	laue += SGdata[pId]['SGUniq']
3263	for symlist,celllist in cellGUIlist:
3264	if laue in symlist:
3265	uniqCellIndx[pId] = celllist
3266	break
3267	else: # should not happen
3268	uniqCellIndx[pId] = range(6)
3269	for i in uniqCellIndx[pId]:
3270	initialCell[str(pId)+'::A'+str(i)] = RecpCellTerms[pId][i]
3271
3272	SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
3273	G2frame.dataFrame.SetLabel('Sequential refinement results')
3274	if not G2frame.dataFrame.GetStatusBar():
3275	Status = G2frame.dataFrame.CreateStatusBar()
3276	Status.SetStatusText('')
3277	G2frame.dataFrame.Bind(wx.EVT_MENU, OnRenameSelSeq, id=wxID_RENAMESEQSEL)
3278	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
3279	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeqCSV, id=wxID_SAVESEQSELCSV)
3280	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSeqCSV, id=wxID_SAVESEQCSV)
3281	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotSelSeq, id=wxID_PLOTSEQSEL)
3282	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAveSelSeq, id=wxID_AVESEQSEL)
3283	G2frame.dataFrame.Bind(wx.EVT_MENU, OnReOrgSelSeq, id=wxID_ORGSEQSEL)
3284	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewPseudoVar, id=wxADDSEQVAR)
3285	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewDistPseudoVar, id=wxADDSEQDIST)
3286	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewAnglePseudoVar, id=wxADDSEQANGLE)
3287	G2frame.dataFrame.Bind(wx.EVT_MENU, DelPseudoVar, id=wxDELSEQVAR)
3288	G2frame.dataFrame.Bind(wx.EVT_MENU, EditPseudoVar, id=wxEDITSEQVAR)
3289	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewParFitEq, id=wxADDPARFIT)
3290	G2frame.dataFrame.Bind(wx.EVT_MENU, CopyParFitEq, id=wxCOPYPARFIT)
3291	G2frame.dataFrame.Bind(wx.EVT_MENU, DelParFitEq, id=wxDELPARFIT)
3292	G2frame.dataFrame.Bind(wx.EVT_MENU, EditParFitEq, id=wxEDITPARFIT)
3293	G2frame.dataFrame.Bind(wx.EVT_MENU, DoParEqFit, id=wxDOPARFIT)
3294	EnablePseudoVarMenus()
3295	EnableParFitEqMenus()
3296
3297	# scan for locations where the variables change
3298	VaryListChanges = [] # histograms where there is a change
3299	combinedVaryList = []
3300	firstValueDict = {}
3301	vallookup = {}
3302	posdict = {}
3303	prevVaryList = []
3304	for i,name in enumerate(histNames):
3305	for var,val,sig in zip(data[name]['varyList'],data[name]['variables'],data[name]['sig']):
3306	svar = striphist(var,'*') # wild-carded
3307	if svar not in combinedVaryList:
3308	# add variables to list as they appear
3309	combinedVaryList.append(svar)
3310	firstValueDict[svar] = (val,sig)
3311	if prevVaryList != data[name]['varyList']: # this refinement has a different refinement list from previous
3312	prevVaryList = data[name]['varyList']
3313	vallookup[name] = dict(zip(data[name]['varyList'],data[name]['variables']))
3314	posdict[name] = {}
3315	for var in data[name]['varyList']:
3316	svar = striphist(var,'*')
3317	posdict[name][combinedVaryList.index(svar)] = svar
3318	VaryListChanges.append(name)
3319	if len(VaryListChanges) > 1:
3320	G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,True)
3321	else:
3322	G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,False)
3323	#-----------------------------------------------------------------------------------
3324	# build up the data table by columns -----------------------------------------------
3325	nRows = len(histNames)
3326	colList = [nRows*[True]]
3327	colSigs = [None]
3328	colLabels = ['Use']
3329	Types = [wg.GRID_VALUE_BOOL]
3330	# start with Rwp values
3331	if 'IMG ' not in histNames[0][:4]:
3332	colList += [[data[name]['Rvals']['Rwp'] for name in histNames]]
3333	colSigs += [None]
3334	colLabels += ['Rwp']
3335	Types += [wg.GRID_VALUE_FLOAT+':10,3',]
3336	# add % change in Chi^2 in last cycle
3337	if histNames[0][:4] not in ['SASD','IMG '] and Controls.get('ShowCell'):
3338	colList += [[100.*data[name]['Rvals'].get('DelChi2',-1) for name in histNames]]
3339	colSigs += [None]
3340	colLabels += [u'\u0394\u03C7\u00B2 (%)']
3341	Types += [wg.GRID_VALUE_FLOAT,]
3342	deltaChiCol = len(colLabels)-1
3343	# add changing sample parameters to table
3344	for key in sampleParms:
3345	colList += [sampleParms[key]]
3346	colSigs += [None]
3347	colLabels += [key]
3348	Types += [wg.GRID_VALUE_FLOAT,]
3349	sampleDict = {}
3350	for i,name in enumerate(histNames):
3351	sampleDict[name] = dict(zip(sampleParms.keys(),[sampleParms[key][i] for key in sampleParms.keys()]))
3352	# add unique cell parameters TODO: review this where the cell symmetry changes (when possible)
3353	if Controls.get('ShowCell',False):
3354	for pId in sorted(RecpCellTerms):
3355	pfx = str(pId)+'::' # prefix for A values from phase
3356	cells = []
3357	cellESDs = []
3358	colLabels += [pfx+cellUlbl[i] for i in uniqCellIndx[pId]]
3359	colLabels += [pfx+'Vol']
3360	Types += (1+len(uniqCellIndx[pId]))*[wg.GRID_VALUE_FLOAT,]
3361	for name in histNames:
3362	covData = {
3363	'varyList': [Dlookup.get(striphist(v),v) for v in data[name]['varyList']],
3364	'covMatrix': data[name]['covMatrix']
3365	}
3366	A = RecpCellTerms[pId][:] # make copy of starting A values
3367	# update with refined values
3368	for i in range(6):
3369	var = str(pId)+'::A'+str(i)
3370	if var in ESDlookup:
3371	val = data[name]['newCellDict'][ESDlookup[var]][1] # get refined value
3372	A[i] = val # override with updated value
3373	# apply symmetry
3374	Albls = [pfx+'A'+str(i) for i in range(6)]
3375	cellDict = dict(zip(Albls,A))
3376	A,zeros = G2stIO.cellFill(pfx,SGdata[pId],cellDict,zeroDict[pId])
3377	# convert to direct cell & add only unique values to table
3378	c = G2lat.A2cell(A)
3379	vol = G2lat.calc_V(A)
3380	cE = G2stIO.getCellEsd(pfx,SGdata[pId],A,covData)
3381	cells += [[c[i] for i in uniqCellIndx[pId]]+[vol]]
3382	cellESDs += [[cE[i] for i in uniqCellIndx[pId]]+[cE[-1]]]
3383	colList += zip(*cells)
3384	colSigs += zip(*cellESDs)
3385	# sort out the variables in their selected order
3386	varcols = 0
3387	for d in posdict.itervalues():
3388	varcols = max(varcols,max(d.keys())+1)
3389	# get labels for each column
3390	for i in range(varcols):
3391	lbl = ''
3392	for h in VaryListChanges:
3393	if posdict[h].get(i):
3394	if posdict[h].get(i) in lbl: continue
3395	if lbl != "": lbl += '/'
3396	lbl += posdict[h].get(i)
3397	colLabels.append(lbl)
3398	Types += varcols*[wg.GRID_VALUE_FLOAT]
3399	vals = []
3400	esds = []
3401	varsellist = None # will be a list of variable names in the order they are selected to appear
3402	# tabulate values for each hist, leaving None for blank columns
3403	for name in histNames:
3404	if name in posdict:
3405	varsellist = [posdict[name].get(i) for i in range(varcols)]
3406	# translate variable names to how they will be used in the headings
3407	vs = [striphist(v,'*') for v in data[name]['varyList']]
3408	# determine the index for each column (or None) in the data[]['variables'] and ['sig'] lists
3409	sellist = [vs.index(v) if v is not None else None for v in varsellist]
3410	#sellist = [i if striphist(v,'*') in varsellist else None for i,v in enumerate(data[name]['varyList'])]
3411	if not varsellist: raise Exception()
3412	vals.append([data[name]['variables'][s] if s is not None else None for s in sellist])
3413	esds.append([data[name]['sig'][s] if s is not None else None for s in sellist])
3414	#GSASIIpath.IPyBreak()
3415	colList += zip(*vals)
3416	colSigs += zip(*esds)
3417
3418	# tabulate constrained variables, removing histogram numbers if needed
3419	# from parameter label
3420	depValDict = {}
3421	depSigDict = {}
3422	for name in histNames:
3423	for var in data[name].get('depParmDict',{}):
3424	val,sig = data[name]['depParmDict'][var]
3425	svar = striphist(var,'*')
3426	if svar not in depValDict:
3427	depValDict[svar] = [val]
3428	depSigDict[svar] = [sig]
3429	else:
3430	depValDict[svar].append(val)
3431	depSigDict[svar].append(sig)
3432	# add the dependent constrained variables to the table
3433	for var in sorted(depValDict):
3434	if len(depValDict[var]) != len(histNames): continue
3435	colLabels.append(var)
3436	Types += [wg.GRID_VALUE_FLOAT,]
3437	colSigs += [depSigDict[var]]
3438	colList += [depValDict[var]]
3439
3440	# add atom parameters to table
3441	colLabels += atomLookup.keys()
3442	Types += len(atomLookup)*[wg.GRID_VALUE_FLOAT]
3443	for parm in sorted(atomLookup):
3444	colList += [[data[name]['newAtomDict'][atomLookup[parm]][1] for name in histNames]]
3445	if atomLookup[parm] in data[histNames[0]]['varyList']:
3446	col = data[histNames[0]]['varyList'].index(atomLookup[parm])
3447	colSigs += [[data[name]['sig'][col] for name in histNames]]
3448	else:
3449	colSigs += [None] # should not happen
3450	# evaluate Pseudovars, their ESDs and add them to grid
3451	for expr in Controls['SeqPseudoVars']:
3452	obj = Controls['SeqPseudoVars'][expr]
3453	calcobj = G2obj.ExpressionCalcObj(obj)
3454	valList = []
3455	esdList = []
3456	for seqnum,name in enumerate(histNames):
3457	sigs = data[name]['sig']
3458	G2mv.InitVars()
3459	parmDict = data[name].get('parmDict')
3460	badVary = data[name].get('badVary',[])
3461	constraintInfo = data[name].get('constraintInfo',[[],[],{},[],seqnum])
3462	groups,parmlist,constrDict,fixedList,ihst = constraintInfo
3463	varyList = data[name]['varyList']
3464	parmDict = data[name]['parmDict']
3465	G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList,parmDict,SeqHist=ihst)
3466	if 'Dist' in expr:
3467	derivs = G2mth.CalcDistDeriv(obj.distance_dict,obj.distance_atoms, parmDict)
3468	pId = obj.distance_dict['pId']
3469	aId,bId = obj.distance_atoms
3470	varyNames = ['%d::dA%s:%d'%(pId,ip,aId) for ip in ['x','y','z']]
3471	varyNames += ['%d::dA%s:%d'%(pId,ip,bId) for ip in ['x','y','z']]
3472	VCoV = G2mth.getVCov(varyNames,varyList,data[name]['covMatrix'])
3473	esdList.append(np.sqrt(np.inner(derivs,np.inner(VCoV,derivs.T)) ))
3474	# GSASIIpath.IPyBreak()
3475	elif 'Angle' in expr:
3476	derivs = G2mth.CalcAngleDeriv(obj.angle_dict,obj.angle_atoms, parmDict)
3477	pId = obj.angle_dict['pId']
3478	aId,bId = obj.angle_atoms
3479	varyNames = ['%d::dA%s:%d'%(pId,ip,aId) for ip in ['x','y','z']]
3480	varyNames += ['%d::dA%s:%d'%(pId,ip,bId[0]) for ip in ['x','y','z']]
3481	varyNames += ['%d::dA%s:%d'%(pId,ip,bId[1]) for ip in ['x','y','z']]
3482	VCoV = G2mth.getVCov(varyNames,varyList,data[name]['covMatrix'])
3483	esdList.append(np.sqrt(np.inner(derivs,np.inner(VCoV,derivs.T)) ))
3484	else:
3485	derivs = np.array(
3486	[EvalPSvarDeriv(calcobj,parmDict.copy(),sampleDict[name],var,ESD)
3487	for var,ESD in zip(varyList,sigs)])
3488	esdList.append(np.sqrt(
3489	np.inner(derivs,np.inner(data[name]['covMatrix'],derivs.T)) ))
3490	PSvarDict = parmDict.copy()
3491	PSvarDict.update(sampleDict[name])
3492	UpdateParmDict(PSvarDict)
3493	calcobj.UpdateDict(PSvarDict)
3494	valList.append(calcobj.EvalExpression())
3495	# if calcobj.su is not None: esdList[-1] = calcobj.su
3496	if not esdList:
3497	esdList = None
3498	colList += [valList]
3499	colSigs += [esdList]
3500	colLabels += [expr]
3501	Types += [wg.GRID_VALUE_FLOAT,]
3502	#---- table build done -------------------------------------------------------------
3503
3504	# Make dict needed for creating & editing pseudovars (PSvarDict).
3505	name = histNames[0]
3506	parmDict = data[name].get('parmDict',{})
3507	PSvarDict = parmDict.copy()
3508	PSvarDict.update(sampleParms)
3509	UpdateParmDict(PSvarDict)
3510	# Also dicts of dependent (depVarDict) & independent vars (indepVarDict)
3511	# for Parametric fitting from the data table
3512	parmDict = dict(zip(colLabels,zip(*colList)[0])) # scratch dict w/all values in table
3513	parmDict.update(
3514	{var:val for var,val in data[name].get('newCellDict',{}).values()} # add varied reciprocal cell terms
3515	)
3516	name = histNames[0]
3517
3518	#******************************************************************************
3519	# create a set of values for example evaluation of pseudovars and
3520	# this does not work for refinements that have differing numbers of variables.
3521	#raise Exception
3522	indepVarDict = {} # values in table w/o ESDs
3523	depVarDict = {}
3524	for i,var in enumerate(colLabels):
3525	if var == 'Use': continue
3526	if colList[i][0] is None:
3527	val,sig = firstValueDict.get(var,[None,None])
3528	elif colSigs[i]:
3529	val,sig = colList[i][0],colSigs[i][0]
3530	else:
3531	val,sig = colList[i][0],None
3532	if val is None:
3533	continue
3534	elif sig is None:
3535	indepVarDict[var] = val
3536	elif striphist(var) not in Dlookup:
3537	depVarDict[var] = val
3538	# add recip cell coeff. values
3539	depVarDict.update({var:val for var,val in data[name].get('newCellDict',{}).values()})
3540
3541	G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
3542	G2frame.SeqTable = G2G.Table(
3543	[list(c) for c in zip(*colList)], # convert from columns to rows
3544	colLabels=colLabels,rowLabels=histNames,types=Types)
3545	G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
3546	#G2frame.dataDisplay.EnableEditing(False)
3547	# make all but first column read-only
3548	for c in range(1,len(colLabels)):
3549	for r in range(nRows):
3550	G2frame.dataDisplay.SetCellReadOnly(r,c)
3551	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, PlotSelect)
3552	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_RIGHT_CLICK, SetLabelString)
3553	G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0])) #pretty arbitrary 8
3554	G2frame.dataDisplay.SetMargins(0,0)
3555	G2frame.dataDisplay.AutoSizeColumns(True)
3556	if prevSize:
3557	G2frame.dataDisplay.SetSize(prevSize)
3558	else:
3559	G2frame.dataFrame.setSizePosLeft([700,350])
3560	# highlight unconverged shifts
3561	if histNames[0][:4] not in ['SASD','IMG ']:
3562	for row,name in enumerate(histNames):
3563	deltaChi = G2frame.SeqTable.GetValue(row,deltaChiCol)
3564	if deltaChi > 10.:
3565	G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,0,0))
3566	elif deltaChi > 1.0:
3567	G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,255,0))
3568	G2frame.dataDisplay.InstallGridToolTip(GridSetToolTip,GridColLblToolTip)
3569	G2frame.dataDisplay.SendSizeEvent() # resize needed on mac
3570	G2frame.dataDisplay.Refresh() # shows colored text on mac
3571
3572	################################################################################
3573	##### Main PWDR panel
3574	################################################################################
3575
3576	def UpdatePWHKPlot(G2frame,kind,item):
3577	'''Called when the histogram main tree entry is called. Displays the
3578	histogram weight factor, refinement statistics for the histogram
3579	and the range of data for a simulation.
3580
3581	Also invokes a plot of the histogram.
3582	'''
3583	def onEditSimRange(event):
3584	'Edit simulation range'
3585	inp = [
3586	min(data[1][0]),
3587	max(data[1][0]),
3588	None
3589	]
3590	inp[2] = (inp[1] - inp[0])/(len(data[1][0])-1.)
3591	names = ('start angle', 'end angle', 'step size')
3592	dictlst = [inp] * len(inp)
3593	elemlst = range(len(inp))
3594	dlg = G2G.ScrolledMultiEditor(
3595	G2frame,[inp] * len(inp), range(len(inp)), names,
3596	header='Edit simulation range',
3597	minvals=(0.001,0.001,0.0001),
3598	maxvals=(180.,180.,.1),
3599	)
3600	dlg.CenterOnParent()
3601	val = dlg.ShowModal()
3602	dlg.Destroy()
3603	if val != wx.ID_OK: return
3604	if inp[0] > inp[1]:
3605	end,start,step = inp
3606	else:
3607	start,end,step = inp
3608	step = abs(step)
3609	N = int((end-start)/step)+1
3610	newdata = np.linspace(start,end,N,True)
3611	if len(newdata) < 2: return # too small a range - reject
3612	data[1] = [newdata,np.zeros_like(newdata),np.ones_like(newdata),
3613	np.zeros_like(newdata),np.zeros_like(newdata),np.zeros_like(newdata)]
3614	Tmin = newdata[0]
3615	Tmax = newdata[-1]
3616	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,item,'Limits'),
3617	[(Tmin,Tmax),[Tmin,Tmax]])
3618	UpdatePWHKPlot(G2frame,kind,item) # redisplay data screen
3619
3620	def OnPlot3DHKL(event):
3621	refList = data[1]['RefList']
3622	FoMax = np.max(refList.T[8+Super])
3623	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3624	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3625	Vpoint = np.array([int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))])
3626	controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
3627	'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
3628	'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
3629	'Scale':1.0,'oldxy':[],'viewDir':[0,0,1]},'Super':Super,'SuperVec':SuperVec}
3630	G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
3631
3632	def OnPlotAll3DHKL(event):
3633	choices = GetPatternTreeDataNames(G2frame,['HKLF',])
3634	dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to plot',
3635	'Use data',choices)
3636	try:
3637	if dlg.ShowModal() == wx.ID_OK:
3638	refNames = [choices[i] for i in dlg.GetSelections()]
3639	else:
3640	return
3641	finally:
3642	dlg.Destroy()
3643	refList = np.zeros(0)
3644	for name in refNames:
3645	Id = GetPatternTreeItemId(G2frame,G2frame.root, name)
3646	reflData = G2frame.PatternTree.GetItemPyData(Id)[1]
3647	if len(refList):
3648	refList = np.concatenate((refList,reflData['RefList']))
3649	else:
3650	refList = reflData['RefList']
3651
3652	FoMax = np.max(refList.T[8+Super])
3653	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3654	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3655	Vpoint = [int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))]
3656	controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
3657	'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
3658	'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
3659	'Scale':1.0,'oldxy':[],'viewDir':[1,0,0]},'Super':Super,'SuperVec':SuperVec}
3660	G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
3661
3662	def OnMergeHKL(event):
3663	Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
3664	Inst = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,
3665	G2frame.PatternId,'Instrument Parameters'))
3666	CId = GetPatternTreeItemId(G2frame,G2frame.PatternId,'Comments')
3667	if CId:
3668	Comments = G2frame.PatternTree.GetItemPyData(CId)
3669	else:
3670	Comments = []
3671	refList = np.copy(data[1]['RefList'])
3672	Comments.append(' Merging %d reflections from %s'%(len(refList),Name))
3673	dlg = MergeDialog(G2frame,data)
3674	try:
3675	if dlg.ShowModal() == wx.ID_OK:
3676	Trans,Cent,Laue = dlg.GetSelection()
3677	else:
3678	return
3679	finally:
3680	dlg.Destroy()
3681	Super = data[1]['Super']
3682	refList,badRefs = G2lat.transposeHKLF(Trans,Super,refList)
3683	if len(badRefs): #do I want to list badRefs?
3684	G2frame.ErrorDialog('Failed transformation','Matrix yields fractional hkl indices')
3685	return
3686	Comments.append(" Transformation M*H = H' applied; M=")
3687	Comments.append(str(Trans))
3688	SG = 'P '+Laue
3689	SGData = G2spc.SpcGroup(SG)[1]
3690	refList = G2lat.LaueUnique(Laue,refList)
3691	dlg = wx.ProgressDialog('Build HKL dictonary','',len(refList)+1,
3692	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
3693	HKLdict = {}
3694	for ih,hkl in enumerate(refList):
3695	if str(hkl[:3+Super]) not in HKLdict:
3696	HKLdict[str(hkl[:3+Super])] = [hkl[:3+Super],[hkl[3+Super:],]]
3697	else:
3698	HKLdict[str(hkl[:3+Super])][1].append(hkl[3+Super:])
3699	dlg.Update(ih)
3700	dlg.Destroy()
3701	mergeRef = []
3702	dlg = wx.ProgressDialog('Processing merge','',len(HKLdict)+1,
3703	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
3704	sumDf = 0.
3705	sumFo = 0.
3706	for ih,hkl in enumerate(HKLdict):
3707	HKL = HKLdict[hkl]
3708	newHKL = list(HKL[0])+list(HKL[1][0])
3709	if len(HKL[1]) > 1:
3710	fos = np.array(HKL[1])
3711	wFo = 1/fos[:,3]**2
3712	Fo = np.average(fos[:,2],weights=wFo)
3713	std = np.std(fos[:,2])
3714	sig = np.sqrt(np.mean(fos[:,3])2+std2)
3715	sumFo += np.sum(fos[:,2])
3716	sumDf += np.sum(np.abs(fos[:,2]-Fo))
3717	dlg.Update(ih)
3718	newHKL[5+Super] = Fo
3719	newHKL[6+Super] = sig
3720	newHKL[8+Super] = Fo
3721	if newHKL[5+Super] > 0.:
3722	mergeRef.append(list(newHKL))
3723	dlg.Destroy()
3724	if Super:
3725	mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,3),2),1),0)
3726	else:
3727	mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,2),1),0)
3728	mergeRef = np.array(mergeRef)
3729	if sumFo:
3730	mtext = ' merge R = %6.2f%s for %d reflections in %s'%(100.*sumDf/sumFo,'%',mergeRef.shape[0],Laue)
3731	print mtext
3732	Comments.append(mtext)
3733	else:
3734	print 'nothing to merge for %s reflections'%(mergeRef.shape[0])
3735	HKLFlist = []
3736	newName = Name+' '+Laue
3737	if G2frame.PatternTree.GetCount():
3738	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3739	while item:
3740	name = G2frame.PatternTree.GetItemText(item)
3741	if name.startswith('HKLF ') and name not in HKLFlist:
3742	HKLFlist.append(name)
3743	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3744	newName = G2obj.MakeUniqueLabel(newName,HKLFlist)
3745	newData = copy.deepcopy(data)
3746	newData[0]['ranId'] = ran.randint(0,sys.maxint)
3747	newData[1]['RefList'] = mergeRef
3748	Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=newName)
3749	G2frame.PatternTree.SetItemPyData(
3750	G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)
3751	G2frame.PatternTree.SetItemPyData(Id,newData)
3752	G2frame.PatternTree.SetItemPyData(
3753	G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
3754	G2frame.PatternTree.SetItemPyData(
3755	G2frame.PatternTree.AppendItem(Id,text='Reflection List'),{}) #dummy entry for GUI use
3756
3757	def OnErrorAnalysis(event):
3758	G2plt.PlotDeltSig(G2frame,kind)
3759
3760	def OnWtFactor(event):
3761	try:
3762	val = float(wtval.GetValue())
3763	except ValueError:
3764	val = data[0]['wtFactor']
3765	data[0]['wtFactor'] = val
3766	wtval.SetValue('%.3f'%(val))
3767
3768	def OnCompression(event):
3769	data[0] = int(comp.GetValue())
3770
3771	def onCopyPlotCtrls(event):
3772	'''Respond to menu item to copy multiple sections from a histogram.
3773	Need this here to pass on the G2frame object.
3774	'''
3775	G2pdG.CopyPlotCtrls(G2frame)
3776
3777	def onCopySelectedItems(event):
3778	'''Respond to menu item to copy multiple sections from a histogram.
3779	Need this here to pass on the G2frame object.
3780	'''
3781	G2pdG.CopySelectedHistItems(G2frame)
3782
3783	data = G2frame.PatternTree.GetItemPyData(item)
3784	#patches
3785	if 'wtFactor' not in data[0]:
3786	data[0] = {'wtFactor':1.0}
3787	# if kind == 'PWDR' and 'Compression' not in data[0]:
3788	# data[0]['Compression'] = 1
3789	#if isinstance(data[1],list) and kind == 'HKLF':
3790	if 'list' in str(type(data[1])) and kind == 'HKLF':
3791	RefData = {'RefList':[],'FF':[]}
3792	for ref in data[1]:
3793	RefData['RefList'].append(ref[:11]+[ref[13],])
3794	RefData['FF'].append(ref[14])
3795	data[1] = RefData
3796	G2frame.PatternTree.SetItemPyData(item,data)
3797	#end patches
3798	if G2frame.dataDisplay:
3799	G2frame.dataDisplay.Destroy()
3800	if kind in ['PWDR','SASD']:
3801	SetDataMenuBar(G2frame,G2frame.dataFrame.PWDRMenu)
3802	G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
3803	G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
3804	G2frame.dataFrame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
3805	elif kind in ['HKLF',]:
3806	SetDataMenuBar(G2frame,G2frame.dataFrame.HKLFMenu)
3807	G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
3808	G2frame.dataFrame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
3809	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
3810	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
3811	# G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
3812	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3813
3814	mainSizer = wx.BoxSizer(wx.VERTICAL)
3815	mainSizer.Add((5,5),)
3816	wtSizer = wx.BoxSizer(wx.HORIZONTAL)
3817	wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,WACV)
3818	wtval = wx.TextCtrl(G2frame.dataDisplay,-1,'%.3f'%(data[0]['wtFactor']),style=wx.TE_PROCESS_ENTER)
3819	wtval.Bind(wx.EVT_TEXT_ENTER,OnWtFactor)
3820	wtval.Bind(wx.EVT_KILL_FOCUS,OnWtFactor)
3821	wtSizer.Add(wtval,0,WACV)
3822	# if kind == 'PWDR': #possible future compression feature; NB above patch as well
3823	# wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Compression factor: '),0,WACV)
3824	# choice = ['1','2','3','4','5','6']
3825	# comp = wx.ComboBox(parent=G2frame.dataDisplay,choices=choice,
3826	# style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3827	# comp.SetValue(str(data[0]['Compression']))
3828	# comp.Bind(wx.EVT_COMBOBOX, OnCompression)
3829	# wtSizer.Add(comp,0,WACV)
3830	mainSizer.Add(wtSizer)
3831	if data[0].get('Dummy'):
3832	simSizer = wx.BoxSizer(wx.HORIZONTAL)
3833	Tmin = min(data[1][0])
3834	Tmax = max(data[1][0])
3835	num = len(data[1][0])
3836	step = (Tmax - Tmin)/(num-1)
3837	t = u'2\u03b8' # 2theta
3838	lbl = u'Simulation range: {:.2f} to {:.2f} {:s}\nwith {:.4f} steps ({:d} points)'
3839	lbl += u'\n(Edit range resets observed intensities).'
3840	lbl = lbl.format(Tmin,Tmax,t,step,num)
3841	simSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,lbl),
3842	0,WACV)
3843	but = wx.Button(G2frame.dataDisplay,wx.ID_ANY,"Edit range")
3844	but.Bind(wx.EVT_BUTTON,onEditSimRange)
3845	simSizer.Add(but,0,WACV)
3846	mainSizer.Add(simSizer)
3847	if 'Nobs' in data[0]:
3848	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3849	' Data residual wR: %.3f%% on %d observations'%(data[0]['wR'],data[0]['Nobs'])))
3850	for value in data[0]:
3851	if 'Nref' in value:
3852	pfx = value.split('Nref')[0]
3853	name = data[0].get(pfx.split(':')[0]+'::Name','?')
3854	if 'SS' in value:
3855	mainSizer.Add((5,5),)
3856	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For incommensurate phase '+name+':'))
3857	for m,(Rf2,Rf,Nobs) in enumerate(zip(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])):
3858	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3859	u' m = +/- %d: RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections '% \
3860	(m,Rf2,Rf,Nobs)))
3861	else:
3862	mainSizer.Add((5,5),)
3863	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For phase '+name+':'))
3864	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3865	u' Unweighted phase residuals RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections '% \
3866	(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])))
3867
3868	mainSizer.Add((5,5),)
3869	mainSizer.Layout()
3870	G2frame.dataDisplay.SetSizer(mainSizer)
3871	Size = mainSizer.Fit(G2frame.dataFrame)
3872	Size[1] += 10
3873	G2frame.dataFrame.setSizePosLeft(Size)
3874	G2frame.PatternTree.SetItemPyData(item,data)
3875	if kind in ['PWDR','SASD']:
3876	NewPlot = True
3877	if 'xylim' in dir(G2frame):
3878	NewPlot = False
3879	G2plt.PlotPatterns(G2frame,plotType=kind,newPlot=NewPlot)
3880	elif kind == 'HKLF':
3881	Name = G2frame.PatternTree.GetItemText(item)
3882	phaseName = G2pdG.IsHistogramInAnyPhase(G2frame,Name)
3883	if phaseName:
3884	pId = GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
3885	phaseId = GetPatternTreeItemId(G2frame,pId,phaseName)
3886	General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
3887	Super = General.get('Super',0)
3888	SuperVec = General.get('SuperVec',[])
3889	else:
3890	Super = 0
3891	SuperVec = []
3892	refList = data[1]['RefList']
3893	# GSASIIpath.IPyBreak()
3894	FoMax = np.max(refList.T[5+data[1].get('Super',0)])
3895	page = G2frame.G2plotNB.nb.GetSelection()
3896	tab = ''
3897	if page >= 0:
3898	tab = G2frame.G2plotNB.nb.GetPageText(page)
3899	if '3D' in tab:
3900	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3901	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3902	Vpoint = [int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))]
3903	Page = G2frame.G2plotNB.nb.GetPage(page)
3904	controls = Page.controls
3905	G2plt.Plot3DSngl(G2frame,newPlot=False,Data=controls,hklRef=refList,Title=phaseName)
3906	else:
3907	controls = {'Type' : 'Fo','ifFc' : True,
3908	'HKLmax' : [int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))],
3909	'HKLmin' : [int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))],
3910	'FoMax' : FoMax,'Zone' : '001','Layer' : 0,'Scale' : 1.0,'Super':Super,'SuperVec':SuperVec}
3911	G2plt.PlotSngl(G2frame,newPlot=True,Data=controls,hklRef=refList)
3912
3913	################################################################################
3914	##### Pattern tree routines
3915	################################################################################
3916
3917	def GetPatternTreeDataNames(G2frame,dataTypes):
3918	'''Finds all items in tree that match a 4 character prefix
3919
3920	:param wx.Frame G2frame: Data tree frame object
3921	:param list dataTypes: Contains one or more data tree item types to be matched
3922	such as ['IMG '] or ['PWDR','HKLF']
3923	:returns: a list of tree item names for the matching items
3924	'''
3925	names = []
3926	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3927	while item:
3928	name = G2frame.PatternTree.GetItemText(item)
3929	if name[:4] in dataTypes:
3930	names.append(name)
3931	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3932	return names
3933
3934	def GetPatternTreeItemId(G2frame, parentId, itemText):
3935	'''Find the tree item that matches the text in itemText starting with parentId
3936
3937	:param wx.Frame G2frame: Data tree frame object
3938	:param wx.TreeItemId parentId: tree item to start search with
3939	:param str itemText: text for tree item
3940	'''
3941	item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
3942	while item:
3943	if G2frame.PatternTree.GetItemText(item) == itemText:
3944	return item
3945	item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
3946	return 0
3947
3948	def MovePatternTreeToGrid(G2frame,item):
3949	'''Called from GSASII.OnPatternTreeSelChanged when a item is selected on the tree
3950	'''
3951	pickName = G2frame.PatternTree.GetItemText(item)
3952	if G2frame.PickIdText == pickName:
3953	return
3954
3955	oldPage = None # will be set later if already on a Phase item
3956	if G2frame.dataFrame:
3957	SetDataMenuBar(G2frame)
3958	if G2frame.dataFrame.GetLabel() == 'Comments':
3959	try:
3960	data = [G2frame.dataDisplay.GetValue()]
3961	G2frame.dataDisplay.Clear()
3962	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
3963	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3964	except: #clumsy but avoids dead window problem when opening another project
3965	pass
3966	elif G2frame.dataFrame.GetLabel() == 'Notebook':
3967	try:
3968	data = [G2frame.dataDisplay.GetValue()]
3969	G2frame.dataDisplay.Clear()
3970	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
3971	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3972	except: #clumsy but avoids dead window problem when opening another project
3973	pass
3974	elif 'Phase Data for' in G2frame.dataFrame.GetLabel():
3975	if G2frame.dataDisplay:
3976	oldPage = G2frame.dataDisplay.GetSelection()
3977	G2frame.dataFrame.Clear()
3978	G2frame.dataFrame.SetLabel('')
3979	else:
3980	#create the frame for the data item window
3981	G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
3982	G2frame.dataFrame.PhaseUserSize = None
3983
3984	G2frame.dataFrame.Raise()
3985	G2frame.PickId = item
3986	G2frame.PickIdText = None
3987	parentID = G2frame.root
3988	#for i in G2frame.ExportPattern: i.Enable(False)
3989	defWid = [250,150]
3990	if item != G2frame.root:
3991	parentID = G2frame.PatternTree.GetItemParent(item)
3992	if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
3993	G2frame.PatternId = item
3994	if G2frame.PatternTree.GetItemText(item) == 'Notebook':
3995	SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
3996	G2frame.PatternId = 0
3997	#for i in G2frame.ExportPattern: i.Enable(False)
3998	data = G2frame.PatternTree.GetItemPyData(item)
3999	UpdateNotebook(G2frame,data)
4000	elif G2frame.PatternTree.GetItemText(item) == 'Controls':
4001	G2frame.PatternId = 0
4002	#for i in G2frame.ExportPattern: i.Enable(False)
4003	data = G2frame.PatternTree.GetItemPyData(item)
4004	if not data: #fill in defaults
4005	data = copy.copy(G2obj.DefaultControls) #least squares controls
4006	G2frame.PatternTree.SetItemPyData(item,data)
4007	for i in G2frame.Refine: i.Enable(True)
4008	G2frame.EnableSeqRefineMenu()
4009	UpdateControls(G2frame,data)
4010	elif G2frame.PatternTree.GetItemText(item) == 'Sequential results':
4011	data = G2frame.PatternTree.GetItemPyData(item)
4012	UpdateSeqResults(G2frame,data)
4013	elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
4014	data = G2frame.PatternTree.GetItemPyData(item)
4015	G2frame.dataFrame.setSizePosLeft(defWid)
4016	text = ''
4017	if 'Rvals' in data:
4018	Nvars = len(data['varyList'])
4019	Rvals = data['Rvals']
4020	text = '\nFinal residuals: \nwR = %.3f%% \nchi**2 = %.1f \nGOF = %.2f'%(Rvals['Rwp'],Rvals['chisq'],Rvals['GOF'])
4021	text += '\nNobs = %d \nNvals = %d'%(Rvals['Nobs'],Nvars)
4022	if 'lamMax' in Rvals:
4023	text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
4024	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
4025	value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
4026	G2plt.PlotCovariance(G2frame,data)
4027	elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
4028	data = G2frame.PatternTree.GetItemPyData(item)
4029	G2cnstG.UpdateConstraints(G2frame,data)
4030	elif G2frame.PatternTree.GetItemText(item) == 'Rigid bodies':
4031	data = G2frame.PatternTree.GetItemPyData(item)
4032	G2cnstG.UpdateRigidBodies(G2frame,data)
4033	elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
4034	data = G2frame.PatternTree.GetItemPyData(item)
4035	Phases = G2frame.GetPhaseData()
4036	phase = ''
4037	phaseName = ''
4038	if Phases:
4039	phaseName = Phases.keys()[0]
4040	G2frame.dataFrame.setSizePosLeft(defWid)
4041	G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
4042	elif 'IMG' in G2frame.PatternTree.GetItemText(item):
4043	G2frame.Image = item
4044	G2frame.dataFrame.SetTitle('Image Data')
4045	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(
4046	G2frame,item,'Image Controls'))
4047	G2imG.UpdateImageData(G2frame,data)
4048	G2plt.PlotImage(G2frame,newPlot=True)
4049	elif 'PKS' in G2frame.PatternTree.GetItemText(item):
4050	G2plt.PlotPowderLines(G2frame)
4051	elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
4052	#for i in G2frame.ExportPattern: i.Enable(True)
4053	if G2frame.EnablePlot:
4054	UpdatePWHKPlot(G2frame,'PWDR',item)
4055	elif 'SASD' in G2frame.PatternTree.GetItemText(item):
4056	#for i in G2frame.ExportPattern: i.Enable(True)
4057	if G2frame.EnablePlot:
4058	UpdatePWHKPlot(G2frame,'SASD',item)
4059	elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
4060	G2frame.Sngl = True
4061	UpdatePWHKPlot(G2frame,'HKLF',item)
4062	elif 'PDF' in G2frame.PatternTree.GetItemText(item):
4063	G2frame.PatternId = item
4064	for i in G2frame.ExportPDF: i.Enable(True)
4065	G2plt.PlotISFG(G2frame,type='S(Q)')
4066	elif G2frame.PatternTree.GetItemText(item) == 'Phases':
4067	G2frame.dataFrame.setSizePosLeft(defWid)
4068	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
4069	value='Select one phase to see its parameters')
4070	elif 'I(Q)' in G2frame.PatternTree.GetItemText(item):
4071	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4072	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4073	G2pdG.UpdatePDFGrid(G2frame,data)
4074	G2plt.PlotISFG(G2frame,type='I(Q)',newPlot=True)
4075	elif 'S(Q)' in G2frame.PatternTree.GetItemText(item):
4076	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4077	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4078	G2pdG.UpdatePDFGrid(G2frame,data)
4079	G2plt.PlotISFG(G2frame,type='S(Q)',newPlot=True)
4080	elif 'F(Q)' in G2frame.PatternTree.GetItemText(item):
4081	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4082	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4083	G2pdG.UpdatePDFGrid(G2frame,data)
4084	G2plt.PlotISFG(G2frame,type='F(Q)',newPlot=True)
4085	elif 'G(R)' in G2frame.PatternTree.GetItemText(item):
4086	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4087	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4088	G2pdG.UpdatePDFGrid(G2frame,data)
4089	G2plt.PlotISFG(G2frame,type='G(R)',newPlot=True)
4090	elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
4091	data = G2frame.PatternTree.GetItemPyData(item)
4092	G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
4093	elif G2frame.PatternTree.GetItemText(item) == 'Comments':
4094	SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
4095	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4096	data = G2frame.PatternTree.GetItemPyData(item)
4097	UpdateComments(G2frame,data)
4098	elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
4099	G2frame.dataFrame.SetTitle('Image Controls')
4100	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4101	masks = G2frame.PatternTree.GetItemPyData(
4102	GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
4103	data = G2frame.PatternTree.GetItemPyData(item)
4104	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4105	G2imG.UpdateImageControls(G2frame,data,masks)
4106	G2plt.PlotImage(G2frame,newPlot=True)
4107	elif G2frame.PatternTree.GetItemText(item) == 'Masks':
4108	G2frame.dataFrame.SetTitle('Masks')
4109	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4110	masks = G2frame.PatternTree.GetItemPyData(item)
4111	data = G2frame.PatternTree.GetItemPyData(
4112	GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
4113	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4114	G2imG.UpdateMasks(G2frame,masks)
4115	G2plt.PlotImage(G2frame,newPlot=True)
4116	elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
4117	G2frame.dataFrame.SetTitle('Stress/Strain')
4118	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4119	data = G2frame.PatternTree.GetItemPyData(
4120	GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
4121	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4122	strsta = G2frame.PatternTree.GetItemPyData(item)
4123	G2plt.PlotImage(G2frame,newPlot=True)
4124	G2plt.PlotStrain(G2frame,strsta,newPlot=True)
4125	G2imG.UpdateStressStrain(G2frame,strsta)
4126	elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
4127	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4128	for i in G2frame.ExportPDF: i.Enable(True)
4129	data = G2frame.PatternTree.GetItemPyData(item)
4130	G2pdG.UpdatePDFGrid(G2frame,data)
4131	G2plt.PlotISFG(G2frame,type='I(Q)')
4132	G2plt.PlotISFG(G2frame,type='S(Q)')
4133	G2plt.PlotISFG(G2frame,type='F(Q)')
4134	G2plt.PlotISFG(G2frame,type='G(R)')
4135	elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
4136	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4137	for i in G2frame.ExportPeakList: i.Enable(True)
4138	data = G2frame.PatternTree.GetItemPyData(item)
4139	#patch
4140	if 'list' in str(type(data)):
4141	data = {'peaks':data,'sigDict':{}}
4142	G2frame.PatternTree.SetItemPyData(item,data)
4143	#end patch
4144	G2pdG.UpdatePeakGrid(G2frame,data)
4145	G2plt.PlotPatterns(G2frame)
4146	elif G2frame.PatternTree.GetItemText(item) == 'Background':
4147	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4148	data = G2frame.PatternTree.GetItemPyData(item)
4149	G2pdG.UpdateBackground(G2frame,data)
4150	G2plt.PlotPatterns(G2frame)
4151	elif G2frame.PatternTree.GetItemText(item) == 'Limits':
4152	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4153	datatype = G2frame.PatternTree.GetItemText(G2frame.PatternId)[:4]
4154	data = G2frame.PatternTree.GetItemPyData(item)
4155	G2pdG.UpdateLimitsGrid(G2frame,data,datatype)
4156	G2plt.PlotPatterns(G2frame,plotType=datatype)
4157	elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
4158	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4159	data = G2frame.PatternTree.GetItemPyData(item)[0]
4160	G2pdG.UpdateInstrumentGrid(G2frame,data)
4161	if 'P' in data['Type'][0]: #powder data only
4162	G2plt.PlotPeakWidths(G2frame)
4163	elif G2frame.PatternTree.GetItemText(item) == 'Models':
4164	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4165	data = G2frame.PatternTree.GetItemPyData(item)
4166	G2pdG.UpdateModelsGrid(G2frame,data)
4167	G2plt.PlotPatterns(G2frame,plotType='SASD')
4168	if len(data['Size']['Distribution']):
4169	G2plt.PlotSASDSizeDist(G2frame)
4170	elif G2frame.PatternTree.GetItemText(item) == 'Substances':
4171	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4172	data = G2frame.PatternTree.GetItemPyData(item)
4173	G2pdG.UpdateSubstanceGrid(G2frame,data)
4174	elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
4175	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4176	data = G2frame.PatternTree.GetItemPyData(item)
4177	datatype = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[2][:4]
4178
4179	if 'Temperature' not in data: #temp fix for old gpx files
4180	data = {'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],'DisplaceX':[0.0,False],
4181	'DisplaceY':[0.0,False],'Diffuse':[],'Temperature':300.,'Pressure':1.0,
4182	'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
4183	'Gonio. radius':200.0}
4184	G2frame.PatternTree.SetItemPyData(item,data)
4185
4186	G2pdG.UpdateSampleGrid(G2frame,data)
4187	G2plt.PlotPatterns(G2frame,plotType=datatype)
4188	elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
4189	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4190	for i in G2frame.ExportPeakList: i.Enable(True)
4191	data = G2frame.PatternTree.GetItemPyData(item)
4192	#patch
4193	if len(data) != 2:
4194	data = [data,[]]
4195	G2frame.PatternTree.SetItemPyData(item,data)
4196	#end patch
4197	G2pdG.UpdateIndexPeaksGrid(G2frame,data)
4198	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
4199	G2plt.PlotPowderLines(G2frame)
4200	else:
4201	G2plt.PlotPatterns(G2frame)
4202	elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
4203	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4204	data = G2frame.PatternTree.GetItemPyData(item)
4205	if not data:
4206	data.append([0,0.0,4,25.0,0,'P1',1,1,1,90,90,90]) #zero error flag, zero value, max Nc/No, start volume
4207	data.append([0,0,0,0,0,0,0,0,0,0,0,0,0,0]) #Bravais lattice flags
4208	data.append([]) #empty cell list
4209	data.append([]) #empty dmin
4210	data.append({}) #empty superlattice stuff
4211	G2frame.PatternTree.SetItemPyData(item,data)
4212	#patch
4213	if len(data) < 5:
4214	data.append({'Use':False,'ModVec':[0,0,0.1],'maxH':1,'ssSymb':''}) #empty superlattice stuff
4215	G2frame.PatternTree.SetItemPyData(item,data)
4216	#end patch
4217	G2pdG.UpdateUnitCellsGrid(G2frame,data)
4218	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
4219	G2plt.PlotPowderLines(G2frame)
4220	else:
4221