source: trunk/GSASIIpwdGUI.py @ 519

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

fixes to ViewParmDialog? try to get size right
add copy of refinement flags to various parameters
put some comment section breaks in
fix to eA derivative & wRp in seq refinement
add to help/gsasII.html

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