Context Navigation

source: trunk/GSASIIgrid.py @ 2316

Last change on this file since 2316 was 2316, checked in by toby, 7 years ago
prototype distance calc.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 198.0 KB

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

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

Download in other formats: