source: trunk/GSASIIgrid.py @ 2674

Last change on this file since 2674 was 2674, checked in by vondreele, 5 years ago

prevent delete if PWDR if corresponding PDF exists
use PickElements? instead of PickElement? - allows multiple selection, blacks out ones already picked & can unpick a pick
add delete spots option to masks

  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Author Revision URL Id
File size: 223.2 KB
Line 
1# -*- coding: utf-8 -*-
2#GSASIIgrid - data display routines
3########### SVN repository information ###################
4# $Date: 2017-01-30 20:25:48 +0000 (Mon, 30 Jan 2017) $
5# $Author: vondreele $
6# $Revision: 2674 $
7# $URL: trunk/GSASIIgrid.py $
8# $Id: GSASIIgrid.py 2674 2017-01-30 20:25:48Z vondreele $
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: 2674 $")
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_LAYERSFIT, wxID_COPYPHASE,
89] = [wx.NewId() for item in range(5)]
90
91[ wxID_PAWLEYLOAD, wxID_PAWLEYESTIMATE, wxID_PAWLEYUPDATE, wxID_PAWLEYSELALL, wxID_PAWLEYSELNONE,
92  wxID_PAWLEYSELTOGGLE, wxID_PAWLEYSET,
93] = [wx.NewId() for item in range(7)]
94
95[ wxID_IMCALIBRATE,wxID_IMRECALIBRATE,wxID_IMINTEGRATE, wxID_IMCLEARCALIB,wxID_IMRECALIBALL, 
96    wxID_IMCOPYCONTROLS, wxID_INTEGRATEALL, wxID_IMSAVECONTROLS, wxID_IMLOADCONTROLS, wxID_IMAUTOINTEG,
97    wxID_IMCOPYSELECTED, wxID_SAVESELECTEDCONTROLS, wxID_IMXFERCONTROLS,
98] = [wx.NewId() for item in range(13)]
99
100[ wxID_MASKCOPY, wxID_MASKSAVE, wxID_MASKLOAD, wxID_NEWMASKSPOT,wxID_NEWMASKARC,wxID_NEWMASKRING,
101    wxID_NEWMASKFRAME, wxID_NEWMASKPOLY,wxID_MASKLOADNOT,wxID_FINDSPOTS,wxID_DELETESPOTS
102] = [wx.NewId() for item in range(11)]
103
104[ wxID_STRSTACOPY, wxID_STRSTAFIT, wxID_STRSTASAVE, wxID_STRSTALOAD,wxID_STRSTSAMPLE,
105    wxID_APPENDDZERO,wxID_STRSTAALLFIT,wxID_UPDATEDZERO,wxID_STRSTAPLOT,
106] = [wx.NewId() for item in range(9)]
107
108[ wxID_BACKCOPY,wxID_LIMITCOPY, wxID_SAMPLECOPY, wxID_SAMPLECOPYSOME, wxID_BACKFLAGCOPY, wxID_SAMPLEFLAGCOPY,
109    wxID_SAMPLESAVE, wxID_SAMPLELOAD,wxID_ADDEXCLREGION,wxID_SETSCALE,wxID_SAMPLE1VAL,wxID_ALLSAMPLELOAD,
110    wxID_MAKEBACKRDF,
111] = [wx.NewId() for item in range(13)]
112
113[ wxID_INSTPRMRESET,wxID_CHANGEWAVETYPE,wxID_INSTCOPY, wxID_INSTFLAGCOPY, wxID_INSTLOAD,
114    wxID_INSTSAVE, wxID_INST1VAL, wxID_INSTCALIB,wxID_INSTSAVEALL,
115] = [wx.NewId() for item in range(9)]
116
117[ wxID_UNDO,wxID_LSQPEAKFIT,wxID_LSQONECYCLE,wxID_RESETSIGGAM,wxID_CLEARPEAKS,wxID_AUTOSEARCH,
118    wxID_PEAKSCOPY, wxID_SEQPEAKFIT,
119] = [wx.NewId() for item in range(8)]
120
121[  wxID_INDXRELOAD, wxID_INDEXPEAKS, wxID_REFINECELL, wxID_COPYCELL, wxID_MAKENEWPHASE,
122    wxID_EXPORTCELLS,
123] = [wx.NewId() for item in range(6)]
124
125[ wxID_CONSTRAINTADD,wxID_EQUIVADD,wxID_HOLDADD,wxID_FUNCTADD,wxID_ADDRIDING,
126  wxID_CONSPHASE, wxID_CONSHIST, wxID_CONSHAP, wxID_CONSGLOBAL,wxID_EQUIVALANCEATOMS,
127] = [wx.NewId() for item in range(10)]
128
129[ wxID_RESTRAINTADD, wxID_RESTSELPHASE,wxID_RESTDELETE, wxID_RESRCHANGEVAL, 
130    wxID_RESTCHANGEESD,wxID_AARESTRAINTADD,wxID_AARESTRAINTPLOT,
131] = [wx.NewId() for item in range(7)]
132
133[ wxID_RIGIDBODYADD,wxID_DRAWDEFINERB,wxID_RIGIDBODYIMPORT,wxID_RESIDUETORSSEQ,
134    wxID_AUTOFINDRESRB,wxID_GLOBALRESREFINE,wxID_RBREMOVEALL,wxID_COPYRBPARMS,
135    wxID_GLOBALTHERM,wxID_VECTORBODYADD
136] = [wx.NewId() for item in range(10)]
137
138[ wxID_RENAMESEQSEL,wxID_SAVESEQSEL,wxID_SAVESEQSELCSV,wxID_SAVESEQCSV,wxID_PLOTSEQSEL,
139  wxID_ORGSEQSEL,wxADDSEQVAR,wxDELSEQVAR,wxEDITSEQVAR,wxCOPYPARFIT,wxID_AVESEQSEL,
140  wxADDPARFIT,wxDELPARFIT,wxEDITPARFIT,wxDOPARFIT,wxADDSEQDIST,wxADDSEQANGLE
141] = [wx.NewId() for item in range(17)]
142
143[ wxID_MODELCOPY,wxID_MODELFIT,wxID_MODELADD,wxID_ELEMENTADD,wxID_ELEMENTDELETE,
144    wxID_ADDSUBSTANCE,wxID_LOADSUBSTANCE,wxID_DELETESUBSTANCE,wxID_COPYSUBSTANCE,
145    wxID_MODELUNDO,wxID_MODELFITALL,wxID_MODELCOPYFLAGS,
146] = [wx.NewId() for item in range(12)]
147
148[ wxID_SELECTPHASE,wxID_PWDHKLPLOT,wxID_PWD3DHKLPLOT,wxID_3DALLHKLPLOT,wxID_MERGEHKL,
149] = [wx.NewId() for item in range(5)]
150
151[ wxID_PDFCOPYCONTROLS, wxID_PDFSAVECONTROLS, wxID_PDFLOADCONTROLS, wxID_PDFCOMPUTE, wxID_PDFCOMPUTEALL, 
152    wxID_PDFADDELEMENT, wxID_PDFDELELEMENT, wxID_PDFPKSFIT,wxID_PDFPKSFITALL,wxID_PDFCOPYPEAKS,
153] = [wx.NewId() for item in range(10)]
154
155[ wxID_MCRON,wxID_MCRLIST,wxID_MCRSAVE,wxID_MCRPLAY,
156] = [wx.NewId() for item in range(4)]
157
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        self.MaskEdit.Append(help='Delete all spot masks', 
2124            id=wxID_DELETESPOTS, kind=wx.ITEM_NORMAL,text='Delete spot masks')       
2125        submenu.Append(help='Create an arc mask with mouse input', 
2126            id=wxID_NEWMASKARC, kind=wx.ITEM_NORMAL,text='Arc mask')
2127        submenu.Append(help='Create a frame mask with mouse input', 
2128            id=wxID_NEWMASKFRAME, kind=wx.ITEM_NORMAL,text='Frame mask')
2129        submenu.Append(help='Create a polygon mask with mouse input', 
2130            id=wxID_NEWMASKPOLY, kind=wx.ITEM_NORMAL,text='Polygon mask')
2131        submenu.Append(help='Create a ring mask with mouse input', 
2132            id=wxID_NEWMASKRING, kind=wx.ITEM_NORMAL,text='Ring mask')
2133        submenu.Append(help='Create spot masks with mouse input', 
2134            id=wxID_NEWMASKSPOT, kind=wx.ITEM_NORMAL,text='Spot mask')
2135        self.PostfillDataMenu()
2136           
2137        # IMG / Stress/Strain
2138        self.StrStaMenu = wx.MenuBar()
2139        self.PrefillDataMenu(self.StrStaMenu)
2140        self.StrStaEdit = wx.Menu(title='')
2141        self.StrStaMenu.Append(menu=self.StrStaEdit, title='Operations')
2142        self.StrStaEdit.Append(help='Append d-zero for one ring', 
2143            id=wxID_APPENDDZERO, kind=wx.ITEM_NORMAL,text='Append d-zero')
2144        self.StrStaEdit.Append(help='Fit stress/strain data', 
2145            id=wxID_STRSTAFIT, kind=wx.ITEM_NORMAL,text='Fit stress/strain')
2146        self.StrStaEdit.Append(help='Plot intensity distribution', 
2147            id=wxID_STRSTAPLOT, kind=wx.ITEM_NORMAL,text='Plot intensity distribution')
2148        self.StrStaEdit.Append(help='Update d-zero from ave d-zero',
2149            id=wxID_UPDATEDZERO, kind=wx.ITEM_NORMAL,text='Update d-zero')       
2150        self.StrStaEdit.Append(help='Fit stress/strain data for all images', 
2151            id=wxID_STRSTAALLFIT, kind=wx.ITEM_NORMAL,text='All image fit')
2152        self.StrStaEdit.Append(help='Copy stress/strain data to other images', 
2153            id=wxID_STRSTACOPY, kind=wx.ITEM_NORMAL,text='Copy stress/strain')
2154        self.StrStaEdit.Append(help='Save stress/strain data to file', 
2155            id=wxID_STRSTASAVE, kind=wx.ITEM_NORMAL,text='Save stress/strain')
2156        self.StrStaEdit.Append(help='Load stress/strain data from file', 
2157            id=wxID_STRSTALOAD, kind=wx.ITEM_NORMAL,text='Load stress/strain')
2158        self.StrStaEdit.Append(help='Load sample data from file', 
2159            id=wxID_STRSTSAMPLE, kind=wx.ITEM_NORMAL,text='Load sample data')
2160        self.PostfillDataMenu()
2161           
2162        # PDF / PDF Controls
2163        self.PDFMenu = wx.MenuBar()
2164        self.PrefillDataMenu(self.PDFMenu)
2165        self.PDFEdit = wx.Menu(title='')
2166        self.PDFMenu.Append(menu=self.PDFEdit, title='PDF Controls')
2167        self.PDFEdit.Append(help='Add one or more elements to sample composition',id=wxID_PDFADDELEMENT, kind=wx.ITEM_NORMAL,
2168            text='Add elements')
2169        self.PDFEdit.Append(help='Delete element from sample composition',id=wxID_PDFDELELEMENT, kind=wx.ITEM_NORMAL,
2170            text='Delete element')
2171        self.PDFEdit.Append(help='Copy PDF controls', id=wxID_PDFCOPYCONTROLS, kind=wx.ITEM_NORMAL,
2172            text='Copy controls')
2173        self.PDFEdit.Append(help='Load PDF controls from file',id=wxID_PDFLOADCONTROLS, kind=wx.ITEM_NORMAL,
2174            text='Load Controls')
2175        self.PDFEdit.Append(help='Save PDF controls to file', id=wxID_PDFSAVECONTROLS, kind=wx.ITEM_NORMAL,
2176            text='Save controls')
2177        self.PDFEdit.Append(help='Compute PDF', id=wxID_PDFCOMPUTE, kind=wx.ITEM_NORMAL,
2178            text='Compute PDF')
2179        self.PDFEdit.Append(help='Compute all PDFs', id=wxID_PDFCOMPUTEALL, kind=wx.ITEM_NORMAL,
2180            text='Compute all PDFs')
2181#        self.PDFEdit.Append(help='Optimize PDF', id=wxID_PDFOPT, kind=wx.ITEM_NORMAL,
2182#            text='Optimize corrections for r<Rmin section of current G(r)')
2183        self.PostfillDataMenu()
2184       
2185        # PDF / PDF Peaks
2186        self.PDFPksMenu = wx.MenuBar()
2187        self.PrefillDataMenu(self.PDFPksMenu)
2188        self.PDFPksEdit = wx.Menu(title='')
2189        self.PDFPksMenu.Append(menu=self.PDFPksEdit, title='PDF Peaks')
2190        self.PDFPksEdit.Append(help='Fit PDF peaks', id=wxID_PDFPKSFIT, kind=wx.ITEM_NORMAL,
2191            text='Fit Peaks')
2192        self.PDFPksEdit.Append(help='Fit all PDF peaks', id=wxID_PDFPKSFITALL, kind=wx.ITEM_NORMAL,
2193            text='Fit all PDF peakss')
2194        self.PDFPksEdit.Append(help='Copy PDF peaks', id=wxID_PDFCOPYPEAKS, kind=wx.ITEM_NORMAL,
2195            text='Copy peaks')
2196       
2197        self.PostfillDataMenu()
2198
2199       
2200        # Phase / General tab
2201        self.DataGeneral = wx.MenuBar()
2202        self.PrefillDataMenu(self.DataGeneral)
2203        self.DataGeneral.Append(menu=wx.Menu(title=''),title='Select tab')
2204        self.GeneralCalc = wx.Menu(title='')
2205        self.DataGeneral.Append(menu=self.GeneralCalc,title='Compute')
2206        self.GeneralCalc.Append(help='Compute Fourier map',id=wxID_FOURCALC, kind=wx.ITEM_NORMAL,
2207            text='Fourier map')
2208        self.GeneralCalc.Append(help='Search Fourier map',id=wxID_FOURSEARCH, kind=wx.ITEM_NORMAL,
2209            text='Search map')
2210        self.GeneralCalc.Append(help='Run charge flipping',id=wxID_CHARGEFLIP, kind=wx.ITEM_NORMAL,
2211            text='Charge flipping')
2212        self.GeneralCalc.Append(help='Run 4D charge flipping',id=wxID_4DCHARGEFLIP, kind=wx.ITEM_NORMAL,
2213            text='4D Charge flipping')
2214        self.GeneralCalc.Enable(wxID_4DCHARGEFLIP,False)   
2215        self.GeneralCalc.Append(help='Clear map',id=wxID_FOURCLEAR, kind=wx.ITEM_NORMAL,
2216            text='Clear map')
2217        self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing',id=wxID_SINGLEMCSA, kind=wx.ITEM_NORMAL,
2218            text='MC/SA')
2219        self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing on multiprocessors',id=wxID_MULTIMCSA, kind=wx.ITEM_NORMAL,
2220            text='Multi MC/SA')            #currently not useful
2221        self.GeneralCalc.Append(help='Transform crystal structure',id=wxID_TRANSFORMSTRUCTURE, kind=wx.ITEM_NORMAL,
2222            text='Transform')
2223        self.PostfillDataMenu()
2224       
2225        # Phase / Data tab
2226        self.DataMenu = wx.MenuBar()
2227        self.PrefillDataMenu(self.DataMenu)
2228        self.DataMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2229        self.DataEdit = wx.Menu(title='')
2230        self.DataMenu.Append(menu=self.DataEdit, title='Edit Phase')
2231        self.DataEdit.Append(id=wxID_DATACOPY, kind=wx.ITEM_NORMAL,text='Copy data',
2232            help='Copy phase data to other histograms')
2233        self.DataEdit.Append(id=wxID_DATACOPYFLAGS, kind=wx.ITEM_NORMAL,text='Copy flags',
2234            help='Copy phase data flags to other histograms')
2235        self.DataEdit.Append(id=wxID_DATASELCOPY, kind=wx.ITEM_NORMAL,text='Copy selected data',
2236            help='Copy selected phase data to other histograms')
2237        self.DataEdit.Append(id=wxID_DATAUSE, kind=wx.ITEM_NORMAL,text='Select used data',
2238            help='Select all histograms to use')
2239        self.DataEdit.Append(id=wxID_PWDRADD, kind=wx.ITEM_NORMAL,text='Add powder histograms',
2240            help='Select new powder histograms to be used for this phase')
2241        self.DataEdit.Append(id=wxID_HKLFADD, kind=wx.ITEM_NORMAL,text='Add single crystal histograms',
2242            help='Select new single crystal histograms to be used for this phase')
2243        self.DataEdit.Append(id=wxID_DATADELETE, kind=wx.ITEM_NORMAL,text='Remove histograms',
2244            help='Remove histograms from use for this phase')
2245        self.PostfillDataMenu()
2246           
2247        # Phase / Atoms tab
2248        self.AtomsMenu = wx.MenuBar()
2249        self.PrefillDataMenu(self.AtomsMenu)
2250        self.AtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2251        self.AtomEdit = wx.Menu(title='')
2252        self.AtomCompute = wx.Menu(title='')
2253        self.AtomsMenu.Append(menu=self.AtomEdit, title='Edit Atoms')
2254        self.AtomsMenu.Append(menu=self.AtomCompute, title='Compute')
2255        submenu = wx.Menu()
2256        self.AtomEdit.AppendMenu(wx.ID_ANY, 'On selected atoms...', submenu, 
2257            help='Set/Act on selected atoms')
2258        submenu.Append(wxID_ATOMSSETSEL,
2259            help='Set refinement flags for selected atoms',
2260            kind=wx.ITEM_NORMAL,
2261            text='Refine selected')
2262        submenu.Append(id=wxID_ATOMSMODIFY, kind=wx.ITEM_NORMAL,text='Modify parameters',
2263            help='Modify parameters values for all selected atoms')
2264        submenu.Append(id=wxID_ATOMSEDITINSERT, kind=wx.ITEM_NORMAL,text='Insert atom',
2265            help='Inserts an H atom before all selected atoms')
2266        submenu.Append(id=wxID_ADDHATOM, kind=wx.ITEM_NORMAL,text='Calc H atoms',
2267            help='Insert H atoms in expected bonding positions for selected atoms')
2268        submenu.Append(id=wxID_ATOMSEDITDELETE, kind=wx.ITEM_NORMAL,text='Delete atom',
2269            help='Delete selected atoms')
2270        submenu.Append(id=wxID_ATOMSTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
2271            help='Symmetry transform selected atoms')
2272#        self.AtomEdit.Append(id=wxID_ATOMSROTATE, kind=wx.ITEM_NORMAL,text='Rotate atoms',
2273#            help='Select atoms to rotate first')
2274        submenu.Append(wxID_ATOMSSETALL,
2275            help='Set refinement flags for all atoms',
2276            kind=wx.ITEM_NORMAL,
2277            text='Select All')
2278       
2279        self.AtomEdit.Append(id=wxID_ATOMSEDITADD, kind=wx.ITEM_NORMAL,text='Append atom',
2280            help='Appended as an H atom')
2281        self.AtomEdit.Append(id=wxID_ATOMSVIEWADD, kind=wx.ITEM_NORMAL,text='Append view point',
2282            help='Appended as an H atom')
2283        self.AtomEdit.Append(id=wxID_ATOMVIEWINSERT, kind=wx.ITEM_NORMAL,text='Insert view point',
2284            help='Select atom row to insert before; inserted as an H atom')
2285        self.AtomEdit.Append(id=wxID_UPDATEHATOM, kind=wx.ITEM_NORMAL,text='Update H atoms',
2286            help='Update H atoms in standard positions')
2287        self.AtomEdit.Append(id=wxID_ATOMMOVE, kind=wx.ITEM_NORMAL,text='Move selected atom to view point',
2288            help='Select a single atom to be moved to view point in plot')
2289        self.AtomEdit.Append(id=wxID_MAKEMOLECULE, kind=wx.ITEM_NORMAL,text='Assemble molecule',
2290            help='Select a single atom to assemble as a molecule from scattered atom positions')
2291        self.AtomEdit.Append(id=wxID_RELOADDRAWATOMS, kind=wx.ITEM_NORMAL,text='Reload draw atoms',
2292            help='Reload atom drawing list')
2293        submenu = wx.Menu()
2294        self.AtomEdit.AppendMenu(wx.ID_ANY, 'Reimport atoms', submenu, 
2295            help='Reimport atoms from file; sequence must match')
2296        # setup a cascade menu for the formats that have been defined
2297        self.ReImportMenuId = {}  # points to readers for each menu entry
2298        for reader in self.G2frame.ImportPhaseReaderlist:
2299            item = submenu.Append(
2300                wx.ID_ANY,help=reader.longFormatName,
2301                kind=wx.ITEM_NORMAL,text='reimport coordinates from '+reader.formatName+' file')
2302            self.ReImportMenuId[item.GetId()] = reader
2303        item = submenu.Append(
2304            wx.ID_ANY,
2305            help='Reimport coordinates, try to determine format from file',
2306            kind=wx.ITEM_NORMAL,
2307            text='guess format from file')
2308        self.ReImportMenuId[item.GetId()] = None # try all readers
2309
2310        self.AtomCompute.Append(id=wxID_ATOMSDISAGL, kind=wx.ITEM_NORMAL,text='Show Distances && Angles',
2311            help='Compute distances & angles for selected atoms')
2312        self.AtomCompute.Append(id=wxID_ATOMSPDISAGL, kind=wx.ITEM_NORMAL,text='Save Distances && Angles',
2313            help='Compute distances & angles for selected atoms')
2314        self.AtomCompute.ISOcalc = self.AtomCompute.Append(
2315            id=wxID_ISODISP, kind=wx.ITEM_NORMAL,
2316            text='ISODISTORT mode values',
2317            help='Compute values of ISODISTORT modes from atom parameters')
2318        self.AtomCompute.Append(id=wxID_ATOMSDENSITY, kind=wx.ITEM_NORMAL,
2319            text='Density',
2320            help='Compute density for current phase')
2321        self.PostfillDataMenu()
2322       
2323        # Phase / Imcommensurate "waves" tab
2324        self.WavesData = wx.MenuBar()
2325        self.PrefillDataMenu(self.WavesData)
2326        self.WavesData.Append(menu=wx.Menu(title=''),title='Select tab')
2327        self.WavesDataEdit = wx.Menu(title='')
2328        self.WavesData.Append(menu=self.WavesDataEdit, title='Edit Wave')
2329        self.WavesDataEdit.Append(id=wxID_WAVEVARY, kind=wx.ITEM_NORMAL,text='Global wave vary',
2330            help='Global setting of wave vary flags')
2331        self.PostfillDataMenu()
2332       
2333        # Phase / Layer tab
2334        self.LayerData = wx.MenuBar()
2335        self.PrefillDataMenu(self.LayerData)
2336        self.LayerData.Append(menu=wx.Menu(title=''),title='Select tab')
2337        self.LayerDataEdit = wx.Menu(title='')
2338        self.LayerData.Append(menu=self.LayerDataEdit, title='Operations')
2339        self.LayerDataEdit.Append(id=wxID_LOADDIFFAX, kind=wx.ITEM_NORMAL,text='Load from DIFFaX file',
2340            help='Load layer info from DIFFaX file')
2341        self.LayerDataEdit.Append(id=wxID_COPYPHASE, kind=wx.ITEM_NORMAL,text='Copy phase cell',
2342            help='Copy phase cell from another project')
2343        self.LayerDataEdit.Append(id=wxID_LAYERSIMULATE, kind=wx.ITEM_NORMAL,text='Simulate pattern',
2344            help='Simulate diffraction pattern from layer stacking')
2345        self.LayerDataEdit.Append(id=wxID_LAYERSFIT, kind=wx.ITEM_NORMAL,text='Fit pattern',
2346            help='Fit diffraction pattern with layer stacking model')
2347        self.LayerDataEdit.Append(id=wxID_SEQUENCESIMULATE, kind=wx.ITEM_NORMAL,text='Sequence simulations',
2348            help='Sequence simulation changing one parameter')
2349        self.PostfillDataMenu()
2350                 
2351        # Phase / Draw Options tab
2352        self.DataDrawOptions = wx.MenuBar()
2353        self.PrefillDataMenu(self.DataDrawOptions)
2354        self.DataDrawOptions.Append(menu=wx.Menu(title=''),title='Select tab')
2355        self.PostfillDataMenu()
2356       
2357        # Phase / Draw Atoms tab
2358        self.DrawAtomsMenu = wx.MenuBar()
2359        self.PrefillDataMenu(self.DrawAtomsMenu)
2360        self.DrawAtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2361        self.DrawAtomEdit = wx.Menu(title='')
2362        self.DrawAtomCompute = wx.Menu(title='')
2363        self.DrawAtomRestraint = wx.Menu(title='')
2364        self.DrawAtomRigidBody = wx.Menu(title='')
2365        self.DrawAtomsMenu.Append(menu=self.DrawAtomEdit, title='Edit Figure')
2366        self.DrawAtomsMenu.Append(menu=self.DrawAtomCompute,title='Compute')
2367        self.DrawAtomsMenu.Append(menu=self.DrawAtomRestraint, title='Restraints')
2368        self.DrawAtomsMenu.Append(menu=self.DrawAtomRigidBody, title='Rigid body')
2369        self.DrawAtomEdit.Append(id=wxID_DRAWATOMSTYLE, kind=wx.ITEM_NORMAL,text='Atom style',
2370            help='Select atoms first')
2371        self.DrawAtomEdit.Append(id=wxID_DRAWATOMLABEL, kind=wx.ITEM_NORMAL,text='Atom label',
2372            help='Select atoms first')
2373        self.DrawAtomEdit.Append(id=wxID_DRAWATOMCOLOR, kind=wx.ITEM_NORMAL,text='Atom color',
2374            help='Select atoms first')
2375        self.DrawAtomEdit.Append(id=wxID_DRAWATOMRESETCOLOR, kind=wx.ITEM_NORMAL,text='Reset atom colors',
2376            help='Resets all atom colors to defaults')
2377        self.DrawAtomEdit.Append(id=wxID_DRWAEDITRADII, kind=wx.ITEM_NORMAL,text='Edit atom radii',
2378            help='Edit drawing atom radii')
2379        self.DrawAtomEdit.Append(id=wxID_DRAWVIEWPOINT, kind=wx.ITEM_NORMAL,text='View point',
2380            help='View point is 1st atom selected')
2381        self.DrawAtomEdit.Append(id=wxID_DRAWADDEQUIV, kind=wx.ITEM_NORMAL,text='Add atoms',
2382            help='Add symmetry & cell equivalents to drawing set from selected atoms')
2383        self.DrawAtomEdit.Append(id=wxID_DRAWADDSPHERE, kind=wx.ITEM_NORMAL,text='Add sphere of atoms',
2384            help='Add atoms within sphere of enclosure')
2385        self.DrawAtomEdit.Append(id=wxID_DRAWTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform draw atoms',
2386            help='Transform selected atoms by symmetry & cell translations')
2387        self.DrawAtomEdit.Append(id=wxID_DRAWFILLCOORD, kind=wx.ITEM_NORMAL,text='Fill CN-sphere',
2388            help='Fill coordination sphere for selected atoms')           
2389        self.DrawAtomEdit.Append(id=wxID_DRAWFILLCELL, kind=wx.ITEM_NORMAL,text='Fill unit cell',
2390            help='Fill unit cell with selected atoms')
2391        self.DrawAtomEdit.Append(id=wxID_DRAWDELETE, kind=wx.ITEM_NORMAL,text='Delete atoms',
2392            help='Delete atoms from drawing set')
2393        self.DrawAtomCompute.Append(id=wxID_DRAWDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2394            help='Compute distance of selected atoms from view point')   
2395        self.DrawAtomCompute.Append(id=wxID_DRAWDISAGLTOR, kind=wx.ITEM_NORMAL,text='Dist. Ang. Tors.',
2396            help='Compute distance, angle or torsion for 2-4 selected atoms')   
2397        self.DrawAtomCompute.Append(id=wxID_DRAWPLANE, kind=wx.ITEM_NORMAL,text='Best plane',
2398            help='Compute best plane for 4+ selected atoms')   
2399        self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRBOND, kind=wx.ITEM_NORMAL,text='Add bond restraint',
2400            help='Add bond restraint for selected atoms (2)')
2401        self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRANGLE, kind=wx.ITEM_NORMAL,text='Add angle restraint',
2402            help='Add angle restraint for selected atoms (3: one end 1st)')
2403        self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRPLANE, kind=wx.ITEM_NORMAL,text='Add plane restraint',
2404            help='Add plane restraint for selected atoms (4+)')
2405        self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRCHIRAL, kind=wx.ITEM_NORMAL,text='Add chiral restraint',
2406            help='Add chiral restraint for selected atoms (4: center atom 1st)')
2407        self.DrawAtomRigidBody.Append(id=wxID_DRAWDEFINERB, kind=wx.ITEM_NORMAL,text='Define rigid body',
2408            help='Define rigid body with selected atoms')
2409        self.PostfillDataMenu()
2410
2411        # Phase / MCSA tab
2412        self.MCSAMenu = wx.MenuBar()
2413        self.PrefillDataMenu(self.MCSAMenu)
2414        self.MCSAMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2415        self.MCSAEdit = wx.Menu(title='')
2416        self.MCSAMenu.Append(menu=self.MCSAEdit, title='MC/SA')
2417        self.MCSAEdit.Append(id=wxID_ADDMCSAATOM, kind=wx.ITEM_NORMAL,text='Add atom', 
2418            help='Add single atom to MC/SA model')
2419        self.MCSAEdit.Append(id=wxID_ADDMCSARB, kind=wx.ITEM_NORMAL,text='Add rigid body', 
2420            help='Add rigid body to MC/SA model' )
2421        self.MCSAEdit.Append(id=wxID_CLEARMCSARB, kind=wx.ITEM_NORMAL,text='Clear rigid bodies', 
2422            help='Clear all atoms & rigid bodies from MC/SA model' )
2423        self.MCSAEdit.Append(id=wxID_MOVEMCSA, kind=wx.ITEM_NORMAL,text='Move MC/SA solution', 
2424            help='Move MC/SA solution to atom list' )
2425        self.MCSAEdit.Append(id=wxID_MCSACLEARRESULTS, kind=wx.ITEM_NORMAL,text='Clear results', 
2426            help='Clear table of MC/SA results' )
2427        self.PostfillDataMenu()
2428           
2429        # Phase / Texture tab
2430        self.TextureMenu = wx.MenuBar()
2431        self.PrefillDataMenu(self.TextureMenu)
2432        self.TextureMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2433        self.TextureEdit = wx.Menu(title='')
2434        self.TextureMenu.Append(menu=self.TextureEdit, title='Texture')
2435        self.TextureEdit.Append(id=wxID_REFINETEXTURE, kind=wx.ITEM_NORMAL,text='Refine texture', 
2436            help='Refine the texture coefficients from sequential results')
2437#        self.TextureEdit.Append(id=wxID_CLEARTEXTURE, kind=wx.ITEM_NORMAL,text='Clear texture',
2438#            help='Clear the texture coefficients' )
2439        self.PostfillDataMenu()
2440           
2441        # Phase / Pawley tab
2442        self.PawleyMenu = wx.MenuBar()
2443        self.PrefillDataMenu(self.PawleyMenu)
2444        self.PawleyMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2445        self.PawleyEdit = wx.Menu(title='')
2446        self.PawleyMenu.Append(menu=self.PawleyEdit,title='Operations')
2447        self.PawleyEdit.Append(id=wxID_PAWLEYSET, kind=wx.ITEM_NORMAL,text='Pawley settings',
2448            help='Change Pawley refinement settings')
2449        self.PawleyEdit.Append(id=wxID_PAWLEYLOAD, kind=wx.ITEM_NORMAL,text='Pawley create',
2450            help='Initialize Pawley reflection list')
2451        self.PawleyEdit.Append(id=wxID_PAWLEYESTIMATE, kind=wx.ITEM_NORMAL,text='Pawley estimate',
2452            help='Estimate initial Pawley intensities')
2453        self.PawleyEdit.Append(id=wxID_PAWLEYUPDATE, kind=wx.ITEM_NORMAL,text='Pawley update',
2454            help='Update negative Pawley intensities with -0.5*Fobs and turn off refinement')
2455        self.PawleyEdit.Append(id=wxID_PAWLEYSELALL, kind=wx.ITEM_NORMAL,text='Select all',
2456            help='Select all reflections to be refined')
2457        self.PawleyEdit.Append(id=wxID_PAWLEYSELNONE, kind=wx.ITEM_NORMAL,text='Select none',
2458            help='Set flag for all reflections for no refinement')
2459        self.PawleyEdit.Append(id=wxID_PAWLEYSELTOGGLE, kind=wx.ITEM_NORMAL,text='Toggle Selection',
2460            help='Toggle Selection flag for all reflections to opposite setting')
2461        self.PostfillDataMenu()
2462           
2463        # Phase / Map peaks tab
2464        self.MapPeaksMenu = wx.MenuBar()
2465        self.PrefillDataMenu(self.MapPeaksMenu)
2466        self.MapPeaksMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2467        self.MapPeaksEdit = wx.Menu(title='')
2468        self.MapPeaksMenu.Append(menu=self.MapPeaksEdit, title='Map peaks')
2469        self.MapPeaksEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks', 
2470            help='Move selected peaks to atom list')
2471        self.MapPeaksEdit.Append(id=wxID_PEAKSVIEWPT, kind=wx.ITEM_NORMAL,text='View point',
2472            help='View point is 1st peak selected')
2473        self.MapPeaksEdit.Append(id=wxID_PEAKSDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2474            help='Compute distance of selected peaks from view point')   
2475        self.MapPeaksEdit.Append(id=wxID_SHOWBONDS, kind=wx.ITEM_NORMAL,text='Hide bonds',
2476            help='Hide or show bonds between peak positions')   
2477        self.MapPeaksEdit.Append(id=wxID_PEAKSDA, kind=wx.ITEM_NORMAL,text='Calc dist/ang', 
2478            help='Calculate distance or angle for selection')
2479        self.MapPeaksEdit.Append(id=wxID_FINDEQVPEAKS, kind=wx.ITEM_NORMAL,text='Equivalent peaks', 
2480            help='Find equivalent peaks')
2481        self.MapPeaksEdit.Append(id=wxID_PEAKSUNIQUE, kind=wx.ITEM_NORMAL,text='Unique peaks', 
2482            help='Select unique set')
2483        self.MapPeaksEdit.Append(id=wxID_PEAKSDELETE, kind=wx.ITEM_NORMAL,text='Delete peaks', 
2484            help='Delete selected peaks')
2485        self.MapPeaksEdit.Append(id=wxID_PEAKSCLEAR, kind=wx.ITEM_NORMAL,text='Clear peaks', 
2486            help='Clear the map peak list')
2487        self.PostfillDataMenu()
2488
2489        # Phase / Rigid bodies tab
2490        self.RigidBodiesMenu = wx.MenuBar()
2491        self.PrefillDataMenu(self.RigidBodiesMenu)
2492        self.RigidBodiesMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2493        self.RigidBodiesEdit = wx.Menu(title='')
2494        self.RigidBodiesMenu.Append(menu=self.RigidBodiesEdit, title='Edit Body')
2495        self.RigidBodiesEdit.Append(id=wxID_ASSIGNATMS2RB, kind=wx.ITEM_NORMAL,text='Assign atoms to rigid body',
2496            help='Select & position rigid body in structure of existing atoms')
2497        self.RigidBodiesEdit.Append(id=wxID_AUTOFINDRESRB, kind=wx.ITEM_NORMAL,text='Auto find residues',
2498            help='Auto find of residue RBs in macromolecule')
2499        self.RigidBodiesEdit.Append(id=wxID_COPYRBPARMS, kind=wx.ITEM_NORMAL,text='Copy rigid body parms',
2500            help='Copy rigid body location & TLS parameters')
2501        self.RigidBodiesEdit.Append(id=wxID_GLOBALTHERM, kind=wx.ITEM_NORMAL,text='Global thermal motion',
2502            help='Global setting of residue thermal motion models')
2503        self.RigidBodiesEdit.Append(id=wxID_GLOBALRESREFINE, kind=wx.ITEM_NORMAL,text='Global residue refine',
2504            help='Global setting of residue RB refinement flags')
2505        self.RigidBodiesEdit.Append(id=wxID_RBREMOVEALL, kind=wx.ITEM_NORMAL,text='Remove all rigid bodies',
2506            help='Remove all rigid body assignment for atoms')
2507        self.PostfillDataMenu()
2508    # end of GSAS-II menu definitions
2509       
2510    def _init_ctrls(self, parent,name=None,size=None,pos=None):
2511        wx.Frame.__init__(
2512            self,parent=parent,
2513            #style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX | wx.FRAME_FLOAT_ON_PARENT ,
2514            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
2515            size=size,pos=pos,title='GSAS-II data display')
2516        self._init_menus()
2517        if name:
2518            self.SetLabel(name)
2519        self.Show()
2520       
2521    def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
2522        self.G2frame = frame
2523        self._init_ctrls(parent,name,size,pos)
2524        self.data = data
2525        clientSize = wx.ClientDisplayRect()
2526        Size = self.GetSize()
2527        xPos = clientSize[2]-Size[0]
2528        self.SetPosition(wx.Point(xPos,clientSize[1]+250))
2529        self.AtomGrid = []
2530        self.selectedRow = 0
2531        self.lastSize = Size       
2532        self.manualPhaseSize = None
2533        self.userReSize = False
2534        wx.Frame.Bind(self,wx.EVT_SIZE,self.OnReSize)
2535           
2536    def OnReSize(self,event):
2537        '''Keep track of size changes for Phase windows
2538        '''
2539        id = self.G2frame.PatternTree.GetSelection()
2540        try:
2541            parent = self.G2frame.PatternTree.GetItemParent(id)
2542        except:         #avoid bad tree item on start via gpx file selection
2543            parent = 0
2544        if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases": 
2545            if self.lastSize == event.EventObject.GetSize():
2546#                if GSASIIpath.GetConfigValue('debug'):
2547#                    print 'no save size=',self.lastSize
2548                return
2549            self.manualPhaseSize = event.EventObject.GetSize()
2550            self.lastSize = event.EventObject.GetSize()
2551#            if GSASIIpath.GetConfigValue('debug'):
2552#                print 'Saving Phase size=',self.manualPhaseSize
2553                #HowDidIgetHere()
2554        event.Skip()
2555
2556    def SendSizeEvent(self):
2557        '''Prevent SendSizeEvent from overriding the saved size
2558        '''
2559        self.userReSize = False
2560        wx.Frame.SendSizeEvent(self)
2561        self.userReSize = True
2562       
2563    def setSizePosLeft(self,Size):
2564        '''Place the dataFrame window so that the upper left-hand corner remains in the same place;
2565        The size is dictated by parameter Width, unless overridden by a previous Phase window resize
2566        '''
2567        self.userReSize = False
2568        Size = list(Size)
2569        id = self.G2frame.PatternTree.GetSelection()
2570        try:            #avoid bad tree item on start via gpx file selection
2571            pid = self.G2frame.PatternTree.GetItemParent(id)
2572        except:
2573            pid = 0
2574        if pid:
2575            parent = self.G2frame.PatternTree.GetItemText(pid)
2576            # is this a phase window and has a previous window has been resized?
2577            if self.manualPhaseSize and parent == "Phases":
2578                Size = list(self.manualPhaseSize)
2579        Pos = self.GetPosition()
2580        clientSize = wx.ClientDisplayRect()     #display window size (e.g. 1304x768)
2581        Size[1] = min(Size[1],clientSize[2]-300)
2582        Size[0] = max(Size[0],300)
2583#        print 'current position/width:',Pos,Width
2584        self.SetSize(Size)
2585        Size[1] += 1        #kluge to ensure scrollbar settings & window properly displayed
2586        self.SetSize(Size)
2587        Pos[0] += self.lastSize[0]-Size[0]
2588        offSet = 0
2589        if Pos[0] < clientSize[2]:
2590            offSet = Pos[0]+Size[0]-clientSize[2]
2591        if offSet > 0:
2592            Pos[0] -= offSet
2593        self.SetPosition(wx.Point(Pos[0],Pos[1]))
2594        self.lastSize = Size
2595        self.userReSize = True
2596       
2597    def Clear(self):
2598        self.ClearBackground()
2599        self.DestroyChildren()
2600                   
2601
2602################################################################################
2603#####  Notebook Tree Item editor
2604################################################################################                 
2605def UpdateNotebook(G2frame,data):
2606    '''Called when the data tree notebook entry is selected. Allows for
2607    editing of the text in that tree entry
2608    '''
2609    def OnNoteBook(event):
2610        event.Skip()
2611        data = G2frame.dataDisplay.GetValue().split('\n')
2612        G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
2613        if 'nt' not in os.name:
2614            G2frame.dataDisplay.AppendText('\n')
2615                   
2616    if G2frame.dataDisplay:
2617        G2frame.dataDisplay.Destroy()
2618    G2frame.dataFrame.SetLabel('Notebook')
2619    G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2620        style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
2621    G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
2622    G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
2623    for line in data:
2624        G2frame.dataDisplay.AppendText(line+"\n")
2625    G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
2626    G2frame.dataFrame.setSizePosLeft([400,250])
2627           
2628################################################################################
2629#####  Controls Tree Item editor
2630################################################################################           
2631def UpdateControls(G2frame,data):
2632    '''Edit overall GSAS-II controls in main Controls data tree entry
2633    '''
2634    #patch
2635    if 'deriv type' not in data:
2636        data = {}
2637        data['deriv type'] = 'analytic Hessian'
2638        data['min dM/M'] = 0.0001
2639        data['shift factor'] = 1.
2640        data['max cyc'] = 3       
2641        data['F**2'] = False
2642    if 'shift factor' not in data:
2643        data['shift factor'] = 1.
2644    if 'max cyc' not in data:
2645        data['max cyc'] = 3
2646    if 'F**2' not in data:
2647        data['F**2'] = False
2648    if 'Author' not in data:
2649        data['Author'] = 'no name'
2650    if 'FreePrm1' not in data:
2651        data['FreePrm1'] = 'Sample humidity (%)'
2652    if 'FreePrm2' not in data:
2653        data['FreePrm2'] = 'Sample voltage (V)'
2654    if 'FreePrm3' not in data:
2655        data['FreePrm3'] = 'Applied load (MN)'
2656    if 'Copy2Next' not in data:
2657        data['Copy2Next'] = False
2658    if 'Reverse Seq' not in data:
2659        data['Reverse Seq'] = False
2660    if 'UsrReject' not in data:
2661        data['UsrReject'] = {'minF/sig':0,'MinExt':0.01,'MaxDF/F':20.,'MaxD':500.,'MinD':0.05}
2662    if 'HatomFix' not in data:
2663        data['HatomFix'] = False
2664    if 'Marquardt' not in data:
2665        data['Marquardt'] = -3
2666   
2667    #end patch
2668
2669    def SeqSizer():
2670       
2671        def OnSelectData(event):
2672            choices = GetPatternTreeDataNames(G2frame,['PWDR','HKLF',])
2673            sel = []
2674            try:
2675                if 'Seq Data' in data:
2676                    for item in data['Seq Data']:
2677                        sel.append(choices.index(item))
2678                    sel = [choices.index(item) for item in data['Seq Data']]
2679            except ValueError:  #data changed somehow - start fresh
2680                sel = []
2681            dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential refinement',
2682                'Select dataset to include',choices)
2683            dlg.SetSelections(sel)
2684            names = []
2685            if dlg.ShowModal() == wx.ID_OK:
2686                for sel in dlg.GetSelections():
2687                    names.append(choices[sel])
2688                data['Seq Data'] = names               
2689                G2frame.EnableSeqRefineMenu()
2690            dlg.Destroy()
2691            wx.CallAfter(UpdateControls,G2frame,data)
2692           
2693        def OnReverse(event):
2694            data['Reverse Seq'] = reverseSel.GetValue()
2695           
2696        def OnCopySel(event):
2697            data['Copy2Next'] = copySel.GetValue() 
2698                   
2699        seqSizer = wx.BoxSizer(wx.VERTICAL)
2700        dataSizer = wx.BoxSizer(wx.HORIZONTAL)
2701        dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement: '),0,WACV)
2702        selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
2703        selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
2704        dataSizer.Add(selSeqData,0,WACV)
2705        SeqData = data.get('Seq Data',[])
2706        if not SeqData:
2707            lbl = ' (no data selected)'
2708        else:
2709            lbl = ' ('+str(len(SeqData))+' dataset(s) selected)'
2710
2711        dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=lbl),0,WACV)
2712        seqSizer.Add(dataSizer,0)
2713        if SeqData:
2714            selSizer = wx.BoxSizer(wx.HORIZONTAL)
2715            reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
2716            reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
2717            reverseSel.SetValue(data['Reverse Seq'])
2718            selSizer.Add(reverseSel,0,WACV)
2719            copySel =  wx.CheckBox(G2frame.dataDisplay,-1,label=' Copy results to next histogram?')
2720            copySel.Bind(wx.EVT_CHECKBOX,OnCopySel)
2721            copySel.SetValue(data['Copy2Next'])
2722            selSizer.Add(copySel,0,WACV)
2723            seqSizer.Add(selSizer,0)
2724        return seqSizer
2725       
2726    def LSSizer():       
2727       
2728        def OnDerivType(event):
2729            data['deriv type'] = derivSel.GetValue()
2730            derivSel.SetValue(data['deriv type'])
2731            wx.CallAfter(UpdateControls,G2frame,data)
2732           
2733        def OnConvergence(event):
2734            event.Skip()
2735            try:
2736                value = max(1.e-9,min(1.0,float(Cnvrg.GetValue())))
2737            except ValueError:
2738                value = 0.0001
2739            data['min dM/M'] = value
2740            Cnvrg.SetValue('%.2g'%(value))
2741           
2742        def OnMaxCycles(event):
2743            data['max cyc'] = int(maxCyc.GetValue())
2744            maxCyc.SetValue(str(data['max cyc']))
2745           
2746        def OnMarqLam(event):
2747            data['Marquardt'] = int(marqLam.GetValue())
2748            marqLam.SetValue(str(data['Marquardt']))
2749                       
2750        def OnFactor(event):
2751            event.Skip()
2752            try:
2753                value = min(max(float(Factr.GetValue()),0.00001),100.)
2754            except ValueError:
2755                value = 1.0
2756            data['shift factor'] = value
2757            Factr.SetValue('%.5f'%(value))
2758           
2759        def OnFsqRef(event):
2760            data['F**2'] = fsqRef.GetValue()
2761           
2762#        def OnHatomFix(event):
2763#            data['HatomFix'] = Hfix.GetValue()
2764       
2765        def OnUsrRej(event):
2766            event.Skip()
2767            Obj = event.GetEventObject()
2768            item,limits = Indx[Obj]
2769            try:
2770                value = min(max(float(Obj.GetValue()),limits[0]),limits[1])
2771            except ValueError:
2772                value = data['UsrReject'][item]
2773            data['UsrReject'][item] = value
2774            Obj.SetValue('%.2f'%(value))
2775
2776        LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
2777        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,WACV)
2778        Choice=['analytic Jacobian','numeric','analytic Hessian']
2779        derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
2780            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2781        derivSel.SetValue(data['deriv type'])
2782        derivSel.Bind(wx.EVT_COMBOBOX, OnDerivType)
2783           
2784        LSSizer.Add(derivSel,0,WACV)
2785        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,WACV)
2786        Cnvrg = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
2787        Cnvrg.Bind(wx.EVT_TEXT_ENTER,OnConvergence)
2788        Cnvrg.Bind(wx.EVT_KILL_FOCUS,OnConvergence)
2789        LSSizer.Add(Cnvrg,0,WACV)
2790        Indx = {}
2791        if 'Hessian' in data['deriv type']:
2792            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,WACV)
2793            Choice = ['0','1','2','3','5','10','15','20']
2794            maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
2795                style=wx.CB_READONLY|wx.CB_DROPDOWN)
2796#            maxCyc.SetValue(str(data['max cyc']))
2797            maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
2798            LSSizer.Add(maxCyc,0,WACV)
2799            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial lambda = 10**'),0,WACV)
2800            MarqChoice = ['-3','-2','-1','0','1','2','3','4']
2801            marqLam = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['Marquardt']),choices=MarqChoice,
2802                style=wx.CB_READONLY|wx.CB_DROPDOWN)
2803            marqLam.Bind(wx.EVT_COMBOBOX,OnMarqLam)
2804            LSSizer.Add(marqLam,0,WACV)
2805        else:
2806            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,WACV)
2807            Factr = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
2808            Factr.Bind(wx.EVT_TEXT_ENTER,OnFactor)
2809            Factr.Bind(wx.EVT_KILL_FOCUS,OnFactor)
2810            LSSizer.Add(Factr,0,WACV)
2811        if G2frame.Sngl:
2812            userReject = data['UsrReject']
2813            usrRej = {'minF/sig':[' Min obs/sig (0-5): ',[0,5], ],'MinExt':[' Min extinct. (0-.9): ',[0,.9],],
2814                'MaxDF/F':[' Max delt-F/sig (3-1000): ',[3.,1000.],],'MaxD':[' Max d-spacing (3-500): ',[3,500],],
2815                'MinD':[' Min d-spacing (0.1-2.0): ',[0.1,2.0],]}
2816
2817            fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
2818            fsqRef.SetValue(data['F**2'])
2819            fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
2820            LSSizer.Add(fsqRef,0,WACV)
2821            LSSizer.Add((1,0),)
2822            for item in usrRej:
2823                LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=usrRej[item][0]),0,WACV)
2824                usrrej = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(userReject[item]),style=wx.TE_PROCESS_ENTER)
2825                Indx[usrrej] = [item,usrRej[item][1]]
2826                usrrej.Bind(wx.EVT_TEXT_ENTER,OnUsrRej)
2827                usrrej.Bind(wx.EVT_KILL_FOCUS,OnUsrRej)
2828                LSSizer.Add(usrrej,0,WACV)
2829#        Hfix = wx.CheckBox(G2frame.dataDisplay,-1,label='Regularize H atoms? ')
2830#        Hfix.SetValue(data['HatomFix'])
2831#        Hfix.Bind(wx.EVT_CHECKBOX,OnHatomFix)
2832#        LSSizer.Add(Hfix,0,WACV)   #for now
2833        return LSSizer
2834       
2835    def AuthSizer():
2836
2837        def OnAuthor(event):
2838            event.Skip()
2839            data['Author'] = auth.GetValue()
2840
2841        Author = data['Author']
2842        authSizer = wx.BoxSizer(wx.HORIZONTAL)
2843        authSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' CIF Author (last, first):'),0,WACV)
2844        auth = wx.TextCtrl(G2frame.dataDisplay,-1,value=Author,style=wx.TE_PROCESS_ENTER)
2845        auth.Bind(wx.EVT_TEXT_ENTER,OnAuthor)
2846        auth.Bind(wx.EVT_KILL_FOCUS,OnAuthor)
2847        authSizer.Add(auth,0,WACV)
2848        return authSizer
2849       
2850       
2851    if G2frame.dataDisplay:
2852        G2frame.dataDisplay.Destroy()
2853    if not G2frame.dataFrame.GetStatusBar():
2854        Status = G2frame.dataFrame.CreateStatusBar()
2855        Status.SetStatusText('')
2856    G2frame.dataFrame.SetLabel('Controls')
2857    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2858    SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
2859    mainSizer = wx.BoxSizer(wx.VERTICAL)
2860    mainSizer.Add((5,5),0)
2861    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,WACV)   
2862    mainSizer.Add(LSSizer())
2863    mainSizer.Add((5,5),0)
2864    mainSizer.Add(SeqSizer())
2865    mainSizer.Add((5,5),0)
2866    mainSizer.Add(AuthSizer())
2867    mainSizer.Add((5,5),0)
2868       
2869    mainSizer.Layout()   
2870    G2frame.dataDisplay.SetSizer(mainSizer)
2871    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
2872     
2873################################################################################
2874#####  Comments
2875################################################################################           
2876       
2877def UpdateComments(G2frame,data):                   
2878
2879    if G2frame.dataDisplay:
2880        G2frame.dataDisplay.Destroy()
2881    G2frame.dataFrame.SetLabel('Comments')
2882    G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2883        style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
2884    for line in data:
2885        if '\n' not in line:
2886            G2frame.dataDisplay.AppendText(line+'\n')
2887        else:
2888            G2frame.dataDisplay.AppendText(line)
2889    G2frame.dataFrame.setSizePosLeft([400,250])
2890           
2891################################################################################
2892#####  Display of Sequential Results
2893################################################################################           
2894       
2895def UpdateSeqResults(G2frame,data,prevSize=None):
2896    """
2897    Called when the Sequential Results data tree entry is selected
2898    to show results from a sequential refinement.
2899   
2900    :param wx.Frame G2frame: main GSAS-II data tree windows
2901
2902    :param dict data: a dictionary containing the following items: 
2903
2904            * 'histNames' - list of histogram names in order as processed by Sequential Refinement
2905            * 'varyList' - list of variables - identical over all refinements in sequence
2906              note that this is the original list of variables, prior to processing
2907              constraints.
2908            * 'variableLabels' -- a dict of labels to be applied to each parameter
2909              (this is created as an empty dict if not present in data).
2910            * keyed by histName - dictionaries for all data sets processed, which contains:
2911
2912              * 'variables'- result[0] from leastsq call
2913              * 'varyList' - list of variables passed to leastsq call (not same as above)
2914              * 'sig' - esds for variables
2915              * 'covMatrix' - covariance matrix from individual refinement
2916              * 'title' - histogram name; same as dict item name
2917              * 'newAtomDict' - new atom parameters after shifts applied
2918              * 'newCellDict' - refined cell parameters after shifts to A0-A5 from Dij terms applied'
2919    """
2920
2921    def GetSampleParms():
2922        '''Make a dictionary of the sample parameters are not the same over the
2923        refinement series.
2924        '''
2925        if 'IMG' in histNames[0]:
2926            sampleParmDict = {'Sample load':[],}
2927        else:
2928            sampleParmDict = {'Temperature':[],'Pressure':[],'Time':[],
2929                'FreePrm1':[],'FreePrm2':[],'FreePrm3':[],'Omega':[],
2930                'Chi':[],'Phi':[],'Azimuth':[],}
2931        Controls = G2frame.PatternTree.GetItemPyData(
2932            GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
2933        sampleParm = {}
2934        for name in histNames:
2935            if 'IMG' in name:
2936                for item in sampleParmDict:
2937                    sampleParmDict[item].append(data[name]['parmDict'].get(item,0))
2938            else:
2939                Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
2940                sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
2941                for item in sampleParmDict:
2942                    sampleParmDict[item].append(sampleData.get(item,0))
2943        for item in sampleParmDict:
2944            frstValue = sampleParmDict[item][0]
2945            if np.any(np.array(sampleParmDict[item])-frstValue):
2946                if item.startswith('FreePrm'):
2947                    sampleParm[Controls[item]] = sampleParmDict[item]
2948                else:
2949                    sampleParm[item] = sampleParmDict[item]
2950        return sampleParm
2951
2952    def GetColumnInfo(col):
2953        '''returns column label, lists of values and errors (or None) for each column in the table
2954        for plotting. The column label is reformatted from Unicode to MatPlotLib encoding
2955        '''
2956        colName = G2frame.SeqTable.GetColLabelValue(col)
2957        plotName = variableLabels.get(colName,colName)
2958        plotName = plotSpCharFix(plotName)
2959        return plotName,colList[col],colSigs[col]
2960           
2961    def PlotSelect(event):
2962        'Plots a row (covariance) or column on double-click'
2963        cols = G2frame.dataDisplay.GetSelectedCols()
2964        rows = G2frame.dataDisplay.GetSelectedRows()
2965        if cols:
2966            G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
2967        elif rows:
2968            name = histNames[rows[0]]       #only does 1st one selected
2969            G2plt.PlotCovariance(G2frame,data[name])
2970        else:
2971            G2frame.ErrorDialog(
2972                'Select row or columns',
2973                'Nothing selected in table. Click on column or row label(s) to plot. N.B. Grid selection can be a bit funky.'
2974                )
2975           
2976    def OnPlotSelSeq(event):
2977        'plot the selected columns or row from menu command'
2978        cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2979        rows = G2frame.dataDisplay.GetSelectedRows()
2980        if cols:
2981            G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
2982        elif rows:
2983            name = histNames[rows[0]]       #only does 1st one selected
2984            G2plt.PlotCovariance(G2frame,data[name])
2985        else:
2986            G2frame.ErrorDialog(
2987                'Select columns',
2988                'No columns or rows selected in table. Click on row or column labels to select fields for plotting.'
2989                )
2990               
2991    def OnAveSelSeq(event):
2992        'average the selected columns from menu command'
2993        cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
2994        if cols:
2995            for col in cols:
2996                ave = np.mean(GetColumnInfo(col)[1])
2997                sig = np.std(GetColumnInfo(col)[1])
2998                print ' Average for '+G2frame.SeqTable.GetColLabelValue(col)+': '+'%.6g'%(ave)+' +/- '+'%.6g'%(sig)
2999        else:
3000            G2frame.ErrorDialog(
3001                'Select columns',
3002                'No columns selected in table. Click on column labels to select fields for averaging.'
3003                )
3004               
3005    def OnRenameSelSeq(event):
3006        cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
3007        colNames = [G2frame.SeqTable.GetColLabelValue(c) for c in cols]
3008        newNames = colNames[:]
3009        for i,name in enumerate(colNames):
3010            if name in variableLabels:
3011                newNames[i] = variableLabels[name]
3012        if not cols:
3013            G2frame.ErrorDialog('Select columns',
3014                'No columns selected in table. Click on column labels to select fields for rename.')
3015            return
3016        dlg = G2G.MultiStringDialog(G2frame.dataDisplay,'Set column names',colNames,newNames)
3017        if dlg.Show():
3018            newNames = dlg.GetValues()           
3019            variableLabels.update(dict(zip(colNames,newNames)))
3020        data['variableLabels'] = variableLabels
3021        dlg.Destroy()
3022        UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3023        G2plt.PlotSelectedSequence(G2frame,cols,GetColumnInfo,SelectXaxis)
3024           
3025    def OnReOrgSelSeq(event):
3026        'Reorder the columns'
3027        G2G.GetItemOrder(G2frame,VaryListChanges,vallookup,posdict)   
3028        UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3029
3030    def OnSaveSelSeqCSV(event):
3031        'export the selected columns to a .csv file from menu command'
3032        OnSaveSelSeq(event,csv=True)
3033       
3034    def OnSaveSeqCSV(event):
3035        'export all columns to a .csv file from menu command'
3036        OnSaveSelSeq(event,csv=True,allcols=True)
3037       
3038    def OnSaveSelSeq(event,csv=False,allcols=False):
3039        'export the selected columns to a .txt or .csv file from menu command'
3040        def WriteCSV():
3041            def WriteList(headerItems):
3042                line = ''
3043                for lbl in headerItems:
3044                    if line: line += ','
3045                    line += '"'+lbl+'"'
3046                return line
3047            head = ['name']
3048            for col in cols:
3049                item = G2frame.SeqTable.GetColLabelValue(col)
3050                # get rid of labels that have Unicode characters
3051                if not all([ord(c) < 128 and ord(c) != 0 for c in item]): item = '?'
3052                if col in havesig:
3053                    head += [item,'esd-'+item]
3054                else:
3055                    head += [item]
3056            SeqFile.write(WriteList(head)+'\n')
3057            for row,name in enumerate(saveNames):
3058                line = '"'+saveNames[row]+'"'
3059                for col in cols:
3060                    if col in havesig:
3061                        line += ','+str(saveData[col][row])+','+str(saveSigs[col][row])
3062                    else:
3063                        line += ','+str(saveData[col][row])
3064                SeqFile.write(line+'\n')
3065        def WriteSeq():
3066            lenName = len(saveNames[0])
3067            line = %s  '%('name'.center(lenName))
3068            for col in cols:
3069                item = G2frame.SeqTable.GetColLabelValue(col)
3070                if col in havesig:
3071                    line += ' %12s %12s '%(item.center(12),'esd'.center(12))
3072                else:
3073                    line += ' %12s '%(item.center(12))
3074            SeqFile.write(line+'\n')
3075            for row,name in enumerate(saveNames):
3076                line = " '%s' "%(saveNames[row])
3077                for col in cols:
3078                    if col in havesig:
3079                        line += ' %12.6f %12.6f '%(saveData[col][row],saveSigs[col][row])
3080                    else:
3081                        line += ' %12.6f '%saveData[col][row]
3082                SeqFile.write(line+'\n')
3083
3084        # start of OnSaveSelSeq code
3085        if allcols:
3086            cols = range(G2frame.SeqTable.GetNumberCols())
3087        else:
3088            cols = sorted(G2frame.dataDisplay.GetSelectedCols()) # ignore selection order
3089        nrows = G2frame.SeqTable.GetNumberRows()
3090        if not cols:
3091            G2frame.ErrorDialog('Select columns',
3092                             'No columns selected in table. Click on column labels to select fields for output.')
3093            return
3094        saveNames = [G2frame.SeqTable.GetRowLabelValue(r) for r in range(nrows)]
3095        saveData = {}
3096        saveSigs = {}
3097        havesig = []
3098        for col in cols:
3099            name,vals,sigs = GetColumnInfo(col)
3100            saveData[col] = vals
3101            if sigs:
3102                havesig.append(col)
3103                saveSigs[col] = sigs
3104        if csv:
3105            wild = 'CSV output file (*.csv)|*.csv'
3106        else:
3107            wild = 'Text output file (*.txt)|*.txt'
3108        pth = G2G.GetExportPath(G2frame)
3109        dlg = wx.FileDialog(
3110            G2frame,
3111            'Choose text output file for your selection', pth, '', 
3112            wild,wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT)
3113        try:
3114            if dlg.ShowModal() == wx.ID_OK:
3115                SeqTextFile = dlg.GetPath()
3116                SeqTextFile = G2IO.FileDlgFixExt(dlg,SeqTextFile) 
3117                SeqFile = open(SeqTextFile,'w')
3118                if csv:
3119                    WriteCSV()
3120                else:
3121                    WriteSeq()
3122                SeqFile.close()
3123        finally:
3124            dlg.Destroy()
3125               
3126    def striphist(var,insChar=''):
3127        'strip a histogram number from a var name'
3128        sv = var.split(':')
3129        if len(sv) <= 1: return var
3130        if sv[1]:
3131            sv[1] = insChar
3132        return ':'.join(sv)
3133       
3134    def plotSpCharFix(lbl):
3135        'Change selected unicode characters to their matplotlib equivalent'
3136        for u,p in [
3137            (u'\u03B1',r'$\alpha$'),
3138            (u'\u03B2',r'$\beta$'),
3139            (u'\u03B3',r'$\gamma$'),
3140            (u'\u0394\u03C7',r'$\Delta\chi$'),
3141            ]:
3142            lbl = lbl.replace(u,p)
3143        return lbl
3144   
3145    def SelectXaxis():
3146        'returns a selected column number (or None) as the X-axis selection'
3147        ncols = G2frame.SeqTable.GetNumberCols()
3148        colNames = [G2frame.SeqTable.GetColLabelValue(r) for r in range(ncols)]
3149        dlg = G2G.G2SingleChoiceDialog(
3150            G2frame.dataDisplay,
3151            'Select x-axis parameter for plot or Cancel for sequence number',
3152            'Select X-axis',
3153            colNames)
3154        try:
3155            if dlg.ShowModal() == wx.ID_OK:
3156                col = dlg.GetSelection()
3157            else:
3158                col = None
3159        finally:
3160            dlg.Destroy()
3161        return col
3162   
3163    def EnablePseudoVarMenus():
3164        'Enables or disables the PseudoVar menu items that require existing defs'
3165        if Controls['SeqPseudoVars']:
3166            val = True
3167        else:
3168            val = False
3169        G2frame.dataFrame.SequentialPvars.Enable(wxDELSEQVAR,val)
3170        G2frame.dataFrame.SequentialPvars.Enable(wxEDITSEQVAR,val)
3171
3172    def DelPseudoVar(event):
3173        'Ask the user to select a pseudo var expression to delete'
3174        choices = Controls['SeqPseudoVars'].keys()
3175        selected = G2G.ItemSelector(
3176            choices,G2frame.dataFrame,
3177            multiple=True,
3178            title='Select expressions to remove',
3179            header='Delete expression')
3180        if selected is None: return
3181        for item in selected:
3182            del Controls['SeqPseudoVars'][choices[item]]
3183        if selected:
3184            UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3185
3186    def EditPseudoVar(event):
3187        'Edit an existing pseudo var expression'
3188        choices = Controls['SeqPseudoVars'].keys()
3189        if len(choices) == 1:
3190            selected = 0
3191        else:
3192            selected = G2G.ItemSelector(
3193                choices,G2frame.dataFrame,
3194                multiple=False,
3195                title='Select an expression to edit',
3196                header='Edit expression')
3197        if selected is not None:
3198            dlg = G2exG.ExpressionDialog(
3199                G2frame.dataDisplay,PSvarDict,
3200                Controls['SeqPseudoVars'][choices[selected]],
3201                header="Edit the PseudoVar expression",
3202                VarLabel="PseudoVar #"+str(selected+1),
3203                fit=False)
3204            newobj = dlg.Show(True)
3205            if newobj:
3206                calcobj = G2obj.ExpressionCalcObj(newobj)
3207                del Controls['SeqPseudoVars'][choices[selected]]
3208                Controls['SeqPseudoVars'][calcobj.eObj.expression] = newobj
3209                UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3210       
3211    def AddNewPseudoVar(event):
3212        'Create a new pseudo var expression'
3213        dlg = G2exG.ExpressionDialog(
3214            G2frame.dataDisplay,PSvarDict,
3215            header='Enter an expression for a PseudoVar here',
3216            VarLabel = "New PseudoVar",
3217            fit=False)
3218        obj = dlg.Show(True)
3219        dlg.Destroy()
3220        if obj:
3221            calcobj = G2obj.ExpressionCalcObj(obj)
3222            Controls['SeqPseudoVars'][calcobj.eObj.expression] = obj
3223            UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3224           
3225    def AddNewDistPseudoVar(event):
3226        obj = None
3227        dlg = G2exG.BondDialog(
3228            G2frame.dataDisplay,Phases,PSvarDict,
3229            header='Select a Bond here',
3230            VarLabel = "New Bond")
3231        if dlg.ShowModal() == wx.ID_OK:
3232            pName,Oatom,Tatom = dlg.GetSelection()
3233            if Tatom:
3234                Phase = Phases[pName]
3235                General = Phase['General']
3236                cx,ct = General['AtomPtrs'][:2]
3237                pId = Phase['pId']
3238                SGData = General['SGData']
3239                sB = Tatom.find('(')+1
3240                symNo = 0
3241                if sB:
3242                    sF = Tatom.find(')')
3243                    symNo = int(Tatom[sB:sF])
3244                cellNo = [0,0,0]
3245                cB = Tatom.find('[')
3246                if cB>0:
3247                    cF = Tatom.find(']')+1
3248                    cellNo = eval(Tatom[cB:cF])
3249                Atoms = Phase['Atoms']
3250                aNames = [atom[ct-1] for atom in Atoms]
3251                oId = aNames.index(Oatom)
3252                tId = aNames.index(Tatom.split(' +')[0])
3253                # create an expression object
3254                obj = G2obj.ExpressionObj()
3255                obj.expression = 'Dist(%s,\n%s)'%(Oatom,Tatom.split(' d=')[0].replace(' ',''))
3256                obj.distance_dict = {'pId':pId,'SGData':SGData,'symNo':symNo,'cellNo':cellNo}
3257                obj.distance_atoms = [oId,tId]
3258        else: 
3259            dlg.Destroy()
3260            return
3261        dlg.Destroy()
3262        if obj:
3263            Controls['SeqPseudoVars'][obj.expression] = obj
3264            UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3265
3266    def AddNewAnglePseudoVar(event):
3267        obj = None
3268        dlg = G2exG.AngleDialog(
3269            G2frame.dataDisplay,Phases,PSvarDict,
3270            header='Enter an Angle here',
3271            VarLabel = "New Angle")
3272        if dlg.ShowModal() == wx.ID_OK:
3273            pName,Oatom,Tatoms = dlg.GetSelection()
3274            if Tatoms:
3275                Phase = Phases[pName]
3276                General = Phase['General']
3277                cx,ct = General['AtomPtrs'][:2]
3278                pId = Phase['pId']
3279                SGData = General['SGData']
3280                Atoms = Phase['Atoms']
3281                aNames = [atom[ct-1] for atom in Atoms]
3282                tIds = []
3283                symNos = []
3284                cellNos = []
3285                oId = aNames.index(Oatom)
3286                Tatoms = Tatoms.split(';')
3287                for Tatom in Tatoms:
3288                    sB = Tatom.find('(')+1
3289                    symNo = 0
3290                    if sB:
3291                        sF = Tatom.find(')')
3292                        symNo = int(Tatom[sB:sF])
3293                    symNos.append(symNo)
3294                    cellNo = [0,0,0]
3295                    cB = Tatom.find('[')
3296                    if cB>0:
3297                        cF = Tatom.find(']')+1
3298                        cellNo = eval(Tatom[cB:cF])
3299                    cellNos.append(cellNo)
3300                    tIds.append(aNames.index(Tatom.split('+')[0]))
3301                # create an expression object
3302                obj = G2obj.ExpressionObj()
3303                obj.expression = 'Angle(%s,%s,\n%s)'%(Tatoms[0],Oatom,Tatoms[1])
3304                obj.angle_dict = {'pId':pId,'SGData':SGData,'symNo':symNos,'cellNo':cellNos}
3305                obj.angle_atoms = [oId,tIds]
3306        else: 
3307            dlg.Destroy()
3308            return
3309        dlg.Destroy()
3310        if obj:
3311            Controls['SeqPseudoVars'][obj.expression] = obj
3312            UpdateSeqResults(G2frame,data,G2frame.dataDisplay.GetSize()) # redisplay variables
3313           
3314    def UpdateParmDict(parmDict):
3315        '''generate the atom positions and the direct & reciprocal cell values,
3316        because they might be needed to evaluate the pseudovar
3317        '''
3318        Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
3319                         ['A'+str(i) for i in range(6)])
3320                     )
3321        delList = []
3322        phaselist = []
3323        for item in parmDict: 
3324            if ':' not in item: continue
3325            key = item.split(':')
3326            if len(key) < 3: continue
3327            # remove the dA[xyz] terms, they would only bring confusion
3328            if key[2].startswith('dA'):
3329                delList.append(item)
3330            # compute and update the corrected reciprocal cell terms using the Dij values
3331            elif key[2] in Ddict:
3332                if key[0] not in phaselist: phaselist.append(key[0])
3333                akey = key[0]+'::'+Ddict[key[2]]
3334                parmDict[akey] -= parmDict[item]
3335                delList.append(item)
3336        for item in delList:
3337            del parmDict[item]               
3338        for i in phaselist:
3339            pId = int(i)
3340            # apply cell symmetry
3341            A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],parmDict,zeroDict[pId])
3342            # convert to direct cell & add the unique terms to the dictionary
3343            for i,val in enumerate(G2lat.A2cell(A)):
3344                if i in uniqCellIndx[pId]:
3345                    lbl = str(pId)+'::'+cellUlbl[i]
3346                    parmDict[lbl] = val
3347            lbl = str(pId)+'::'+'Vol'
3348            parmDict[lbl] = G2lat.calc_V(A)
3349        return parmDict
3350
3351    def EvalPSvarDeriv(calcobj,parmDict,sampleDict,var,ESD):
3352        '''Evaluate an expression derivative with respect to a
3353        GSAS-II variable name.
3354
3355        Note this likely could be faster if the loop over calcobjs were done
3356        inside after the Dict was created.
3357        '''
3358        step = ESD/10
3359        Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],
3360                         ['A'+str(i) for i in range(6)])
3361                     )
3362        results = []
3363        phaselist = []
3364        VparmDict = sampleDict.copy()
3365        for incr in step,-step:
3366            VparmDict.update(parmDict.copy())           
3367            # as saved, the parmDict has updated 'A[xyz]' values, but 'dA[xyz]'
3368            # values are not zeroed: fix that!
3369            VparmDict.update({item:0.0 for item in parmDict if 'dA' in item})
3370            VparmDict[var] += incr
3371            G2mv.Dict2Map(VparmDict,[]) # apply constraints
3372            # generate the atom positions and the direct & reciprocal cell values now, because they might
3373            # needed to evaluate the pseudovar
3374            for item in VparmDict:
3375                if item in sampleDict:
3376                    continue 
3377                if ':' not in item: continue
3378                key = item.split(':')
3379                if len(key) < 3: continue
3380                # apply any new shifts to atom positions
3381                if key[2].startswith('dA'):
3382                    VparmDict[''.join(item.split('d'))] += VparmDict[item]
3383                    VparmDict[item] = 0.0
3384                # compute and update the corrected reciprocal cell terms using the Dij values
3385                if key[2] in Ddict:
3386                    if key[0] not in phaselist: phaselist.append(key[0])
3387                    akey = key[0]+'::'+Ddict[key[2]]
3388                    VparmDict[akey] -= VparmDict[item]
3389            for i in phaselist:
3390                pId = int(i)
3391                # apply cell symmetry
3392                A,zeros = G2stIO.cellFill(str(pId)+'::',SGdata[pId],VparmDict,zeroDict[pId])
3393                # convert to direct cell & add the unique terms to the dictionary
3394                for i,val in enumerate(G2lat.A2cell(A)):
3395                    if i in uniqCellIndx[pId]:
3396                        lbl = str(pId)+'::'+cellUlbl[i]
3397                        VparmDict[lbl] = val
3398                lbl = str(pId)+'::'+'Vol'
3399                VparmDict[lbl] = G2lat.calc_V(A)
3400            # dict should be fully updated, use it & calculate
3401            calcobj.SetupCalc(VparmDict)
3402            results.append(calcobj.EvalExpression())
3403        return (results[0] - results[1]) / (2.*step)
3404       
3405    def EnableParFitEqMenus():
3406        'Enables or disables the Parametric Fit menu items that require existing defs'
3407        if Controls['SeqParFitEqList']:
3408            val = True
3409        else:
3410            val = False
3411        G2frame.dataFrame.SequentialPfit.Enable(wxDELPARFIT,val)
3412        G2frame.dataFrame.SequentialPfit.Enable(wxEDITPARFIT,val)
3413        G2frame.dataFrame.SequentialPfit.Enable(wxDOPARFIT,val)
3414
3415    def ParEqEval(Values,calcObjList,varyList):
3416        '''Evaluate the parametric expression(s)
3417        :param list Values: a list of values for each variable parameter
3418        :param list calcObjList: a list of :class:`GSASIIobj.ExpressionCalcObj`
3419          expression objects to evaluate
3420        :param list varyList: a list of variable names for each value in Values
3421        '''
3422        result = []
3423        for calcobj in calcObjList:
3424            calcobj.UpdateVars(varyList,Values)
3425            result.append((calcobj.depVal-calcobj.EvalExpression())/calcobj.depSig)
3426        return result
3427
3428    def DoParEqFit(event,eqObj=None):
3429        'Parametric fit minimizer'
3430        varyValueDict = {} # dict of variables and their initial values
3431        calcObjList = [] # expression objects, ready to go for each data point
3432        if eqObj is not None:
3433            eqObjList = [eqObj,]
3434        else:
3435            eqObjList = Controls['SeqParFitEqList']
3436        UseFlags = G2frame.SeqTable.GetColValues(0)         
3437        for obj in eqObjList:
3438            # assemble refined vars for this equation
3439            varyValueDict.update({var:val for var,val in obj.GetVariedVarVal()})
3440            # lookup dependent var position
3441            depVar = obj.GetDepVar()
3442            if depVar in colLabels:
3443                indx = colLabels.index(depVar)
3444            else:
3445                raise Exception('Dependent variable '+depVar+' not found')
3446            # assemble a list of the independent variables
3447            indepVars = obj.GetIndependentVars()
3448            # loop over each datapoint
3449            for j,row in enumerate(zip(*colList)):
3450                if not UseFlags[j]: continue
3451                # assemble equations to fit
3452                calcobj = G2obj.ExpressionCalcObj(obj)
3453                # prepare a dict of needed independent vars for this expression
3454                indepVarDict = {var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
3455                calcobj.SetupCalc(indepVarDict)               
3456                # values and sigs for current value of dependent var
3457                calcobj.depVal = row[indx]
3458                calcobj.depSig = colSigs[indx][j]
3459                calcObjList.append(calcobj)
3460        # varied parameters
3461        varyList = varyValueDict.keys()
3462        values = varyValues = [varyValueDict[key] for key in varyList]
3463        if not varyList:
3464            print 'no variables to refine!'
3465            return
3466        try:
3467            result = so.leastsq(ParEqEval,varyValues,full_output=True,   #ftol=Ftol,
3468                                args=(calcObjList,varyList)
3469                                )
3470            values = result[0]
3471            covar = result[1]
3472            if covar is None:
3473                raise Exception
3474            esdDict = {}
3475            for i,avar in enumerate(varyList):
3476                esdDict[avar] = np.sqrt(covar[i,i])
3477        except:
3478            print('====> Fit failed')
3479            return
3480        print('==== Fit Results ====')
3481        for obj in eqObjList:
3482            obj.UpdateVariedVars(varyList,values)
3483            ind = '      '
3484            print('  '+obj.GetDepVar()+' = '+obj.expression)
3485            for var in obj.assgnVars:
3486                print(ind+var+' = '+obj.assgnVars[var])
3487            for var in obj.freeVars:
3488                avar = "::"+obj.freeVars[var][0]
3489                val = obj.freeVars[var][1]
3490                if obj.freeVars[var][2]:
3491                    print(ind+var+' = '+avar + " = " + G2mth.ValEsd(val,esdDict[avar]))
3492                else:
3493                    print(ind+var+' = '+avar + " =" + G2mth.ValEsd(val,0))
3494        # create a plot for each parametric variable
3495        for fitnum,obj in enumerate(eqObjList):
3496            calcobj = G2obj.ExpressionCalcObj(obj)
3497            # lookup dependent var position
3498            indx = colLabels.index(obj.GetDepVar())
3499            # assemble a list of the independent variables
3500            indepVars = obj.GetIndependentVars()           
3501            # loop over each datapoint
3502            fitvals = []
3503            for j,row in enumerate(zip(*colList)):
3504                calcobj.SetupCalc(
3505                    {var:row[i] for i,var in enumerate(colLabels) if var in indepVars}
3506                    )
3507                fitvals.append(calcobj.EvalExpression())
3508            G2plt.PlotSelectedSequence(
3509                G2frame,[indx],GetColumnInfo,SelectXaxis,
3510                fitnum,fitvals)
3511
3512    def SingleParEqFit(eqObj):
3513        DoParEqFit(None,eqObj)
3514
3515    def DelParFitEq(event):
3516        'Ask the user to select function to delete'
3517        txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3518        selected = G2G.ItemSelector(
3519            txtlst,G2frame.dataFrame,
3520            multiple=True,
3521            title='Select a parametric equation(s) to remove',
3522            header='Delete equation')
3523        if selected is None: return
3524        Controls['SeqParFitEqList'] = [obj for i,obj in enumerate(Controls['SeqParFitEqList']) if i not in selected]
3525        EnableParFitEqMenus()
3526        if Controls['SeqParFitEqList']: DoParEqFit(event)
3527       
3528    def EditParFitEq(event):
3529        'Edit an existing parametric equation'
3530        txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3531        if len(txtlst) == 1:
3532            selected = 0
3533        else:
3534            selected = G2G.ItemSelector(
3535                txtlst,G2frame.dataFrame,
3536                multiple=False,
3537                title='Select a parametric equation to edit',
3538                header='Edit equation')
3539        if selected is not None:
3540            dlg = G2exG.ExpressionDialog(
3541                G2frame.dataDisplay,indepVarDict,
3542                Controls['SeqParFitEqList'][selected],
3543                depVarDict=depVarDict,
3544                header="Edit the formula for this minimization function",
3545                ExtraButton=['Fit',SingleParEqFit])
3546            newobj = dlg.Show(True)
3547            if newobj:
3548                Controls['SeqParFitEqList'][selected] = newobj
3549                EnableParFitEqMenus()
3550            if Controls['SeqParFitEqList']: DoParEqFit(event)
3551
3552    def AddNewParFitEq(event):
3553        'Create a new parametric equation to be fit to sequential results'
3554
3555        # compile the variable names used in previous freevars to avoid accidental name collisions
3556        usedvarlist = []
3557        for obj in Controls['SeqParFitEqList']:
3558            for var in obj.freeVars:
3559                if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3560
3561        dlg = G2exG.ExpressionDialog(
3562            G2frame.dataDisplay,indepVarDict,
3563            depVarDict=depVarDict,
3564            header='Define an equation to minimize in the parametric fit',
3565            ExtraButton=['Fit',SingleParEqFit],
3566            usedVars=usedvarlist)
3567        obj = dlg.Show(True)
3568        dlg.Destroy()
3569        if obj:
3570            Controls['SeqParFitEqList'].append(obj)
3571            EnableParFitEqMenus()
3572            if Controls['SeqParFitEqList']: DoParEqFit(event)
3573               
3574    def CopyParFitEq(event):
3575        'Copy an existing parametric equation to be fit to sequential results'
3576        # compile the variable names used in previous freevars to avoid accidental name collisions
3577        usedvarlist = []
3578        for obj in Controls['SeqParFitEqList']:
3579            for var in obj.freeVars:
3580                if obj.freeVars[var][0] not in usedvarlist: usedvarlist.append(obj.freeVars[var][0])
3581        txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
3582        if len(txtlst) == 1:
3583            selected = 0
3584        else:
3585            selected = G2G.ItemSelector(
3586                txtlst,G2frame.dataFrame,
3587                multiple=False,
3588                title='Select a parametric equation to copy',
3589                header='Copy equation')
3590        if selected is not None:
3591            newEqn = copy.deepcopy(Controls['SeqParFitEqList'][selected])
3592            for var in newEqn.freeVars:
3593                newEqn.freeVars[var][0] = G2obj.MakeUniqueLabel(newEqn.freeVars[var][0],usedvarlist)
3594            dlg = G2exG.ExpressionDialog(
3595                G2frame.dataDisplay,indepVarDict,
3596                newEqn,
3597                depVarDict=depVarDict,
3598                header="Edit the formula for this minimization function",
3599                ExtraButton=['Fit',SingleParEqFit])
3600            newobj = dlg.Show(True)
3601            if newobj:
3602                Controls['SeqParFitEqList'].append(newobj)
3603                EnableParFitEqMenus()
3604            if Controls['SeqParFitEqList']: DoParEqFit(event)
3605                                           
3606    def GridSetToolTip(row,col):
3607        '''Routine to show standard uncertainties for each element in table
3608        as a tooltip
3609        '''
3610        if colSigs[col]:
3611            return u'\u03c3 = '+str(colSigs[col][row])
3612        return ''
3613       
3614    def GridColLblToolTip(col):
3615        '''Define a tooltip for a column. This will be the user-entered value
3616        (from data['variableLabels']) or the default name
3617        '''
3618        if col < 0 or col > len(colLabels):
3619            print 'Illegal column #',col
3620            return
3621        var = colLabels[col]
3622        return variableLabels.get(var,G2obj.fmtVarDescr(var))
3623       
3624    def SetLabelString(event):
3625        '''Define or edit the label for a column in the table, to be used
3626        as a tooltip and for plotting
3627        '''
3628        col = event.GetCol()
3629        if col < 0 or col > len(colLabels):
3630            return
3631        var = colLabels[col]
3632        lbl = variableLabels.get(var,G2obj.fmtVarDescr(var))
3633        dlg = G2G.SingleStringDialog(G2frame.dataFrame,'Set variable label',
3634                                 'Set a new name for variable '+var,lbl,size=(400,-1))
3635        if dlg.Show():
3636            variableLabels[var] = dlg.GetValue()
3637        dlg.Destroy()
3638
3639    def DoSequentialExport(event):
3640        '''Event handler for all Sequential Export menu items
3641        '''
3642        vals = G2frame.dataFrame.SeqExportLookup.get(event.GetId())
3643        if vals is None:
3644            print('Error: Id not found. This should not happen!')
3645        G2IO.ExportSequential(G2frame,data,*vals)
3646   
3647    #def GridRowLblToolTip(row): return 'Row ='+str(row)
3648   
3649    # lookup table for unique cell parameters by symmetry
3650    cellGUIlist = [
3651        [['m3','m3m'],(0,)],
3652        [['3R','3mR'],(0,3)],
3653        [['3','3m1','31m','6/m','6/mmm','4/m','4/mmm'],(0,2)],
3654        [['mmm'],(0,1,2)],
3655        [['2/m'+'a'],(0,1,2,3)],
3656        [['2/m'+'b'],(0,1,2,4)],
3657        [['2/m'+'c'],(0,1,2,5)],
3658        [['-1'],(0,1,2,3,4,5)],
3659        ]
3660    # cell labels
3661    cellUlbl = ('a','b','c',u'\u03B1',u'\u03B2',u'\u03B3') # unicode a,b,c,alpha,beta,gamma
3662
3663    #======================================================================
3664    # start processing sequential results here (UpdateSeqResults)
3665    #======================================================================
3666    if not data:
3667        print 'No sequential refinement results'
3668        return
3669    variableLabels = data.get('variableLabels',{})
3670    data['variableLabels'] = variableLabels
3671    Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
3672    Controls = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
3673    # create a place to store Pseudo Vars & Parametric Fit functions, if not present
3674    if 'SeqPseudoVars' not in Controls: Controls['SeqPseudoVars'] = {}
3675    if 'SeqParFitEqList' not in Controls: Controls['SeqParFitEqList'] = []
3676    histNames = data['histNames']
3677    if G2frame.dataDisplay:
3678        G2frame.dataDisplay.Destroy()
3679    if not G2frame.dataFrame.GetStatusBar():
3680        Status = G2frame.dataFrame.CreateStatusBar()
3681        Status.SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
3682    sampleParms = GetSampleParms()
3683
3684    # make dict of varied atom coords keyed by absolute position
3685    newAtomDict = data[histNames[0]].get('newAtomDict',{}) # dict with atom positions; relative & absolute
3686    # Possible error: the next might need to be data[histNames[0]]['varyList']
3687    # error will arise if there constraints on coordinates?
3688    atomLookup = {newAtomDict[item][0]:item for item in newAtomDict if item in data['varyList']}
3689   
3690    # make dict of varied cell parameters equivalents
3691    ESDlookup = {} # provides the Dij term for each Ak term (where terms are refined)
3692    Dlookup = {} # provides the Ak term for each Dij term (where terms are refined)
3693    # N.B. These Dij vars are missing a histogram #
3694    newCellDict = data[histNames[0]].get('newCellDict',{})
3695    for item in newCellDict:
3696        if item in data['varyList']:
3697            ESDlookup[newCellDict[item][0]] = item
3698            Dlookup[item] = newCellDict[item][0]
3699    # add coordinate equivalents to lookup table
3700    for parm in atomLookup:
3701        Dlookup[atomLookup[parm]] = parm
3702        ESDlookup[parm] = atomLookup[parm]
3703
3704    # get unit cell & symmetry for all phases & initial stuff for later use
3705    RecpCellTerms = {}
3706    SGdata = {}
3707    uniqCellIndx = {}
3708    initialCell = {}
3709    RcellLbls = {}
3710    zeroDict = {}
3711    for phase in Phases:
3712        phasedict = Phases[phase]
3713        pId = phasedict['pId']
3714        pfx = str(pId)+'::' # prefix for A values from phase
3715        RcellLbls[pId] = [pfx+'A'+str(i) for i in range(6)]
3716        RecpCellTerms[pId] = G2lat.cell2A(phasedict['General']['Cell'][1:7])
3717        zeroDict[pId] = dict(zip(RcellLbls[pId],6*[0.,]))
3718        SGdata[pId] = phasedict['General']['SGData']
3719        laue = SGdata[pId]['SGLaue']
3720        if laue == '2/m':
3721            laue += SGdata[pId]['SGUniq']
3722        for symlist,celllist in cellGUIlist:
3723            if laue in symlist:
3724                uniqCellIndx[pId] = celllist
3725                break
3726        else: # should not happen
3727            uniqCellIndx[pId] = range(6)
3728        for i in uniqCellIndx[pId]:
3729            initialCell[str(pId)+'::A'+str(i)] =  RecpCellTerms[pId][i]
3730
3731    SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
3732    G2frame.dataFrame.SetLabel('Sequential refinement results')
3733    if not G2frame.dataFrame.GetStatusBar():
3734        Status = G2frame.dataFrame.CreateStatusBar()
3735        Status.SetStatusText('')
3736    G2frame.dataFrame.Bind(wx.EVT_MENU, OnRenameSelSeq, id=wxID_RENAMESEQSEL)
3737    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
3738    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeqCSV, id=wxID_SAVESEQSELCSV)
3739    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSeqCSV, id=wxID_SAVESEQCSV)
3740    G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotSelSeq, id=wxID_PLOTSEQSEL)
3741    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAveSelSeq, id=wxID_AVESEQSEL)
3742    G2frame.dataFrame.Bind(wx.EVT_MENU, OnReOrgSelSeq, id=wxID_ORGSEQSEL)
3743    G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewPseudoVar, id=wxADDSEQVAR)
3744    G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewDistPseudoVar, id=wxADDSEQDIST)
3745    G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewAnglePseudoVar, id=wxADDSEQANGLE)
3746    G2frame.dataFrame.Bind(wx.EVT_MENU, DelPseudoVar, id=wxDELSEQVAR)
3747    G2frame.dataFrame.Bind(wx.EVT_MENU, EditPseudoVar, id=wxEDITSEQVAR)
3748    G2frame.dataFrame.Bind(wx.EVT_MENU, AddNewParFitEq, id=wxADDPARFIT)
3749    G2frame.dataFrame.Bind(wx.EVT_MENU, CopyParFitEq, id=wxCOPYPARFIT)
3750    G2frame.dataFrame.Bind(wx.EVT_MENU, DelParFitEq, id=wxDELPARFIT)
3751    G2frame.dataFrame.Bind(wx.EVT_MENU, EditParFitEq, id=wxEDITPARFIT)
3752    G2frame.dataFrame.Bind(wx.EVT_MENU, DoParEqFit, id=wxDOPARFIT)
3753
3754    for id in G2frame.dataFrame.SeqExportLookup:       
3755        G2frame.dataFrame.Bind(wx.EVT_MENU, DoSequentialExport, id=id)
3756
3757    EnablePseudoVarMenus()
3758    EnableParFitEqMenus()
3759
3760    # scan for locations where the variables change
3761    VaryListChanges = [] # histograms where there is a change
3762    combinedVaryList = []
3763    firstValueDict = {}
3764    vallookup = {}
3765    posdict = {}
3766    prevVaryList = []
3767    foundNames = []
3768    for i,name in enumerate(histNames):
3769        if name not in data:
3770            print("Error: "+name+" not found!")
3771            continue
3772        foundNames.append(name)
3773        for var,val,sig in zip(data[name]['varyList'],data[name]['variables'],data[name]['sig']):
3774            svar = striphist(var,'*') # wild-carded
3775            if svar not in combinedVaryList:
3776                # add variables to list as they appear
3777                combinedVaryList.append(svar)
3778                firstValueDict[svar] = (val,sig)
3779        if prevVaryList != data[name]['varyList']: # this refinement has a different refinement list from previous
3780            prevVaryList = data[name]['varyList']
3781            vallookup[name] = dict(zip(data[name]['varyList'],data[name]['variables']))
3782            posdict[name] = {}
3783            for var in data[name]['varyList']:
3784                svar = striphist(var,'*')
3785                posdict[name][combinedVaryList.index(svar)] = svar
3786            VaryListChanges.append(name)
3787    if len(VaryListChanges) > 1:
3788        G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,True)
3789    else:
3790        G2frame.dataFrame.SequentialFile.Enable(wxID_ORGSEQSEL,False)
3791    #-----------------------------------------------------------------------------------
3792    # build up the data table by columns -----------------------------------------------
3793    histNames = foundNames
3794    nRows = len(histNames)
3795    colList = [nRows*[True]]
3796    colSigs = [None]
3797    colLabels = ['Use']
3798    Types = [wg.GRID_VALUE_BOOL]
3799    # start with Rwp values
3800    if 'IMG ' not in histNames[0][:4]:
3801        colList += [[data[name]['Rvals']['Rwp'] for name in histNames]]
3802        colSigs += [None]
3803        colLabels += ['Rwp']
3804        Types += [wg.GRID_VALUE_FLOAT+':10,3',]
3805    # add % change in Chi^2 in last cycle
3806    if histNames[0][:4] not in ['SASD','IMG '] and Controls.get('ShowCell'):
3807        colList += [[100.*data[name]['Rvals'].get('DelChi2',-1) for name in histNames]]
3808        colSigs += [None]
3809        colLabels += [u'\u0394\u03C7\u00B2 (%)']
3810        Types += [wg.GRID_VALUE_FLOAT,]
3811    deltaChiCol = len(colLabels)-1
3812    # add changing sample parameters to table
3813    for key in sampleParms:
3814        colList += [sampleParms[key]]
3815        colSigs += [None]
3816        colLabels += [key]
3817        Types += [wg.GRID_VALUE_FLOAT,]
3818    sampleDict = {}
3819    for i,name in enumerate(histNames):
3820        sampleDict[name] = dict(zip(sampleParms.keys(),[sampleParms[key][i] for key in sampleParms.keys()])) 
3821    # add unique cell parameters TODO: review this where the cell symmetry changes (when possible)
3822    if Controls.get('ShowCell',False):
3823        for pId in sorted(RecpCellTerms):
3824            pfx = str(pId)+'::' # prefix for A values from phase
3825            cells = []
3826            cellESDs = []
3827            colLabels += [pfx+cellUlbl[i] for i in uniqCellIndx[pId]]
3828            colLabels += [pfx+'Vol']
3829            Types += (1+len(uniqCellIndx[pId]))*[wg.GRID_VALUE_FLOAT,]
3830            for name in histNames:
3831                covData = {
3832                    'varyList': [Dlookup.get(striphist(v),v) for v in data[name]['varyList']],
3833                    'covMatrix': data[name]['covMatrix']
3834                    }
3835                A = RecpCellTerms[pId][:] # make copy of starting A values
3836                # update with refined values
3837                for i in range(6):
3838                    var = str(pId)+'::A'+str(i)
3839                    if var in ESDlookup:
3840                        val = data[name]['newCellDict'][ESDlookup[var]][1] # get refined value
3841                        A[i] = val # override with updated value
3842                # apply symmetry
3843                Albls = [pfx+'A'+str(i) for i in range(6)]
3844                cellDict = dict(zip(Albls,A))
3845                A,zeros = G2stIO.cellFill(pfx,SGdata[pId],cellDict,zeroDict[pId])
3846                # convert to direct cell & add only unique values to table
3847                c = G2lat.A2cell(A)
3848                vol = G2lat.calc_V(A)
3849                cE = G2stIO.getCellEsd(pfx,SGdata[pId],A,covData)
3850                cells += [[c[i] for i in uniqCellIndx[pId]]+[vol]]
3851                cellESDs += [[cE[i] for i in uniqCellIndx[pId]]+[cE[-1]]]
3852            colList += zip(*cells)
3853            colSigs += zip(*cellESDs)
3854    # sort out the variables in their selected order
3855    varcols = 0
3856    for d in posdict.itervalues():
3857        varcols = max(varcols,max(d.keys())+1)
3858    # get labels for each column
3859    for i in range(varcols):
3860        lbl = ''
3861        for h in VaryListChanges:
3862            if posdict[h].get(i):
3863                if posdict[h].get(i) in lbl: continue
3864                if lbl != "": lbl += '/'
3865                lbl += posdict[h].get(i)
3866        colLabels.append(lbl)
3867    Types += varcols*[wg.GRID_VALUE_FLOAT]
3868    vals = []
3869    esds = []
3870    varsellist = None        # will be a list of variable names in the order they are selected to appear
3871    # tabulate values for each hist, leaving None for blank columns
3872    for name in histNames:
3873        if name in posdict:
3874            varsellist = [posdict[name].get(i) for i in range(varcols)]
3875            # translate variable names to how they will be used in the headings
3876            vs = [striphist(v,'*') for v in data[name]['varyList']]
3877            # determine the index for each column (or None) in the data[]['variables'] and ['sig'] lists
3878            sellist = [vs.index(v) if v is not None else None for v in varsellist]
3879            #sellist = [i if striphist(v,'*') in varsellist else None for i,v in enumerate(data[name]['varyList'])]
3880        if not varsellist: raise Exception()
3881        vals.append([data[name]['variables'][s] if s is not None else None for s in sellist])
3882        esds.append([data[name]['sig'][s] if s is not None else None for s in sellist])
3883        #GSASIIpath.IPyBreak()
3884    colList += zip(*vals)
3885    colSigs += zip(*esds)
3886    # compute and add weight fractions to table if varied
3887    for phase in Phases:
3888        var = str(Phases[phase]['pId'])+':*:Scale'
3889        if var not in combinedVaryList: continue
3890        wtFrList = []
3891        sigwtFrList = []
3892        for i,name in enumerate(histNames):
3893            wtFrSum = 0.
3894            for phase1 in Phases:
3895                wtFrSum += Phases[phase1]['Histograms'][name]['Scale'][0]*Phases[phase1]['General']['Mass']
3896            var = str(Phases[phase]['pId'])+':'+str(i)+':Scale'
3897            wtFr = Phases[phase]['Histograms'][name]['Scale'][0]*Phases[phase]['General']['Mass']/wtFrSum
3898            wtFrList.append(wtFr)
3899            if var in data[name]['varyList']:
3900                sig = data[name]['sig'][data[name]['varyList'].index(var)]*wtFr/Phases[phase]['Histograms'][name]['Scale'][0]
3901            else:
3902                sig = 0.0
3903            sigwtFrList.append(sig)
3904        colLabels.append(str(Phases[phase]['pId'])+':*:WgtFrac')
3905        colList += [wtFrList]
3906        colSigs += [sigwtFrList]
3907               
3908    # tabulate constrained variables, removing histogram numbers if needed
3909    # from parameter label
3910    depValDict = {}
3911    depSigDict = {}
3912    for name in histNames:
3913        for var in data[name].get('depParmDict',{}):
3914            val,sig = data[name]['depParmDict'][var]
3915            svar = striphist(var,'*')
3916            if svar not in depValDict:
3917               depValDict[svar] = [val]
3918               depSigDict[svar] = [sig]
3919            else:
3920               depValDict[svar].append(val)
3921               depSigDict[svar].append(sig)
3922    # add the dependent constrained variables to the table
3923    for var in sorted(depValDict):
3924        if len(depValDict[var]) != len(histNames): continue
3925        colLabels.append(var)
3926        Types += [wg.GRID_VALUE_FLOAT,]
3927        colSigs += [depSigDict[var]]
3928        colList += [depValDict[var]]
3929
3930    # add atom parameters to table
3931    colLabels += atomLookup.keys()
3932    Types += len(atomLookup)*[wg.GRID_VALUE_FLOAT]
3933    for parm in sorted(atomLookup):
3934        colList += [[data[name]['newAtomDict'][atomLookup[parm]][1] for name in histNames]]
3935        if atomLookup[parm] in data[histNames[0]]['varyList']:
3936            col = data[histNames[0]]['varyList'].index(atomLookup[parm])
3937            colSigs += [[data[name]['sig'][col] for name in histNames]]
3938        else:
3939            colSigs += [None] # should not happen
3940    # evaluate Pseudovars, their ESDs and add them to grid
3941    for expr in Controls['SeqPseudoVars']:
3942        obj = Controls['SeqPseudoVars'][expr]
3943        calcobj = G2obj.ExpressionCalcObj(obj)
3944        valList = []
3945        esdList = []
3946        for seqnum,name in enumerate(histNames):
3947            sigs = data[name]['sig']
3948            G2mv.InitVars()
3949            parmDict = data[name].get('parmDict')
3950            constraintInfo = data[name].get('constraintInfo',[[],[],{},[],seqnum])
3951            groups,parmlist,constrDict,fixedList,ihst = constraintInfo
3952            varyList = data[name]['varyList']
3953            parmDict = data[name]['parmDict']
3954            G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList,parmDict,SeqHist=ihst)
3955            if 'Dist' in expr:
3956                derivs = G2mth.CalcDistDeriv(obj.distance_dict,obj.distance_atoms, parmDict)
3957                pId = obj.distance_dict['pId']
3958                aId,bId = obj.distance_atoms
3959                varyNames = ['%d::dA%s:%d'%(pId,ip,aId) for ip in ['x','y','z']]
3960                varyNames += ['%d::dA%s:%d'%(pId,ip,bId) for ip in ['x','y','z']]
3961                VCoV = G2mth.getVCov(varyNames,varyList,data[name]['covMatrix'])
3962                esdList.append(np.sqrt(np.inner(derivs,np.inner(VCoV,derivs.T)) ))
3963#                GSASIIpath.IPyBreak()
3964            elif 'Angle' in expr:
3965                derivs = G2mth.CalcAngleDeriv(obj.angle_dict,obj.angle_atoms, parmDict)
3966                pId = obj.angle_dict['pId']
3967                aId,bId = obj.angle_atoms
3968                varyNames = ['%d::dA%s:%d'%(pId,ip,aId) for ip in ['x','y','z']]
3969                varyNames += ['%d::dA%s:%d'%(pId,ip,bId[0]) for ip in ['x','y','z']]
3970                varyNames += ['%d::dA%s:%d'%(pId,ip,bId[1]) for ip in ['x','y','z']]
3971                VCoV = G2mth.getVCov(varyNames,varyList,data[name]['covMatrix'])
3972                esdList.append(np.sqrt(np.inner(derivs,np.inner(VCoV,derivs.T)) ))
3973            else:
3974                derivs = np.array(
3975                    [EvalPSvarDeriv(calcobj,parmDict.copy(),sampleDict[name],var,ESD)
3976                     for var,ESD in zip(varyList,sigs)])
3977                esdList.append(np.sqrt(
3978                    np.inner(derivs,np.inner(data[name]['covMatrix'],derivs.T)) ))
3979            PSvarDict = parmDict.copy()
3980            PSvarDict.update(sampleDict[name])
3981            UpdateParmDict(PSvarDict)
3982            calcobj.UpdateDict(PSvarDict)
3983            valList.append(calcobj.EvalExpression())
3984#            if calcobj.su is not None: esdList[-1] = calcobj.su
3985        if not esdList:
3986            esdList = None
3987        colList += [valList]
3988        colSigs += [esdList]
3989        colLabels += [expr]
3990        Types += [wg.GRID_VALUE_FLOAT,]
3991    #---- table build done -------------------------------------------------------------
3992
3993    # Make dict needed for creating & editing pseudovars (PSvarDict).
3994    name = histNames[0]
3995    parmDict = data[name].get('parmDict',{})
3996    PSvarDict = parmDict.copy()
3997    PSvarDict.update(sampleParms)
3998    UpdateParmDict(PSvarDict)
3999    # Also dicts of dependent (depVarDict) & independent vars (indepVarDict)
4000    # for Parametric fitting from the data table
4001    parmDict = dict(zip(colLabels,zip(*colList)[0])) # scratch dict w/all values in table
4002    parmDict.update(
4003        {var:val for var,val in data[name].get('newCellDict',{}).values()} #  add varied reciprocal cell terms
4004    )
4005    name = histNames[0]
4006
4007    #******************************************************************************
4008    # create a set of values for example evaluation of pseudovars and
4009    # this does not work for refinements that have differing numbers of variables.
4010    #raise Exception
4011    indepVarDict = {}     #  values in table w/o ESDs
4012    depVarDict = {}
4013    for i,var in enumerate(colLabels):
4014        if var == 'Use': continue
4015        if colList[i][0] is None:
4016            val,sig = firstValueDict.get(var,[None,None])
4017        elif colSigs[i]:
4018            val,sig = colList[i][0],colSigs[i][0]
4019        else:
4020            val,sig = colList[i][0],None
4021        if val is None:
4022            continue
4023        elif sig is None:
4024            indepVarDict[var] = val
4025        elif striphist(var) not in Dlookup:
4026            depVarDict[var] = val
4027    # add recip cell coeff. values
4028    depVarDict.update({var:val for var,val in data[name].get('newCellDict',{}).values()})
4029
4030    G2frame.dataFrame.currentGrids = []
4031    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
4032    G2frame.SeqTable = G2G.Table(
4033        [list(cl) for cl in zip(*colList)],     # convert from columns to rows
4034        colLabels=colLabels,rowLabels=histNames,types=Types)
4035    G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
4036    #G2frame.dataDisplay.EnableEditing(False)
4037    # make all but first column read-only
4038    for c in range(1,len(colLabels)):
4039        for r in range(nRows):
4040            G2frame.dataDisplay.SetCellReadOnly(r,c)
4041    G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, PlotSelect)
4042    G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_RIGHT_CLICK, SetLabelString)
4043    G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0]))       #pretty arbitrary 8
4044    G2frame.dataDisplay.SetMargins(0,0)
4045    G2frame.dataDisplay.AutoSizeColumns(True)
4046    if prevSize:
4047        G2frame.dataFrame.setSizePosLeft(prevSize)
4048    else:
4049        G2frame.dataFrame.setSizePosLeft([700,350])
4050    # highlight unconverged shifts
4051    if histNames[0][:4] not in ['SASD','IMG ']:
4052        for row,name in enumerate(histNames):
4053            deltaChi = G2frame.SeqTable.GetValue(row,deltaChiCol)
4054            if deltaChi > 10.:
4055                G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,0,0))
4056            elif deltaChi > 1.0:
4057                G2frame.dataDisplay.SetCellStyle(row,deltaChiCol,color=wx.Colour(255,255,0))
4058    G2frame.dataDisplay.InstallGridToolTip(GridSetToolTip,GridColLblToolTip)
4059    G2frame.dataDisplay.SendSizeEvent() # resize needed on mac
4060    G2frame.dataDisplay.Refresh() # shows colored text on mac
4061   
4062################################################################################
4063#####  Main PWDR panel
4064################################################################################           
4065       
4066def UpdatePWHKPlot(G2frame,kind,item):
4067    '''Called when the histogram main tree entry is called. Displays the
4068    histogram weight factor, refinement statistics for the histogram
4069    and the range of data for a simulation.
4070
4071    Also invokes a plot of the histogram.
4072    '''
4073    def onEditSimRange(event):
4074        'Edit simulation range'
4075        inp = [
4076            min(data[1][0]),
4077            max(data[1][0]),
4078            None
4079            ]
4080        inp[2] = (inp[1] - inp[0])/(len(data[1][0])-1.)
4081        names = ('start angle', 'end angle', 'step size')
4082        dlg = G2G.ScrolledMultiEditor(
4083            G2frame,[inp] * len(inp), range(len(inp)), names,
4084            header='Edit simulation range',
4085            minvals=(0.001,0.001,0.0001),
4086            maxvals=(180.,180.,.1),
4087            )
4088        dlg.CenterOnParent()
4089        val = dlg.ShowModal()
4090        dlg.Destroy()
4091        if val != wx.ID_OK: return
4092        if inp[0] > inp[1]:
4093            end,start,step = inp
4094        else:               
4095            start,end,step = inp
4096        step = abs(step)
4097        N = int((end-start)/step)+1
4098        newdata = np.linspace(start,end,N,True)
4099        if len(newdata) < 2: return # too small a range - reject
4100        data[1] = [newdata,np.zeros_like(newdata),np.ones_like(newdata),
4101            np.zeros_like(newdata),np.zeros_like(newdata),np.zeros_like(newdata)]
4102        Tmin = newdata[0]
4103        Tmax = newdata[-1]
4104        G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,item,'Limits'),
4105            [(Tmin,Tmax),[Tmin,Tmax]])
4106        UpdatePWHKPlot(G2frame,kind,item) # redisplay data screen
4107
4108    def OnPlot3DHKL(event):
4109        refList = data[1]['RefList']
4110        FoMax = np.max(refList.T[8+Super])
4111        Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
4112        Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
4113        Vpoint = np.array([int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))])
4114        controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
4115            'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
4116            'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
4117            'Scale':1.0,'oldxy':[],'viewDir':[0,0,1]},'Super':Super,'SuperVec':SuperVec}
4118        G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
4119       
4120    def OnPlotAll3DHKL(event):
4121        choices = GetPatternTreeDataNames(G2frame,['HKLF',])
4122        dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to plot',
4123            'Use data',choices)
4124        try:
4125            if dlg.ShowModal() == wx.ID_OK:
4126                refNames = [choices[i] for i in dlg.GetSelections()]
4127            else:
4128                return
4129        finally:
4130            dlg.Destroy()
4131        refList = np.zeros(0)
4132        for name in refNames:
4133            Id = GetPatternTreeItemId(G2frame,G2frame.root, name)
4134            reflData = G2frame.PatternTree.GetItemPyData(Id)[1]
4135            if len(refList):
4136                refList = np.concatenate((refList,reflData['RefList']))
4137            else:
4138                refList = reflData['RefList']
4139           
4140        FoMax = np.max(refList.T[8+Super])
4141        Hmin = np.array([int(np.min(refList.T[0])),int(np.min(refList.T[1])),int(np.min(refList.T[2]))])
4142        Hmax = np.array([int(np.max(refList.T[0])),int(np.max(refList.T[1])),int(np.max(refList.T[2]))])
4143        Vpoint = [int(np.mean(refList.T[0])),int(np.mean(refList.T[1])),int(np.mean(refList.T[2]))]
4144        controls = {'Type' : 'Fosq','Iscale' : False,'HKLmax' : Hmax,'HKLmin' : Hmin,'Zone':False,'viewKey':'L',
4145            'FoMax' : FoMax,'Scale' : 1.0,'Drawing':{'viewPoint':[Vpoint,[]],'default':Vpoint[:],
4146            'backColor':[0,0,0],'depthFog':False,'Zclip':10.0,'cameraPos':10.,'Zstep':0.05,'viewUp':[0,1,0],
4147            'Scale':1.0,'oldxy':[],'viewDir':[1,0,0]},'Super':Super,'SuperVec':SuperVec}
4148        G2plt.Plot3DSngl(G2frame,newPlot=True,Data=controls,hklRef=refList,Title=phaseName)
4149                 
4150    def OnMergeHKL(event):
4151        Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
4152        Inst = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,
4153            G2frame.PatternId,'Instrument Parameters'))
4154        CId = GetPatternTreeItemId(G2frame,G2frame.PatternId,'Comments')
4155        if CId:
4156            Comments = G2frame.PatternTree.GetItemPyData(CId)
4157        else:
4158            Comments = []
4159        refList = np.copy(data[1]['RefList'])
4160        Comments.append(' Merging %d reflections from %s'%(len(refList),Name))
4161        dlg = MergeDialog(G2frame,data)
4162        try:
4163            if dlg.ShowModal() == wx.ID_OK:
4164                Trans,Cent,Laue = dlg.GetSelection()
4165            else:
4166                return
4167        finally:
4168            dlg.Destroy()
4169        Super = data[1]['Super']
4170        refList,badRefs = G2lat.transposeHKLF(Trans,Super,refList)
4171        if len(badRefs):    #do I want to list badRefs?
4172            G2frame.ErrorDialog('Failed transformation','Matrix yields fractional hkl indices')
4173            return
4174        Comments.append(" Transformation M*H = H' applied; M=")
4175        Comments.append(str(Trans))
4176        refList = G2lat.LaueUnique(Laue,refList)
4177        dlg = wx.ProgressDialog('Build HKL dictonary','',len(refList)+1, 
4178            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE)
4179        HKLdict = {}
4180        for ih,hkl in enumerate(refList):
4181            if str(hkl[:3+Super]) not in HKLdict:
4182                HKLdict[str(hkl[:3+Super])] = [hkl[:3+Super],[hkl[3+Super:],]]
4183            else:
4184                HKLdict[str(hkl[:3+Super])][1].append(hkl[3+Super:])
4185            dlg.Update(ih)
4186        dlg.Destroy()
4187        mergeRef = []
4188        dlg = wx.ProgressDialog('Processing merge','',len(HKLdict)+1, 
4189            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE)
4190        sumDf = 0.
4191        sumFo = 0.
4192        for ih,hkl in enumerate(HKLdict):
4193            HKL = HKLdict[hkl]
4194            newHKL = list(HKL[0])+list(HKL[1][0])
4195            if len(HKL[1]) > 1:
4196                fos = np.array(HKL[1])
4197                wFo = 1/fos[:,3]**2
4198                Fo = np.average(fos[:,2],weights=wFo)
4199                std = np.std(fos[:,2])
4200                sig = np.sqrt(np.mean(fos[:,3])**2+std**2)
4201                sumFo += np.sum(fos[:,2])
4202                sumDf += np.sum(np.abs(fos[:,2]-Fo))
4203                dlg.Update(ih)
4204                newHKL[5+Super] = Fo
4205                newHKL[6+Super] = sig
4206                newHKL[8+Super] = Fo
4207            if newHKL[5+Super] > 0.:
4208                mergeRef.append(list(newHKL)) 
4209        dlg.Destroy()
4210        if Super:
4211            mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,3),2),1),0)
4212        else:
4213            mergeRef = G2mth.sortArray(G2mth.sortArray(G2mth.sortArray(mergeRef,2),1),0)
4214        mergeRef = np.array(mergeRef)
4215        if sumFo:
4216            mtext = ' merge R = %6.2f%s for %d reflections in %s'%(100.*sumDf/sumFo,'%',mergeRef.shape[0],Laue)
4217            print mtext
4218            Comments.append(mtext)
4219        else:
4220            print 'nothing to merge for %s reflections'%(mergeRef.shape[0])
4221        HKLFlist = []
4222        newName = Name+' '+Laue
4223        if G2frame.PatternTree.GetCount():
4224            item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
4225            while item:
4226                name = G2frame.PatternTree.GetItemText(item)
4227                if name.startswith('HKLF ') and name not in HKLFlist:
4228                    HKLFlist.append(name)
4229                item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
4230        newName = G2obj.MakeUniqueLabel(newName,HKLFlist)
4231        newData = copy.deepcopy(data)
4232        newData[0]['ranId'] = ran.randint(0,sys.maxint)
4233        newData[1]['RefList'] = mergeRef
4234        Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=newName)
4235        G2frame.PatternTree.SetItemPyData(
4236            G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)
4237        G2frame.PatternTree.SetItemPyData(Id,newData)
4238        G2frame.PatternTree.SetItemPyData(
4239            G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
4240        G2frame.PatternTree.SetItemPyData(
4241            G2frame.PatternTree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
4242                   
4243    def OnErrorAnalysis(event):
4244        G2plt.PlotDeltSig(G2frame,kind)
4245       
4246    def OnWtFactor(event):
4247        event.Skip()
4248        try:
4249            val = float(wtval.GetValue())
4250        except ValueError:
4251            val = data[0]['wtFactor']
4252        data[0]['wtFactor'] = val
4253        wtval.SetValue('%.3f'%(val))
4254       
4255#    def OnCompression(event):
4256#        data[0] = int(comp.GetValue())
4257       
4258    def onCopyPlotCtrls(event):
4259        '''Respond to menu item to copy multiple sections from a histogram.
4260        Need this here to pass on the G2frame object.
4261        '''
4262        G2pdG.CopyPlotCtrls(G2frame)
4263
4264    def onCopySelectedItems(event):
4265        '''Respond to menu item to copy multiple sections from a histogram.
4266        Need this here to pass on the G2frame object.
4267        '''
4268        G2pdG.CopySelectedHistItems(G2frame)
4269           
4270    data = G2frame.PatternTree.GetItemPyData(item)
4271#patches
4272    if not data:
4273        return
4274    if 'wtFactor' not in data[0]:
4275        data[0] = {'wtFactor':1.0}
4276#    if kind == 'PWDR' and 'Compression' not in data[0]:
4277#        data[0]['Compression'] = 1
4278    #if isinstance(data[1],list) and kind == 'HKLF':
4279    if 'list' in str(type(data[1])) and kind == 'HKLF':
4280        RefData = {'RefList':[],'FF':[]}
4281        for ref in data