source: trunk/GSASIIgrid.py @ 2645

Last change on this file since 2645 was 2645, checked in by toby, 8 years ago

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