Context Navigation

source: trunk/GSASIIgrid.py @ 2659

Last change on this file since 2659 was 2659, checked in by vondreele, 6 years ago
make lab data (2 x-ray wavelengths) instrument default 'Bragg-Brentano', all others 'Debye-Scherrer' refactor PDF stuff to show PDF Controls & (new) PDF Peaks on G2 tree (removing I(Q)...). Old gpx files with I(Q)... updated automatically to new scheme Add new tree item for PDF Peaks - does nothing yet. Fix FWHM calc for TOF so bins/FWHM on peak fitting make sense.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 223.0 KB

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