source: trunk/GSASIIpwdGUI.py @ 563

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

add "None" element to table - used for charge flipping
mods to charge flipping
fix PickElement? errors in pdf controls, etc.

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