source: trunk/GSASIIpwdGUI.py @ 526

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

make SetNewPhase? routine in GSASIIIO.py to initialize phase info
begin Fourier map search routine
fix atom plotting if no map

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