Context Navigation

source: trunk/GSASIIgrid.py @ 2321

Last change on this file since 2321 was 2321, checked in by vondreele, 7 years ago
start on CalcDistSig? & AddAngleDialog? from tablet
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 198.8 KB

Line
1	# -- coding: utf-8 --
2	#GSASIIgrid - data display routines
3	########### SVN repository information ###################
4	# $Date: 2016-06-15 12:10:38 +0000 (Wed, 15 Jun 2016) $
5	# $Author: vondreele $
6	# $Revision: 2321 $
7	# $URL: trunk/GSASIIgrid.py $
8	# $Id: GSASIIgrid.py 2321 2016-06-15 12:10:38Z vondreele $
9	########### SVN repository information ###################
10	'''
11	GSASIIgrid: Basic GUI routines
12	--------------------------------
13
14	'''
15	import wx
16	import wx.grid as wg
17	#import wx.wizard as wz
18	#import wx.aui
19	import wx.lib.scrolledpanel as wxscroll
20	import time
21	import copy
22	import 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: 2321 $")
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='Add Distance',
1468	help='Add a new bond distance pseudo-variable')
1469	self.SequentialPvars.Append(
1470	id=wxADDSEQANGLE, kind=wx.ITEM_NORMAL,text='Add Angle',
1471	help='Add a new bond angle pseudo-variable')
1472	self.SequentialPvars.Append(
1473	id=wxDELSEQVAR, kind=wx.ITEM_NORMAL,text='Delete',
1474	help='Delete an existing pseudo-variable')
1475	self.SequentialPvars.Append(
1476	id=wxEDITSEQVAR, kind=wx.ITEM_NORMAL,text='Edit',
1477	help='Edit an existing pseudo-variable')
1478
1479	self.SequentialPfit = wx.Menu(title='')
1480	self.SequentialMenu.Append(menu=self.SequentialPfit, title='Parametric Fit')
1481	self.SequentialPfit.Append(
1482	id=wxADDPARFIT, kind=wx.ITEM_NORMAL,text='Add equation',
1483	help='Add a new equation to minimize')
1484	self.SequentialPfit.Append(
1485	id=wxCOPYPARFIT, kind=wx.ITEM_NORMAL,text='Copy equation',
1486	help='Copy an equation to minimize - edit it next')
1487	self.SequentialPfit.Append(
1488	id=wxDELPARFIT, kind=wx.ITEM_NORMAL,text='Delete equation',
1489	help='Delete an equation for parametric minimization')
1490	self.SequentialPfit.Append(
1491	id=wxEDITPARFIT, kind=wx.ITEM_NORMAL,text='Edit equation',
1492	help='Edit an existing parametric minimization equation')
1493	self.SequentialPfit.Append(
1494	id=wxDOPARFIT, kind=wx.ITEM_NORMAL,text='Fit to equation(s)',
1495	help='Perform a parametric minimization')
1496	self.PostfillDataMenu()
1497
1498	# PWDR & SASD
1499	self.PWDRMenu = wx.MenuBar()
1500	self.PrefillDataMenu(self.PWDRMenu,helpType='PWDR Analysis',helpLbl='Powder Fit Error Analysis')
1501	self.ErrorAnal = wx.Menu(title='')
1502	self.PWDRMenu.Append(menu=self.ErrorAnal,title='Commands')
1503	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Error Analysis',
1504	help='Error analysis on powder pattern')
1505	self.ErrorAnal.Append(id=wxID_PWDCOPY,kind=wx.ITEM_NORMAL,text='Copy params',
1506	help='Copy of PWDR parameters')
1507	self.ErrorAnal.Append(id=wxID_PLOTCTRLCOPY,kind=wx.ITEM_NORMAL,text='Copy plot controls',
1508	help='Copy of PWDR plot controls')
1509
1510	self.PostfillDataMenu()
1511
1512	# HKLF
1513	self.HKLFMenu = wx.MenuBar()
1514	self.PrefillDataMenu(self.HKLFMenu,helpType='HKLF Analysis',helpLbl='HKLF Fit Error Analysis')
1515	self.ErrorAnal = wx.Menu(title='')
1516	self.HKLFMenu.Append(menu=self.ErrorAnal,title='Commands')
1517	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Error Analysis',
1518	help='Error analysis on single crystal data')
1519	self.ErrorAnal.Append(id=wxID_MERGEHKL,kind=wx.ITEM_NORMAL,text='Merge HKLs',
1520	help='Transform & merge HKLF data to new histogram')
1521	self.ErrorAnal.Append(id=wxID_PWD3DHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot 3D HKLs',
1522	help='Plot HKLs from single crystal data in 3D')
1523	self.ErrorAnal.Append(id=wxID_3DALLHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot all 3D HKLs',
1524	help='Plot HKLs from all single crystal data in 3D')
1525	self.ErrorAnal.Append(id=wxID_PWDCOPY,kind=wx.ITEM_NORMAL,text='Copy params',
1526	help='Copy of HKLF parameters')
1527	self.PostfillDataMenu()
1528
1529	# PDR / Limits
1530	self.LimitMenu = wx.MenuBar()
1531	self.PrefillDataMenu(self.LimitMenu,helpType='Limits')
1532	self.LimitEdit = wx.Menu(title='')
1533	self.LimitMenu.Append(menu=self.LimitEdit, title='Edit')
1534	self.LimitEdit.Append(id=wxID_LIMITCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1535	help='Copy limits to other histograms')
1536	self.LimitEdit.Append(id=wxID_ADDEXCLREGION, kind=wx.ITEM_NORMAL,text='Add exclude',
1537	help='Add excluded region - select a point on plot; drag to adjust')
1538	self.PostfillDataMenu()
1539
1540	# PDR / Background
1541	self.BackMenu = wx.MenuBar()
1542	self.PrefillDataMenu(self.BackMenu,helpType='Background')
1543	self.BackEdit = wx.Menu(title='')
1544	self.BackMenu.Append(menu=self.BackEdit, title='File')
1545	self.BackEdit.Append(id=wxID_BACKCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1546	help='Copy background parameters to other histograms')
1547	self.BackEdit.Append(id=wxID_BACKFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1548	help='Copy background refinement flags to other histograms')
1549	self.BackEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks',
1550	help='Move background peaks to Peak List')
1551	self.BackFixed = wx.Menu(title='') # fixed background point menu
1552	self.BackMenu.Append(menu=self.BackFixed, title='Fixed Points')
1553	self.wxID_BackPts = {}
1554	self.wxID_BackPts['Add'] = wx.NewId() # N.B. not using wxID_ global as for other menu items
1555	self.BackFixed.Append(id=self.wxID_BackPts['Add'], kind=wx.ITEM_RADIO,text='Add',
1556	help='Add fixed background points with mouse clicks')
1557	self.wxID_BackPts['Move'] = wx.NewId()
1558	item = self.BackFixed.Append(id=self.wxID_BackPts['Move'], kind=wx.ITEM_RADIO,text='Move',
1559	help='Move selected fixed background points with mouse drags')
1560	item.Check(True)
1561	self.wxID_BackPts['Del'] = wx.NewId()
1562	self.BackFixed.Append(id=self.wxID_BackPts['Del'], kind=wx.ITEM_RADIO,text='Delete',
1563	help='Delete fixed background points with mouse clicks')
1564	self.wxID_BackPts['Clear'] = wx.NewId()
1565	self.BackFixed.Append(id=self.wxID_BackPts['Clear'], kind=wx.ITEM_NORMAL,text='Clear',
1566	help='Clear fixed background points')
1567	self.wxID_BackPts['Fit'] = wx.NewId()
1568	self.BackFixed.Append(id=self.wxID_BackPts['Fit'], kind=wx.ITEM_NORMAL,text='Fit background',
1569	help='Fit background function to fixed background points')
1570	self.PostfillDataMenu()
1571
1572	# PDR / Instrument Parameters
1573	self.InstMenu = wx.MenuBar()
1574	self.PrefillDataMenu(self.InstMenu,helpType='Instrument Parameters')
1575	self.InstEdit = wx.Menu(title='')
1576	self.InstMenu.Append(menu=self.InstEdit, title='Operations')
1577	self.InstEdit.Append(help='Calibrate from indexed peaks',
1578	id=wxID_INSTCALIB, kind=wx.ITEM_NORMAL,text='Calibrate')
1579	self.InstEdit.Append(help='Reset instrument profile parameters to default',
1580	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
1581	self.InstEdit.Append(help='Load instrument profile parameters from file',
1582	id=wxID_INSTLOAD, kind=wx.ITEM_NORMAL,text='Load profile...')
1583	self.InstEdit.Append(help='Save all instrument profile parameters to one file',
1584	id=wxID_INSTSAVE, kind=wx.ITEM_NORMAL,text='Save profile...')
1585	self.InstEdit.Append(help='Save instrument profile parameters to file',
1586	id=wxID_INSTSAVEALL, kind=wx.ITEM_NORMAL,text='Save all profile...')
1587	self.InstEdit.Append(help='Copy instrument profile parameters to other histograms',
1588	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
1589	self.InstEdit.Append(id=wxID_INSTFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1590	help='Copy instrument parameter refinement flags to other histograms')
1591	# self.InstEdit.Append(help='Change radiation type (Ka12 - synch)',
1592	# id=wxID_CHANGEWAVETYPE, kind=wx.ITEM_NORMAL,text='Change radiation')
1593	self.InstEdit.Append(id=wxID_INST1VAL, kind=wx.ITEM_NORMAL,text='Set one value',
1594	help='Set one instrument parameter value across multiple histograms')
1595
1596	self.PostfillDataMenu()
1597
1598	# PDR / Sample Parameters
1599	self.SampleMenu = wx.MenuBar()
1600	self.PrefillDataMenu(self.SampleMenu,helpType='Sample Parameters')
1601	self.SampleEdit = wx.Menu(title='')
1602	self.SampleMenu.Append(menu=self.SampleEdit, title='Command')
1603	self.SetScale = self.SampleEdit.Append(id=wxID_SETSCALE, kind=wx.ITEM_NORMAL,text='Set scale',
1604	help='Set scale by matching to another histogram')
1605	self.SampleEdit.Append(id=wxID_SAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load',
1606	help='Load sample parameters from file')
1607	self.SampleEdit.Append(id=wxID_SAMPLESAVE, kind=wx.ITEM_NORMAL,text='Save',
1608	help='Save sample parameters to file')
1609	self.SampleEdit.Append(id=wxID_SAMPLECOPY, kind=wx.ITEM_NORMAL,text='Copy',
1610	help='Copy refinable and most other sample parameters to other histograms')
1611	self.SampleEdit.Append(id=wxID_SAMPLECOPYSOME, kind=wx.ITEM_NORMAL,text='Copy selected...',
1612	help='Copy selected sample parameters to other histograms')
1613	self.SampleEdit.Append(id=wxID_SAMPLEFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1614	help='Copy sample parameter refinement flags to other histograms')
1615	self.SampleEdit.Append(id=wxID_SAMPLE1VAL, kind=wx.ITEM_NORMAL,text='Set one value',
1616	help='Set one sample parameter value across multiple histograms')
1617	self.SampleEdit.Append(id=wxID_ALLSAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load all',
1618	help='Load sample parmameters over multiple histograms')
1619
1620	self.PostfillDataMenu()
1621	self.SetScale.Enable(False)
1622
1623	# PDR / Peak List
1624	self.PeakMenu = wx.MenuBar()
1625	self.PrefillDataMenu(self.PeakMenu,helpType='Peak List')
1626	self.PeakEdit = wx.Menu(title='')
1627	self.PeakMenu.Append(menu=self.PeakEdit, title='Peak Fitting')
1628	self.AutoSearch = self.PeakEdit.Append(help='Automatic peak search',
1629	id=wxID_AUTOSEARCH, kind=wx.ITEM_NORMAL,text='Auto search')
1630	self.UnDo = self.PeakEdit.Append(help='Undo last least squares refinement',
1631	id=wxID_UNDO, kind=wx.ITEM_NORMAL,text='UnDo')
1632	self.PeakFit = self.PeakEdit.Append(id=wxID_LSQPEAKFIT, kind=wx.ITEM_NORMAL,text='Peakfit',
1633	help='Peak fitting' )
1634	self.PFOneCycle = self.PeakEdit.Append(id=wxID_LSQONECYCLE, kind=wx.ITEM_NORMAL,text='Peakfit one cycle',
1635	help='One cycle of Peak fitting' )
1636	self.PeakEdit.Append(id=wxID_RESETSIGGAM, kind=wx.ITEM_NORMAL,
1637	text='Reset sig and gam',help='Reset sigma and gamma to global fit' )
1638	self.PeakCopy = self.PeakEdit.Append(help='Copy peaks to other histograms',
1639	id=wxID_PEAKSCOPY, kind=wx.ITEM_NORMAL,text='Peak copy')
1640	self.SeqPeakFit = self.PeakEdit.Append(id=wxID_SEQPEAKFIT, kind=wx.ITEM_NORMAL,text='Seq PeakFit',
1641	help='Sequential Peak fitting for all histograms' )
1642	self.PeakEdit.Append(id=wxID_CLEARPEAKS, kind=wx.ITEM_NORMAL,text='Clear peaks',
1643	help='Clear the peak list' )
1644	self.PostfillDataMenu()
1645	self.UnDo.Enable(False)
1646	self.PeakFit.Enable(False)
1647	self.PFOneCycle.Enable(False)
1648	self.AutoSearch.Enable(True)
1649
1650	# PDR / Index Peak List
1651	self.IndPeaksMenu = wx.MenuBar()
1652	self.PrefillDataMenu(self.IndPeaksMenu,helpType='Index Peak List')
1653	self.IndPeaksEdit = wx.Menu(title='')
1654	self.IndPeaksMenu.Append(menu=self.IndPeaksEdit,title='Operations')
1655	self.IndPeaksEdit.Append(help='Load/Reload index peaks from peak list',id=wxID_INDXRELOAD,
1656	kind=wx.ITEM_NORMAL,text='Load/Reload')
1657	self.PostfillDataMenu()
1658
1659	# PDR / Unit Cells List
1660	self.IndexMenu = wx.MenuBar()
1661	self.PrefillDataMenu(self.IndexMenu,helpType='Unit Cells List')
1662	self.IndexEdit = wx.Menu(title='')
1663	self.IndexMenu.Append(menu=self.IndexEdit, title='Cell Index/Refine')
1664	self.IndexPeaks = self.IndexEdit.Append(help='', id=wxID_INDEXPEAKS, kind=wx.ITEM_NORMAL,
1665	text='Index Cell')
1666	self.CopyCell = self.IndexEdit.Append( id=wxID_COPYCELL, kind=wx.ITEM_NORMAL,text='Copy Cell',
1667	help='Copy selected unit cell from indexing to cell refinement fields')
1668	self.RefineCell = self.IndexEdit.Append( id=wxID_REFINECELL, kind=wx.ITEM_NORMAL,
1669	text='Refine Cell',help='Refine unit cell parameters from indexed peaks')
1670	self.MakeNewPhase = self.IndexEdit.Append( id=wxID_MAKENEWPHASE, kind=wx.ITEM_NORMAL,
1671	text='Make new phase',help='Make new phase from selected unit cell')
1672	self.ExportCells = self.IndexEdit.Append( id=wxID_EXPORTCELLS, kind=wx.ITEM_NORMAL,
1673	text='Export cell list',help='Export cell list to csv file')
1674	self.PostfillDataMenu()
1675	self.IndexPeaks.Enable(False)
1676	self.CopyCell.Enable(False)
1677	self.RefineCell.Enable(False)
1678	self.MakeNewPhase.Enable(False)
1679
1680	# PDR / Reflection Lists
1681	self.ReflMenu = wx.MenuBar()
1682	self.PrefillDataMenu(self.ReflMenu,helpType='Reflection List')
1683	self.ReflEdit = wx.Menu(title='')
1684	self.ReflMenu.Append(menu=self.ReflEdit, title='Reflection List')
1685	self.SelectPhase = self.ReflEdit.Append(help='Select phase for reflection list',id=wxID_SELECTPHASE,
1686	kind=wx.ITEM_NORMAL,text='Select phase')
1687	self.ReflEdit.Append(id=wxID_PWDHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot HKLs',
1688	help='Plot HKLs from powder pattern')
1689	self.ReflEdit.Append(id=wxID_PWD3DHKLPLOT,kind=wx.ITEM_NORMAL,text='Plot 3D HKLs',
1690	help='Plot HKLs from powder pattern in 3D')
1691	self.PostfillDataMenu()
1692
1693	# SASD / Instrument Parameters
1694	self.SASDInstMenu = wx.MenuBar()
1695	self.PrefillDataMenu(self.SASDInstMenu,helpType='Instrument Parameters')
1696	self.SASDInstEdit = wx.Menu(title='')
1697	self.SASDInstMenu.Append(menu=self.SASDInstEdit, title='Operations')
1698	self.InstEdit.Append(help='Reset instrument profile parameters to default',
1699	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
1700	self.SASDInstEdit.Append(help='Copy instrument profile parameters to other histograms',
1701	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
1702	self.PostfillDataMenu()
1703
1704	#SASD & REFL/ Substance editor
1705	self.SubstanceMenu = wx.MenuBar()
1706	self.PrefillDataMenu(self.SubstanceMenu,helpType='Substances')
1707	self.SubstanceEdit = wx.Menu(title='')
1708	self.SubstanceMenu.Append(menu=self.SubstanceEdit, title='Edit')
1709	self.SubstanceEdit.Append(id=wxID_LOADSUBSTANCE, kind=wx.ITEM_NORMAL,text='Load substance',
1710	help='Load substance from file')
1711	self.SubstanceEdit.Append(id=wxID_ADDSUBSTANCE, kind=wx.ITEM_NORMAL,text='Add substance',
1712	help='Add new substance to list')
1713	self.SubstanceEdit.Append(id=wxID_COPYSUBSTANCE, kind=wx.ITEM_NORMAL,text='Copy substances',
1714	help='Copy substances')
1715	self.SubstanceEdit.Append(id=wxID_DELETESUBSTANCE, kind=wx.ITEM_NORMAL,text='Delete substance',
1716	help='Delete substance from list')
1717	self.SubstanceEdit.Append(id=wxID_ELEMENTADD, kind=wx.ITEM_NORMAL,text='Add elements',
1718	help='Add elements to substance')
1719	self.SubstanceEdit.Append(id=wxID_ELEMENTDELETE, kind=wx.ITEM_NORMAL,text='Delete elements',
1720	help='Delete elements from substance')
1721	self.PostfillDataMenu()
1722
1723	# SASD/ Models
1724	self.ModelMenu = wx.MenuBar()
1725	self.PrefillDataMenu(self.ModelMenu,helpType='Models')
1726	self.ModelEdit = wx.Menu(title='')
1727	self.ModelMenu.Append(menu=self.ModelEdit, title='Models')
1728	self.ModelEdit.Append(id=wxID_MODELADD,kind=wx.ITEM_NORMAL,text='Add',
1729	help='Add new term to model')
1730	self.ModelEdit.Append(id=wxID_MODELFIT, kind=wx.ITEM_NORMAL,text='Fit',
1731	help='Fit model parameters to data')
1732	self.SasdUndo = self.ModelEdit.Append(id=wxID_MODELUNDO, kind=wx.ITEM_NORMAL,text='Undo',
1733	help='Undo model fit')
1734	self.SasdUndo.Enable(False)
1735	self.ModelEdit.Append(id=wxID_MODELFITALL, kind=wx.ITEM_NORMAL,text='Sequential fit',
1736	help='Sequential fit of model parameters to all SASD data')
1737	self.ModelEdit.Append(id=wxID_MODELCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1738	help='Copy model parameters to other histograms')
1739	self.ModelEdit.Append(id=wxID_MODELCOPYFLAGS, kind=wx.ITEM_NORMAL,text='Copy flags',
1740	help='Copy model refinement flags to other histograms')
1741	self.PostfillDataMenu()
1742
1743	# IMG / Image Controls
1744	self.ImageMenu = wx.MenuBar()
1745	self.PrefillDataMenu(self.ImageMenu,helpType='Image Controls')
1746	self.ImageEdit = wx.Menu(title='')
1747	self.ImageMenu.Append(menu=self.ImageEdit, title='Operations')
1748	self.ImageEdit.Append(help='Calibrate detector by fitting to calibrant lines',
1749	id=wxID_IMCALIBRATE, kind=wx.ITEM_NORMAL,text='Calibrate')
1750	self.ImageEdit.Append(help='Recalibrate detector by fitting to calibrant lines',
1751	id=wxID_IMRECALIBRATE, kind=wx.ITEM_NORMAL,text='Recalibrate')
1752	self.ImageEdit.Append(help='Recalibrate all images by fitting to calibrant lines',
1753	id=wxID_IMRECALIBALL, kind=wx.ITEM_NORMAL,text='Recalibrate all')
1754	self.ImageEdit.Append(help='Clear calibration data points and rings',id=wxID_IMCLEARCALIB,
1755	kind=wx.ITEM_NORMAL,text='Clear calibration')
1756	self.ImageEdit.Append(help='Integrate selected image',id=wxID_IMINTEGRATE,
1757	kind=wx.ITEM_NORMAL,text='Integrate')
1758	self.ImageEdit.Append(help='Integrate all images selected from list',id=wxID_INTEGRATEALL,
1759	kind=wx.ITEM_NORMAL,text='Integrate all')
1760	self.ImageEdit.Append(help='Copy image controls to other images',
1761	id=wxID_IMCOPYCONTROLS, kind=wx.ITEM_NORMAL,text='Copy Controls')
1762	self.ImageEdit.Append(help='Copy selected image controls to other images',
1763	id=wxID_IMCOPYSELECTED, kind=wx.ITEM_NORMAL,text='Copy Selected')
1764	self.ImageEdit.Append(help='Save image controls to file',
1765	id=wxID_IMSAVECONTROLS, kind=wx.ITEM_NORMAL,text='Save Controls')
1766	self.ImageEdit.Append(help='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	obj = None
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	pName,Oatom,Tatom = dlg.GetSelection()
2775	if Tatom:
2776	Phase = Phases[pName]
2777	General = Phase['General']
2778	cx,ct = General['AtomPtrs'][:2]
2779	pId = Phase['pId']
2780	SGData = General['SGData']
2781	sB = Tatom.find('(')+1
2782	symNo = 0
2783	if sB:
2784	sF = Tatom.find(')')
2785	symNo = int(Tatom[sB:sF])
2786	cellNo = [0,0,0]
2787	cB = Tatom.find('[')
2788	if cB>0:
2789	cF = Tatom.find(']')+1
2790	cellNo = eval(Tatom[cB:cF])
2791	Atoms = Phase['Atoms']
2792	aNames = [atom[ct-1] for atom in Atoms]
2793	oId = aNames.index(Oatom)
2794	tId = aNames.index(Tatom.split(' +')[0])
2795	# create an expression object
2796	obj = G2obj.ExpressionObj()
2797	obj.expression = 'Dist(%s,\n%s)'%(Oatom,Tatom.split(' d=')[0].replace(' ',''))
2798	obj.distance_dict = {'pId':pId,'SGData':SGData,'symNo':symNo,'cellNo':cellNo}
2799	obj.distance_atoms = [oId,tId]
2800	else:
2801	dlg.Destroy()
2802	return
2803	dlg.Destroy()
2804	if obj:
2805	Controls['SeqPseudoVars'][obj.expression] = obj
2806	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2807
2808	def AddNewAnglePseudoVar(event):
2809	print 'Add bond angle pseudo-variable here - TBD'
2810	dlg = G2exG.AngleDialog(
2811	G2frame.dataDisplay,Phases,PSvarDict,
2812	header='Enter an Angle here',
2813	VarLabel = "New Angle")
2814	if dlg.ShowModal() == wx.ID_OK:
2815	obj = dlg.GetSelection()
2816	else:
2817	dlg.Destroy()
2818	return
2819	dlg.Destroy()
2820	if obj:
2821	calcobj = G2obj.ExpressionCalcObj(obj)
2822	Controls['SeqPseudoVars'][calcobj.eObj.expression] = obj
2823	UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
2824
2825	def UpdateParmDict(parmDict):
2826	'''generate the atom positions and the direct & reciprocal cell values,
2827	because they might be needed to evaluate the pseudovar
2828	'''
2829	Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
2830	['A'+str(i) for i in range(6)])
2831	)
2832	delList = []
2833	phaselist = []
2834	for item in parmDict:
2835	if ':' not in item: continue
2836	key = item.split(':')
2837	if len(key) < 3: continue
2838	# remove the dA[xyz] terms, they would only bring confusion
2839	if key[2].startswith('dA'):
2840	delList.append(item)
2841	# compute and update the corrected reciprocal cell terms using the Dij values
2842	elif key[2] in Ddict:
2843	if key[0] not in phaselist: phaselist.append(key[0])
2844	akey = key[0]+'::'+Ddict[key[2]]
2845	parmDict[akey] -= parmDict[item]
2846	delList.append(item)
2847	for item in delList:
2848	del parmDict[item]
2849	for i in phaselist:
2850	pId = int(i)
2851	# apply cell symmetry
2852	A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],parmDict,zeroDict[pId])
2853	# convert to direct cell & add the unique terms to the dictionary
2854	for i,val in enumerate(G2lat.A2cell(A)):
2855	if i in uniqCellIndx[pId]:
2856	lbl = str(pId)+'::'+cellUlbl[i]
2857	parmDict[lbl] = val
2858	lbl = str(pId)+'::'+'vol'
2859	parmDict[lbl] = G2lat.calc_V(A)
2860	return parmDict
2861
2862	def EvalPSvarDeriv(calcobj,parmDict,sampleDict,var,ESD):
2863	'''Evaluate an expression derivative with respect to a
2864	GSAS-II variable name.
2865
2866	Note this likely could be faster if the loop over calcobjs were done
2867	inside after the Dict was created.
2868	'''
2869	step = ESD/10
2870	Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
2871	['A'+str(i) for i in range(6)])
2872	)
2873	results = []
2874	phaselist = []
2875	VparmDict = sampleDict.copy()
2876	for incr in step,-step:
2877	VparmDict.update(parmDict.copy())
2878	# as saved, the parmDict has updated 'A[xyz]' values, but 'dA[xyz]'
2879	# values are not zeroed: fix that!
2880	VparmDict.update({item:0.0 for item in parmDict if 'dA' in item})
2881	VparmDict[var] += incr
2882	G2mv.Dict2Map(VparmDict,[]) # apply constraints
2883	# generate the atom positions and the direct & reciprocal cell values now, because they might
2884	# needed to evaluate the pseudovar
2885	for item in VparmDict:
2886	if item in sampleDict:
2887	continue
2888	if ':' not in item: continue
2889	key = item.split(':')
2890	if len(key) < 3: continue
2891	# apply any new shifts to atom positions
2892	if key[2].startswith('dA'):
2893	VparmDict[''.join(item.split('d'))] += VparmDict[item]
2894	VparmDict[item] = 0.0
2895	# compute and update the corrected reciprocal cell terms using the Dij values
2896	if key[2] in Ddict:
2897	if key[0] not in phaselist: phaselist.append(key[0])
2898	akey = key[0]+'::'+Ddict[key[2]]
2899	VparmDict[akey] -= VparmDict[item]
2900	for i in phaselist:
2901	pId = int(i)
2902	# apply cell symmetry
2903	A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],VparmDict,zeroDict[pId])
2904	# convert to direct cell & add the unique terms to the dictionary
2905	for i,val in enumerate(G2lat.A2cell(A)):
2906	if i in uniqCellIndx[pId]:
2907	lbl = str(pId)+'::'+cellUlbl[i]
2908	VparmDict[lbl] = val
2909	lbl = str(pId)+'::'+'vol'
2910	VparmDict[lbl] = G2lat.calc_V(A)
2911	# dict should be fully updated, use it & calculate
2912	calcobj.SetupCalc(VparmDict)
2913	results.append(calcobj.EvalExpression())
2914	return (results[0] - results[1]) / (2.*step)
2915
2916	def EnableParFitEqMenus():
2917	'Enables or disables the Parametric Fit menu items that require existing defs'
2918	if Controls['SeqParFitEqList']:
2919	val = True
2920	else:
2921	val = False
2922	G2frame.dataFrame.SequentialPfit.Enable(wxDELPARFIT,val)
2923	G2frame.dataFrame.SequentialPfit.Enable(wxEDITPARFIT,val)
2924	G2frame.dataFrame.SequentialPfit.Enable(wxDOPARFIT,val)
2925
2926	def ParEqEval(Values,calcObjList,varyList):
2927	'''Evaluate the parametric expression(s)
2928	:param list Values: a list of values for each variable parameter
2929	:param list calcObjList: a list of :class:`GSASIIobj.ExpressionCalcObj`
2930	expression objects to evaluate
2931	:param list varyList: a list of variable names for each value in Values
2932	'''
2933	result = []
2934	for calcobj in calcObjList:
2935	calcobj.UpdateVars(varyList,Values)
2936	result.append((calcobj.depVal-calcobj.EvalExpression())/calcobj.depSig)
2937	return result
2938
2939	def DoParEqFit(event,eqObj=None):
2940	'Parametric fit minimizer'
2941	varyValueDict = {} # dict of variables and their initial values
2942	calcObjList = [] # expression objects, ready to go for each data point
2943	if eqObj is not None:
2944	eqObjList = [eqObj,]
2945	else:
2946	eqObjList = Controls['SeqParFitEqList']
2947	UseFlags = G2frame.SeqTable.GetColValues(0)
2948	for obj in eqObjList:
2949	expr = obj.expression
2950	# assemble refined vars for this equation
2951	varyValueDict.update({var:val for var,val in obj.GetVariedVarVal()})
2952	# lookup dependent var position
2953	depVar = obj.GetDepVar()
2954	if depVar in colLabels:
2955	indx = colLabels.index(depVar)
2956	else:
2957	raise Exception('Dependent variable '+depVar+' not found')
2958	# assemble a list of the independent variables
2959	indepVars = obj.GetIndependentVars()
2960	# loop over each datapoint
2961	for j,row in enumerate(zip(*colList)):
2962	if not UseFlags[j]: continue
2963	# assemble equations to fit
2964	calcobj = G2obj.ExpressionCalcObj(obj)
2965	# prepare a dict of needed independent vars for this expression
2966	indepVarDict = {var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
2967	calcobj.SetupCalc(indepVarDict)
2968	# values and sigs for current value of dependent var
2969	calcobj.depVal = row[indx]
2970	calcobj.depSig = colSigs[indx][j]
2971	calcObjList.append(calcobj)
2972	# varied parameters
2973	varyList = varyValueDict.keys()
2974	values = varyValues = [varyValueDict[key] for key in varyList]
2975	if not varyList:
2976	print 'no variables to refine!'
2977	return
2978	try:
2979	result = so.leastsq(ParEqEval,varyValues,full_output=True, #ftol=Ftol,
2980	args=(calcObjList,varyList)
2981	)
2982	values = result[0]
2983	covar = result[1]
2984	if covar is None:
2985	raise Exception
2986	esdDict = {}
2987	for i,avar in enumerate(varyList):
2988	esdDict[avar] = np.sqrt(covar[i,i])
2989	except:
2990	print('====> Fit failed')
2991	return
2992	print('==== Fit Results ====')
2993	for obj in eqObjList:
2994	obj.UpdateVariedVars(varyList,values)
2995	ind = ' '
2996	print(' '+obj.GetDepVar()+' = '+obj.expression)
2997	for var in obj.assgnVars:
2998	print(ind+var+' = '+obj.assgnVars[var])
2999	for var in obj.freeVars:
3000	avar = "::"+obj.freeVars[var][0]
3001	val = obj.freeVars[var][1]
3002	if obj.freeVars[var][2]:
3003	print(ind+var+' = '+avar + " = " + G2mth.ValEsd(val,esdDict[avar]))
3004	else:
3005	print(ind+var+' = '+avar + " =" + G2mth.ValEsd(val,0))
3006	# create a plot for each parametric variable
3007	for fitnum,obj in enumerate(eqObjList):
3008	calcobj = G2obj.ExpressionCalcObj(obj)
3009	# lookup dependent var position
3010	indx = colLabels.index(obj.GetDepVar())
3011	# assemble a list of the independent variables
3012	indepVars = obj.GetIndependentVars()
3013	# loop over each datapoint
3014	fitvals = []
3015	for j,row in enumerate(zip(*colList)):
3016	calcobj.SetupCalc(
3017	{var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
3018	)
3019	fitvals.append(calcobj.EvalExpression())
3020	G2plt.PlotSelectedSequence(
3021	G2frame,[indx],GetColumnInfo,SelectXaxis,
3022	fitnum,fitvals)
3023
3024	def SingleParEqFit(eqObj):
3025	DoParEqFit(None,eqObj)
3026
3027	def DelParFitEq(event):
3028	'Ask the user to select function to delete'
3029	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3030	selected = G2G.ItemSelector(
3031	txtlst,G2frame.dataFrame,
3032	multiple=True,
3033	title='Select a parametric equation(s) to remove',
3034	header='Delete equation')
3035	if selected is None: return
3036	Controls['SeqParFitEqList'] = [obj for i,obj in enumerate(Controls['SeqParFitEqList']) if i not in selected]
3037	EnableParFitEqMenus()
3038	if Controls['SeqParFitEqList']: DoParEqFit(event)
3039
3040	def EditParFitEq(event):
3041	'Edit an existing parametric equation'
3042	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3043	if len(txtlst) == 1:
3044	selected = 0
3045	else:
3046	selected = G2G.ItemSelector(
3047	txtlst,G2frame.dataFrame,
3048	multiple=False,
3049	title='Select a parametric equation to edit',
3050	header='Edit equation')
3051	if selected is not None:
3052	dlg = G2exG.ExpressionDialog(
3053	G2frame.dataDisplay,indepVarDict,
3054	Controls['SeqParFitEqList'][selected],
3055	depVarDict=depVarDict,
3056	header="Edit the formula for this minimization function",
3057	ExtraButton=['Fit',SingleParEqFit])
3058	newobj = dlg.Show(True)
3059	if newobj:
3060	calcobj = G2obj.ExpressionCalcObj(newobj)
3061	Controls['SeqParFitEqList'][selected] = newobj
3062	EnableParFitEqMenus()
3063	if Controls['SeqParFitEqList']: DoParEqFit(event)
3064
3065	def AddNewParFitEq(event):
3066	'Create a new parametric equation to be fit to sequential results'
3067
3068	# compile the variable names used in previous freevars to avoid accidental name collisions
3069	usedvarlist = []
3070	for obj in Controls['SeqParFitEqList']:
3071	for var in obj.freeVars:
3072	if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3073
3074	dlg = G2exG.ExpressionDialog(
3075	G2frame.dataDisplay,indepVarDict,
3076	depVarDict=depVarDict,
3077	header='Define an equation to minimize in the parametric fit',
3078	ExtraButton=['Fit',SingleParEqFit],
3079	usedVars=usedvarlist)
3080	obj = dlg.Show(True)
3081	dlg.Destroy()
3082	if obj:
3083	Controls['SeqParFitEqList'].append(obj)
3084	EnableParFitEqMenus()
3085	if Controls['SeqParFitEqList']: DoParEqFit(event)
3086
3087	def CopyParFitEq(event):
3088	'Copy an existing parametric equation to be fit to sequential results'
3089	# compile the variable names used in previous freevars to avoid accidental name collisions
3090	usedvarlist = []
3091	for obj in Controls['SeqParFitEqList']:
3092	for var in obj.freeVars:
3093	if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3094	txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3095	if len(txtlst) == 1:
3096	selected = 0
3097	else:
3098	selected = G2G.ItemSelector(
3099	txtlst,G2frame.dataFrame,
3100	multiple=False,
3101	title='Select a parametric equation to copy',
3102	header='Copy equation')
3103	if selected is not None:
3104	newEqn = copy.deepcopy(Controls['SeqParFitEqList'][selected])
3105	for var in newEqn.freeVars:
3106	newEqn.freeVars[var][0] = G2obj.MakeUniqueLabel(newEqn.freeVars[var][0],usedvarlist)
3107	dlg = G2exG.ExpressionDialog(
3108	G2frame.dataDisplay,indepVarDict,
3109	newEqn,
3110	depVarDict=depVarDict,
3111	header="Edit the formula for this minimization function",
3112	ExtraButton=['Fit',SingleParEqFit])
3113	newobj = dlg.Show(True)
3114	if newobj:
3115	calcobj = G2obj.ExpressionCalcObj(newobj)
3116	Controls['SeqParFitEqList'].append(newobj)
3117	EnableParFitEqMenus()
3118	if Controls['SeqParFitEqList']: DoParEqFit(event)
3119
3120	def GridSetToolTip(row,col):
3121	'''Routine to show standard uncertainties for each element in table
3122	as a tooltip
3123	'''
3124	if colSigs[col]:
3125	return u'\u03c3 = '+str(colSigs[col][row])
3126	return ''
3127
3128	def GridColLblToolTip(col):
3129	'''Define a tooltip for a column. This will be the user-entered value
3130	(from data['variableLabels']) or the default name
3131	'''
3132	if col < 0 or col > len(colLabels):
3133	print 'Illegal column #',col
3134	return
3135	var = colLabels[col]
3136	return variableLabels.get(var,G2obj.fmtVarDescr(var))
3137
3138	def SetLabelString(event):
3139	'''Define or edit the label for a column in the table, to be used
3140	as a tooltip and for plotting
3141	'''
3142	col = event.GetCol()
3143	if col < 0 or col > len(colLabels):
3144	return
3145	var = colLabels[col]
3146	lbl = variableLabels.get(var,G2obj.fmtVarDescr(var))
3147	dlg = G2G.SingleStringDialog(G2frame.dataFrame,'Set variable label',
3148	'Set a new name for variable '+var,lbl,size=(400,-1))
3149	if dlg.Show():
3150	variableLabels[var] = dlg.GetValue()
3151	dlg.Destroy()
3152
3153	#def GridRowLblToolTip(row): return 'Row ='+str(row)
3154
3155	# lookup table for unique cell parameters by symmetry
3156	cellGUIlist = [
3157	[['m3','m3m'],(0,)],
3158	[['3R','3mR'],(0,3)],
3159	[['3','3m1','31m','6/m','6/mmm','4/m','4/mmm'],(0,2)],
3160	[['mmm'],(0,1,2)],
3161	[['2/m'+'a'],(0,1,2,3)],
3162	[['2/m'+'b'],(0,1,2,4)],
3163	[['2/m'+'c'],(0,1,2,5)],
3164	[['-1'],(0,1,2,3,4,5)],
3165	]
3166	# cell labels
3167	cellUlbl = ('a','b','c',u'\u03B1',u'\u03B2',u'\u03B3') # unicode a,b,c,alpha,beta,gamma
3168
3169	#======================================================================
3170	# start processing sequential results here (UpdateSeqResults)
3171	#======================================================================
3172	if not data:
3173	print 'No sequential refinement results'
3174	return
3175	variableLabels = data.get('variableLabels',{})
3176	data['variableLabels'] = variableLabels
3177	Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
3178	Controls = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
3179	# create a place to store Pseudo Vars & Parametric Fit functions, if not present
3180	if 'SeqPseudoVars' not in Controls: Controls['SeqPseudoVars'] = {}
3181	if 'SeqParFitEqList' not in Controls: Controls['SeqParFitEqList'] = []
3182	histNames = data['histNames']
3183	if G2frame.dataDisplay:
3184	G2frame.dataDisplay.Destroy()
3185	if not G2frame.dataFrame.GetStatusBar():
3186	Status = G2frame.dataFrame.CreateStatusBar()
3187	Status.SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
3188	sampleParms = GetSampleParms()
3189
3190	# make dict of varied atom coords keyed by absolute position
3191	newAtomDict = data[histNames[0]].get('newAtomDict',{}) # dict with atom positions; relative & absolute
3192	# Possible error: the next might need to be data[histNames[0]]['varyList']
3193	# error will arise if there constraints on coordinates?
3194	atomLookup = {newAtomDict[item][0]:item for item in newAtomDict if item in data['varyList']}
3195
3196	# make dict of varied cell parameters equivalents
3197	ESDlookup = {} # provides the Dij term for each Ak term (where terms are refined)
3198	Dlookup = {} # provides the Ak term for each Dij term (where terms are refined)
3199	# N.B. These Dij vars are missing a histogram #
3200	newCellDict = data[histNames[0]].get('newCellDict',{})
3201	for item in newCellDict:
3202	if item in data['varyList']:
3203	ESDlookup[newCellDict[item][0]] = item
3204	Dlookup[item] = newCellDict[item][0]
3205	# add coordinate equivalents to lookup table
3206	for parm in atomLookup:
3207	Dlookup[atomLookup[parm]] = parm
3208	ESDlookup[parm] = atomLookup[parm]
3209
3210	# get unit cell & symmetry for all phases & initial stuff for later use
3211	RecpCellTerms = {}
3212	SGdata = {}
3213	uniqCellIndx = {}
3214	initialCell = {}
3215	RcellLbls = {}
3216	zeroDict = {}
3217	Rcelldict = {}
3218	for phase in Phases:
3219	phasedict = Phases[phase]
3220	pId = phasedict['pId']
3221	pfx = str(pId)+'::' # prefix for A values from phase
3222	RcellLbls[pId] = [pfx+'A'+str(i) for i in range(6)]
3223	RecpCellTerms[pId] = G2lat.cell2A(phasedict['General']['Cell'][1:7])
3224	zeroDict[pId] = dict(zip(RcellLbls[pId],6*[0.,]))
3225	SGdata[pId] = phasedict['General']['SGData']
3226	Rcelldict.update({lbl:val for lbl,val in zip(RcellLbls[pId],RecpCellTerms[pId])})
3227	laue = SGdata[pId]['SGLaue']
3228	if laue == '2/m':
3229	laue += SGdata[pId]['SGUniq']
3230	for symlist,celllist in cellGUIlist:
3231	if laue in symlist:
3232	uniqCellIndx[pId] = celllist
3233	break
3234	else: # should not happen
3235	uniqCellIndx[pId] = range(6)
3236	for i in uniqCellIndx[pId]:
3237	initialCell[str(pId)+'::A'+str(i)] = RecpCellTerms[pId][i]
3238
3239	SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
3240	G2frame.dataFrame.SetLabel('Sequential refinement results')
3241	if not G2frame.dataFrame.GetStatusBar():
3242	Status = G2frame.dataFrame.CreateStatusBar()
3243	Status.SetStatusText('')
3244	G2frame.dataFrame.Bind(wx.EVT_MENU, OnRenameSelSeq, id=wxID_RENAMESEQSEL)
3245	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
3246	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeqCSV, id=wxID_SAVESEQSELCSV)
3247	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSeqCSV, id=wxID_SAVESEQCSV)
3248	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotSelSeq, id=wxID_PLOTSEQSEL)
3249	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAveSelSeq, id=wxID_AVESEQSEL)
3250	G2frame.dataFrame.Bind(wx.EVT_MENU, OnReOrgSelSeq, id=wxID_ORGSEQSEL)
3251	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewPseudoVar, id=wxADDSEQVAR)
3252	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewDistPseudoVar, id=wxADDSEQDIST)
3253	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewAnglePseudoVar, id=wxADDSEQANGLE)
3254	G2frame.dataFrame.Bind(wx.EVT_MENU, DelPseudoVar, id=wxDELSEQVAR)
3255	G2frame.dataFrame.Bind(wx.EVT_MENU, EditPseudoVar, id=wxEDITSEQVAR)
3256	G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewParFitEq, id=wxADDPARFIT)
3257	G2frame.dataFrame.Bind(wx.EVT_MENU, CopyParFitEq, id=wxCOPYPARFIT)
3258	G2frame.dataFrame.Bind(wx.EVT_MENU, DelParFitEq, id=wxDELPARFIT)
3259	G2frame.dataFrame.Bind(wx.EVT_MENU, EditParFitEq, id=wxEDITPARFIT)
3260	G2frame.dataFrame.Bind(wx.EVT_MENU, DoParEqFit, id=wxDOPARFIT)
3261	EnablePseudoVarMenus()
3262	EnableParFitEqMenus()
3263
3264	# scan for locations where the variables change
3265	VaryListChanges = [] # histograms where there is a change
3266	combinedVaryList = []
3267	firstValueDict = {}
3268	vallookup = {}
3269	posdict = {}
3270	prevVaryList = []
3271	for i,name in enumerate(histNames):
3272	for var,val,sig in zip(data[name]['varyList'],data[name]['variables'],data[name]['sig']):
3273	svar = striphist(var,'*') # wild-carded
3274	if svar not in combinedVaryList:
3275	# add variables to list as they appear
3276	combinedVaryList.append(svar)
3277	firstValueDict[svar] = (val,sig)
3278	if prevVaryList != data[name]['varyList']: # this refinement has a different refinement list from previous
3279	prevVaryList = data[name]['varyList']
3280	vallookup[name] = dict(zip(data[name]['varyList'],data[name]['variables']))
3281	posdict[name] = {}
3282	for var in data[name]['varyList']:
3283	svar = striphist(var,'*')
3284	posdict[name][combinedVaryList.index(svar)] = svar
3285	VaryListChanges.append(name)
3286	if len(VaryListChanges) > 1:
3287	G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,True)
3288	else:
3289	G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,False)
3290	#-----------------------------------------------------------------------------------
3291	# build up the data table by columns -----------------------------------------------
3292	nRows = len(histNames)
3293	colList = [nRows*[True]]
3294	colSigs = [None]
3295	colLabels = ['Use']
3296	Types = [wg.GRID_VALUE_BOOL]
3297	# start with Rwp values
3298	if 'IMG ' not in histNames[0][:4]:
3299	colList += [[data[name]['Rvals']['Rwp'] for name in histNames]]
3300	colSigs += [None]
3301	colLabels += ['Rwp']
3302	Types += [wg.GRID_VALUE_FLOAT+':10,3',]
3303	# add % change in Chi^2 in last cycle
3304	if histNames[0][:4] not in ['SASD','IMG '] and Controls.get('ShowCell'):
3305	colList += [[100.*data[name]['Rvals'].get('DelChi2',-1) for name in histNames]]
3306	colSigs += [None]
3307	colLabels += [u'\u0394\u03C7\u00B2 (%)']
3308	Types += [wg.GRID_VALUE_FLOAT,]
3309	deltaChiCol = len(colLabels)-1
3310	# add changing sample parameters to table
3311	for key in sampleParms:
3312	colList += [sampleParms[key]]
3313	colSigs += [None]
3314	colLabels += [key]
3315	Types += [wg.GRID_VALUE_FLOAT,]
3316	sampleDict = {}
3317	for i,name in enumerate(histNames):
3318	sampleDict[name] = dict(zip(sampleParms.keys(),[sampleParms[key][i] for key in sampleParms.keys()]))
3319	# add unique cell parameters TODO: review this where the cell symmetry changes (when possible)
3320	if Controls.get('ShowCell',False):
3321	for pId in sorted(RecpCellTerms):
3322	pfx = str(pId)+'::' # prefix for A values from phase
3323	cells = []
3324	cellESDs = []
3325	colLabels += [pfx+cellUlbl[i] for i in uniqCellIndx[pId]]
3326	colLabels += [pfx+'Vol']
3327	Types += (1+len(uniqCellIndx[pId]))*[wg.GRID_VALUE_FLOAT,]
3328	for name in histNames:
3329	covData = {
3330	'varyList': [Dlookup.get(striphist(v),v) for v in data[name]['varyList']],
3331	'covMatrix': data[name]['covMatrix']
3332	}
3333	A = RecpCellTerms[pId][:] # make copy of starting A values
3334	# update with refined values
3335	for i in range(6):
3336	var = str(pId)+'::A'+str(i)
3337	if var in ESDlookup:
3338	val = data[name]['newCellDict'][ESDlookup[var]][1] # get refined value
3339	A[i] = val # override with updated value
3340	# apply symmetry
3341	Albls = [pfx+'A'+str(i) for i in range(6)]
3342	cellDict = dict(zip(Albls,A))
3343	A,zeros = G2stIO.cellFill(pfx,SGdata[pId],cellDict,zeroDict[pId])
3344	# convert to direct cell & add only unique values to table
3345	c = G2lat.A2cell(A)
3346	vol = G2lat.calc_V(A)
3347	cE = G2stIO.getCellEsd(pfx,SGdata[pId],A,covData)
3348	cells += [[c[i] for i in uniqCellIndx[pId]]+[vol]]
3349	cellESDs += [[cE[i] for i in uniqCellIndx[pId]]+[cE[-1]]]
3350	colList += zip(*cells)
3351	colSigs += zip(*cellESDs)
3352	# sort out the variables in their selected order
3353	varcols = 0
3354	for d in posdict.itervalues():
3355	varcols = max(varcols,max(d.keys())+1)
3356	# get labels for each column
3357	for i in range(varcols):
3358	lbl = ''
3359	for h in VaryListChanges:
3360	if posdict[h].get(i):
3361	if posdict[h].get(i) in lbl: continue
3362	if lbl != "": lbl += '/'
3363	lbl += posdict[h].get(i)
3364	colLabels.append(lbl)
3365	Types += varcols*[wg.GRID_VALUE_FLOAT]
3366	vals = []
3367	esds = []
3368	varsellist = None # will be a list of variable names in the order they are selected to appear
3369	# tabulate values for each hist, leaving None for blank columns
3370	for name in histNames:
3371	if name in posdict:
3372	varsellist = [posdict[name].get(i) for i in range(varcols)]
3373	# translate variable names to how they will be used in the headings
3374	vs = [striphist(v,'*') for v in data[name]['varyList']]
3375	# determine the index for each column (or None) in the data[]['variables'] and ['sig'] lists
3376	sellist = [vs.index(v) if v is not None else None for v in varsellist]
3377	#sellist = [i if striphist(v,'*') in varsellist else None for i,v in enumerate(data[name]['varyList'])]
3378	if not varsellist: raise Exception()
3379	vals.append([data[name]['variables'][s] if s is not None else None for s in sellist])
3380	esds.append([data[name]['sig'][s] if s is not None else None for s in sellist])
3381	#GSASIIpath.IPyBreak()
3382	colList += zip(*vals)
3383	colSigs += zip(*esds)
3384
3385	# tabulate constrained variables, removing histogram numbers if needed
3386	# from parameter label
3387	depValDict = {}
3388	depSigDict = {}
3389	for name in histNames:
3390	for var in data[name].get('depParmDict',{}):
3391	val,sig = data[name]['depParmDict'][var]
3392	svar = striphist(var,'*')
3393	if svar not in depValDict:
3394	depValDict[svar] = [val]
3395	depSigDict[svar] = [sig]
3396	else:
3397	depValDict[svar].append(val)
3398	depSigDict[svar].append(sig)
3399	# add the dependent constrained variables to the table
3400	for var in sorted(depValDict):
3401	if len(depValDict[var]) != len(histNames): continue
3402	colLabels.append(var)
3403	Types += [wg.GRID_VALUE_FLOAT,]
3404	colSigs += [depSigDict[var]]
3405	colList += [depValDict[var]]
3406
3407	# add atom parameters to table
3408	colLabels += atomLookup.keys()
3409	Types += len(atomLookup)*[wg.GRID_VALUE_FLOAT]
3410	for parm in sorted(atomLookup):
3411	colList += [[data[name]['newAtomDict'][atomLookup[parm]][1] for name in histNames]]
3412	if atomLookup[parm] in data[histNames[0]]['varyList']:
3413	col = data[histNames[0]]['varyList'].index(atomLookup[parm])
3414	colSigs += [[data[name]['sig'][col] for name in histNames]]
3415	else:
3416	colSigs += [None] # should not happen
3417	# evaluate Pseudovars, their ESDs and add them to grid
3418	for expr in Controls['SeqPseudoVars']:
3419	obj = Controls['SeqPseudoVars'][expr]
3420	calcobj = G2obj.ExpressionCalcObj(obj)
3421	valList = []
3422	esdList = []
3423	for seqnum,name in enumerate(histNames):
3424	sigs = data[name]['sig']
3425	G2mv.InitVars()
3426	parmDict = data[name].get('parmDict')
3427	badVary = data[name].get('badVary',[])
3428	constraintInfo = data[name].get('constraintInfo',[[],[],{},[],seqnum])
3429	groups,parmlist,constrDict,fixedList,ihst = constraintInfo
3430	varyList = data[name]['varyList']
3431	parmDict = data[name]['parmDict']
3432	G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList,parmDict,SeqHist=ihst)
3433	derivs = np.array(
3434	[EvalPSvarDeriv(calcobj,parmDict.copy(),sampleDict[name],var,ESD)
3435	for var,ESD in zip(varyList,sigs)])
3436	esdList.append(np.sqrt(
3437	np.inner(derivs,np.inner(data[name]['covMatrix'],derivs.T)) ))
3438	PSvarDict = parmDict.copy()
3439	PSvarDict.update(sampleDict[name])
3440	UpdateParmDict(PSvarDict)
3441	calcobj.UpdateDict(PSvarDict)
3442	valList.append(calcobj.EvalExpression())
3443	if not esdList:
3444	esdList = None
3445	colList += [valList]
3446	colSigs += [esdList]
3447	colLabels += [expr]
3448	Types += [wg.GRID_VALUE_FLOAT,]
3449	#---- table build done -------------------------------------------------------------
3450
3451	# Make dict needed for creating & editing pseudovars (PSvarDict).
3452	name = histNames[0]
3453	parmDict = data[name].get('parmDict',{})
3454	PSvarDict = parmDict.copy()
3455	PSvarDict.update(sampleParms)
3456	UpdateParmDict(PSvarDict)
3457	# Also dicts of dependent (depVarDict) & independent vars (indepVarDict)
3458	# for Parametric fitting from the data table
3459	parmDict = dict(zip(colLabels,zip(*colList)[0])) # scratch dict w/all values in table
3460	parmDict.update(
3461	{var:val for var,val in data[name].get('newCellDict',{}).values()} # add varied reciprocal cell terms
3462	)
3463	name = histNames[0]
3464
3465	#******************************************************************************
3466	# create a set of values for example evaluation of pseudovars and
3467	# this does not work for refinements that have differing numbers of variables.
3468	#raise Exception
3469	indepVarDict = {} # values in table w/o ESDs
3470	depVarDict = {}
3471	for i,var in enumerate(colLabels):
3472	if var == 'Use': continue
3473	if colList[i][0] is None:
3474	val,sig = firstValueDict.get(var,[None,None])
3475	elif colSigs[i]:
3476	val,sig = colList[i][0],colSigs[i][0]
3477	else:
3478	val,sig = colList[i][0],None
3479	if val is None:
3480	continue
3481	elif sig is None:
3482	indepVarDict[var] = val
3483	elif striphist(var) not in Dlookup:
3484	depVarDict[var] = val
3485	# add recip cell coeff. values
3486	depVarDict.update({var:val for var,val in data[name].get('newCellDict',{}).values()})
3487
3488	G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
3489	G2frame.SeqTable = G2G.Table(
3490	[list(c) for c in zip(*colList)], # convert from columns to rows
3491	colLabels=colLabels,rowLabels=histNames,types=Types)
3492	G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
3493	#G2frame.dataDisplay.EnableEditing(False)
3494	# make all but first column read-only
3495	for c in range(1,len(colLabels)):
3496	for r in range(nRows):
3497	G2frame.dataDisplay.SetCellReadOnly(r,c)
3498	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, PlotSelect)
3499	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_RIGHT_CLICK, SetLabelString)
3500	G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0])) #pretty arbitrary 8
3501	G2frame.dataDisplay.SetMargins(0,0)
3502	G2frame.dataDisplay.AutoSizeColumns(True)
3503	if prevSize:
3504	G2frame.dataDisplay.SetSize(prevSize)
3505	else:
3506	G2frame.dataFrame.setSizePosLeft([700,350])
3507	# highlight unconverged shifts
3508	if histNames[0][:4] not in ['SASD','IMG ']:
3509	for row,name in enumerate(histNames):
3510	deltaChi = G2frame.SeqTable.GetValue(row,deltaChiCol)
3511	if deltaChi > 10.:
3512	G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,0,0))
3513	elif deltaChi > 1.0:
3514	G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,255,0))
3515	G2frame.dataDisplay.InstallGridToolTip(GridSetToolTip,GridColLblToolTip)
3516	G2frame.dataDisplay.SendSizeEvent() # resize needed on mac
3517	G2frame.dataDisplay.Refresh() # shows colored text on mac
3518
3519	################################################################################
3520	##### Main PWDR panel
3521	################################################################################
3522
3523	def UpdatePWHKPlot(G2frame,kind,item):
3524	'''Called when the histogram main tree entry is called. Displays the
3525	histogram weight factor, refinement statistics for the histogram
3526	and the range of data for a simulation.
3527
3528	Also invokes a plot of the histogram.
3529	'''
3530	def onEditSimRange(event):
3531	'Edit simulation range'
3532	inp = [
3533	min(data[1][0]),
3534	max(data[1][0]),
3535	None
3536	]
3537	inp[2] = (inp[1] - inp[0])/(len(data[1][0])-1.)
3538	names = ('start angle', 'end angle', 'step size')
3539	dictlst = [inp] * len(inp)
3540	elemlst = range(len(inp))
3541	dlg = G2G.ScrolledMultiEditor(
3542	G2frame,[inp] * len(inp), range(len(inp)), names,
3543	header='Edit simulation range',
3544	minvals=(0.001,0.001,0.0001),
3545	maxvals=(180.,180.,.1),
3546	)
3547	dlg.CenterOnParent()
3548	val = dlg.ShowModal()
3549	dlg.Destroy()
3550	if val != wx.ID_OK: return
3551	if inp[0] > inp[1]:
3552	end,start,step = inp
3553	else:
3554	start,end,step = inp
3555	step = abs(step)
3556	N = int((end-start)/step)+1
3557	newdata = np.linspace(start,end,N,True)
3558	if len(newdata) < 2: return # too small a range - reject
3559	data[1] = [newdata,np.zeros_like(newdata),np.ones_like(newdata),
3560	np.zeros_like(newdata),np.zeros_like(newdata),np.zeros_like(newdata)]
3561	Tmin = newdata[0]
3562	Tmax = newdata[-1]
3563	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,item,'Limits'),
3564	[(Tmin,Tmax),[Tmin,Tmax]])
3565	UpdatePWHKPlot(G2frame,kind,item) # redisplay data screen
3566
3567	def OnPlot3DHKL(event):
3568	refList = data[1]['RefList']
3569	FoMax = np.max(refList.T[8+Super])
3570	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3571	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3572	Vpoint = np.array([int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))])
3573	controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
3574	'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
3575	'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
3576	'Scale':1.0,'oldxy':[],'viewDir':[0,0,1]},'Super':Super,'SuperVec':SuperVec}
3577	G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
3578
3579	def OnPlotAll3DHKL(event):
3580	choices = GetPatternTreeDataNames(G2frame,['HKLF',])
3581	dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to plot',
3582	'Use data',choices)
3583	try:
3584	if dlg.ShowModal() == wx.ID_OK:
3585	refNames = [choices[i] for i in dlg.GetSelections()]
3586	else:
3587	return
3588	finally:
3589	dlg.Destroy()
3590	refList = np.zeros(0)
3591	for name in refNames:
3592	Id = GetPatternTreeItemId(G2frame,G2frame.root, name)
3593	reflData = G2frame.PatternTree.GetItemPyData(Id)[1]
3594	if len(refList):
3595	refList = np.concatenate((refList,reflData['RefList']))
3596	else:
3597	refList = reflData['RefList']
3598
3599	FoMax = np.max(refList.T[8+Super])
3600	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3601	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3602	Vpoint = [int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))]
3603	controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
3604	'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
3605	'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
3606	'Scale':1.0,'oldxy':[],'viewDir':[1,0,0]},'Super':Super,'SuperVec':SuperVec}
3607	G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
3608
3609	def OnMergeHKL(event):
3610	Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
3611	Inst = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,
3612	G2frame.PatternId,'Instrument Parameters'))
3613	CId = GetPatternTreeItemId(G2frame,G2frame.PatternId,'Comments')
3614	if CId:
3615	Comments = G2frame.PatternTree.GetItemPyData(CId)
3616	else:
3617	Comments = []
3618	refList = np.copy(data[1]['RefList'])
3619	Comments.append(' Merging %d reflections from %s'%(len(refList),Name))
3620	dlg = MergeDialog(G2frame,data)
3621	try:
3622	if dlg.ShowModal() == wx.ID_OK:
3623	Trans,Cent,Laue = dlg.GetSelection()
3624	else:
3625	return
3626	finally:
3627	dlg.Destroy()
3628	Super = data[1]['Super']
3629	refList,badRefs = G2lat.transposeHKLF(Trans,Super,refList)
3630	if len(badRefs): #do I want to list badRefs?
3631	G2frame.ErrorDialog('Failed transformation','Matrix yields fractional hkl indices')
3632	return
3633	Comments.append(" Transformation M*H = H' applied; M=")
3634	Comments.append(str(Trans))
3635	SG = 'P '+Laue
3636	SGData = G2spc.SpcGroup(SG)[1]
3637	refList = G2lat.LaueUnique(Laue,refList)
3638	dlg = wx.ProgressDialog('Build HKL dictonary','',len(refList)+1,
3639	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
3640	HKLdict = {}
3641	for ih,hkl in enumerate(refList):
3642	if str(hkl[:3+Super]) not in HKLdict:
3643	HKLdict[str(hkl[:3+Super])] = [hkl[:3+Super],[hkl[3+Super:],]]
3644	else:
3645	HKLdict[str(hkl[:3+Super])][1].append(hkl[3+Super:])
3646	dlg.Update(ih)
3647	dlg.Destroy()
3648	mergeRef = []
3649	dlg = wx.ProgressDialog('Processing merge','',len(HKLdict)+1,
3650	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
3651	sumDf = 0.
3652	sumFo = 0.
3653	for ih,hkl in enumerate(HKLdict):
3654	HKL = HKLdict[hkl]
3655	newHKL = list(HKL[0])+list(HKL[1][0])
3656	if len(HKL[1]) > 1:
3657	fos = np.array(HKL[1])
3658	wFo = 1/fos[:,3]**2
3659	Fo = np.average(fos[:,2],weights=wFo)
3660	std = np.std(fos[:,2])
3661	sig = np.sqrt(np.mean(fos[:,3])2+std2)
3662	sumFo += np.sum(fos[:,2])
3663	sumDf += np.sum(np.abs(fos[:,2]-Fo))
3664	dlg.Update(ih)
3665	newHKL[5+Super] = Fo
3666	newHKL[6+Super] = sig
3667	newHKL[8+Super] = Fo
3668	if newHKL[5+Super] > 0.:
3669	mergeRef.append(list(newHKL))
3670	dlg.Destroy()
3671	if Super:
3672	mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,3),2),1),0)
3673	else:
3674	mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,2),1),0)
3675	mergeRef = np.array(mergeRef)
3676	if sumFo:
3677	mtext = ' merge R = %6.2f%s for %d reflections in %s'%(100.*sumDf/sumFo,'%',mergeRef.shape[0],Laue)
3678	print mtext
3679	Comments.append(mtext)
3680	else:
3681	print 'nothing to merge for %s reflections'%(mergeRef.shape[0])
3682	HKLFlist = []
3683	newName = Name+' '+Laue
3684	if G2frame.PatternTree.GetCount():
3685	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3686	while item:
3687	name = G2frame.PatternTree.GetItemText(item)
3688	if name.startswith('HKLF ') and name not in HKLFlist:
3689	HKLFlist.append(name)
3690	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3691	newName = G2obj.MakeUniqueLabel(newName,HKLFlist)
3692	newData = copy.deepcopy(data)
3693	newData[0]['ranId'] = ran.randint(0,sys.maxint)
3694	newData[1]['RefList'] = mergeRef
3695	Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=newName)
3696	G2frame.PatternTree.SetItemPyData(
3697	G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)
3698	G2frame.PatternTree.SetItemPyData(Id,newData)
3699	G2frame.PatternTree.SetItemPyData(
3700	G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
3701	G2frame.PatternTree.SetItemPyData(
3702	G2frame.PatternTree.AppendItem(Id,text='Reflection List'),{}) #dummy entry for GUI use
3703
3704	def OnErrorAnalysis(event):
3705	G2plt.PlotDeltSig(G2frame,kind)
3706
3707	def OnWtFactor(event):
3708	try:
3709	val = float(wtval.GetValue())
3710	except ValueError:
3711	val = data[0]['wtFactor']
3712	data[0]['wtFactor'] = val
3713	wtval.SetValue('%.3f'%(val))
3714
3715	def OnCompression(event):
3716	data[0] = int(comp.GetValue())
3717
3718	def onCopyPlotCtrls(event):
3719	'''Respond to menu item to copy multiple sections from a histogram.
3720	Need this here to pass on the G2frame object.
3721	'''
3722	G2pdG.CopyPlotCtrls(G2frame)
3723
3724	def onCopySelectedItems(event):
3725	'''Respond to menu item to copy multiple sections from a histogram.
3726	Need this here to pass on the G2frame object.
3727	'''
3728	G2pdG.CopySelectedHistItems(G2frame)
3729
3730	data = G2frame.PatternTree.GetItemPyData(item)
3731	#patches
3732	if 'wtFactor' not in data[0]:
3733	data[0] = {'wtFactor':1.0}
3734	# if kind == 'PWDR' and 'Compression' not in data[0]:
3735	# data[0]['Compression'] = 1
3736	#if isinstance(data[1],list) and kind == 'HKLF':
3737	if 'list' in str(type(data[1])) and kind == 'HKLF':
3738	RefData = {'RefList':[],'FF':[]}
3739	for ref in data[1]:
3740	RefData['RefList'].append(ref[:11]+[ref[13],])
3741	RefData['FF'].append(ref[14])
3742	data[1] = RefData
3743	G2frame.PatternTree.SetItemPyData(item,data)
3744	#end patches
3745	if G2frame.dataDisplay:
3746	G2frame.dataDisplay.Destroy()
3747	if kind in ['PWDR','SASD']:
3748	SetDataMenuBar(G2frame,G2frame.dataFrame.PWDRMenu)
3749	G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
3750	G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
3751	G2frame.dataFrame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
3752	elif kind in ['HKLF',]:
3753	SetDataMenuBar(G2frame,G2frame.dataFrame.HKLFMenu)
3754	G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
3755	G2frame.dataFrame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
3756	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
3757	G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
3758	# G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
3759	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3760
3761	mainSizer = wx.BoxSizer(wx.VERTICAL)
3762	mainSizer.Add((5,5),)
3763	wtSizer = wx.BoxSizer(wx.HORIZONTAL)
3764	wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,WACV)
3765	wtval = wx.TextCtrl(G2frame.dataDisplay,-1,'%.3f'%(data[0]['wtFactor']),style=wx.TE_PROCESS_ENTER)
3766	wtval.Bind(wx.EVT_TEXT_ENTER,OnWtFactor)
3767	wtval.Bind(wx.EVT_KILL_FOCUS,OnWtFactor)
3768	wtSizer.Add(wtval,0,WACV)
3769	# if kind == 'PWDR': #possible future compression feature; NB above patch as well
3770	# wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Compression factor: '),0,WACV)
3771	# choice = ['1','2','3','4','5','6']
3772	# comp = wx.ComboBox(parent=G2frame.dataDisplay,choices=choice,
3773	# style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3774	# comp.SetValue(str(data[0]['Compression']))
3775	# comp.Bind(wx.EVT_COMBOBOX, OnCompression)
3776	# wtSizer.Add(comp,0,WACV)
3777	mainSizer.Add(wtSizer)
3778	if data[0].get('Dummy'):
3779	simSizer = wx.BoxSizer(wx.HORIZONTAL)
3780	Tmin = min(data[1][0])
3781	Tmax = max(data[1][0])
3782	num = len(data[1][0])
3783	step = (Tmax - Tmin)/(num-1)
3784	t = u'2\u03b8' # 2theta
3785	lbl = u'Simulation range: {:.2f} to {:.2f} {:s}\nwith {:.4f} steps ({:d} points)'
3786	lbl += u'\n(Edit range resets observed intensities).'
3787	lbl = lbl.format(Tmin,Tmax,t,step,num)
3788	simSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,lbl),
3789	0,WACV)
3790	but = wx.Button(G2frame.dataDisplay,wx.ID_ANY,"Edit range")
3791	but.Bind(wx.EVT_BUTTON,onEditSimRange)
3792	simSizer.Add(but,0,WACV)
3793	mainSizer.Add(simSizer)
3794	if 'Nobs' in data[0]:
3795	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3796	' Data residual wR: %.3f%% on %d observations'%(data[0]['wR'],data[0]['Nobs'])))
3797	for value in data[0]:
3798	if 'Nref' in value:
3799	pfx = value.split('Nref')[0]
3800	name = data[0].get(pfx.split(':')[0]+'::Name','?')
3801	if 'SS' in value:
3802	mainSizer.Add((5,5),)
3803	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For incommensurate phase '+name+':'))
3804	for m,(Rf2,Rf,Nobs) in enumerate(zip(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])):
3805	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3806	u' m = +/- %d: RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections '% \
3807	(m,Rf2,Rf,Nobs)))
3808	else:
3809	mainSizer.Add((5,5),)
3810	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For phase '+name+':'))
3811	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3812	u' Unweighted phase residuals RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections '% \
3813	(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])))
3814
3815	mainSizer.Add((5,5),)
3816	mainSizer.Layout()
3817	G2frame.dataDisplay.SetSizer(mainSizer)
3818	Size = mainSizer.Fit(G2frame.dataFrame)
3819	Size[1] += 10
3820	G2frame.dataFrame.setSizePosLeft(Size)
3821	G2frame.PatternTree.SetItemPyData(item,data)
3822	if kind in ['PWDR','SASD']:
3823	NewPlot = True
3824	if 'xylim' in dir(G2frame):
3825	NewPlot = False
3826	G2plt.PlotPatterns(G2frame,plotType=kind,newPlot=NewPlot)
3827	elif kind == 'HKLF':
3828	Name = G2frame.PatternTree.GetItemText(item)
3829	phaseName = G2pdG.IsHistogramInAnyPhase(G2frame,Name)
3830	if phaseName:
3831	pId = GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
3832	phaseId = GetPatternTreeItemId(G2frame,pId,phaseName)
3833	General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
3834	Super = General.get('Super',0)
3835	SuperVec = General.get('SuperVec',[])
3836	else:
3837	Super = 0
3838	SuperVec = []
3839	refList = data[1]['RefList']
3840	# GSASIIpath.IPyBreak()
3841	FoMax = np.max(refList.T[5+data[1].get('Super',0)])
3842	page = G2frame.G2plotNB.nb.GetSelection()
3843	tab = ''
3844	if page >= 0:
3845	tab = G2frame.G2plotNB.nb.GetPageText(page)
3846	if '3D' in tab:
3847	Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
3848	Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
3849	Vpoint = [int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))]
3850	Page = G2frame.G2plotNB.nb.GetPage(page)
3851	controls = Page.controls
3852	G2plt.Plot3DSngl(G2frame,newPlot=False,Data=controls,hklRef=refList,Title=phaseName)
3853	else:
3854	controls = {'Type' : 'Fo','ifFc' : True,
3855	'HKLmax' : [int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))],
3856	'HKLmin' : [int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))],
3857	'FoMax' : FoMax,'Zone' : '001','Layer' : 0,'Scale' : 1.0,'Super':Super,'SuperVec':SuperVec}
3858	G2plt.PlotSngl(G2frame,newPlot=True,Data=controls,hklRef=refList)
3859
3860	################################################################################
3861	##### Pattern tree routines
3862	################################################################################
3863
3864	def GetPatternTreeDataNames(G2frame,dataTypes):
3865	'''Finds all items in tree that match a 4 character prefix
3866
3867	:param wx.Frame G2frame: Data tree frame object
3868	:param list dataTypes: Contains one or more data tree item types to be matched
3869	such as ['IMG '] or ['PWDR','HKLF']
3870	:returns: a list of tree item names for the matching items
3871	'''
3872	names = []
3873	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3874	while item:
3875	name = G2frame.PatternTree.GetItemText(item)
3876	if name[:4] in dataTypes:
3877	names.append(name)
3878	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3879	return names
3880
3881	def GetPatternTreeItemId(G2frame, parentId, itemText):
3882	'''Find the tree item that matches the text in itemText starting with parentId
3883
3884	:param wx.Frame G2frame: Data tree frame object
3885	:param wx.TreeItemId parentId: tree item to start search with
3886	:param str itemText: text for tree item
3887	'''
3888	item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
3889	while item:
3890	if G2frame.PatternTree.GetItemText(item) == itemText:
3891	return item
3892	item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
3893	return 0
3894
3895	def MovePatternTreeToGrid(G2frame,item):
3896	'''Called from GSASII.OnPatternTreeSelChanged when a item is selected on the tree
3897	'''
3898	pickName = G2frame.PatternTree.GetItemText(item)
3899	if G2frame.PickIdText == pickName:
3900	return
3901
3902	oldPage = None # will be set later if already on a Phase item
3903	if G2frame.dataFrame:
3904	SetDataMenuBar(G2frame)
3905	if G2frame.dataFrame.GetLabel() == 'Comments':
3906	try:
3907	data = [G2frame.dataDisplay.GetValue()]
3908	G2frame.dataDisplay.Clear()
3909	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
3910	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3911	except: #clumsy but avoids dead window problem when opening another project
3912	pass
3913	elif G2frame.dataFrame.GetLabel() == 'Notebook':
3914	try:
3915	data = [G2frame.dataDisplay.GetValue()]
3916	G2frame.dataDisplay.Clear()
3917	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
3918	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3919	except: #clumsy but avoids dead window problem when opening another project
3920	pass
3921	elif 'Phase Data for' in G2frame.dataFrame.GetLabel():
3922	if G2frame.dataDisplay:
3923	oldPage = G2frame.dataDisplay.GetSelection()
3924	G2frame.dataFrame.Clear()
3925	G2frame.dataFrame.SetLabel('')
3926	else:
3927	#create the frame for the data item window
3928	G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
3929	G2frame.dataFrame.PhaseUserSize = None
3930
3931	G2frame.dataFrame.Raise()
3932	G2frame.PickId = item
3933	G2frame.PickIdText = None
3934	parentID = G2frame.root
3935	#for i in G2frame.ExportPattern: i.Enable(False)
3936	defWid = [250,150]
3937	if item != G2frame.root:
3938	parentID = G2frame.PatternTree.GetItemParent(item)
3939	if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
3940	G2frame.PatternId = item
3941	if G2frame.PatternTree.GetItemText(item) == 'Notebook':
3942	SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
3943	G2frame.PatternId = 0
3944	#for i in G2frame.ExportPattern: i.Enable(False)
3945	data = G2frame.PatternTree.GetItemPyData(item)
3946	UpdateNotebook(G2frame,data)
3947	elif G2frame.PatternTree.GetItemText(item) == 'Controls':
3948	G2frame.PatternId = 0
3949	#for i in G2frame.ExportPattern: i.Enable(False)
3950	data = G2frame.PatternTree.GetItemPyData(item)
3951	if not data: #fill in defaults
3952	data = copy.copy(G2obj.DefaultControls) #least squares controls
3953	G2frame.PatternTree.SetItemPyData(item,data)
3954	for i in G2frame.Refine: i.Enable(True)
3955	G2frame.EnableSeqRefineMenu()
3956	UpdateControls(G2frame,data)
3957	elif G2frame.PatternTree.GetItemText(item) == 'Sequential results':
3958	data = G2frame.PatternTree.GetItemPyData(item)
3959	UpdateSeqResults(G2frame,data)
3960	elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
3961	data = G2frame.PatternTree.GetItemPyData(item)
3962	G2frame.dataFrame.setSizePosLeft(defWid)
3963	text = ''
3964	if 'Rvals' in data:
3965	Nvars = len(data['varyList'])
3966	Rvals = data['Rvals']
3967	text = '\nFinal residuals: \nwR = %.3f%% \nchi**2 = %.1f \nGOF = %.2f'%(Rvals['Rwp'],Rvals['chisq'],Rvals['GOF'])
3968	text += '\nNobs = %d \nNvals = %d'%(Rvals['Nobs'],Nvars)
3969	if 'lamMax' in Rvals:
3970	text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
3971	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
3972	value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
3973	G2plt.PlotCovariance(G2frame,data)
3974	elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
3975	data = G2frame.PatternTree.GetItemPyData(item)
3976	G2cnstG.UpdateConstraints(G2frame,data)
3977	elif G2frame.PatternTree.GetItemText(item) == 'Rigid bodies':
3978	data = G2frame.PatternTree.GetItemPyData(item)
3979	G2cnstG.UpdateRigidBodies(G2frame,data)
3980	elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
3981	data = G2frame.PatternTree.GetItemPyData(item)
3982	Phases = G2frame.GetPhaseData()
3983	phase = ''
3984	phaseName = ''
3985	if Phases:
3986	phaseName = Phases.keys()[0]
3987	G2frame.dataFrame.setSizePosLeft(defWid)
3988	G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
3989	elif 'IMG' in G2frame.PatternTree.GetItemText(item):
3990	G2frame.Image = item
3991	G2frame.dataFrame.SetTitle('Image Data')
3992	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(
3993	G2frame,item,'Image Controls'))
3994	G2imG.UpdateImageData(G2frame,data)
3995	G2plt.PlotImage(G2frame,newPlot=True)
3996	elif 'PKS' in G2frame.PatternTree.GetItemText(item):
3997	G2plt.PlotPowderLines(G2frame)
3998	elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
3999	#for i in G2frame.ExportPattern: i.Enable(True)
4000	if G2frame.EnablePlot:
4001	UpdatePWHKPlot(G2frame,'PWDR',item)
4002	elif 'SASD' in G2frame.PatternTree.GetItemText(item):
4003	#for i in G2frame.ExportPattern: i.Enable(True)
4004	if G2frame.EnablePlot:
4005	UpdatePWHKPlot(G2frame,'SASD',item)
4006	elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
4007	G2frame.Sngl = True
4008	UpdatePWHKPlot(G2frame,'HKLF',item)
4009	elif 'PDF' in G2frame.PatternTree.GetItemText(item):
4010	G2frame.PatternId = item
4011	for i in G2frame.ExportPDF: i.Enable(True)
4012	G2plt.PlotISFG(G2frame,type='S(Q)')
4013	elif G2frame.PatternTree.GetItemText(item) == 'Phases':
4014	G2frame.dataFrame.setSizePosLeft(defWid)
4015	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
4016	value='Select one phase to see its parameters')
4017	elif 'I(Q)' in G2frame.PatternTree.GetItemText(item):
4018	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4019	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4020	G2pdG.UpdatePDFGrid(G2frame,data)
4021	G2plt.PlotISFG(G2frame,type='I(Q)',newPlot=True)
4022	elif 'S(Q)' in G2frame.PatternTree.GetItemText(item):
4023	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4024	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4025	G2pdG.UpdatePDFGrid(G2frame,data)
4026	G2plt.PlotISFG(G2frame,type='S(Q)',newPlot=True)
4027	elif 'F(Q)' in G2frame.PatternTree.GetItemText(item):
4028	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4029	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4030	G2pdG.UpdatePDFGrid(G2frame,data)
4031	G2plt.PlotISFG(G2frame,type='F(Q)',newPlot=True)
4032	elif 'G(R)' in G2frame.PatternTree.GetItemText(item):
4033	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4034	data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
4035	G2pdG.UpdatePDFGrid(G2frame,data)
4036	G2plt.PlotISFG(G2frame,type='G(R)',newPlot=True)
4037	elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
4038	data = G2frame.PatternTree.GetItemPyData(item)
4039	G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
4040	elif G2frame.PatternTree.GetItemText(item) == 'Comments':
4041	SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
4042	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4043	data = G2frame.PatternTree.GetItemPyData(item)
4044	UpdateComments(G2frame,data)
4045	elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
4046	G2frame.dataFrame.SetTitle('Image Controls')
4047	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4048	masks = G2frame.PatternTree.GetItemPyData(
4049	GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
4050	data = G2frame.PatternTree.GetItemPyData(item)
4051	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4052	G2imG.UpdateImageControls(G2frame,data,masks)
4053	G2plt.PlotImage(G2frame,newPlot=True)
4054	elif G2frame.PatternTree.GetItemText(item) == 'Masks':
4055	G2frame.dataFrame.SetTitle('Masks')
4056	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4057	masks = G2frame.PatternTree.GetItemPyData(item)
4058	data = G2frame.PatternTree.GetItemPyData(
4059	GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
4060	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4061	G2imG.UpdateMasks(G2frame,masks)
4062	G2plt.PlotImage(G2frame,newPlot=True)
4063	elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
4064	G2frame.dataFrame.SetTitle('Stress/Strain')
4065	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
4066	data = G2frame.PatternTree.GetItemPyData(
4067	GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
4068	G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
4069	strsta = G2frame.PatternTree.GetItemPyData(item)
4070	G2plt.PlotImage(G2frame,newPlot=True)
4071	G2plt.PlotStrain(G2frame,strsta,newPlot=True)
4072	G2imG.UpdateStressStrain(G2frame,strsta)
4073	elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
4074	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4075	for i in G2frame.ExportPDF: i.Enable(True)
4076	data = G2frame.PatternTree.GetItemPyData(item)
4077	G2pdG.UpdatePDFGrid(G2frame,data)
4078	G2plt.PlotISFG(G2frame,type='I(Q)')
4079	G2plt.PlotISFG(G2frame,type='S(Q)')
4080	G2plt.PlotISFG(G2frame,type='F(Q)')
4081	G2plt.PlotISFG(G2frame,type='G(R)')
4082	elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
4083	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4084	for i in G2frame.ExportPeakList: i.Enable(True)
4085	data = G2frame.PatternTree.GetItemPyData(item)
4086	#patch
4087	if 'list' in str(type(data)):
4088	data = {'peaks':data,'sigDict':{}}
4089	G2frame.PatternTree.SetItemPyData(item,data)
4090	#end patch
4091	G2pdG.UpdatePeakGrid(G2frame,data)
4092	G2plt.PlotPatterns(G2frame)
4093	elif G2frame.PatternTree.GetItemText(item) == 'Background':
4094	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4095	data = G2frame.PatternTree.GetItemPyData(item)
4096	G2pdG.UpdateBackground(G2frame,data)
4097	G2plt.PlotPatterns(G2frame)
4098	elif G2frame.PatternTree.GetItemText(item) == 'Limits':
4099	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4100	datatype = G2frame.PatternTree.GetItemText(G2frame.PatternId)[:4]
4101	data = G2frame.PatternTree.GetItemPyData(item)
4102	G2pdG.UpdateLimitsGrid(G2frame,data,datatype)
4103	G2plt.PlotPatterns(G2frame,plotType=datatype)
4104	elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
4105	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4106	data = G2frame.PatternTree.GetItemPyData(item)[0]
4107	G2pdG.UpdateInstrumentGrid(G2frame,data)
4108	if 'P' in data['Type'][0]: #powder data only
4109	G2plt.PlotPeakWidths(G2frame)
4110	elif G2frame.PatternTree.GetItemText(item) == 'Models':
4111	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4112	data = G2frame.PatternTree.GetItemPyData(item)
4113	G2pdG.UpdateModelsGrid(G2frame,data)
4114	G2plt.PlotPatterns(G2frame,plotType='SASD')
4115	if len(data['Size']['Distribution']):
4116	G2plt.PlotSASDSizeDist(G2frame)
4117	elif G2frame.PatternTree.GetItemText(item) == 'Substances':
4118	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4119	data = G2frame.PatternTree.GetItemPyData(item)
4120	G2pdG.UpdateSubstanceGrid(G2frame,data)
4121	elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
4122	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4123	data = G2frame.PatternTree.GetItemPyData(item)
4124	datatype = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[2][:4]
4125
4126	if 'Temperature' not in data: #temp fix for old gpx files
4127	data = {'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],'DisplaceX':[0.0,False],
4128	'DisplaceY':[0.0,False],'Diffuse':[],'Temperature':300.,'Pressure':1.0,
4129	'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
4130	'Gonio. radius':200.0}
4131	G2frame.PatternTree.SetItemPyData(item,data)
4132
4133	G2pdG.UpdateSampleGrid(G2frame,data)
4134	G2plt.PlotPatterns(G2frame,plotType=datatype)
4135	elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
4136	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4137	for i in G2frame.ExportPeakList: i.Enable(True)
4138	data = G2frame.PatternTree.GetItemPyData(item)
4139	#patch
4140	if len(data) != 2:
4141	data = [data,[]]
4142	G2frame.PatternTree.SetItemPyData(item,data)
4143	#end patch
4144	G2pdG.UpdateIndexPeaksGrid(G2frame,data)
4145	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
4146	G2plt.PlotPowderLines(G2frame)
4147	else:
4148	G2plt.PlotPatterns(G2frame)
4149	elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
4150	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4151	data = G2frame.PatternTree.GetItemPyData(item)
4152	if not data:
4153	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
4154	data.append([0,0,0,0,0,0,0,0,0,0,0,0,0,0]) #Bravais lattice flags
4155	data.append([]) #empty cell list
4156	data.append([]) #empty dmin
4157	data.append({}) #empty superlattice stuff
4158	G2frame.PatternTree.SetItemPyData(item,data)
4159	#patch
4160	if len(data) < 5:
4161	data.append({'Use':False,'ModVec':[0,0,0.1],'maxH':1,'ssSymb':''}) #empty superlattice stuff
4162	G2frame.PatternTree.SetItemPyData(item,data)
4163	#end patch
4164	G2pdG.UpdateUnitCellsGrid(G2frame,data)
4165	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
4166	G2plt.PlotPowderLines(G2frame)
4167	else:
4168	G2plt.PlotPatterns(G2frame)
4169	elif G2frame.PatternTree.GetItemText(item) == 'Reflection Lists': #powder reflections
4170	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4171	data = G2frame.PatternTree.GetItemPyData(item)
4172	G2frame.RefList = ''
4173	if len(data):
4174	G2frame.RefList = data.keys()[0]
4175	G2pdG.UpdateReflectionGrid(G2frame,data)
4176	G2plt.PlotPatterns(G2frame)
4177	elif G2frame.PatternTree.GetItemText(item) == 'Reflection List': #HKLF reflections
4178	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
4179	name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
4180	data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
4181	G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True,Name=name)
4182
4183	if G2frame.PickId:
4184	G2frame.PickIdText = G2frame.GetTreeItemsList(G2frame.PickId)
4185	G2frame.dataFrame.Raise()
4186
4187	def SetDataMenuBar(G2frame,menu=None):
4188	'''Set the menu for the data frame. On the Mac put this
4189	menu for the data tree window instead.
4190
4191	Note that data frame items do not have menus, for these (menu=None)
4192	display a blank menu or on the Mac display the standard menu for
4193	the data tree window.
4194	'''
4195	if sys.platform == "darwin":
4196	if menu is None:
4197	G2frame.SetMenuBar(G2frame.GSASIIMenu)
4198	else:
4199	G2frame.SetMenuBar(menu)
4200	else:
4201	if menu is None:
4202	G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
4203	else:
4204	G2frame.dataFrame.SetMenuBar(menu)
4205
4206	def HowDidIgetHere():
4207	'''Show a traceback with calls that brought us to the current location.
4208	Used for debugging.
4209	'''
4210	import traceback
4211	print 70''
4212	for i in traceback.format_list(traceback.extract_stack()[:-1]): print(i.strip.rstrip())
4213	print 70''
4214

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

Download in other formats: