source: trunk/GSASIIpwdGUI.py @ 630

Last change on this file since 630 was 630, checked in by vondreele, 11 years ago

major mods for HKLF data
remove some dead code
mark more code as dead (#)
implement cif data style as 'val(esd)' for f & f_squared
continue implementation of HKLF data in refinement
HKLF now OK in Fourier & charge flip calcs.

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