source: trunk/GSASIIpwdGUI.py @ 574

Last change on this file since 574 was 574, checked in by vondreele, 10 years ago

fixed import of .gpx phases

  • Property svn:keywords set to Date Author Revision URL Id
File size: 105.4 KB
Line 
1#GSASII - data display routines
2########### SVN repository information ###################
3# $Date: 2012-04-25 19:38:19 +0000 (Wed, 25 Apr 2012) $
4# $Author: vondreele $
5# $Revision: 574 $
6# $URL: trunk/GSASIIpwdGUI.py $
7# $Id: GSASIIpwdGUI.py 574 2012-04-25 19:38:19Z vondreele $
8########### SVN repository information ###################
9import wx
10import wx.grid as wg
11import numpy as np
12import math
13import time
14import copy
15import cPickle
16import GSASIIpath
17import GSASIIpwd as G2pwd
18import GSASIIIO as G2IO
19import GSASIIlattice as G2lat
20import GSASIIspc as G2spc
21import GSASIIindex as G2indx
22import GSASIIplot as G2plt
23import GSASIIgrid as G2gd
24import GSASIIElemGUI as G2elemGUI
25import GSASIIElem as G2elem
26
27VERY_LIGHT_GREY = wx.Colour(235,235,235)
28
29# trig functions in degrees
30sind = lambda x: math.sin(x*math.pi/180.)
31tand = lambda x: math.tan(x*math.pi/180.)
32cosd = lambda x: math.cos(x*math.pi/180.)
33asind = lambda x: 180.*math.asin(x)/math.pi
34   
35def IsHistogramInAnyPhase(G2frame,histoName):
36    phases = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
37    if phases:
38        item, cookie = G2frame.PatternTree.GetFirstChild(phases)
39        while item:
40            data = G2frame.PatternTree.GetItemPyData(item)
41            histoList = data['Histograms'].keys()
42            if histoName in histoList:
43                return True
44            item, cookie = G2frame.PatternTree.GetNextChild(phases, cookie)
45        return False
46    else:
47        return False
48
49def SetDefaultSample():
50    return {'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],
51        'DisplaceX':[0.0,False],'DisplaceY':[0.0,False],'Diffuse':[],
52        'Temperature':300.,'Pressure':1.0,'Humidity':0.0,
53        'Voltage':0.0,'Force':0.0,'Gonio. radius':200.0,
54        'Omega':0.0,'Chi':0.0,'Phi':0.0}   
55           
56################################################################################
57#####  Powder Peaks
58################################################################################           
59       
60def UpdatePeakGrid(G2frame, data):
61    if G2frame.dataDisplay:
62        G2frame.dataFrame.Clear()
63   
64    def OnUnDo(event):
65        DoUnDo()
66        G2frame.dataFrame.UnDo.Enable(False)
67       
68    def DoUnDo():
69        print 'Undo last refinement'
70        file = open(G2frame.undofile,'rb')
71        PatternId = G2frame.PatternId
72        for item in ['Background','Instrument Parameters','Peak List']:
73            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
74            if G2frame.dataDisplay.GetName() == item:
75                if item == 'Background':
76                    UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
77                elif item == 'Instrument Parameters':
78                    UpdateInstrumentGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
79                elif item == 'Peak List':
80                    UpdatePeakGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
81            print item,' recovered'
82        file.close()
83       
84    def SaveState():
85        G2frame.undofile = G2frame.dirname+'\\GSASII.save'
86        file = open(G2frame.undofile,'wb')
87        PatternId = G2frame.PatternId
88        for item in ['Background','Instrument Parameters','Peak List']:
89            cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
90        file.close()
91        G2frame.dataFrame.UnDo.Enable(True)
92       
93    def OnLSQPeakFit(event):
94        if not G2frame.GSASprojectfile:            #force a save of the gpx file so SaveState can wirte in the same directory
95            G2frame.OnFileSaveas(event)
96        OnPeakFit('LSQ')
97       
98    def OnOneCycle(event):
99        OnPeakFit('LSQ',oneCycle=True)
100       
101    def OnClearPeaks(event):
102        dlg = wx.MessageDialog(G2frame,'Delete all peaks?','Clear peak list',wx.OK|wx.CANCEL)
103        try:
104            if dlg.ShowModal() == wx.ID_OK:
105                peaks = []
106        finally:
107            dlg.Destroy()
108        UpdatePeakGrid(G2frame,peaks)
109        G2plt.PlotPatterns(G2frame)
110       
111    def OnPeakFit(FitPgm,oneCycle=False):
112        SaveState()
113        controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
114        if not controls:
115            controls = {'deriv type':'analytic','min dM/M':0.0001,}     #fill in defaults if needed
116        print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
117        PatternId = G2frame.PatternId
118        PickId = G2frame.PickId
119        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
120        if not peaks:
121            G2frame.ErrorDialog('No peaks!','Nothing to fit!')
122            return
123        background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
124        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
125        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
126        data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
127        wx.BeginBusyCursor()
128        dlg = wx.ProgressDialog('Residual','Peak fit Rwp = ',101.0, 
129            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE|wx.PD_REMAINING_TIME|wx.PD_CAN_ABORT)
130        screenSize = wx.ClientDisplayRect()
131        Size = dlg.GetSize()
132        dlg.SetPosition(wx.Point(screenSize[2]-Size[0]-305,screenSize[1]+5))
133        try:
134            G2pwd.DoPeakFit(FitPgm,peaks,background,limits,inst,data,oneCycle,controls,dlg)
135        finally:
136            wx.EndBusyCursor()   
137        UpdatePeakGrid(G2frame,peaks)
138        G2plt.PlotPatterns(G2frame)
139        print 'finished'
140        return
141       
142    def OnResetSigGam(event):
143        PatternId = G2frame.PatternId
144        PickId = G2frame.PickId
145        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
146        if not peaks:
147            G2frame.ErrorDialog('No peaks!','Nothing to do!')
148            return
149        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
150        Inst = dict(zip(inst[3],inst[1]))
151        print len(Inst['Type'])
152        for peak in peaks:
153            if Inst['Type'] in ['PXC','PNC']:
154                peak[4] = Inst['U']*tand(peak[0]/2.0)**2+Inst['V']*tand(peak[0]/2.0)+Inst['W']
155                peak[6] = Inst['X']/cosd(peak[0]/2.0)+Inst['Y']*tand(peak[0]/2.0)
156        UpdatePeakGrid(G2frame,peaks)
157               
158    def RefreshPeakGrid(event):
159        r,c =  event.GetRow(),event.GetCol()
160       
161        event.StopPropagation()
162        data = G2frame.PeakTable.GetData()
163        T = []
164        for peak in data:T.append(peak[0])
165        D = dict(zip(T,data))
166        T.sort()
167        X = []
168        for key in T: X.append(D[key])
169        data = X       
170       
171    def setBackgroundColors():
172       for r in range(G2frame.dataDisplay.GetNumberRows()):
173           for c in range(G2frame.dataDisplay.GetNumberCols()):
174               if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','sigma','gamma']:
175                   if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
176                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
177                   else:
178                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
179                                                 
180    def KeyEditPeakGrid(event):
181        rowList = G2frame.dataDisplay.GetSelectedRows()
182        colList = G2frame.dataDisplay.GetSelectedCols()
183        selectList = G2frame.dataDisplay.GetSelectedCells()
184        data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
185        if event.GetKeyCode() == wx.WXK_RETURN:
186            event.Skip(True)
187        elif event.GetKeyCode() == wx.WXK_CONTROL:
188            event.Skip(True)
189        elif event.GetKeyCode() == wx.WXK_SHIFT:
190            event.Skip(True)
191        elif rowList:
192            G2frame.dataDisplay.ClearSelection()
193            if event.GetKeyCode() == wx.WXK_DELETE:
194                G2frame.dataDisplay.ClearGrid()
195                rowList.reverse()
196                nDel = 0
197                for row in rowList:
198                    G2frame.PeakTable.DeleteRow(row)
199                    nDel += 1
200                if nDel:
201                    msg = wg.GridTableMessage(G2frame.PeakTable, 
202                        wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
203                    G2frame.dataDisplay.ProcessTableMessage(msg)
204                data = G2frame.PeakTable.GetData()
205                G2frame.PatternTree.SetItemPyData(G2frame.PickId,data[:-nDel])
206                G2frame.dataDisplay.ForceRefresh()
207                setBackgroundColors()
208                if not len(G2frame.PatternTree.GetItemPyData(G2frame.PickId)): 
209                    G2frame.dataFrame.PeakFit.Enable(False)
210                       
211        elif colList:
212            G2frame.dataDisplay.ClearSelection()
213            key = event.GetKeyCode()
214            for col in colList:
215                if G2frame.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
216                    if key == 89: #'Y'
217                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=True
218                    elif key == 78:  #'N'
219                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=False
220        elif selectList:
221            G2frame.dataDisplay.ClearSelection()
222            key = event.GetKeyCode()
223            for row,col in selectList:
224                if G2frame.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
225                    if key == 89: #'Y'
226                        data[row][col]=True
227                    elif key == 78:  #'N'
228                        data[row][col]=False
229        G2plt.PlotPatterns(G2frame)
230           
231    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.PeakMenu)
232    if not G2frame.dataFrame.GetStatusBar():
233        Status = G2frame.dataFrame.CreateStatusBar()
234    G2frame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_UNDO)
235    G2frame.Bind(wx.EVT_MENU, OnLSQPeakFit, id=G2gd.wxID_LSQPEAKFIT)
236    G2frame.Bind(wx.EVT_MENU, OnOneCycle, id=G2gd.wxID_LSQONECYCLE)
237    G2frame.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
238    G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
239    G2frame.dataFrame.PeakFit.Enable(False)
240    if data:
241        G2frame.dataFrame.PeakFit.Enable(True)
242        G2frame.dataFrame.PFOneCycle.Enable(True)
243    G2frame.PickTable = []
244    rowLabels = []
245    for i in range(len(data)): rowLabels.append(str(i+1))
246    colLabels = ['position','refine','intensity','refine','sigma','refine','gamma','refine']
247    Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
248        wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
249        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
250        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
251    T = []
252    for peak in data:
253        T.append(peak[0])
254    D = dict(zip(T,data))
255    T.sort()
256    X = []
257    for key in T: X.append(D[key])
258    data = X       
259    G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
260    G2frame.PeakTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
261    G2frame.dataFrame.SetLabel('Peak List')
262    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
263    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
264    setBackgroundColors()                         
265    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
266    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
267    G2frame.dataDisplay.SetMargins(0,0)
268    G2frame.dataDisplay.AutoSizeColumns(False)
269    G2frame.dataFrame.setSizePosLeft([535,350])
270       
271################################################################################
272#####  Background
273################################################################################           
274       
275def UpdateBackground(G2frame,data):
276    if len(data) < 2:       #add Debye diffuse & peaks scattering here
277        data.append({'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]})
278    if 'nPeaks' not in data[1]:
279        data[1].update({'nPeaks':0,'peaksList':[]})
280    ValObj = {}
281   
282    def OnBackFlagCopy(event):
283        print data
284        flag = data[1]
285        backDict = data[-1]
286        if backDict['nDebye']:
287            DBflags = []
288            for term in backDict['debyeTerms']:
289                DBflags.append(term[1::2])
290        if backDict['nPeaks']:
291            PKflags = []
292            for term in backDict['peaksList']:
293                PKflags.append(term[1::2])           
294        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
295        copyList = []
296        dlg = wx.MultiChoiceDialog(G2frame, 
297            'Copy refinement flags to which histograms?', 'Copy flags', 
298            histList, wx.CHOICEDLG_STYLE)
299        try:
300            if dlg.ShowModal() == wx.ID_OK:
301                result = dlg.GetSelections()
302                for i in result: 
303                    copyList.append(histList[i])
304                if 'All' in copyList: 
305                    copyList = histList[1:]
306            for item in copyList:
307                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
308                backData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'))
309                backData[1] = copy.copy(flag)
310                bkDict = backData[-1]
311                if bkDict['nDebye'] == backDict['nDebye']:
312                    for i,term in enumerate(bkDict['debyeTerms']):
313                        term[1::2] = copy.copy(DBflags[i])
314                if bkDict['nPeaks'] == backDict['nPeaks']:
315                    for i,term in enumerate(bkDict['peaksList']):
316                        term[1::2] = copy.copy(PKflags[i])                   
317        finally:
318            dlg.Destroy()
319           
320    def OnBackCopy(event):
321        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
322        copyList = []
323        dlg = wx.MultiChoiceDialog(G2frame, 
324            'Copy parameters to which histograms?', 'Copy parameters', 
325            histList, wx.CHOICEDLG_STYLE)
326        try:
327            if dlg.ShowModal() == wx.ID_OK:
328                result = dlg.GetSelections()
329                for i in result: 
330                    copyList.append(histList[i])
331                if 'All' in copyList: 
332                    copyList = histList[1:]
333            for item in copyList:
334                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
335                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),
336                    copy.copy(data))
337        finally:
338            dlg.Destroy()
339       
340    def BackSizer():
341       
342        def OnNewType(event):
343            data[0][0] = bakType.GetValue()
344           
345        def OnBakRef(event):
346            data[0][1] = bakRef.GetValue()
347           
348        def OnBakTerms(event):
349            data[0][2] = int(bakTerms.GetValue())
350            M = len(data[0])
351            N = data[0][2]+3
352            item = data[0]
353            if N > M:       #add terms
354                for i in range(M,N): 
355                    item.append(0.0)
356            elif N < M:     #delete terms
357                for i in range(N,M):
358                    del(item[-1])
359            G2frame.PatternTree.SetItemPyData(BackId,data)
360            UpdateBackground(G2frame,data)
361           
362        def OnBakVal(event):
363            Obj = event.GetEventObject()
364            item = ValObj[Obj.GetId()][0]
365            try:
366                value = float(Obj.GetValue())
367            except ValueError:
368                value = data[0][item]
369            data[0][item] = value
370            Obj.SetValue('%10.4f'%(value))
371       
372        backSizer = wx.BoxSizer(wx.VERTICAL)
373        topSizer = wx.BoxSizer(wx.HORIZONTAL)
374        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,wx.ALIGN_CENTER_VERTICAL)
375        bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
376                choices=Choices,style=wx.CB_READONLY|wx.CB_DROPDOWN)
377        bakType.Bind(wx.EVT_COMBOBOX, OnNewType)
378        topSizer.Add(bakType)
379        topSizer.Add((5,0),0)
380        bakRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
381        bakRef.SetValue(bool(data[0][1]))
382        bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
383        topSizer.Add(bakRef,0,wx.ALIGN_CENTER_VERTICAL)
384        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
385        bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
386            style=wx.CB_READONLY|wx.CB_DROPDOWN)
387        bakTerms.Bind(wx.EVT_COMBOBOX,OnBakTerms)
388        topSizer.Add(bakTerms,0,wx.ALIGN_CENTER_VERTICAL)
389        topSizer.Add((5,0),0)
390        backSizer.Add(topSizer)
391        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,wx.ALIGN_CENTER_VERTICAL)
392        bakSizer = wx.FlexGridSizer(1,5,5,5)
393        for i,value in enumerate(data[0][3:]):
394            bakVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(value),style=wx.TE_PROCESS_ENTER)
395            bakSizer.Add(bakVal,0,wx.ALIGN_CENTER_VERTICAL)
396            ValObj[bakVal.GetId()] = [i+3]
397            bakVal.Bind(wx.EVT_TEXT_ENTER,OnBakVal)
398            bakVal.Bind(wx.EVT_KILL_FOCUS,OnBakVal)
399        backSizer.Add(bakSizer)
400        return backSizer
401       
402    def DebyeSizer():
403       
404        def OnDebTerms(event):
405            data[1]['nDebye'] = int(debTerms.GetValue())
406            M = len(data[1]['debyeTerms'])
407            N = data[1]['nDebye']
408            if N > M:       #add terms
409                for i in range(M,N): 
410                    data[1]['debyeTerms'].append([1.0,False,1.0,False,0.010,False])
411            elif N < M:     #delete terms
412                for i in range(N,M):
413                    del(data[1]['debyeTerms'][-1])
414            UpdateBackground(G2frame,data)
415
416        def KeyEditPeakGrid(event):
417            colList = debyeGrid.GetSelectedCols()
418            if event.GetKeyCode() == wx.WXK_RETURN:
419                event.Skip(True)
420            elif event.GetKeyCode() == wx.WXK_CONTROL:
421                event.Skip(True)
422            elif event.GetKeyCode() == wx.WXK_SHIFT:
423                event.Skip(True)
424            elif colList:
425                debyeGrid.ClearSelection()
426                key = event.GetKeyCode()
427                for col in colList:
428                    if debyeTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
429                        if key == 89: #'Y'
430                            for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=True
431                        elif key == 78:  #'N'
432                            for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=False
433
434       
435        debSizer = wx.BoxSizer(wx.VERTICAL)
436        topSizer = wx.BoxSizer(wx.HORIZONTAL)
437        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,wx.ALIGN_CENTER_VERTICAL)
438        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
439        debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
440            style=wx.CB_READONLY|wx.CB_DROPDOWN)
441        debTerms.Bind(wx.EVT_COMBOBOX,OnDebTerms)
442        topSizer.Add(debTerms,0,wx.ALIGN_CENTER_VERTICAL)
443        topSizer.Add((5,0),0)
444        debSizer.Add(topSizer)
445        if data[1]['nDebye']:
446            debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,wx.ALIGN_CENTER_VERTICAL)       
447            rowLabels = []
448            for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
449            colLabels = ['A','refine','R','refine','U','refine']
450            Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
451            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
452            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
453            debyeTable = G2gd.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
454            debyeGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
455            debyeGrid.SetTable(debyeTable, True)
456            debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
457            debyeGrid.AutoSizeColumns(False)
458            debSizer.Add(debyeGrid)       
459        return debSizer
460     
461    def PeaksSizer():
462
463        def OnPeaks(event):
464            data[1]['nPeaks'] = int(peaks.GetValue())
465            M = len(data[1]['peaksList'])
466            N = data[1]['nPeaks']
467            if N > M:       #add terms
468                for i in range(M,N): 
469                    data[1]['peaksList'].append([1.0,False,1.0,False,0.10,False,0.10,False])
470            elif N < M:     #delete terms
471                for i in range(N,M):
472                    del(data[1]['peaksList'][-1])
473            UpdateBackground(G2frame,data)
474
475        def KeyEditPeakGrid(event):
476            colList = peaksGrid.GetSelectedCols()
477            if event.GetKeyCode() == wx.WXK_RETURN:
478                event.Skip(True)
479            elif event.GetKeyCode() == wx.WXK_CONTROL:
480                event.Skip(True)
481            elif event.GetKeyCode() == wx.WXK_SHIFT:
482                event.Skip(True)
483            elif colList:
484                peaksGrid.ClearSelection()
485                key = event.GetKeyCode()
486                for col in colList:
487                    if peaksTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
488                        if key == 89: #'Y'
489                            for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=True
490                        elif key == 78:  #'N'
491                            for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=False
492
493        peaksSizer = wx.BoxSizer(wx.VERTICAL)
494        topSizer = wx.BoxSizer(wx.HORIZONTAL)
495        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,wx.ALIGN_CENTER_VERTICAL)
496        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,wx.ALIGN_CENTER_VERTICAL)
497        peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(12)],
498            style=wx.CB_READONLY|wx.CB_DROPDOWN)
499        peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
500        topSizer.Add(peaks,0,wx.ALIGN_CENTER_VERTICAL)
501        topSizer.Add((5,0),0)
502        peaksSizer.Add(topSizer)
503        if data[1]['nPeaks']:
504            peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,wx.ALIGN_CENTER_VERTICAL)       
505            rowLabels = []
506            for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
507            colLabels = ['pos','refine','int','refine','sig','refine','gam','refine']
508            Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
509            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
510            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
511            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
512            peaksTable = G2gd.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
513            peaksGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
514            peaksGrid.SetTable(peaksTable, True)
515            peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
516            peaksGrid.AutoSizeColumns(False)
517            peaksSizer.Add(peaksGrid)       
518        return peaksSizer
519               
520    if G2frame.dataDisplay:
521#        G2frame.dataFrame.Clear()
522        G2frame.dataFrame.DestroyChildren()
523    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
524    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BackMenu)
525    G2frame.dataFrame.SetLabel('Background')
526    if not G2frame.dataFrame.GetStatusBar():
527        Status = G2frame.dataFrame.CreateStatusBar()
528    G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
529    G2frame.Bind(wx.EVT_MENU,OnBackFlagCopy,id=G2gd.wxID_BACKFLAGCOPY)
530    BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background')
531    Choices = ['chebyschev','cosine','lin interpolate','inv interpolate','log interpolate']
532    mainSizer = wx.BoxSizer(wx.VERTICAL)
533    mainSizer.Add(BackSizer())
534    mainSizer.Add((0,5),0)
535    mainSizer.Add(DebyeSizer())
536    mainSizer.Add((0,5),0)
537    mainSizer.Add(PeaksSizer())
538    mainSizer.Layout()   
539    G2frame.dataDisplay.SetSizer(mainSizer)
540    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
541       
542################################################################################
543#####  Limits
544################################################################################           
545       
546def UpdateLimitsGrid(G2frame, data):
547    if G2frame.dataDisplay:
548        G2frame.dataFrame.Clear()
549       
550    def RefreshLimitsGrid(event):
551        event.StopPropagation()
552        data = G2frame.LimitsTable.GetData()
553        old = data[0]
554        new = data[1]
555        new[0] = max(old[0],new[0])
556        new[1] = max(new[0],min(old[1],new[1]))
557        data = [old,new]
558        G2plt.PlotPatterns(G2frame)
559       
560    def OnLimitCopy(event):
561        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
562        copyList = []
563        dlg = wx.MultiChoiceDialog(G2frame, 
564            'Copy limits to which histograms?', 'Copy limits', 
565            histList, wx.CHOICEDLG_STYLE)
566        try:
567            if dlg.ShowModal() == wx.ID_OK:
568                result = dlg.GetSelections()
569                for i in result: 
570                    copyList.append(histList[i])
571                if 'All' in copyList: 
572                    copyList = histList[1:]
573            for item in copyList:
574                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
575                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),
576                    copy.copy(data))
577        finally:
578            dlg.Destroy()
579       
580    G2frame.LimitsTable = []
581    colLabels = ['Tmin','Tmax']
582    rowLabels = ['original','changed']
583    Types = 2*[wg.GRID_VALUE_FLOAT+':10,3',]
584    G2frame.LimitsTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
585    G2frame.dataFrame.SetLabel('Limits')
586    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.LimitMenu)
587    if not G2frame.dataFrame.GetStatusBar():
588        Status = G2frame.dataFrame.CreateStatusBar()
589    G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
590    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
591    G2frame.dataDisplay.SetTable(G2frame.LimitsTable, True)
592    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshLimitsGrid)               
593    G2frame.dataDisplay.SetMargins(0,0)
594    G2frame.dataDisplay.AutoSizeColumns(False)
595    G2frame.dataFrame.setSizePosLeft([230,160])
596   
597################################################################################
598#####  Instrument parameters
599################################################################################           
600       
601def UpdateInstrumentGrid(G2frame,data):
602    if len(data) > 3:                   #powder data
603        insVal = dict(zip(data[3],data[1]))
604        insDef = dict(zip(data[3],data[0]))
605        insRef = dict(zip(data[3],data[2]))
606        if 'N' in insDef['Type']:
607            del(insDef['Polariz.'])
608            del(insVal['Polariz.'])
609            del(insRef['Polariz.'])
610    else:                               #single crystal data
611        insVal = dict(zip(data[2],data[1]))
612        insDef = dict(zip(data[2],data[0]))
613        insRef = {}
614    ValObj = {}
615    RefObj = {}
616    waves = {'CuKa':[1.54051,1.54433],'TiKa':[2.74841,2.75207],'CrKa':[2.28962,2.29351],
617        'FeKa':[1.93597,1.93991],'CoKa':[1.78892,1.79278],'MoKa':[0.70926,0.713543],
618        'AgKa':[0.559363,0.563775]}
619       
620    def inst2data(inst,ref,data):
621        if len(data) > 3:
622            for i,item in enumerate(data[3]):
623                try:
624                    data[1][i] = inst[item]
625                    data[2][i] = ref[item]
626                except KeyError:
627                    data[1][i] = 0
628                    data[2][i] = 0                   
629        else:
630            for i,item in enumerate(data[2]):
631                data[1][i] = inst[item]           
632        return data
633       
634    def updateData(inst,ref):
635        return inst2data(inst,ref,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
636            G2frame.PatternId,'Instrument Parameters')))       
637   
638    def RefreshInstrumentGrid(event,doAnyway=False):
639        if doAnyway or event.GetRow() == 1:
640            peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
641            if 'P' in insVal['Type']:                                       #update powder peak parameters
642                for peak in peaks:
643                    peak[4] = insVal['U']*tand(peak[0]/2.0)**2+insVal['V']*tand(peak[0]/2.0)+insVal['W']
644                    peak[6] = insVal['X']/cosd(peak[0]/2.0)+insVal['Y']*tand(peak[0]/2.0)
645                   
646    def OnLoad(event):
647        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
648            'instrument parameter files (*.instprm)|*.instprm',wx.OPEN|wx.CHANGE_DIR)
649        try:
650            if dlg.ShowModal() == wx.ID_OK:
651                filename = dlg.GetPath()
652                File = open(filename,'r')
653                S = File.readline()
654                newItems = []
655                newVals = []
656                while S:
657                    if S[0] == '#':
658                        S = File.readline()
659                        continue
660                    [item,val] = S[:-1].split(':')
661                    newItems.append(item)
662                    try:
663                        newVals.append(float(val))
664                    except ValueError:
665                        newVals.append(val)                       
666                    S = File.readline()               
667                File.close()
668                data = [tuple(newVals),newVals,len(newVals)*[False,],newItems]
669                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),data)
670                RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
671                UpdateInstrumentGrid(G2frame,data)
672        finally:
673            dlg.Destroy()
674       
675    def OnSave(event):
676        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
677            'instrument parameter files (*.instprm)|*.instprm',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
678        try:
679            if dlg.ShowModal() == wx.ID_OK:
680                filename = dlg.GetPath()
681                File = open(filename,'w')
682                File.write("#GSAS-II instrument parameter file; do not add/delete or change order of items!") 
683                for i,item in enumerate(data[3]):
684                    File.write(item+':'+str(data[1][i])+'\n')
685                File.close()
686        finally:
687            dlg.Destroy()
688                                               
689    def OnReset(event):
690        insVal.update(insDef)
691        data = updateData(insVal,insRef)
692        RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
693        UpdateInstrumentGrid(G2frame,data)
694       
695    def OnInstFlagCopy(event):
696        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
697        flags = data[2]
698        instType = data[0][0]
699        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
700        copyList = []
701        dlg = wx.MultiChoiceDialog(G2frame, 
702            'Copy refinement flags from\n'+histName, 'Copy refinement flags', 
703            histList, wx.CHOICEDLG_STYLE)
704        try:
705            if dlg.ShowModal() == wx.ID_OK:
706                result = dlg.GetSelections()
707                for i in result: 
708                    copyList.append(histList[i])
709                if 'All' in copyList: 
710                    copyList = histList[1:]
711            for item in copyList:
712                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
713                instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
714                if len(data) == len(instData) and instType == instData[0][0]:   #don't mix data types or lam & lam1/lam2 parms!
715                    instData[2] = copy.copy(flags)
716                else:
717                    print item+' not copied - instrument parameters not commensurate'
718        finally:
719            dlg.Destroy()
720       
721    def OnInstCopy(event):
722        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
723        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
724        copyList = []
725        instType = data[0][0]
726        dlg = wx.MultiChoiceDialog(G2frame, 
727            'Copy parameters from\n'+histName, 'Copy parameters', 
728            histList, wx.CHOICEDLG_STYLE)
729        try:
730            if dlg.ShowModal() == wx.ID_OK:
731                result = dlg.GetSelections()
732                for i in result: 
733                    copyList.append(histList[i])
734                if 'All' in copyList: 
735                    copyList = histList[1:]
736            for item in copyList:
737                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
738                instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
739                if len(data) == len(instData) and instType == instData[0][0]:  #don't mix data types or lam & lam1/lam2 parms!
740                    for i,item in enumerate(data[1:]):                  #skip default values in tuple
741                        instData[i+1][:-1] = copy.copy(item[:-1])       #skip azimuth at end
742                else:
743                    print item+' not copied - instrument parameters not commensurate'
744        finally:
745            dlg.Destroy()
746       
747    def OnWaveChange(event):
748        if 'Lam' in insVal:           
749            data[0] = data[0][:1]+tuple(waves['CuKa'])+(.5,)+data[0][2:]
750            data[1] = data[1][:1]+waves['CuKa']+[.5,]+data[1][2:]
751            data[2] = data[2][:1]+[0,0,0,]+data[2][2:]
752            data[3] = data[3][:1]+['Lam1','Lam2','I(L2)/I(L1)',]+data[3][2:]           
753        else:
754            data[0] = data[0][:2]+data[0][4:]
755            data[1] = data[1][:2]+data[1][4:]
756            data[2] = data[2][:2]+data[2][4:]
757            data[3] = data[3][:1]+['Lam',]+data[3][4:]           
758        UpdateInstrumentGrid(G2frame,data)
759               
760    def OnNewType(event):
761        insVal['Type'] = typePick.GetValue()
762        data = updateData(insVal,insRef)
763        UpdateInstrumentGrid(G2frame,data)
764       
765    def OnLamPick(event):
766        lamType = lamPick.GetValue()
767        insVal['Lam1'] = waves[lamType][0]
768        insVal['Lam2'] = waves[lamType][1]
769        data = updateData(insVal,insRef)
770        UpdateInstrumentGrid(G2frame,data)
771                 
772    def OnRatValue(event):
773        try:
774            value = float(ratVal.GetValue())
775            if value < 0:
776                raise ValueError
777        except ValueError:
778            value = insVal['I(L2)/I(L1)']
779        insVal['I(L2)/I(L1)'] = value
780        ratVal.SetValue('%10.4f'%(value))
781        data = updateData(insVal,insRef)
782       
783    def OnRatRef(event):
784        insRef['I(L2)/I(L1)'] = ratRef.GetValue()
785        data = updateData(insVal,insRef)
786       
787    def OnWaveValue(event):
788        try:
789            value = float(waveVal.GetValue())
790            if value < 0:
791                raise ValueError
792        except ValueError:
793            value = insVal['Lam']
794        insVal['Lam'] = value
795        waveVal.SetValue('%10.6f'%(value))
796        data = updateData(insVal,insRef)
797       
798    def OnWaveRef(event):
799        insRef['Lam'] = waveRef.GetValue()
800        data = updateData(insVal,insRef)
801       
802    def OnItemValue(event):
803        Obj = event.GetEventObject()
804        item,fmt = ValObj[Obj.GetId()]
805        try:
806            value = float(Obj.GetValue())
807        except ValueError:
808            value = insVal[item]
809        insVal[item] = value
810        Obj.SetValue(fmt%(value))
811        data = updateData(insVal,insRef)
812       
813    def OnItemRef(event):
814        Obj = event.GetEventObject()
815        item = RefObj[Obj.GetId()]
816        insRef[item] = Obj.GetValue()
817        data = updateData(insVal,insRef)
818               
819    if G2frame.dataDisplay:
820        G2frame.dataFrame.Clear()
821    try:
822        histoName = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[-1]
823        ifHisto = IsHistogramInAnyPhase(G2frame,histoName)
824    except TypeError:       #PKS data never used in a phase as data
825        ifhisto = False
826    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
827    G2frame.dataFrame.SetLabel('Instrument Parameters')
828    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
829    instSizer = wx.FlexGridSizer(2,6,5,5)
830    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Histogram Type:'),0,wx.ALIGN_CENTER_VERTICAL)
831    if 'P' in insVal['Type']:                   #powder data
832        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.InstMenu)
833        if not G2frame.dataFrame.GetStatusBar():
834            Status = G2frame.dataFrame.CreateStatusBar()
835        G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
836        G2frame.Bind(wx.EVT_MENU,OnSave,id=G2gd.wxID_INSTSAVE)
837        G2frame.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
838        G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
839        G2frame.Bind(wx.EVT_MENU,OnInstFlagCopy,id=G2gd.wxID_INSTFLAGCOPY)
840        G2frame.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)       
841        typePick = wx.ComboBox(G2frame.dataDisplay,value=insVal['Type'],
842            choices=['PXC','PNC','PNT'],style=wx.CB_READONLY|wx.CB_DROPDOWN)
843        typePick.Bind(wx.EVT_COMBOBOX, OnNewType)
844        instSizer.Add(typePick,0,wx.ALIGN_CENTER_VERTICAL)
845        if 'C' in insVal['Type']:               #constant wavelength
846            #patch
847            if 'Azimuth' not in insVal:
848                insVal['Azimuth'] = 0.0
849                insDef['Azimuth'] = 0.0
850                insRef['Azimuth'] = False
851            #end of patch
852            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,wx.ALIGN_CENTER_VERTICAL)
853            if 'Lam1' in insVal:
854                instSizer.Add((5,5),0)
855                instSizer.Add((5,5),0)
856                instSizer.Add((5,5),0)
857                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Ka1/Ka2:'),
858                        0,wx.ALIGN_CENTER_VERTICAL)
859                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'%8.6f/%8.6f'%(insVal['Lam1'],insVal['Lam2'])),
860                        0,wx.ALIGN_CENTER_VERTICAL)
861                waveSizer = wx.BoxSizer(wx.HORIZONTAL)
862                waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Select:'),0,wx.ALIGN_CENTER_VERTICAL)
863                choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
864                lamPick = wx.ComboBox(G2frame.dataDisplay,value=' ',choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
865                lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
866                waveSizer.Add(lamPick,0)
867                instSizer.Add(waveSizer,0)
868                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' I(L2)/I(L1): (%10.4f)'%(insDef['I(L2)/I(L1)'])),
869                        0,wx.ALIGN_CENTER_VERTICAL)
870                ratVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(insVal['I(L2)/I(L1)']),style=wx.TE_PROCESS_ENTER)
871                ratVal.Bind(wx.EVT_TEXT_ENTER,OnRatValue)
872                ratVal.Bind(wx.EVT_KILL_FOCUS,OnRatValue)
873                instSizer.Add(ratVal,0)
874                ratRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
875                ratRef.SetValue(bool(insRef['I(L2)/I(L1)']))
876                ratRef.Bind(wx.EVT_CHECKBOX, OnRatRef)
877                instSizer.Add(ratRef,0,wx.ALIGN_CENTER_VERTICAL)
878               
879            else:
880                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: (%10.6f)'%(insDef['Lam'])),
881                    0,wx.ALIGN_CENTER_VERTICAL)
882                waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
883                waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
884                waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
885                instSizer.Add(waveVal,0,wx.ALIGN_CENTER_VERTICAL)
886                if ifHisto:
887                    waveRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
888                    waveRef.SetValue(bool(insRef['Lam']))
889                    waveRef.Bind(wx.EVT_CHECKBOX, OnWaveRef)
890                    instSizer.Add(waveRef,0,wx.ALIGN_CENTER_VERTICAL)
891                else:
892                    instSizer.Add((5,5),0)
893            for item in ['Zero','Polariz.']:
894                fmt = '%10.4f'
895                Fmt = ' %s: ('+fmt+')'
896                if item in insDef:
897                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
898                            0,wx.ALIGN_CENTER_VERTICAL)
899                    itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
900                    ValObj[itemVal.GetId()] = [item,fmt]
901                    itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
902                    itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
903                    instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
904                    if ifHisto:
905                        itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
906                        itemRef.SetValue(bool(insRef[item]))
907                        RefObj[itemRef.GetId()] = item
908                        itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
909                        instSizer.Add(itemRef,0,wx.ALIGN_CENTER_VERTICAL)
910                    else:
911                        instSizer.Add((5,5),0)
912                else:                           #skip Polariz. for neutrons
913                    instSizer.Add((5,5),0)
914                    instSizer.Add((5,5),0)
915                    instSizer.Add((5,5),0)
916            for item in ['U','V','W','X','Y','SH/L']:
917                fmt = '%10.3f'
918                if item == 'SH/L':
919                    fmt = '%10.5f'
920                Fmt = ' %s: ('+fmt+')'
921                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
922                        0,wx.ALIGN_CENTER_VERTICAL)
923                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
924                ValObj[itemVal.GetId()] = [item,fmt]
925                itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
926                itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
927                instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
928                itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
929                itemRef.SetValue(bool(insRef[item]))
930                RefObj[itemRef.GetId()] = item
931                itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
932                instSizer.Add(itemRef,0,wx.ALIGN_CENTER_VERTICAL)
933        else:                                   #time of flight (neutrons)
934            pass                                #for now
935       
936       
937
938    else:                       #single crystal data
939        typePick = wx.ComboBox(G2frame.dataDisplay,value=insVal['Type'],
940            choices=['SXC','SNC','SNT'],style=wx.CB_READONLY|wx.CB_DROPDOWN)
941        typePick.Bind(wx.EVT_COMBOBOX, OnNewType)
942        instSizer.Add(typePick,0,wx.ALIGN_CENTER_VERTICAL)
943        if 'C' in insVal['Type']:               #constant wavelength
944            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: %10.6f'%(insDef['Lam'])),
945                    0,wx.ALIGN_CENTER_VERTICAL)
946        else:                                   #time of flight (neutrons)
947            pass                                #for now
948       
949    mainSizer = wx.BoxSizer(wx.VERTICAL)
950    mainSizer.Add(instSizer,0)
951    mainSizer.Layout()   
952    G2frame.dataDisplay.SetSizer(mainSizer)
953    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
954   
955################################################################################
956#####  Sample parameters
957################################################################################           
958       
959def UpdateSampleGrid(G2frame,data):
960   
961    def SetCopyNames(histName,addNames=[]):
962        copyNames = ['Scale',]
963        dataType = data['Type']
964        histType = 'HKLF'
965        if 'PWDR' in histName:          #else HKLF - only Scale
966            histType = 'PWDR'
967            if 'Debye' in dataType:
968                copyNames += ['DisplaceX','DisplaceY','Absorption']
969            else:       #Bragg-Brentano
970                copyNames += ['Shift','Transparency']
971        if len(addNames):
972         copyNames += addNames
973        return histType,copyNames
974   
975    def OnSampleCopy(event):
976        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
977        histType,copyNames = SetCopyNames(histName,addNames=['Omega','Chi','Phi'])
978        copyDict = {}
979        for parm in copyNames:
980            copyDict[parm] = data[parm]
981        histList = ['All '+histType,]
982        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
983        while item:
984            name = G2frame.PatternTree.GetItemText(item)
985            if histType in name and name != histName:
986                histList.append(name)
987            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
988        if len(histList) == 1:      #nothing to copy to!
989            return
990        copyList = []
991        dlg = wx.MultiChoiceDialog(G2frame,'Copy parameters from\n'+histName,
992            'Copy parameters',histList,wx.CHOICEDLG_STYLE)
993        try:
994            if dlg.ShowModal() == wx.ID_OK:
995                result = dlg.GetSelections()
996                for i in result: 
997                    copyList.append(histList[i])
998                if 'All '+histType in copyList: 
999                    copyList = histList[1:]
1000            for item in copyList:
1001                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1002                sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
1003                sampleData.update(copy.deepcopy(copyDict))
1004        finally:
1005            dlg.Destroy()
1006
1007    def OnSampleFlagCopy(event):
1008        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1009        histType,copyNames = SetCopyNames(histName)
1010        flagDict = {}
1011        for parm in copyNames:
1012            flagDict[parm] = data[parm][1]
1013        histList = ['All '+histType,]
1014        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
1015        while item:
1016            name = G2frame.PatternTree.GetItemText(item)
1017            if histType in name and name != histName:
1018                histList.append(name)
1019            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
1020        if len(histList) == 1:      #nothing to copy to!
1021            return
1022        copyList = []
1023        dlg = wx.MultiChoiceDialog(G2frame,'Copy parameters from\n'+histName,
1024            'Copy refinement flags',histList,wx.CHOICEDLG_STYLE)
1025        try:
1026            if dlg.ShowModal() == wx.ID_OK:
1027                result = dlg.GetSelections()
1028                for i in result: 
1029                    copyList.append(histList[i])
1030                if 'All '+histType in copyList: 
1031                    copyList = histList[1:]
1032            for item in copyList:
1033                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1034                sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
1035                for name in copyNames:
1036                    sampleData[name][1] = copy.copy(flagDict[name])
1037        finally:
1038            dlg.Destroy()
1039
1040    if G2frame.dataDisplay:
1041        G2frame.dataFrame.Clear()
1042    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.SampleMenu)
1043    G2frame.dataFrame.SetLabel('Sample Parameters')
1044    G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
1045    G2frame.Bind(wx.EVT_MENU, OnSampleFlagCopy, id=G2gd.wxID_SAMPLEFLAGCOPY)
1046    if not G2frame.dataFrame.GetStatusBar():
1047        Status = G2frame.dataFrame.CreateStatusBar()   
1048    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
1049
1050#patch
1051    if not 'Gonio. radius' in data:
1052        data['Gonio. radius'] = 200.0
1053    if not 'Omega' in data:
1054        data.update({'Omega':0.0,'Chi':0.0,'Phi':0.0})
1055#patch end
1056   
1057    parms = [['Gonio. radius',' Goniometer radius(mm): ','%.2f',]]
1058    if data['Type'] == 'Debye-Scherrer':
1059        parms += [['DisplaceX',u' Sample X displacement(\xb5m): ','%.2f',],
1060            ['DisplaceY',u' Sample Y displacement(\xb5m): ','%.2f',],
1061            ['Absorption',u' Sample absorption(\xb5r): ','%.4f',],]
1062    elif data['Type'] == 'Bragg-Brentano':
1063        parms += [['Shift',u' Sample displacement(\xb5m): ','%.2f',],
1064            ['Transparency',u' Sample transparency(1/\xb5eff,cm): ','%.4f'],]
1065    parms.append(['Omega','Goniometer omega:','%.2f'])
1066    parms.append(['Chi','Goniometer chi:','%.2f'])
1067    parms.append(['Phi','Goniometer phi:','%.2f'])
1068    parms.append(['Temperature',' Sample temperature(K): ','%.2f'])
1069    parms.append(['Pressure',' Sample pressure(MPa): ','%.3f'])
1070    parms.append(['Humidity',' Sample humidity(%): ','%.1f'])
1071    parms.append(['Voltage',' Sample voltage(V): ','%.3f'])
1072    parms.append(['Force',' Applied load(MN): ','%.3f'])
1073    objList = {}
1074
1075    def OnScaleRef(event):
1076        Obj = event.GetEventObject()
1077        data['Scale'][1] = Obj.GetValue()
1078       
1079    def OnScaleVal(event):
1080        Obj = event.GetEventObject()
1081        try:
1082            scale = float(Obj.GetValue())
1083            if scale > 0:
1084                data['Scale'][0] = scale
1085        except ValueError:
1086            pass
1087        Obj.SetValue("%.4f"%(data['Scale'][0]))          #reset in case of error
1088       
1089    def OnHistoType(event):
1090        Obj = event.GetEventObject()
1091        data['Type'] = Obj.GetValue()
1092        if data['Type'] == 'Bragg-Brentano' and 'Shift' not in data:    #set up defaults for new type(s)
1093            data['Shift'] = [0.0,False]
1094            data['Transparency'] = [0.0,False]
1095        G2frame.dataDisplay.Destroy()
1096        UpdateSampleGrid(G2frame,data)
1097       
1098    def OnParmRef(event):
1099        Obj = event.GetEventObject()
1100        parm = objList[Obj.GetId()]
1101        data[parm][1] = Obj.GetValue()
1102       
1103    def OnParmVal(event):
1104        Obj = event.GetEventObject()
1105        parm = objList[Obj.GetId()]
1106        try:
1107            if 'list' in str(type(data[parm[0]])): 
1108                data[parm[0]][0] = float(Obj.GetValue())
1109            else:
1110                data[parm[0]] = float(Obj.GetValue())
1111        except ValueError:
1112            pass
1113        if 'list' in str(type(data[parm[0]])): 
1114            Obj.SetValue(parm[2]%(data[parm[0]][0]))          #reset in case of error
1115        else:
1116            Obj.SetValue(parm[2]%(data[parm[0]]))          #reset in case of error
1117               
1118    mainSizer = wx.BoxSizer(wx.VERTICAL)
1119    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample parameters: '),0,wx.ALIGN_CENTER_VERTICAL)
1120    mainSizer.Add((5,5),0)
1121    parmSizer = wx.FlexGridSizer(9,2,5,0)
1122    scaleRef = wx.CheckBox(G2frame.dataDisplay,label=' Histogram scale factor: ')
1123    scaleRef.SetValue(data['Scale'][1])
1124    scaleRef.Bind(wx.EVT_CHECKBOX, OnScaleRef)
1125    parmSizer.Add(scaleRef,0,wx.ALIGN_CENTER_VERTICAL)
1126    scaleVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
1127        '%.4f'%(data['Scale'][0]),style=wx.TE_PROCESS_ENTER)
1128    scaleVal.Bind(wx.EVT_TEXT_ENTER,OnScaleVal)
1129    scaleVal.Bind(wx.EVT_KILL_FOCUS,OnScaleVal)
1130    parmSizer.Add(scaleVal,0,wx.ALIGN_CENTER_VERTICAL)
1131    typeSizer = wx.BoxSizer(wx.HORIZONTAL)
1132    choices = ['Debye-Scherrer','Bragg-Brentano',]
1133    histoType = wx.ComboBox(G2frame.dataDisplay,wx.ID_ANY,value=data['Type'],choices=choices,
1134        style=wx.CB_READONLY|wx.CB_DROPDOWN)
1135    histoType.Bind(wx.EVT_COMBOBOX, OnHistoType)
1136    parmSizer.Add(histoType)
1137    parmSizer.Add((5,5),0)
1138   
1139    for parm in parms:
1140        if 'list' in str(type(data[parm[0]])):
1141            parmRef = wx.CheckBox(G2frame.dataDisplay,label=parm[1])
1142            objList[parmRef.GetId()] = parm[0]
1143            parmRef.SetValue(data[parm[0]][1])
1144            parmRef.Bind(wx.EVT_CHECKBOX, OnParmRef)
1145            parmSizer.Add(parmRef,0,wx.ALIGN_CENTER_VERTICAL)
1146            parmVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
1147                parm[2]%(data[parm[0]][0]),style=wx.TE_PROCESS_ENTER)
1148        else:
1149            parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=parm[1]),
1150                0,wx.ALIGN_CENTER_VERTICAL)
1151            parmVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
1152                parm[2]%(data[parm[0]]),style=wx.TE_PROCESS_ENTER)       
1153        objList[parmVal.GetId()] = parm
1154        parmVal.Bind(wx.EVT_TEXT_ENTER,OnParmVal)
1155        parmVal.Bind(wx.EVT_KILL_FOCUS,OnParmVal)
1156        parmSizer.Add(parmVal,1,wx.EXPAND)
1157    mainSizer.Add(parmSizer)
1158    mainSizer.Add((0,5),0)   
1159   
1160    mainSizer.Layout()   
1161    G2frame.dataDisplay.SetSizer(mainSizer)
1162    Size = mainSizer.Fit(G2frame.dataFrame)
1163    G2frame.dataDisplay.SetSize(Size)
1164    G2frame.dataFrame.setSizePosLeft(Size)
1165               
1166################################################################################
1167#####  Indexing Peaks
1168################################################################################           
1169       
1170def UpdateIndexPeaksGrid(G2frame, data):
1171    IndexId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
1172    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
1173    Inst = dict(zip(inst[3],inst[1]))
1174    try:
1175        wave = Inst['Lam']
1176    except KeyError:
1177        wave = Inst['Lam1']
1178   
1179    def RefreshIndexPeaksGrid(event):
1180        r,c =  event.GetRow(),event.GetCol()
1181        data = G2frame.IndexPeaksTable.GetData()
1182        if c == 2:
1183            if data[r][c]:
1184                data[r][c] = False
1185            else:
1186                data[r][c] = True
1187            G2frame.IndexPeaksTable.SetData(data)
1188            G2frame.PatternTree.SetItemPyData(IndexId,data)
1189            G2frame.dataDisplay.ForceRefresh()
1190           
1191    def OnReload(event):
1192        data = []
1193        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
1194        for peak in peaks:
1195            dsp = wave/(2.0*sind((peak[0]-Inst['Zero'])/2.0))
1196            data.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
1197        G2frame.PatternTree.SetItemPyData(IndexId,data)
1198        UpdateIndexPeaksGrid(G2frame,data)
1199       
1200    def KeyEditPickGrid(event):
1201        colList = G2frame.dataDisplay.GetSelectedCols()
1202        rowList = G2frame.dataDisplay.GetSelectedRows()
1203        data = G2frame.PatternTree.GetItemPyData(IndexId)
1204        if event.GetKeyCode() == wx.WXK_RETURN:
1205            event.Skip(True)
1206        elif event.GetKeyCode() == wx.WXK_CONTROL:
1207            event.Skip(True)
1208        elif event.GetKeyCode() == wx.WXK_SHIFT:
1209            event.Skip(True)
1210        elif colList:
1211            G2frame.dataDisplay.ClearSelection()
1212            key = event.GetKeyCode()
1213            for col in colList:
1214                if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
1215                    if key == 89: #'Y'
1216                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=True
1217                    elif key == 78:  #'N'
1218                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=False
1219           
1220    if G2frame.dataDisplay:
1221        G2frame.dataFrame.Clear()
1222    if not G2frame.dataFrame.GetStatusBar():
1223        Status = G2frame.dataFrame.CreateStatusBar()
1224    if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1225        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.IndPeaksMenu)
1226        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
1227    G2frame.dataFrame.IndexPeaks.Enable(False)
1228    G2frame.IndexPeaksTable = []
1229    if data:
1230        G2frame.dataFrame.IndexPeaks.Enable(True)
1231        cells = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
1232        if cells:
1233            cellist = cells[2]
1234            dmin = cells[3]
1235            G2frame.HKL = []
1236            for i,cell in enumerate(cellist):
1237                if cell[-1]:
1238                    ibrav = cell[2]
1239                    A = G2lat.cell2A(cell[3:9])
1240                    G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1241                    G2indx.IndexPeaks(data,G2frame.HKL)
1242                    for hkl in G2frame.HKL:
1243                        hkl.append(2.0*asind(wave/(2.*hkl[3]))+Inst['Zero'])             
1244    rowLabels = []
1245    for i in range(len(data)): rowLabels.append(str(i+1))
1246    colLabels = ['position','intensity','use','indexed','h','k','l','d-obs','d-calc']
1247    Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
1248        wg.GRID_VALUE_BOOL,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,
1249        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5']
1250    G2frame.PatternTree.SetItemPyData(IndexId,data)
1251    G2frame.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1252    G2frame.dataFrame.SetLabel('Index Peak List')
1253    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)               
1254    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
1255    for r in range(G2frame.dataDisplay.GetNumberRows()):
1256        for c in range(G2frame.dataDisplay.GetNumberCols()):
1257            if c == 2:
1258                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
1259            else:
1260                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
1261    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
1262    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
1263    G2frame.dataDisplay.SetMargins(0,0)
1264    G2frame.dataDisplay.AutoSizeColumns(False)
1265    G2frame.dataFrame.setSizePosLeft([490,300])
1266 
1267################################################################################
1268#####  Unit cells
1269################################################################################           
1270       
1271def UpdateUnitCellsGrid(G2frame, data):
1272    UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
1273    bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
1274        'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
1275    spaceGroups = ['F m 3 m','I m 3 m','P m 3 m','R -3 H','P 6/m m m','I 4/m m m',
1276        'P 4/m m m','F m m m','I m m m','C m m m','P m m m','C 2/m','P 2/m','P -1']
1277    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
1278    Inst = dict(zip(inst[3],inst[1]))
1279    if 'Lam' in Inst:
1280        wave = Inst['Lam']
1281    else:
1282        wave = Inst['Lam1']
1283       
1284    def SetLattice(controls):
1285        ibrav = bravaisSymb.index(controls[5])
1286        if ibrav in [0,1,2]:
1287            controls[7] = controls[8] = controls[6]
1288            controls[9] = controls[10] = controls[11] = 90.
1289        elif ibrav in [3,4,5,6]:
1290            controls[7] = controls[6]
1291            controls[9] = controls[10] = controls[11] = 90.
1292            if ibrav in [3,4]:
1293                controls[11] = 120.
1294        elif ibrav in [7,8,9,10]:
1295            controls[9] = controls[10] = controls[11] = 90.
1296        elif ibrav in [11,12]:
1297            controls[9] = controls[11] = 90.  # b unique
1298        if len(controls) < 13: controls.append(0)
1299        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1300        return ibrav
1301       
1302    def OnNcNo(event):
1303        controls[2] = NcNo.GetValue()
1304       
1305    def OnStartVol(event):
1306        try:
1307            stVol = int(float(startVol.GetValue()))
1308            if stVol < 25:
1309                raise ValueError
1310        except ValueError:
1311            stVol = 25
1312        controls[3] = stVol
1313        startVol.SetValue("%d"%(stVol))
1314       
1315    def OnBravais(event):
1316        Obj = event.GetEventObject()
1317        bravais[bravList.index(Obj.GetId())] = Obj.GetValue()
1318       
1319    def OnZero(event):
1320        try:
1321            Zero = min(5.0,max(-5.0,float(zero.GetValue())))
1322        except ValueError:
1323            Zero = 0.0
1324        controls[1] = Zero
1325        zero.SetValue("%.4f"%(Zero))
1326       
1327    def OnZeroVar(event):
1328        controls[0] = zeroVar.GetValue()
1329       
1330    def OnBravSel(event):
1331        controls[5] = bravSel.GetString(bravSel.GetSelection())       
1332        UpdateUnitCellsGrid(G2frame,data)
1333       
1334    def OnCellChange(event):
1335        ibrav = bravaisSymb.index(controls[5])
1336        Obj = event.GetEventObject()
1337        ObjId = cellList.index(Obj.GetId())
1338        try:
1339            value = max(1.0,float(Obj.GetValue()))
1340        except ValueError:
1341            if ObjId < 3:               #bad cell edge - reset
1342                value = controls[6+ObjId]
1343            else:                       #bad angle
1344                value = 90.
1345        if ibrav in [0,1,2]:
1346            controls[6] = controls[7] = controls[8] = value
1347            controls[9] = controls[10] = controls[11] = 90.0
1348            Obj.SetValue("%.5f"%(controls[6]))
1349        elif ibrav in [3,4,5,6]:
1350            if ObjId == 0:
1351                controls[6] = controls[7] = value
1352                Obj.SetValue("%.5f"%(controls[6]))
1353            else:
1354                controls[8] = value
1355                Obj.SetValue("%.5f"%(controls[8]))
1356            controls[9] = controls[10] = controls[11] = 90.0
1357            if ibrav in [3,4]:
1358                controls[11] = 120.
1359        elif ibrav in [7,8,9,10]:
1360            controls[6+ObjId] = value
1361            Obj.SetValue("%.5f"%(controls[6+ObjId]))
1362            controls[9] = controls[10] = controls[11] = 90.0
1363        elif ibrav in [11,12]:
1364            controls[9] = controls[11] = 90.0
1365            if ObjId != 3:
1366                controls[6+ObjId] = value
1367                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1368            else:
1369                controls[10] = value
1370                Obj.SetValue("%.3f"%(controls[10]))
1371        else:
1372            controls[6+ObjId] = value
1373            if ObjId < 3:
1374                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1375            else:
1376                Obj.SetValue("%.3f"%(controls[6+ObjId]))
1377        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1378        volVal.SetValue("%.3f"%(controls[12]))
1379       
1380    def OnHklShow(event):
1381        PatternId = G2frame.PatternId
1382        PickId = G2frame.PickId   
1383        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
1384        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1385        cell = controls[6:12]
1386        A = G2lat.cell2A(cell)
1387        ibrav = bravaisSymb.index(controls[5])
1388        dmin = wave/(2.0*sind(limits[1]/2.0))
1389        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1390        for hkl in G2frame.HKL:
1391            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
1392        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1393            G2plt.PlotPowderLines(G2frame)
1394        else:
1395            G2plt.PlotPatterns(G2frame)
1396           
1397    def OnSortCells(event):
1398        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1399        c =  event.GetCol()
1400        if colLabels[c] == 'M20':
1401            cells = G2indx.sortM20(cells)
1402        elif colLabels[c] == 'Volume':
1403            cells = G2indx.sortVolume(cells)
1404        else:
1405            return
1406        data = [controls,bravais,cells,dmin]
1407        G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
1408        UpdateUnitCellsGrid(G2frame,data)
1409       
1410    def CopyUnitCell(event):
1411        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1412        for Cell in cells:
1413            if Cell[-1]:
1414                break
1415        cell = Cell[2:9]
1416        controls[4] = 1
1417        controls[5] = bravaisSymb[cell[0]]
1418        controls[6:12] = cell[1:8]
1419        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1420        G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin])
1421        UpdateUnitCellsGrid(G2frame,data)
1422       
1423        G2frame.dataFrame.RefineCell.Enable(True)
1424               
1425    def RefineCell(event):
1426        def cellPrint(ibrav,A):
1427            cell = G2lat.A2cell(A)
1428            Vol = G2lat.calc_V(A)
1429            if ibrav in [0,1,2]:
1430                print "%s%10.6f" % ('a =',cell[0])
1431            elif ibrav in [3,4,5,6]:
1432                print "%s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],' c =',cell[2],' volume =',Vol)
1433            elif ibrav in [7,8,9,10]:
1434                print "%s%10.6f %s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],' volume =',Vol)
1435            elif ibrav in [11,12]:
1436                print "%s%10.6f %s%10.6f %s%10.6f %s%8.3f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],'beta =',cell[4],' volume =',Vol)
1437            else:
1438                print "%s%10.6f %s%10.6f %s%10.6f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2])
1439                print "%s%8.3f %s%8.3f %s%8.3f %s%12.3f" % ('alpha =',cell[3],'beta =',cell[4],'gamma =',cell[5],' volume =',Vol)
1440             
1441        PatternId = G2frame.PatternId
1442        PickId = G2frame.PickId   
1443        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
1444        if not peaks:
1445            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
1446            return       
1447        print 'Refine cell'
1448        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1449        cell = controls[6:12]
1450        A = G2lat.cell2A(cell)
1451        ibrav = bravaisSymb.index(controls[5])
1452        dmin = G2indx.getDmin(peaks)-0.005
1453        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1454        G2indx.IndexPeaks(peaks,G2frame.HKL)
1455        Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks,wave,ibrav,A,controls[1],controls[0])           
1456        controls[1] = Zero
1457        controls[6:12] = G2lat.A2cell(Aref)
1458        controls[12] = G2lat.calc_V(Aref)
1459        data = [controls,bravais,cells,dmin]
1460        cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
1461        for cell in cells:
1462            cell[-1] = False
1463        cells.insert(0,[M20,X20,ibrav]+controls[6:13]+[True,])
1464        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
1465        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
1466        UpdateUnitCellsGrid(G2frame,data)
1467        print "%s%10.3f" % ('refinement M20 = ',M20)
1468        print 'unindexed lines = ',X20
1469        cellPrint(ibrav,Aref)
1470        for hkl in G2frame.HKL:
1471            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
1472        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1473            G2plt.PlotPowderLines(G2frame)
1474        else:
1475            G2plt.PlotPatterns(G2frame)
1476       
1477    def IndexPeaks(event):
1478        PatternId = G2frame.PatternId   
1479        print 'Peak Indexing'
1480        try:
1481            controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1482            cells = []
1483        except ValueError:
1484            G2frame.ErrorDialog('Error','Need to set controls in Unit Cell List first')
1485            return
1486        if True not in bravais:
1487            G2frame.ErrorDialog('Error','No Bravais lattices selected')
1488            return
1489        G2frame.dataFrame.CopyCell.Enable(False)
1490        G2frame.dataFrame.RefineCell.Enable(False)
1491        OK,dmin,cells = G2indx.DoIndexPeaks(peaks,inst[1],controls,bravais)
1492        if OK:
1493            data = [controls,bravais,cells,dmin]
1494            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
1495            UpdateUnitCellsGrid(G2frame,data)
1496            bestCell = cells[0]
1497            if bestCell[0] > 10.:
1498                G2frame.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
1499                for hkl in G2frame.HKL:
1500                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
1501                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1502                    G2plt.PlotPowderLines(G2frame)
1503                else:
1504                    G2plt.PlotPatterns(G2frame)
1505            G2frame.dataFrame.CopyCell.Enable(True)
1506            G2frame.dataFrame.IndexPeaks.Enable(True)
1507            G2frame.dataFrame.MakeNewPhase.Enable(True)
1508            UpdateUnitCellsGrid(G2frame,data)
1509               
1510    def RefreshUnitCellsGrid(event):
1511        cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2:]
1512        r,c =  event.GetRow(),event.GetCol()
1513        if cells:
1514            if c == 2:
1515                for i in range(len(cells)):
1516                    cells[i][-1] = False
1517                    UnitCellsTable.SetValue(i,c,False)
1518                UnitCellsTable.SetValue(r,c,True)
1519                gridDisplay.ForceRefresh()
1520                cells[r][-1] = True
1521                ibrav = cells[r][2]
1522                A = G2lat.cell2A(cells[r][3:9])
1523                G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1524                for hkl in G2frame.HKL:
1525                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
1526                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1527                    G2plt.PlotPowderLines(G2frame)
1528                else:
1529                    G2plt.PlotPatterns(G2frame)
1530       
1531    def MakeNewPhase(event):
1532        if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
1533            sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
1534        else:
1535            sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
1536        PhaseName = ''
1537        dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
1538            style=wx.OK)
1539        try:
1540            if dlg.ShowModal() == wx.ID_OK:
1541                PhaseName = dlg.GetValue()
1542                cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
1543                for Cell in cells:
1544                    if Cell[-1]:
1545                        break
1546                cell = Cell[2:10]       
1547                sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
1548                E,SGData = G2spc.SpcGroup(spaceGroups[cell[0]])
1549                G2frame.PatternTree.SetItemPyData(sub, \
1550                    G2IO.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:]))
1551                Status.SetStatusText('Change space group if needed')
1552        finally:
1553            dlg.Destroy()
1554           
1555    if G2frame.dataDisplay:
1556        G2frame.dataFrame.Clear()
1557    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.IndexMenu)
1558    if not G2frame.dataFrame.GetStatusBar():
1559        Status = G2frame.dataFrame.CreateStatusBar()
1560    G2frame.Bind(wx.EVT_MENU, IndexPeaks, id=G2gd.wxID_INDEXPEAKS)
1561    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
1562    G2frame.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
1563    G2frame.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
1564   
1565    controls,bravais,cells,dmin = data
1566    if len(controls) < 13:              #add cell volume if missing
1567        controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
1568    G2frame.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
1569    bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
1570        'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
1571        'Orthorhombic-P','Monoclinic-C','Monoclinic-P','Triclinic']
1572    cellGUIlist = [[[0,1,2],4,zip([" Unit cell: a = "," Vol = "],["%.5f","%.3f"],[True,False],[0,0])],
1573    [[3,4,5,6],6,zip([" Unit cell: a = "," c = "," Vol = "],["%.5f","%.5f","%.3f"],[True,True,False],[0,2,0])],
1574    [[7,8,9,10],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "],["%.5f","%.5f","%.5f","%.3f"],
1575        [True,True,True,False],[0,1,2,0])],
1576    [[11,12],10,zip([" Unit cell: a = "," b = "," c = "," beta = "," Vol = "],
1577        ["%.5f","%.5f","%.5f","%.3f","%.3f"],[True,True,True,True,False],[0,1,2,4,0])],
1578    [[13,],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "," alpha = "," beta = "," gamma = "],
1579        ["%.5f","%.5f","%.5f","%.3f","%.3f","%.3f","%.3f"],
1580        [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
1581   
1582    G2frame.dataFrame.SetLabel('Unit Cells List')
1583    G2frame.sp = wx.SplitterWindow(G2frame.dataFrame)
1584    G2frame.dataDisplay = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
1585    G2frame.dataFrame.IndexPeaks.Enable(False)
1586    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
1587    if peaks:
1588        G2frame.dataFrame.IndexPeaks.Enable(True)
1589    G2frame.dataFrame.RefineCell.Enable(False)
1590    if controls[12] > 1.0:                               #if a "real" volume (i.e. not default)
1591        G2frame.dataFrame.RefineCell.Enable(True)   
1592    G2frame.dataFrame.CopyCell.Enable(False)
1593    G2frame.dataFrame.MakeNewPhase.Enable(False)       
1594    if cells:
1595        G2frame.bottom = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
1596        G2frame.sp.SplitHorizontally(G2frame.dataDisplay,G2frame.bottom,0)
1597        G2frame.dataFrame.CopyCell.Enable(True)
1598        G2frame.dataFrame.MakeNewPhase.Enable(True)       
1599    mainSizer = wx.BoxSizer(wx.VERTICAL)
1600    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,wx.ALIGN_CENTER_VERTICAL)
1601    mainSizer.Add((5,5),0)
1602    littleSizer = wx.FlexGridSizer(2,5,5,5)
1603    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,wx.ALIGN_CENTER_VERTICAL)
1604    NcNo = wx.SpinCtrl(G2frame.dataDisplay)
1605    NcNo.SetRange(1,6)
1606    NcNo.SetValue(controls[2])
1607    NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
1608    littleSizer.Add(NcNo,0,wx.ALIGN_CENTER_VERTICAL)
1609    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start Volume '),0,wx.ALIGN_CENTER_VERTICAL)
1610    startVol = wx.TextCtrl(G2frame.dataDisplay,value=str('%d'%(controls[3])),style=wx.TE_PROCESS_ENTER)
1611    startVol.Bind(wx.EVT_TEXT_ENTER,OnStartVol)
1612    startVol.Bind(wx.EVT_KILL_FOCUS,OnStartVol)
1613    littleSizer.Add(startVol,0,wx.ALIGN_CENTER_VERTICAL)
1614    mainSizer.Add(littleSizer,0)
1615    mainSizer.Add((5,5),0)
1616    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
1617        0,wx.ALIGN_CENTER_VERTICAL)
1618    mainSizer.Add((5,5),0)
1619    littleSizer = wx.FlexGridSizer(2,7,5,5)
1620    bravList = []
1621    bravs = zip(bravais,bravaisNames)
1622    for brav,bravName in bravs:
1623        bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
1624        bravList.append(bravCk.GetId())
1625        bravCk.SetValue(brav)
1626        bravCk.Bind(wx.EVT_CHECKBOX,OnBravais)
1627        littleSizer.Add(bravCk,0,wx.ALIGN_CENTER_VERTICAL)
1628    mainSizer.Add(littleSizer,0)
1629    mainSizer.Add((5,5),0)
1630   
1631    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Refinement: '),0,wx.ALIGN_CENTER_VERTICAL)
1632    mainSizer.Add((5,5),0)
1633    littleSizer = wx.BoxSizer(wx.HORIZONTAL)
1634    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,wx.ALIGN_CENTER_VERTICAL)
1635    bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
1636    bravSel.SetSelection(bravaisSymb.index(controls[5]))
1637    bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
1638    littleSizer.Add(bravSel,0,wx.ALIGN_CENTER_VERTICAL)
1639    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,wx.ALIGN_CENTER_VERTICAL)
1640    zero = wx.TextCtrl(G2frame.dataDisplay,value="%.4f"%(controls[1]),style=wx.TE_PROCESS_ENTER)
1641    zero.Bind(wx.EVT_TEXT_ENTER,OnZero)
1642    zero.Bind(wx.EVT_KILL_FOCUS,OnZero)
1643    littleSizer.Add(zero,0,wx.ALIGN_CENTER_VERTICAL)
1644    zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
1645    zeroVar.SetValue(controls[0])
1646    zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
1647    littleSizer.Add(zeroVar,0,wx.ALIGN_CENTER_VERTICAL)
1648    hklShow = wx.Button(G2frame.dataDisplay,label="Show refined hkl positions + Zero offset")
1649    hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
1650    littleSizer.Add(hklShow,0,wx.ALIGN_CENTER_VERTICAL)
1651    mainSizer.Add(littleSizer,0)
1652   
1653    mainSizer.Add((5,5),0)
1654    ibrav = SetLattice(controls)
1655    for cellGUI in cellGUIlist:
1656        if ibrav in cellGUI[0]:
1657            useGUI = cellGUI
1658    cellList = []
1659    littleSizer = wx.FlexGridSizer(2,useGUI[1],5,5)
1660    for txt,fmt,ifEdit,Id in useGUI[2]:
1661        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,wx.ALIGN_CENTER_VERTICAL)
1662        if ifEdit:          #a,b,c,etc.
1663            cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
1664            cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)       
1665            cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
1666            littleSizer.Add(cellVal,0,wx.ALIGN_CENTER_VERTICAL)
1667            cellList.append(cellVal.GetId())
1668        else:               #volume
1669            volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
1670            volVal.SetBackgroundColour(VERY_LIGHT_GREY)
1671            littleSizer.Add(volVal,0,wx.ALIGN_CENTER_VERTICAL)
1672    mainSizer.Add(littleSizer,0)
1673       
1674    mainSizer.Layout()   
1675    G2frame.dataDisplay.SetSizer(mainSizer)
1676    topSize = mainSizer.Fit(G2frame.dataFrame)
1677    G2frame.dataDisplay.SetSize(topSize)
1678    if cells:
1679        if ibrav == 13:
1680            topSize[1] += 230
1681        else:
1682            topSize[1] += 200
1683    G2frame.dataFrame.setSizePosLeft(topSize)   
1684   
1685    if cells:
1686        bottomSize = G2frame.bottom.GetSize()
1687        if ibrav == 13:
1688            bottomSize[1] -= 240
1689        else:
1690            bottomSize[1] -= 210
1691        wx.StaticText(parent=G2frame.bottom,label=' Indexing Result ')
1692        rowLabels = []
1693        colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume']
1694        Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_NUMBER,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_STRING,]+ \
1695            3*[wg.GRID_VALUE_FLOAT+':10,5',]+3*[wg.GRID_VALUE_FLOAT+':10,3',]+ \
1696            [wg.GRID_VALUE_FLOAT+':10,2']
1697        numRows = len(cells)
1698        table = []
1699        for cell in cells:
1700            rowLabels.append('')
1701            row = cell[0:2]+[cell[-1]]+[bravaisSymb[cell[2]]]+cell[3:10]
1702            if cell[-1]:
1703                A = G2lat.cell2A(cell[3:9])
1704                G2frame.HKL = G2lat.GenHBravais(dmin,cell[2],A)
1705                for hkl in G2frame.HKL:
1706                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
1707            table.append(row)
1708        UnitCellsTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1709        gridDisplay = G2gd.GSGrid(G2frame.bottom)
1710        gridDisplay.SetPosition(wx.Point(0,20))               
1711        gridDisplay.SetTable(UnitCellsTable, True)
1712        G2frame.dataFrame.CopyCell.Enable(True)
1713        gridDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshUnitCellsGrid)
1714        gridDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK,OnSortCells)
1715        gridDisplay.SetMargins(0,0)
1716        gridDisplay.SetRowLabelSize(0)
1717        gridDisplay.AutoSizeColumns(False)
1718        for r in range(gridDisplay.GetNumberRows()):
1719            for c in range(gridDisplay.GetNumberCols()):
1720                if c == 2:
1721                    gridDisplay.SetReadOnly(r,c,isReadOnly=False)
1722                else:
1723                    gridDisplay.SetReadOnly(r,c,isReadOnly=True)
1724        gridDisplay.SetSize(bottomSize)
1725
1726################################################################################
1727#####  Reflection list
1728################################################################################           
1729       
1730def UpdateReflectionGrid(G2frame,data):
1731    if not data:
1732        print 'No phases, no reflections'
1733        return
1734    phases = data.keys()
1735   
1736    def OnSelectPhase(event):
1737        dlg = wx.SingleChoiceDialog(G2frame,'Select','Phase',phases)
1738        try:
1739            if dlg.ShowModal() == wx.ID_OK:
1740                sel = dlg.GetSelection()
1741                G2frame.RefList = phases[sel]
1742                UpdateReflectionGrid(G2frame,data)
1743        finally:
1744            dlg.Destroy()
1745        G2plt.PlotPatterns(G2frame)
1746       
1747       
1748    if G2frame.dataDisplay:
1749        G2frame.dataFrame.Clear()
1750    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ReflMenu)
1751    if not G2frame.dataFrame.GetStatusBar():
1752        Status = G2frame.dataFrame.CreateStatusBar()   
1753    G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
1754    G2frame.dataFrame.SelectPhase.Enable(False)
1755    if len(data) > 1:
1756        G2frame.dataFrame.SelectPhase.Enable(True)
1757    rowLabels = []
1758    refList = [refl[:11] for refl in data[G2frame.RefList]]
1759    for i in range(len(refList)): rowLabels.append(str(i))
1760    colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase',]
1761    Types = 4*[wg.GRID_VALUE_LONG,]+4*[wg.GRID_VALUE_FLOAT+':10,4',]+2*[wg.GRID_VALUE_FLOAT+':10,2',]+[wg.GRID_VALUE_FLOAT+':10,3',]
1762    G2frame.PeakTable = G2gd.Table(refList,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1763    G2frame.dataFrame.SetLabel('Reflection List for '+G2frame.RefList)
1764    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
1765    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
1766    G2frame.dataDisplay.EnableEditing(False)
1767    G2frame.dataDisplay.SetMargins(0,0)
1768    G2frame.dataDisplay.AutoSizeColumns(False)
1769    G2frame.dataFrame.setSizePosLeft([555,350])
1770
1771################################################################################
1772#####  PDF controls
1773################################################################################           
1774       
1775def UpdatePDFGrid(G2frame,data):
1776    global inst
1777    tth2q = lambda t,w:4.0*math.pi*sind(t/2.0)/w
1778    dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1779    powName = 'PWDR'+dataFile[4:]
1780    powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
1781    fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))
1782    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))
1783    inst = dict(zip(inst[3],inst[1]))
1784    if 'Lam' in inst:
1785        keV = 12.397639/inst['Lam']
1786    else:
1787        keV = 12.397639/inst['Lam1']
1788    wave = 12.397639/keV
1789    qLimits = [tth2q(fullLimits[0],wave),tth2q(fullLimits[1],wave)]
1790    data['QScaleLim'][1] = min(qLimits[1],data['QScaleLim'][1])
1791    if data['QScaleLim'][0]:
1792        data['QScaleLim'][0] = max(qLimits[0],data['QScaleLim'][0])
1793    else:                                #initial setting at 90% of max Q
1794        data['QScaleLim'][0] = 0.90*data['QScaleLim'][1]
1795    polariz = inst['Polariz.']
1796    azimuth = inst['Azimuth']
1797    itemDict = {}
1798   
1799    def FillFileSizer(fileSizer,key):
1800        #fileSizer is a FlexGridSizer(3,6)
1801       
1802        def OnSelectFile(event):
1803            Obj = event.GetEventObject()
1804            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
1805            if itemKey == 'Name':
1806                value = Obj.GetValue()
1807            Obj.SetValue(fmt%(value))
1808            data[fileKey][itemKey] = value
1809            UpdatePDFGrid(G2frame,data)
1810       
1811        def OnValueChange(event):
1812            Obj = event.GetEventObject()
1813            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
1814            try:
1815                value = float(Obj.GetValue())
1816            except ValueError:
1817                value = -1.0
1818            Obj.SetValue(fmt%(value))
1819            data[fileKey][itemKey] = value
1820            auxPlot = ComputePDF(data)
1821            G2plt.PlotISFG(G2frame,newPlot=True)
1822                       
1823        item = data[key]
1824        fileList = np.array(GetFileList('PWDR')).T[1]
1825        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,wx.ALIGN_CENTER_VERTICAL)
1826        fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
1827            style=wx.CB_READONLY|wx.CB_DROPDOWN)
1828        itemDict[fileName.GetId()] = [key,'Name','%s']
1829        fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)       
1830        fileSizer.Add(fileName,0,)
1831        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,wx.ALIGN_CENTER_VERTICAL)
1832        mult = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(item['Mult']),style=wx.TE_PROCESS_ENTER)
1833        itemDict[mult.GetId()] = [key,'Mult','%.3f']
1834        mult.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
1835        mult.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
1836        fileSizer.Add(mult,0,)
1837        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Add:'),0,wx.ALIGN_CENTER_VERTICAL)
1838        add = wx.TextCtrl(G2frame.dataDisplay,value='%.0f'%(item['Add']),style=wx.TE_PROCESS_ENTER)
1839        itemDict[add.GetId()] = [key,'Add','%.0f']
1840        add.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
1841        add.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
1842        fileSizer.Add(add,0,)
1843       
1844    def SumElementVolumes():
1845        sumVol = 0.
1846        ElList = data['ElList']
1847        for El in ElList:
1848            Avol = (4.*math.pi/3.)*ElList[El]['Drad']**3
1849            sumVol += Avol*ElList[El]['FormulaNo']
1850        return sumVol
1851        auxPlot = ComputePDF(data)
1852        G2plt.PlotISFG(G2frame,newPlot=True)       
1853       
1854    def FillElemSizer(elemSizer,ElData):
1855       
1856        def OnFractionChange(event):
1857            try:
1858                value = max(0.0,float(num.GetValue()))
1859            except ValueError:
1860                value = 0.0
1861            num.SetValue('%.3f'%(value))
1862            ElData['FormulaNo'] = value
1863            data['Form Vol'] = max(10.0,SumElementVolumes())
1864            formVol.SetValue('%.2f'%(data['Form Vol']))
1865            UpdatePDFGrid(G2frame,data)
1866            auxPlot = ComputePDF(data)
1867            G2plt.PlotISFG(G2frame,newPlot=True)       
1868       
1869        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
1870            label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,wx.ALIGN_CENTER_VERTICAL)
1871        num = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(ElData['FormulaNo']),style=wx.TE_PROCESS_ENTER)
1872        num.Bind(wx.EVT_TEXT_ENTER,OnFractionChange)       
1873        num.Bind(wx.EVT_KILL_FOCUS,OnFractionChange)
1874        elemSizer.Add(num,0,wx.ALIGN_CENTER_VERTICAL)
1875        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
1876            label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
1877            0,wx.ALIGN_CENTER_VERTICAL)
1878           
1879    def OnGeometry(event):
1880        data['Geometry'] = geometry.GetValue()
1881        UpdatePDFGrid(G2frame,data)
1882        auxPlot = ComputePDF(data)
1883        G2plt.PlotISFG(G2frame,newPlot=True)       
1884       
1885    def OnDetType(event):
1886        data['DetType'] = detType.GetValue()
1887        UpdatePDFGrid(G2frame,data)
1888        auxPlot = ComputePDF(data)
1889        G2plt.PlotISFG(G2frame,newPlot=True)       
1890       
1891    def OnFormVol(event):
1892        try:
1893            value = float(formVol.GetValue())
1894            if value <= 0.0:
1895                raise ValueError
1896        except ValueError:
1897            value = data['Form Vol']
1898        data['Form Vol'] = value
1899        UpdatePDFGrid(G2frame,data)
1900        auxPlot = ComputePDF(data)
1901        G2plt.PlotISFG(G2frame,newPlot=False)       
1902       
1903    def OnDiameter(event):
1904        try:
1905            value = float(diam.GetValue())
1906            if value <= 0.0:
1907                raise ValueError
1908        except ValueError:
1909            value = data['Diam']
1910        data['Diam'] = value
1911        UpdatePDFGrid(G2frame,data)
1912        auxPlot = ComputePDF(data)
1913        G2plt.PlotISFG(G2frame,newPlot=False)
1914       
1915    def OnPolaVal(event):
1916        try:
1917            value = float(polaVal.GetValue())
1918            if not (0.0 <= value <= 1.0):
1919                raise ValueError
1920        except ValueError:
1921            value = inst['Polariz.']
1922        inst['Polariz.'] = value
1923        polaVal.SetValue('%.2f'%(inst['Polariz.']))
1924        UpdatePDFGrid(G2frame,data)
1925        auxPlot = ComputePDF(data)
1926        G2plt.PlotISFG(G2frame,newPlot=False)
1927               
1928    def OnAzimVal(event):
1929        try:
1930            value = float(azimVal.GetValue())
1931            if not (0. <= value <= 360.):
1932                raise ValueError
1933        except ValueError:
1934            value = inst['Azimuth']
1935        inst['Azimuth'] = value
1936        azimVal.SetValue('%.1f'%(inst['Azimuth']))
1937        UpdatePDFGrid(G2frame,data)
1938        auxPlot = ComputePDF(data)
1939        G2plt.PlotISFG(G2frame,newPlot=False)
1940                       
1941    def OnObliqCoeff(event):
1942        try:
1943            value = float(obliqCoeff.GetValue())
1944            if value < 0.0:
1945                raise ValueError
1946            elif value > 1.0:
1947                value = 1.0
1948        except ValueError:
1949            value = data['ObliqCoeff']
1950        data['ObliqCoeff'] = value
1951        obliqCoeff.SetValue('%.3f'%(value))
1952        auxPlot = ComputePDF(data)
1953        G2plt.PlotISFG(G2frame,newPlot=False)
1954       
1955    def OnRulandWdt(event):
1956        try:
1957            value = float(rulandWdt.GetValue())
1958            if value <= 0.001:
1959                raise ValueError
1960            elif value > 1.0:
1961                value = 1.0
1962        except ValueError:
1963            value = data['Ruland']
1964        data['Ruland'] = value
1965        rulandWdt.SetValue('%.3f'%(value))
1966        auxPlot = ComputePDF(data)
1967        G2plt.PlotISFG(G2frame,newPlot=False)
1968       
1969    def OnRulSlider(event):
1970        value = int(rulandSldr.GetValue())/1000.
1971        data['Ruland'] = max(0.001,value)
1972        rulandWdt.SetValue('%.3f'%(data['Ruland']))
1973        auxPlot = ComputePDF(data)
1974        G2plt.PlotISFG(G2frame,newPlot=False)
1975       
1976    def OnLorch(event):
1977        data['Lorch'] = lorch.GetValue()
1978        auxPlot = ComputePDF(data)
1979        G2plt.PlotISFG(G2frame,newPlot=False)       
1980                       
1981    def OnPacking(event):
1982        try:
1983            value = float(pack.GetValue())
1984            if value <= 0.0:
1985                raise ValueError
1986        except ValueError:
1987            value = data['Pack']
1988        data['Pack'] = value
1989        UpdatePDFGrid(G2frame,data)
1990        auxPlot = ComputePDF(data)
1991        G2plt.PlotISFG(G2frame,newPlot=False)       
1992               
1993    def OnSQmin(event):
1994        try:
1995            value = float(SQmin.GetValue())
1996            if value < qLimits[0]:
1997                raise ValueError
1998        except ValueError:
1999            value = max(qLimits[0],data['QScaleLim'][0])
2000        data['QScaleLim'][0] = value
2001        SQmin.SetValue('%.1f'%(value))
2002        auxPlot = ComputePDF(data)
2003        G2plt.PlotISFG(G2frame,newPlot=True)       
2004       
2005    def OnSQmax(event):
2006        try:
2007            value = float(SQmax.GetValue())
2008            if value > qLimits[1]:
2009                raise ValueError
2010        except ValueError:
2011            value = min(qLimits[1],data['QScaleLim'][1])
2012        data['QScaleLim'][1] = value
2013        if value < data['QScaleLim'][0]:
2014            data['QScaleLim'][0] = 0.90*value
2015            SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
2016        SQmax.SetValue('%.1f'%(value))
2017        auxPlot = ComputePDF(data)
2018        G2plt.PlotISFG(G2frame,newPlot=True)
2019       
2020    def OnResetQ(event):
2021        resetQ.SetValue(False)
2022        data['QScaleLim'][1] = qLimits[1]
2023        SQmax.SetValue('%.1f'%(data['QScaleLim'][1]))
2024        data['QScaleLim'][0] = 0.9*qLimits[1]
2025        SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
2026        auxPlot = ComputePDF(data)
2027        G2plt.PlotISFG(G2frame,newPlot=True)       
2028
2029    def GetFileList(fileType,skip=None):
2030        fileList = [[False,'',0]]
2031        Source = ''
2032        id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2033        while id:
2034            name = G2frame.PatternTree.GetItemText(id)
2035            if fileType in name:
2036                if id == skip:
2037                    Source = name
2038                else:
2039                    fileList.append([False,name,id])
2040            id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2041        if skip:
2042            return fileList,Source
2043        else:
2044            return fileList
2045       
2046    def OnCopyPDFControls(event):
2047        import copy
2048        TextList,Source = GetFileList('PDF',skip=G2frame.PatternId)
2049        TextList[0] = [False,'All PDF',0]
2050        if len(TextList) == 1:
2051            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
2052            return
2053        dlg = G2frame.CopyDialog(G2frame,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
2054        try:
2055            if dlg.ShowModal() == wx.ID_OK:
2056                result = dlg.GetData()
2057                if result[0][0]:
2058                    result = TextList[1:]
2059                    for item in result: item[0] = True
2060                for i,item in enumerate(result):
2061                    ifcopy,name,id = item
2062                    if ifcopy:
2063                        olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
2064                        sample = olddata['Sample']
2065                        olddata.update(copy.deepcopy(data))
2066                        olddata['Sample'] = sample
2067                        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
2068                Status.SetStatusText('PDF controls copied')
2069        finally:
2070            dlg.Destroy()
2071               
2072    def OnSavePDFControls(event):
2073        print 'save PDF controls?'
2074       
2075    def OnLoadPDFControls(event):
2076        print 'Load PDF controls?'
2077       
2078    def OnAddElement(event):
2079        ElList = data['ElList']
2080        PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
2081        if PE.ShowModal() == wx.ID_OK:
2082            El = PE.Elem
2083            if El not in ElList and El != 'None':
2084                ElemSym = El.strip().upper()               
2085                FpMu = G2elem.FPcalc(G2elem.GetXsectionCoeff(ElemSym), keV)
2086                ElData = G2elem.GetFormFactorCoeff(ElemSym)[0]
2087                ElData['FormulaNo'] = 0.0
2088                ElData.update(G2elem.GetAtomInfo(ElemSym))
2089                ElData.update(dict(zip(['fp','fpp','mu'],FpMu)))
2090                ElData.update(G2elem.GetFFC5(El))
2091                data['ElList'][El] = ElData
2092            data['Form Vol'] = max(10.0,SumElementVolumes())
2093        PE.Destroy()
2094        UpdatePDFGrid(G2frame,data)
2095       
2096    def OnDeleteElement(event):
2097        ElList = data['ElList']
2098        choice = ElList.keys()
2099        dlg = G2elemGUI.DeleteElement(G2frame,choice=choice)
2100        if dlg.ShowModal() == wx.ID_OK:
2101            del ElList[dlg.GetDeleteElement()]
2102        dlg.Destroy()
2103        UpdatePDFGrid(G2frame,data)
2104               
2105    def ComputePDF(Data):
2106        xydata = {}
2107        for key in ['Sample','Sample Bkg.','Container','Container Bkg.']:
2108            name = Data[key]['Name']
2109            if name:
2110                xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
2111                PDFname = name
2112        powName = xydata['Sample'][2]
2113        powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
2114        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))
2115        inst = dict(zip(inst[3],inst[1]))
2116        auxPlot = G2pwd.CalcPDF(Data,inst,xydata)
2117        PDFId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PDF '+powName[4:])
2118        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
2119        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
2120        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
2121        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
2122        return auxPlot
2123       
2124    def OnComputePDF(event):
2125        print 'Calculating PDF:'
2126        auxPlot = ComputePDF(data)
2127        print 'Done calculating PDF:'
2128        Status.SetStatusText('PDF computed')
2129        for plot in auxPlot:
2130            G2plt.PlotXY(G2frame,plot[:2],type=plot[2])
2131       
2132        G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
2133        G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
2134        G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
2135        G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
2136       
2137    def OnComputeAllPDF(event):
2138        print 'Calculating PDFs:'
2139        if G2frame.PatternTree.GetCount():
2140            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2141            while id:
2142                Name = G2frame.PatternTree.GetItemText(id)
2143                if 'PDF' in Name:
2144                    Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
2145                    auxPlot = ComputePDF(Data)                   
2146                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2147            Status.SetStatusText('All PDFs computed')
2148            G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
2149            print ' Done calculating PDFs:'
2150       
2151    def OnShowTip(G2frame,tip):
2152        print tip   
2153               
2154    if G2frame.dataDisplay:
2155        G2frame.dataFrame.Clear()
2156    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.PDFMenu)
2157    if not G2frame.dataFrame.GetStatusBar():
2158        Status = G2frame.dataFrame.CreateStatusBar()   
2159    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2160    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
2161    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
2162    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
2163    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
2164    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
2165    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
2166    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
2167    mainSizer = wx.BoxSizer(wx.VERTICAL)
2168    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,wx.ALIGN_CENTER_VERTICAL)
2169    mainSizer.Add((5,5),0)
2170    str = ' Sample file: PWDR %s   Wavelength, A: %.5f  Energy, keV: %.3f  Polariz.: %.2f '%(dataFile[3:],wave,keV,polariz)
2171    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,wx.ALIGN_CENTER_VERTICAL)
2172#    dataSizer = wx.BoxSizer(wx.HORIZONTAL)
2173#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Azimuth'),0,wx.ALIGN_CENTER_VERTICAL)
2174#    azimVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Azimuth']))
2175#    azimVal.Bind(wx.EVT_TEXT_ENTER,OnAzimVal)       
2176#    azimVal.Bind(wx.EVT_KILL_FOCUS,OnAzimVal)
2177#    dataSizer.Add(azimVal,0)   
2178#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Polarization'),0,wx.ALIGN_CENTER_VERTICAL)
2179#    polaVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Polariz.']))
2180#    polaVal.Bind(wx.EVT_TEXT_ENTER,OnPolaVal)       
2181#    polaVal.Bind(wx.EVT_KILL_FOCUS,OnPolaVal)
2182#    dataSizer.Add(polaVal,0)   
2183#    mainSizer.Add(dataSizer,0)
2184    mainSizer.Add((5,5),0)
2185    fileSizer = wx.FlexGridSizer(3,6,5,1)
2186    select = ['Sample Bkg.','Container']
2187    if data['Container']['Name']:
2188        select.append('Container Bkg.')
2189    for key in select:
2190        FillFileSizer(fileSizer,key)
2191    mainSizer.Add(fileSizer,0)
2192    mainSizer.Add((5,5),0)
2193    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,wx.ALIGN_CENTER_VERTICAL)
2194    mainSizer.Add((5,5),0)   
2195
2196    ElList = data['ElList']
2197    Abs = G2lat.CellAbsorption(ElList,data['Form Vol'])
2198    Trans = G2pwd.Transmission(data['Geometry'],Abs*data['Pack'],data['Diam'])
2199    elemSizer = wx.FlexGridSizer(3,3,5,1)
2200    for El in ElList:
2201        FillElemSizer(elemSizer,ElList[El])
2202    mainSizer.Add(elemSizer,0)
2203    mainSizer.Add((5,5),0)   
2204    midSizer = wx.BoxSizer(wx.HORIZONTAL)
2205    midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,wx.ALIGN_CENTER_VERTICAL)
2206    formVol = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Form Vol']))
2207    formVol.Bind(wx.EVT_TEXT_ENTER,OnFormVol)       
2208    formVol.Bind(wx.EVT_KILL_FOCUS,OnFormVol)
2209    midSizer.Add(formVol,0)
2210    midSizer.Add(wx.StaticText(G2frame.dataDisplay,
2211        label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
2212        0,wx.ALIGN_CENTER_VERTICAL)
2213    mainSizer.Add(midSizer,0)
2214    mainSizer.Add((5,5),0)   
2215
2216    geoBox = wx.BoxSizer(wx.HORIZONTAL)
2217    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,wx.ALIGN_CENTER_VERTICAL)
2218    choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
2219    geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
2220            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2221    geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
2222    geoBox.Add(geometry,0)
2223    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,wx.ALIGN_CENTER_VERTICAL)
2224    diam = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Diam']))
2225    diam.Bind(wx.EVT_TEXT_ENTER,OnDiameter)       
2226    diam.Bind(wx.EVT_KILL_FOCUS,OnDiameter)
2227#    diam.Bind(wx.EVT_SET_FOCUS,OnShowTip(G2frame,'tip')) #this doesn't work - what would????
2228    geoBox.Add(diam,0)
2229    mainSizer.Add(geoBox,0)
2230    mainSizer.Add((5,5),0)   
2231    geoBox = wx.BoxSizer(wx.HORIZONTAL)
2232    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,wx.ALIGN_CENTER_VERTICAL)
2233    pack = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Pack']))
2234    pack.Bind(wx.EVT_TEXT_ENTER,OnPacking)       
2235    pack.Bind(wx.EVT_KILL_FOCUS,OnPacking)
2236    geoBox.Add(pack,0)
2237    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,wx.ALIGN_CENTER_VERTICAL)   
2238    mainSizer.Add(geoBox,0)
2239    mainSizer.Add((5,5),0)   
2240       
2241    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,wx.ALIGN_CENTER_VERTICAL)
2242    mainSizer.Add((5,5),0)
2243    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2244    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,wx.ALIGN_CENTER_VERTICAL)
2245    choice = ['Image plate','Point detector']
2246    detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
2247            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2248    detType.Bind(wx.EVT_COMBOBOX, OnDetType)
2249    sqBox.Add(detType,0)
2250    if data['DetType'] == 'Image plate':
2251        sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
2252        obliqCoeff = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['ObliqCoeff']))
2253        obliqCoeff.Bind(wx.EVT_TEXT_ENTER,OnObliqCoeff)       
2254        obliqCoeff.Bind(wx.EVT_KILL_FOCUS,OnObliqCoeff)
2255        sqBox.Add(obliqCoeff,0)
2256    mainSizer.Add(sqBox,0)
2257       
2258    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2259    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,wx.ALIGN_CENTER_VERTICAL)   
2260    rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
2261        value=int(1000*data['Ruland']))
2262    sqBox.Add(rulandSldr,1,wx.EXPAND)
2263    rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
2264    rulandWdt = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Ruland']))
2265    rulandWdt.Bind(wx.EVT_TEXT_ENTER,OnRulandWdt)       
2266    rulandWdt.Bind(wx.EVT_KILL_FOCUS,OnRulandWdt)
2267    sqBox.Add(rulandWdt,0,wx.ALIGN_CENTER_VERTICAL)   
2268    mainSizer.Add(sqBox,0,wx.ALIGN_LEFT|wx.EXPAND)
2269   
2270    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2271    lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
2272    lorch.SetValue(data['Lorch'])
2273    lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
2274    sqBox.Add(lorch,0,wx.ALIGN_CENTER_VERTICAL)
2275    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling q-range: '),0,wx.ALIGN_CENTER_VERTICAL)
2276    SQmin = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][0]))
2277    SQmin.Bind(wx.EVT_TEXT_ENTER,OnSQmin)       
2278    SQmin.Bind(wx.EVT_KILL_FOCUS,OnSQmin)   
2279    sqBox.Add(SQmin,0)
2280    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to '),0,wx.ALIGN_CENTER_VERTICAL)
2281    SQmax = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][1]))
2282    SQmax.Bind(wx.EVT_TEXT_ENTER,OnSQmax)       
2283    SQmax.Bind(wx.EVT_KILL_FOCUS,OnSQmax)
2284    sqBox.Add(SQmax,0)
2285    resetQ = wx.CheckBox(parent=G2frame.dataDisplay,label='Reset?')
2286    sqBox.Add(resetQ,0)
2287    resetQ.Bind(wx.EVT_CHECKBOX, OnResetQ)
2288   
2289    mainSizer.Add(sqBox,0)
2290
2291    mainSizer.Layout()   
2292    G2frame.dataDisplay.SetSizer(mainSizer)
2293    Size = mainSizer.Fit(G2frame.dataFrame)
2294    G2frame.dataDisplay.SetSize(Size)
2295    G2frame.dataFrame.setSizePosLeft(Size)
2296   
Note: See TracBrowser for help on using the repository browser.