source: trunk/GSASIIpwdGUI.py @ 535

Last change on this file since 535 was 535, checked in by vondreele, 13 years ago

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