source: trunk/GSASIIpwdGUI.py @ 736

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

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