source: trunk/GSASIIpwdGUI.py @ 794

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

still more iparm fixes - maybe that's all of them?

  • Property svn:keywords set to Date Author Revision URL Id
File size: 110.0 KB
Line 
1# -*- coding: utf-8 -*-
2#GSASII - data display routines
3########### SVN repository information ###################
4# $Date: 2012-10-24 16:46:26 +0000 (Wed, 24 Oct 2012) $
5# $Author: vondreele $
6# $Revision: 794 $
7# $URL: trunk/GSASIIpwdGUI.py $
8# $Id: GSASIIpwdGUI.py 794 2012-10-24 16:46:26Z 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: 794 $")
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        for peak in peaks:
157            if 'C' in Inst['Type'][0]:
158                peak[4] = Inst['U'][1]*tand(peak[0]/2.0)**2+Inst['V'][1]*tand(peak[0]/2.0)+Inst['W'][1]
159                peak[6] = Inst['X'][1]/cosd(peak[0]/2.0)+Inst['Y'][1]*tand(peak[0]/2.0)
160            else:
161                pass
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    G2gd.SetDataMenuBar(G2frame,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    G2gd.SetDataMenuBar(G2frame,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    G2gd.SetDataMenuBar(G2frame,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    keys = data.keys()
609    if 'P' in data['Type'][0]:          #powder data
610        insVal = dict(zip(keys,[data[key][1] for key in keys]))
611        insDef = dict(zip(keys,[data[key][0] for key in keys]))
612        insRef = dict(zip(keys,[data[key][2] for key in keys]))
613        if 'NC' in data['Type'][0]:
614            del(insDef['Polariz.'])
615            del(insVal['Polariz.'])
616            del(insRef['Polariz.'])
617    else:                               #single crystal data
618        insVal = dict(zip(keys,[data[key][1] for key in keys]))
619        insDef = dict(zip(keys,[data[key][0] for key in keys]))
620        insRef = {}
621    ValObj = {}
622    RefObj = {}
623    waves = {'CuKa':[1.54051,1.54433],'TiKa':[2.74841,2.75207],'CrKa':[2.28962,2.29351],
624        'FeKa':[1.93597,1.93991],'CoKa':[1.78892,1.79278],'MoKa':[0.70926,0.713543],
625        'AgKa':[0.559363,0.563775]}
626       
627    def inst2data(inst,ref,data):
628        for item in data:
629            data[item] = [data[item][0],inst[item],ref[item]]
630        return data
631       
632    def updateData(inst,ref):
633        return inst2data(inst,ref,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
634            G2frame.PatternId,'Instrument Parameters')))       
635   
636    def RefreshInstrumentGrid(event,doAnyway=False):
637        if doAnyway or event.GetRow() == 1:
638            peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
639            if 'C' in data['Type'][0]:                                       #update powder peak parameters
640                for peak in peaks:
641                    peak[4] = insVal['U']*tand(peak[0]/2.0)**2+insVal['V']*tand(peak[0]/2.0)+insVal['W']
642                    peak[6] = insVal['X']/cosd(peak[0]/2.0)+insVal['Y']*tand(peak[0]/2.0)
643            else:
644                pass
645#                for peak in peaks:
646                   
647                   
648    def OnLoad(event):
649        '''Loads instrument parameters from a G2 .instprm file
650        in response to the Instrument Parameters-Operations/Load Profile menu
651       
652        Note that similar code is found in ReadPowderInstprm (GSASII.py)
653        '''
654        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
655            'instrument parameter files (*.instprm)|*.instprm',wx.OPEN|wx.CHANGE_DIR)
656        try:
657            if dlg.ShowModal() == wx.ID_OK:
658                filename = dlg.GetPath()
659                File = open(filename,'r')
660                S = File.readline()
661                newItems = []
662                newVals = []
663                while S:
664                    if S[0] == '#':
665                        S = File.readline()
666                        continue
667                    [item,val] = S[:-1].split(':')
668                    newItems.append(item)
669                    try:
670                        newVals.append(float(val))
671                    except ValueError:
672                        newVals.append(val)                       
673                    S = File.readline()               
674                File.close()
675                data = dict(zip(newItems,zip(newVals,newVals,len(newVals)*[False,])))
676                for item in data:
677                    data[item] = list(data[item])
678                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),data)
679                RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
680                UpdateInstrumentGrid(G2frame,data)
681        finally:
682            dlg.Destroy()
683       
684    def OnSave(event):
685        '''Respond to the Instrument Parameters Operations/Save Profile menu
686        item: writes current parameters to a .instprm file
687        '''
688        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
689            'instrument parameter files (*.instprm)|*.instprm',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
690        try:
691            if dlg.ShowModal() == wx.ID_OK:
692                filename = dlg.GetPath()
693                # make sure extension is .instprm
694                filename = os.path.splitext(filename)[0]+'.instprm'
695                File = open(filename,'w')
696                File.write("#GSAS-II instrument parameter file; do not add/delete or change order of items!\n")
697                for item in data:
698                    File.write(item+':'+str(data[item][1])+'\n')
699                File.close()
700        finally:
701            dlg.Destroy()
702                                               
703    def OnReset(event):
704        insVal.update(insDef)
705        data = updateData(insVal,insRef)
706        RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
707        UpdateInstrumentGrid(G2frame,data)
708       
709    def OnInstFlagCopy(event):
710        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
711        keys = data.keys()
712        flags = dict(zip(keys,[data[key][2] for key in keys]))
713        instType = data['Type'][0]
714        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
715        copyList = []
716        dlg = wx.MultiChoiceDialog(G2frame, 
717            'Copy refinement flags from\n'+histName, 'Copy refinement flags', 
718            histList, wx.CHOICEDLG_STYLE)
719        try:
720            if dlg.ShowModal() == wx.ID_OK:
721                result = dlg.GetSelections()
722                for i in result: 
723                    copyList.append(histList[i])
724                if 'All' in copyList: 
725                    copyList = histList[1:]
726            for item in copyList:
727                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
728                instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
729                if len(data) == len(instData) and instType == instData['Type'][0]:   #don't mix data types or lam & lam1/lam2 parms!
730                   
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        #need fix for dictionary
739        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
740        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
741        copyList = []
742        instType = data['Type'][0]
743        dlg = wx.MultiChoiceDialog(G2frame, 
744            'Copy parameters from\n'+histName, 'Copy parameters', 
745            histList, wx.CHOICEDLG_STYLE)
746        try:
747            if dlg.ShowModal() == wx.ID_OK:
748                result = dlg.GetSelections()
749                for i in result: 
750                    copyList.append(histList[i])
751                if 'All' in copyList: 
752                    copyList = histList[1:]
753            for item in copyList:
754                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
755                instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
756                if len(data) == len(instData) and instType == instData['Type'][0]:  #don't mix data types or lam & lam1/lam2 parms!
757                    for i,item in enumerate(data[1:]):                  #skip default values in tuple
758                        instData[i+1][:-1] = copy.copy(item[:-1])       #skip azimuth at end
759                else:
760                    print item+' not copied - instrument parameters not commensurate'
761        finally:
762            dlg.Destroy()
763       
764    def OnWaveChange(event):
765        if 'Lam' in insVal:
766            data['Lam1'] = [waves['CuKa'][0],waves['CuKa'][0],0]
767            data['Lam2'] = [waves['CuKa'][1],waves['CuKa'][1],0]
768            data['I(L2)/I(L1)'] = [0.5,0.5,0]
769            del(data['Lam'])
770        else:
771            data['Lam'] = [data['Lam1'][0],data['Lam1'][0],0]
772            del(data['Lam1'])
773        UpdateInstrumentGrid(G2frame,data)
774               
775    def OnLamPick(event):
776        lamType = lamPick.GetValue()
777        insVal['Lam1'] = waves[lamType][0]
778        insVal['Lam2'] = waves[lamType][1]
779        data = updateData(insVal,insRef)
780        UpdateInstrumentGrid(G2frame,data)
781                 
782    def OnRatValue(event):
783        try:
784            value = float(ratVal.GetValue())
785            if value < 0:
786                raise ValueError
787        except ValueError:
788            value = insVal['I(L2)/I(L1)']
789        insVal['I(L2)/I(L1)'] = value
790        ratVal.SetValue('%10.4f'%(value))
791        data = updateData(insVal,insRef)
792       
793    def OnRatRef(event):
794        insRef['I(L2)/I(L1)'] = ratRef.GetValue()
795        data = updateData(insVal,insRef)
796       
797    def OnWaveValue(event):
798        try:
799            value = float(waveVal.GetValue())
800            if value < 0:
801                raise ValueError
802        except ValueError:
803            value = insVal['Lam']
804        insVal['Lam'] = value
805        waveVal.SetValue('%10.6f'%(value))
806        data = updateData(insVal,insRef)
807       
808    def OnWaveRef(event):
809        insRef['Lam'] = waveRef.GetValue()
810        data = updateData(insVal,insRef)
811       
812    def OnItemValue(event):
813        Obj = event.GetEventObject()
814        item,fmt = ValObj[Obj.GetId()]
815        try:
816            value = float(Obj.GetValue())
817        except ValueError:
818            value = insVal[item]
819        insVal[item] = value
820        Obj.SetValue(fmt%(value))
821        data = updateData(insVal,insRef)
822       
823    def OnItemRef(event):
824        Obj = event.GetEventObject()
825        item = RefObj[Obj.GetId()]
826        insRef[item] = Obj.GetValue()
827        data = updateData(insVal,insRef)
828               
829    if G2frame.dataDisplay:
830        G2frame.dataFrame.Clear()
831    try:
832        histoName = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[-1]
833        ifHisto = IsHistogramInAnyPhase(G2frame,histoName)
834    except TypeError:       #PKS data never used in a phase as data
835        ifhisto = False
836    G2gd.SetDataMenuBar(G2frame)
837    G2frame.dataFrame.SetLabel('Instrument Parameters')
838    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
839    instSizer = wx.FlexGridSizer(2,6,5,5)
840    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Histogram Type: '+insVal['Type']),0,wx.ALIGN_CENTER_VERTICAL)
841    instSizer.Add((5,5),0)
842    if 'P' in insVal['Type']:                   #powder data
843        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.InstMenu)
844        if not G2frame.dataFrame.GetStatusBar():
845            Status = G2frame.dataFrame.CreateStatusBar()
846        G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
847        G2frame.Bind(wx.EVT_MENU,OnSave,id=G2gd.wxID_INSTSAVE)
848        G2frame.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
849        G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
850        G2frame.Bind(wx.EVT_MENU,OnInstFlagCopy,id=G2gd.wxID_INSTFLAGCOPY)
851        G2frame.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)       
852        if 'C' in insVal['Type']:               #constant wavelength
853            #patch
854            if 'Azimuth' not in insVal:
855                insVal['Azimuth'] = 0.0
856                insDef['Azimuth'] = 0.0
857                insRef['Azimuth'] = False
858            #end of patch
859            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,wx.ALIGN_CENTER_VERTICAL)
860            if 'Lam1' in insVal:
861                instSizer.Add((5,5),0)
862                instSizer.Add((5,5),0)
863                instSizer.Add((5,5),0)
864                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Ka1/Ka2:'),
865                        0,wx.ALIGN_CENTER_VERTICAL)
866                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'%8.6f/%8.6f'%(insVal['Lam1'],insVal['Lam2'])),
867                        0,wx.ALIGN_CENTER_VERTICAL)
868                waveSizer = wx.BoxSizer(wx.HORIZONTAL)
869                waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Select:'),0,wx.ALIGN_CENTER_VERTICAL)
870                choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
871                lamPick = wx.ComboBox(G2frame.dataDisplay,value=' ',choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
872                lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
873                waveSizer.Add(lamPick,0)
874                instSizer.Add(waveSizer,0)
875                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' I(L2)/I(L1): (%10.4f)'%(insDef['I(L2)/I(L1)'])),
876                        0,wx.ALIGN_CENTER_VERTICAL)
877                ratVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(insVal['I(L2)/I(L1)']),style=wx.TE_PROCESS_ENTER)
878                ratVal.Bind(wx.EVT_TEXT_ENTER,OnRatValue)
879                ratVal.Bind(wx.EVT_KILL_FOCUS,OnRatValue)
880                instSizer.Add(ratVal,0)
881                ratRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
882                ratRef.SetValue(bool(insRef['I(L2)/I(L1)']))
883                ratRef.Bind(wx.EVT_CHECKBOX, OnRatRef)
884                instSizer.Add(ratRef,0,wx.ALIGN_CENTER_VERTICAL)
885               
886            else:
887                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: (%10.6f)'%(insDef['Lam'])),
888                    0,wx.ALIGN_CENTER_VERTICAL)
889                waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
890                waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
891                waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
892                instSizer.Add(waveVal,0,wx.ALIGN_CENTER_VERTICAL)
893                if ifHisto:
894                    waveRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
895                    waveRef.SetValue(bool(insRef['Lam']))
896                    waveRef.Bind(wx.EVT_CHECKBOX, OnWaveRef)
897                    instSizer.Add(waveRef,0,wx.ALIGN_CENTER_VERTICAL)
898                else:
899                    instSizer.Add((5,5),0)
900            for item in ['Zero','Polariz.']:
901                fmt = '%10.4f'
902                Fmt = ' %s: ('+fmt+')'
903                if item in insDef:
904                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
905                            0,wx.ALIGN_CENTER_VERTICAL)
906                    itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
907                    ValObj[itemVal.GetId()] = [item,fmt]
908                    itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
909                    itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
910                    instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
911                    if ifHisto:
912                        itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
913                        itemRef.SetValue(bool(insRef[item]))
914                        RefObj[itemRef.GetId()] = item
915                        itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
916                        instSizer.Add(itemRef,0,wx.ALIGN_CENTER_VERTICAL)
917                    else:
918                        instSizer.Add((5,5),0)
919                else:                           #skip Polariz. for neutrons
920                    instSizer.Add((5,5),0)
921                    instSizer.Add((5,5),0)
922                    instSizer.Add((5,5),0)
923            for item in ['U','V','W','X','Y','SH/L']:
924                fmt = '%10.3f'
925                if item == 'SH/L':
926                    fmt = '%10.5f'
927                Fmt = ' %s: ('+fmt+')'
928                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
929                        0,wx.ALIGN_CENTER_VERTICAL)
930                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
931                ValObj[itemVal.GetId()] = [item,fmt]
932                itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
933                itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
934                instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
935                itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
936                itemRef.SetValue(bool(insRef[item]))
937                RefObj[itemRef.GetId()] = item
938                itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
939                instSizer.Add(itemRef,0,wx.ALIGN_CENTER_VERTICAL)
940        else:                                   #time of flight (neutrons)
941            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,wx.ALIGN_CENTER_VERTICAL)
942            for item in ['difC','difA','Zero','alpha','beta-0','beta-1','var-inst','X','Y']:
943                fmt = '%10.3f'
944                if 'beta' in item:
945                    fmt = '%12.4g'
946                Fmt = ' %s: ('+fmt+')'
947                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
948                        0,wx.ALIGN_CENTER_VERTICAL)
949                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
950                ValObj[itemVal.GetId()] = [item,fmt]
951                itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
952                itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
953                instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
954                itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
955                itemRef.SetValue(bool(insRef[item]))
956                RefObj[itemRef.GetId()] = item
957                itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
958                instSizer.Add(itemRef,0,wx.ALIGN_CENTER_VERTICAL)
959       
960    else:                       #single crystal data
961        if 'C' in insVal['Type']:               #constant wavelength
962            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: (%10.6f)'%(insDef['Lam'])),
963                0,wx.ALIGN_CENTER_VERTICAL)
964            waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
965            waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
966            waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
967            instSizer.Add(waveVal,0,wx.ALIGN_CENTER_VERTICAL)
968        else:                                   #time of flight (neutrons)
969            pass                                #for now
970       
971    mainSizer = wx.BoxSizer(wx.VERTICAL)
972    mainSizer.Add(instSizer,0)
973    mainSizer.Layout()   
974    G2frame.dataDisplay.SetSizer(mainSizer)
975    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
976   
977################################################################################
978#####  Sample parameters
979################################################################################           
980       
981def UpdateSampleGrid(G2frame,data):
982   
983    def SetCopyNames(histName,addNames=[]):
984        copyNames = ['Scale',]
985        dataType = data['Type']
986        histType = 'HKLF'
987        if 'PWDR' in histName:          #else HKLF - only Scale
988            histType = 'PWDR'
989            if 'Debye' in dataType:
990                copyNames += ['DisplaceX','DisplaceY','Absorption']
991            else:       #Bragg-Brentano
992                copyNames += ['Shift','Transparency']
993        if len(addNames):
994         copyNames += addNames
995        return histType,copyNames
996       
997    def OnSampleSave(event):
998        '''Respond to the Sample Parameters Operations/Save menu
999        item: writes current parameters to a .samprm file
1000        '''
1001        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', '.', '', 
1002            'sample parameter files (*.samprm)|*.samprm',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
1003        try:
1004            if dlg.ShowModal() == wx.ID_OK:
1005                filename = dlg.GetPath()
1006                # make sure extension is .samprm
1007                filename = os.path.splitext(filename)[0]+'.samprm'
1008                File = open(filename,'w')
1009                File.write("#GSAS-II sample parameter file; do not add/delete or change order of items!\n")
1010                File.write("'Type':'"+str(data['Type'])+"'\n")
1011                File.write("'Gonio. radius':"+str(data['Gonio. radius'])+"\n")
1012                File.close()
1013        finally:
1014            dlg.Destroy()
1015                                               
1016       
1017    def OnSampleLoad(event):
1018        '''Loads sample parameters from a G2 .samprm file
1019        in response to the Sample Parameters-Operations/Load menu
1020       
1021        Note that similar code is found in ReadPowderInstprm (GSASII.py)
1022        '''
1023        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', '.', '', 
1024            'sample parameter files (*.samprm)|*.samprm',wx.OPEN|wx.CHANGE_DIR)
1025        try:
1026            if dlg.ShowModal() == wx.ID_OK:
1027                filename = dlg.GetPath()
1028                File = open(filename,'r')
1029                S = File.readline()
1030                newItems = {}
1031                while S:
1032                    if S[0] == '#':
1033                        S = File.readline()
1034                        continue
1035                    [item,val] = S[:-1].split(':')
1036                    newItems[item.strip("'")] = eval(val)
1037                    S = File.readline()               
1038                File.close()
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    G2gd.SetDataMenuBar(G2frame,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    try:
1267        wave = Inst['Lam'][1]
1268    except KeyError:
1269        wave = Inst['Lam1'][0]
1270   
1271    def RefreshIndexPeaksGrid(event):
1272        r,c =  event.GetRow(),event.GetCol()
1273        data = G2frame.IndexPeaksTable.GetData()
1274        if c == 2:
1275            if data[r][c]:
1276                data[r][c] = False
1277            else:
1278                data[r][c] = True
1279            G2frame.IndexPeaksTable.SetData(data)
1280            G2frame.PatternTree.SetItemPyData(IndexId,data)
1281            G2frame.dataDisplay.ForceRefresh()
1282           
1283    def OnReload(event):
1284        data = []
1285        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
1286        for peak in peaks:
1287            dsp = wave/(2.0*sind((peak[0]-Inst['Zero'][1])/2.0))
1288            data.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
1289        G2frame.PatternTree.SetItemPyData(IndexId,data)
1290        UpdateIndexPeaksGrid(G2frame,data)
1291       
1292    def KeyEditPickGrid(event):
1293        colList = G2frame.dataDisplay.GetSelectedCols()
1294        rowList = G2frame.dataDisplay.GetSelectedRows()
1295        data = G2frame.PatternTree.GetItemPyData(IndexId)
1296        if event.GetKeyCode() == wx.WXK_RETURN:
1297            event.Skip(True)
1298        elif event.GetKeyCode() == wx.WXK_CONTROL:
1299            event.Skip(True)
1300        elif event.GetKeyCode() == wx.WXK_SHIFT:
1301            event.Skip(True)
1302        elif colList:
1303            G2frame.dataDisplay.ClearSelection()
1304            key = event.GetKeyCode()
1305            for col in colList:
1306                if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
1307                    if key == 89: #'Y'
1308                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=True
1309                    elif key == 78:  #'N'
1310                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=False
1311           
1312    if G2frame.dataDisplay:
1313        G2frame.dataFrame.Clear()
1314    if not G2frame.dataFrame.GetStatusBar():
1315        Status = G2frame.dataFrame.CreateStatusBar()
1316    if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1317        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndPeaksMenu)
1318        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
1319    G2frame.dataFrame.IndexPeaks.Enable(False)
1320    G2frame.IndexPeaksTable = []
1321    if data:
1322        G2frame.dataFrame.IndexPeaks.Enable(True)
1323        cells = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
1324        if cells:
1325            cellist = cells[2]
1326            dmin = cells[3]
1327            G2frame.HKL = []
1328            for i,cell in enumerate(cellist):
1329                if cell[-1]:
1330                    ibrav = cell[2]
1331                    A = G2lat.cell2A(cell[3:9])
1332                    G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1333                    G2indx.IndexPeaks(data,G2frame.HKL)
1334                    for hkl in G2frame.HKL:
1335                        hkl.append(2.0*asind(wave/(2.*hkl[3]))+Inst['Zero'][1])             
1336    rowLabels = []
1337    for i in range(len(data)): rowLabels.append(str(i+1))
1338    colLabels = ['position','intensity','use','indexed','h','k','l','d-obs','d-calc']
1339    Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
1340        wg.GRID_VALUE_BOOL,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,
1341        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5']
1342    G2frame.PatternTree.SetItemPyData(IndexId,data)
1343    G2frame.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1344    G2frame.dataFrame.SetLabel('Index Peak List')
1345    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)               
1346    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
1347    for r in range(G2frame.dataDisplay.GetNumberRows()):
1348        for c in range(G2frame.dataDisplay.GetNumberCols()):
1349            if c == 2:
1350                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
1351            else:
1352                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
1353    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
1354    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
1355    G2frame.dataDisplay.SetMargins(0,0)
1356    G2frame.dataDisplay.AutoSizeColumns(False)
1357    G2frame.dataFrame.setSizePosLeft([490,300])
1358 
1359################################################################################
1360#####  Unit cells
1361################################################################################           
1362       
1363def UpdateUnitCellsGrid(G2frame, data):
1364    UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
1365    SPGlist = G2spc.spglist
1366    bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
1367        'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
1368    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',
1369        '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']
1370    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
1371    if 'Lam' in Inst:
1372        wave = Inst['Lam'][1]
1373    else:
1374        wave = Inst['Lam1'][0]
1375       
1376    def SetLattice(controls):
1377        ibrav = bravaisSymb.index(controls[5])
1378        if ibrav in [0,1,2]:
1379            controls[7] = controls[8] = controls[6]
1380            controls[9] = controls[10] = controls[11] = 90.
1381        elif ibrav in [3,4,5,6]:
1382            controls[7] = controls[6]
1383            controls[9] = controls[10] = controls[11] = 90.
1384            if ibrav in [3,4]:
1385                controls[11] = 120.
1386        elif ibrav in [7,8,9,10]:
1387            controls[9] = controls[10] = controls[11] = 90.
1388        elif ibrav in [11,12]:
1389            controls[9] = controls[11] = 90.  # b unique
1390        if len(controls) < 13: controls.append(0)
1391        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1392        return ibrav
1393       
1394    def OnNcNo(event):
1395        controls[2] = NcNo.GetValue()
1396       
1397    def OnStartVol(event):
1398        try:
1399            stVol = int(float(startVol.GetValue()))
1400            if stVol < 25:
1401                raise ValueError
1402        except ValueError:
1403            stVol = 25
1404        controls[3] = stVol
1405        startVol.SetValue("%d"%(stVol))
1406       
1407    def OnBravais(event):
1408        Obj = event.GetEventObject()
1409        bravais[bravList.index(Obj.GetId())] = Obj.GetValue()
1410       
1411    def OnZero(event):
1412        try:
1413            Zero = min(5.0,max(-5.0,float(zero.GetValue())))
1414        except ValueError:
1415            Zero = 0.0
1416        controls[1] = Zero
1417        zero.SetValue("%.4f"%(Zero))
1418       
1419    def OnZeroVar(event):
1420        controls[0] = zeroVar.GetValue()
1421       
1422    def OnBravSel(event):
1423        brav = bravSel.GetString(bravSel.GetSelection())
1424        controls[5] = brav
1425        controls[13] = SPGlist[brav][0]       
1426        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1427       
1428    def OnSpcSel(event):
1429        controls[13] = spcSel.GetString(spcSel.GetSelection())       
1430       
1431    def OnCellChange(event):
1432        ibrav = bravaisSymb.index(controls[5])
1433        Obj = event.GetEventObject()
1434        ObjId = cellList.index(Obj.GetId())
1435        try:
1436            value = max(1.0,float(Obj.GetValue()))
1437        except ValueError:
1438            if ObjId < 3:               #bad cell edge - reset
1439                value = controls[6+ObjId]
1440            else:                       #bad angle
1441                value = 90.
1442        if ibrav in [0,1,2]:
1443            controls[6] = controls[7] = controls[8] = value
1444            controls[9] = controls[10] = controls[11] = 90.0
1445            Obj.SetValue("%.5f"%(controls[6]))
1446        elif ibrav in [3,4,5,6]:
1447            if ObjId == 0:
1448                controls[6] = controls[7] = value
1449                Obj.SetValue("%.5f"%(controls[6]))
1450            else:
1451                controls[8] = value
1452                Obj.SetValue("%.5f"%(controls[8]))
1453            controls[9] = controls[10] = controls[11] = 90.0
1454            if ibrav in [3,4]:
1455                controls[11] = 120.
1456        elif ibrav in [7,8,9,10]:
1457            controls[6+ObjId] = value
1458            Obj.SetValue("%.5f"%(controls[6+ObjId]))
1459            controls[9] = controls[10] = controls[11] = 90.0
1460        elif ibrav in [11,12]:
1461            controls[9] = controls[11] = 90.0
1462            if ObjId != 3:
1463                controls[6+ObjId] = value
1464                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1465            else:
1466                controls[10] = value
1467                Obj.SetValue("%.3f"%(controls[10]))
1468        else:
1469            controls[6+ObjId] = value
1470            if ObjId < 3:
1471                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1472            else:
1473                Obj.SetValue("%.3f"%(controls[6+ObjId]))
1474        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1475        volVal.SetValue("%.3f"%(controls[12]))
1476       
1477    def OnHklShow(event):
1478        PatternId = G2frame.PatternId
1479        PickId = G2frame.PickId   
1480        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
1481        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1482        cell = controls[6:12]
1483        A = G2lat.cell2A(cell)
1484        ibrav = bravaisSymb.index(controls[5])
1485        spc = controls[13]
1486        SGData = G2spc.SpcGroup(spc)[1]
1487        dmin = wave/(2.0*sind(limits[1]/2.0))
1488        G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A)
1489        for hkl in G2frame.HKL:
1490            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1491        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1492            G2plt.PlotPowderLines(G2frame)
1493        else:
1494            G2plt.PlotPatterns(G2frame)
1495           
1496    def OnSortCells(event):
1497        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1498        c =  event.GetCol()
1499        if colLabels[c] == 'M20':
1500            cells = G2indx.sortM20(cells)
1501        elif colLabels[c] == 'Volume':
1502            cells = G2indx.sortVolume(cells)
1503        else:
1504            return
1505        data = [controls,bravais,cells,dmin]
1506        G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
1507        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1508       
1509    def CopyUnitCell(event):
1510        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1511        for Cell in cells:
1512            if Cell[-2]:
1513                break
1514        cell = Cell[2:9]
1515        controls[4] = 1
1516        controls[5] = bravaisSymb[cell[0]]
1517        controls[6:12] = cell[1:8]
1518        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1519        controls[13] = spaceGroups[bravaisSymb.index(controls[5])]
1520        G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin])
1521        G2frame.dataFrame.RefineCell.Enable(True)
1522        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)       
1523               
1524    def RefineCell(event):
1525        def cellPrint(ibrav,A):
1526            cell = G2lat.A2cell(A)
1527            Vol = G2lat.calc_V(A)
1528            if ibrav in [0,1,2]:
1529                print "%s%10.6f" % ('a =',cell[0])
1530            elif ibrav in [3,4,5,6]:
1531                print "%s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],' c =',cell[2],' volume =',Vol)
1532            elif ibrav in [7,8,9,10]:
1533                print "%s%10.6f %s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],' volume =',Vol)
1534            elif ibrav in [11,12]:
1535                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)
1536            else:
1537                print "%s%10.6f %s%10.6f %s%10.6f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2])
1538                print "%s%8.3f %s%8.3f %s%8.3f %s%12.3f" % ('alpha =',cell[3],'beta =',cell[4],'gamma =',cell[5],' volume =',Vol)
1539             
1540        PatternId = G2frame.PatternId
1541        PickId = G2frame.PickId   
1542        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
1543        if not peaks:
1544            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
1545            return       
1546        print 'Refine cell'
1547        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1548        cell = controls[6:12]
1549        A = G2lat.cell2A(cell)
1550        ibrav = bravaisSymb.index(controls[5])
1551        SGData = G2spc.SpcGroup(controls[13])[1]
1552        dmin = G2indx.getDmin(peaks)-0.005
1553        G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A)
1554        G2indx.IndexPeaks(peaks,G2frame.HKL)
1555        Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks,wave,ibrav,A,controls[1],controls[0])           
1556        controls[1] = Zero
1557        controls[6:12] = G2lat.A2cell(Aref)
1558        controls[12] = G2lat.calc_V(Aref)
1559        data = [controls,bravais,cells,dmin]
1560        cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
1561        for cell in cells:
1562            cell[-2] = False
1563        cells.insert(0,[M20,X20,ibrav]+controls[6:13]+[True,False])
1564        data[2] = cells
1565        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
1566        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
1567        print "%s%10.3f" % ('refinement M20 = ',M20)
1568        print 'unindexed lines = ',X20
1569        cellPrint(ibrav,Aref)
1570        for hkl in G2frame.HKL:
1571            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1572        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1573            G2plt.PlotPowderLines(G2frame)
1574        else:
1575            G2plt.PlotPatterns(G2frame)
1576        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1577       
1578    def IndexPeaks(event):
1579        PatternId = G2frame.PatternId   
1580        print 'Peak Indexing'
1581        keepcells = []
1582        try:
1583            controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1584            for cell in cells:
1585                if cell[11]:
1586                    keepcells.append(cell)
1587        except IndexError:
1588            pass
1589        except ValueError:
1590            G2frame.ErrorDialog('Error','Need to set controls in Unit Cell List first')
1591            return
1592        if True not in bravais:
1593            G2frame.ErrorDialog('Error','No Bravais lattices selected')
1594            return
1595        G2frame.dataFrame.CopyCell.Enable(False)
1596        G2frame.dataFrame.RefineCell.Enable(False)
1597        OK,dmin,newcells = G2indx.DoIndexPeaks(peaks,wave,controls,bravais)
1598        cells = keepcells+newcells
1599        cells = G2indx.sortM20(cells)
1600        cells[0][10] = True
1601        if OK:
1602            data = [controls,bravais,cells,dmin]
1603            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
1604            bestCell = cells[0]
1605            if bestCell[0] > 10.:
1606                G2frame.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
1607                for hkl in G2frame.HKL:
1608                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1609                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1610                    G2plt.PlotPowderLines(G2frame)
1611                else:
1612                    G2plt.PlotPatterns(G2frame)
1613            G2frame.dataFrame.CopyCell.Enable(True)
1614            G2frame.dataFrame.IndexPeaks.Enable(True)
1615            G2frame.dataFrame.MakeNewPhase.Enable(True)
1616        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1617               
1618    def RefreshUnitCellsGrid(event):
1619        data =G2frame.PatternTree.GetItemPyData(UnitCellsId)
1620        cells,dmin = data[2:]
1621        r,c =  event.GetRow(),event.GetCol()
1622        if cells:
1623            if c == 2:
1624                for i in range(len(cells)):
1625                    cells[i][-2] = False
1626                    UnitCellsTable.SetValue(i,c,False)
1627                UnitCellsTable.SetValue(r,c,True)
1628                gridDisplay.ForceRefresh()
1629                cells[r][-2] = True
1630                ibrav = cells[r][2]
1631                A = G2lat.cell2A(cells[r][3:9])
1632                G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1633                for hkl in G2frame.HKL:
1634                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1635                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1636                    G2plt.PlotPowderLines(G2frame)
1637                else:
1638                    G2plt.PlotPatterns(G2frame)
1639            elif c == 11:
1640                if UnitCellsTable.GetValue(r,c):
1641                    UnitCellsTable.SetValue(r,c,False)
1642                    cells[r][c] = False
1643                else:
1644                    cells[r][c] = True
1645                    UnitCellsTable.SetValue(r,c,True)
1646                gridDisplay.ForceRefresh()
1647            G2frame.PatternTree.SetItemPyData(UnitCellsId,data)               
1648       
1649    def MakeNewPhase(event):
1650        if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
1651            sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
1652        else:
1653            sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
1654        PhaseName = ''
1655        dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
1656            style=wx.OK)
1657        try:
1658            if dlg.ShowModal() == wx.ID_OK:
1659                PhaseName = dlg.GetValue()
1660                cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
1661                for Cell in cells:
1662                    if Cell[-2]:
1663                        break
1664                cell = Cell[2:10]       
1665                sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
1666                E,SGData = G2spc.SpcGroup(controls[13])
1667                G2frame.PatternTree.SetItemPyData(sub, \
1668                    G2IO.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:]))
1669                Status.SetStatusText('Change space group if needed')
1670        finally:
1671            dlg.Destroy()
1672           
1673    if G2frame.dataDisplay:
1674        G2frame.dataFrame.Clear()
1675    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndexMenu)
1676    if not G2frame.dataFrame.GetStatusBar():
1677        Status = G2frame.dataFrame.CreateStatusBar()
1678    G2frame.Bind(wx.EVT_MENU, IndexPeaks, id=G2gd.wxID_INDEXPEAKS)
1679    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
1680    G2frame.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
1681    G2frame.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
1682   
1683    controls,bravais,cells,dmin = data
1684    if len(controls) < 13:              #add cell volume if missing
1685        controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
1686    if len(controls) < 14:              #add space gropu used in indexing
1687        controls.append(spaceGroups[bravaisSymb.index(controls[5])])
1688    G2frame.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
1689    bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
1690        'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
1691        'Orthorhombic-P','Monoclinic-C','Monoclinic-P','Triclinic']
1692    cellGUIlist = [[[0,1,2],4,zip([" Unit cell: a = "," Vol = "],["%.5f","%.3f"],[True,False],[0,0])],
1693    [[3,4,5,6],6,zip([" Unit cell: a = "," c = "," Vol = "],["%.5f","%.5f","%.3f"],[True,True,False],[0,2,0])],
1694    [[7,8,9,10],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "],["%.5f","%.5f","%.5f","%.3f"],
1695        [True,True,True,False],[0,1,2,0])],
1696    [[11,12],10,zip([" Unit cell: a = "," b = "," c = "," beta = "," Vol = "],
1697        ["%.5f","%.5f","%.5f","%.3f","%.3f"],[True,True,True,True,False],[0,1,2,4,0])],
1698    [[13,],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "," alpha = "," beta = "," gamma = "],
1699        ["%.5f","%.5f","%.5f","%.3f","%.3f","%.3f","%.3f"],
1700        [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
1701   
1702    G2frame.dataFrame.SetLabel('Unit Cells List')
1703    G2frame.sp = wx.SplitterWindow(G2frame.dataFrame)
1704    G2frame.dataDisplay = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
1705    G2frame.dataFrame.IndexPeaks.Enable(False)
1706    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
1707    if peaks:
1708        G2frame.dataFrame.IndexPeaks.Enable(True)
1709    G2frame.dataFrame.RefineCell.Enable(False)
1710    if controls[12] > 1.0:                               #if a "real" volume (i.e. not default)
1711        G2frame.dataFrame.RefineCell.Enable(True)   
1712    G2frame.dataFrame.CopyCell.Enable(False)
1713    G2frame.dataFrame.MakeNewPhase.Enable(False)       
1714    if cells:
1715        G2frame.bottom = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
1716        G2frame.sp.SplitHorizontally(G2frame.dataDisplay,G2frame.bottom,0)
1717        G2frame.dataFrame.CopyCell.Enable(True)
1718        G2frame.dataFrame.MakeNewPhase.Enable(True)       
1719    mainSizer = wx.BoxSizer(wx.VERTICAL)
1720    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,wx.ALIGN_CENTER_VERTICAL)
1721    mainSizer.Add((5,5),0)
1722    littleSizer = wx.FlexGridSizer(2,5,5,5)
1723    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,wx.ALIGN_CENTER_VERTICAL)
1724    NcNo = wx.SpinCtrl(G2frame.dataDisplay)
1725    NcNo.SetRange(1,6)
1726    NcNo.SetValue(controls[2])
1727    NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
1728    littleSizer.Add(NcNo,0,wx.ALIGN_CENTER_VERTICAL)
1729    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start Volume '),0,wx.ALIGN_CENTER_VERTICAL)
1730    startVol = wx.TextCtrl(G2frame.dataDisplay,value=str('%d'%(controls[3])),style=wx.TE_PROCESS_ENTER)
1731    startVol.Bind(wx.EVT_TEXT_ENTER,OnStartVol)
1732    startVol.Bind(wx.EVT_KILL_FOCUS,OnStartVol)
1733    littleSizer.Add(startVol,0,wx.ALIGN_CENTER_VERTICAL)
1734    mainSizer.Add(littleSizer,0)
1735    mainSizer.Add((5,5),0)
1736    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
1737        0,wx.ALIGN_CENTER_VERTICAL)
1738    mainSizer.Add((5,5),0)
1739    littleSizer = wx.FlexGridSizer(2,7,5,5)
1740    bravList = []
1741    bravs = zip(bravais,bravaisNames)
1742    for brav,bravName in bravs:
1743        bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
1744        bravList.append(bravCk.GetId())
1745        bravCk.SetValue(brav)
1746        bravCk.Bind(wx.EVT_CHECKBOX,OnBravais)
1747        littleSizer.Add(bravCk,0,wx.ALIGN_CENTER_VERTICAL)
1748    mainSizer.Add(littleSizer,0)
1749    mainSizer.Add((5,5),0)
1750   
1751    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Refinement: '),0,wx.ALIGN_CENTER_VERTICAL)
1752    mainSizer.Add((5,5),0)
1753    littleSizer = wx.BoxSizer(wx.HORIZONTAL)
1754    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,wx.ALIGN_CENTER_VERTICAL)
1755    bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
1756    bravSel.SetSelection(bravaisSymb.index(controls[5]))
1757    bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
1758    littleSizer.Add(bravSel,0,wx.ALIGN_CENTER_VERTICAL)
1759    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Space group "),0,wx.ALIGN_CENTER_VERTICAL)
1760    spcSel = wx.Choice(G2frame.dataDisplay,choices=SPGlist[controls[5]])
1761    spcSel.SetSelection(SPGlist[controls[5]].index(controls[13]))
1762    spcSel.Bind(wx.EVT_CHOICE,OnSpcSel)
1763    littleSizer.Add(spcSel,0,wx.ALIGN_CENTER_VERTICAL)
1764    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,wx.ALIGN_CENTER_VERTICAL)
1765    zero = wx.TextCtrl(G2frame.dataDisplay,value="%.4f"%(controls[1]),style=wx.TE_PROCESS_ENTER)
1766    zero.Bind(wx.EVT_TEXT_ENTER,OnZero)
1767    zero.Bind(wx.EVT_KILL_FOCUS,OnZero)
1768    littleSizer.Add(zero,0,wx.ALIGN_CENTER_VERTICAL)
1769    zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
1770    zeroVar.SetValue(controls[0])
1771    zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
1772    littleSizer.Add(zeroVar,0,wx.ALIGN_CENTER_VERTICAL)
1773    hklShow = wx.Button(G2frame.dataDisplay,label="Show hkl positions")
1774    hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
1775    littleSizer.Add(hklShow,0,wx.ALIGN_CENTER_VERTICAL)
1776    mainSizer.Add(littleSizer,0)
1777   
1778    mainSizer.Add((5,5),0)
1779    ibrav = SetLattice(controls)
1780    for cellGUI in cellGUIlist:
1781        if ibrav in cellGUI[0]:
1782            useGUI = cellGUI
1783    cellList = []
1784    littleSizer = wx.FlexGridSizer(2,useGUI[1],5,5)
1785    for txt,fmt,ifEdit,Id in useGUI[2]:
1786        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,wx.ALIGN_CENTER_VERTICAL)
1787        if ifEdit:          #a,b,c,etc.
1788            cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
1789            cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)       
1790            cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
1791            littleSizer.Add(cellVal,0,wx.ALIGN_CENTER_VERTICAL)
1792            cellList.append(cellVal.GetId())
1793        else:               #volume
1794            volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
1795            volVal.SetBackgroundColour(VERY_LIGHT_GREY)
1796            littleSizer.Add(volVal,0,wx.ALIGN_CENTER_VERTICAL)
1797    mainSizer.Add(littleSizer,0)
1798       
1799    mainSizer.Layout()   
1800    G2frame.dataDisplay.SetSizer(mainSizer)
1801    topSize = mainSizer.Fit(G2frame.dataFrame)
1802    G2frame.dataDisplay.SetSize(topSize)
1803    if cells:
1804        if ibrav == 13:
1805            topSize[1] += 230
1806        else:
1807            topSize[1] += 200
1808    G2frame.dataFrame.setSizePosLeft(topSize)   
1809   
1810    if cells:
1811        bottomSize = topSize        #screwy but bottom doesn't have a size in linux!
1812        bottomSize[0] -= 20         #to reveal slider
1813        if ibrav == 13:
1814            bottomSize[1] -= 240
1815        else:
1816            bottomSize[1] -= 210
1817        wx.StaticText(parent=G2frame.bottom,label=' Indexing Result ')
1818        rowLabels = []
1819        colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume','Keep']
1820        Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_NUMBER,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_STRING,]+ \
1821            3*[wg.GRID_VALUE_FLOAT+':10,5',]+3*[wg.GRID_VALUE_FLOAT+':10,3',]+ \
1822            [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL]
1823        numRows = len(cells)
1824        table = []
1825        for cell in cells:
1826            rowLabels.append('')
1827            row = cell[0:2]+[cell[-2]]+[bravaisSymb[cell[2]]]+cell[3:10]+[cell[11],]
1828            if cell[-2]:
1829                A = G2lat.cell2A(cell[3:9])
1830                G2frame.HKL = G2lat.GenHBravais(dmin,cell[2],A)
1831                for hkl in G2frame.HKL:
1832                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1833            table.append(row)
1834        UnitCellsTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1835        gridDisplay = G2gd.GSGrid(G2frame.bottom)
1836        gridDisplay.SetPosition(wx.Point(0,20))               
1837        gridDisplay.SetTable(UnitCellsTable, True)
1838        G2frame.dataFrame.CopyCell.Enable(True)
1839        gridDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshUnitCellsGrid)
1840        gridDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK,OnSortCells)
1841        gridDisplay.SetMargins(0,0)
1842        gridDisplay.SetRowLabelSize(0)
1843        gridDisplay.AutoSizeColumns(False)
1844        for r in range(gridDisplay.GetNumberRows()):
1845            for c in range(gridDisplay.GetNumberCols()):
1846                if c == 2:
1847                    gridDisplay.SetReadOnly(r,c,isReadOnly=False)
1848                else:
1849                    gridDisplay.SetReadOnly(r,c,isReadOnly=True)
1850        gridDisplay.SetSize(bottomSize)
1851
1852################################################################################
1853#####  Reflection list
1854################################################################################           
1855       
1856def UpdateReflectionGrid(G2frame,data,HKLF=False,Name=''):
1857    if not data:
1858        print 'No phases, no reflections'
1859        return
1860    if HKLF:
1861        G2frame.RefList = 1
1862        phaseName = Name
1863    else:
1864        phaseName = G2frame.RefList
1865        phases = data.keys()
1866   
1867        def OnSelectPhase(event):
1868            dlg = wx.SingleChoiceDialog(G2frame,'Select','Phase',phases)
1869            try:
1870                if dlg.ShowModal() == wx.ID_OK:
1871                    sel = dlg.GetSelection()
1872                    G2frame.RefList = phases[sel]
1873                    UpdateReflectionGrid(G2frame,data)
1874            finally:
1875                dlg.Destroy()
1876            G2plt.PlotPatterns(G2frame)
1877       
1878       
1879    if G2frame.dataDisplay:
1880        G2frame.dataFrame.Clear()
1881    rowLabels = []
1882    if HKLF:
1883        G2gd.SetDataMenuBar(G2frame)
1884        refList = [refl[:11] for refl in data[1]]
1885    else:       
1886        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
1887        if not G2frame.dataFrame.GetStatusBar():
1888            Status = G2frame.dataFrame.CreateStatusBar()   
1889        G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
1890        G2frame.dataFrame.SelectPhase.Enable(False)
1891        if len(data) > 1:
1892            G2frame.dataFrame.SelectPhase.Enable(True)
1893        refList = np.array([refl[:11] for refl in data[G2frame.RefList]])
1894        Icorr = np.array([refl[13] for refl in data[G2frame.RefList]])
1895        I100 = refList.T[8]*Icorr
1896        Imax = np.max(I100)
1897        if Imax:
1898            I100 *= 100.0/Imax
1899        refList = np.vstack((refList.T,I100)).T
1900    for i in range(len(refList)): rowLabels.append(str(i))
1901    if HKLF:
1902        colLabels = ['H','K','L','mul','d','Fosq','sig','Fcsq','FoTsq','FcTsq','phase',]
1903    else:
1904        colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase','I100',]
1905    Types = 4*[wg.GRID_VALUE_LONG,]+4*[wg.GRID_VALUE_FLOAT+':10,4',]+ \
1906        2*[wg.GRID_VALUE_FLOAT+':10,2',]+[wg.GRID_VALUE_FLOAT+':10,3',]+ \
1907        [wg.GRID_VALUE_FLOAT+':10,2',]
1908    G2frame.PeakTable = G2gd.Table(refList,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1909    G2frame.dataFrame.SetLabel('Reflection List for '+phaseName)
1910    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
1911    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
1912    G2frame.dataDisplay.EnableEditing(False)
1913    G2frame.dataDisplay.SetMargins(0,0)
1914    G2frame.dataDisplay.AutoSizeColumns(False)
1915    G2frame.dataDisplay.Fit()
1916    size = G2frame.dataDisplay.GetSize()
1917    G2frame.dataFrame.setSizePosLeft([size[0]+32,350])
1918################################################################################
1919#####  PDF controls
1920################################################################################           
1921       
1922def UpdatePDFGrid(G2frame,data):
1923    global inst
1924    tth2q = lambda t,w:4.0*math.pi*sind(t/2.0)/w
1925    dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1926    powName = 'PWDR'+dataFile[4:]
1927    powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
1928    fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))
1929    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))
1930    if 'Lam' in inst:
1931        keV = 12.397639/inst['Lam'][1]
1932    else:
1933        keV = 12.397639/inst['Lam1'][0]
1934    wave = 12.397639/keV
1935    qLimits = [tth2q(fullLimits[0],wave),tth2q(fullLimits[1],wave)]
1936    data['QScaleLim'][1] = min(qLimits[1],data['QScaleLim'][1])
1937    if data['QScaleLim'][0]:
1938        data['QScaleLim'][0] = max(qLimits[0],data['QScaleLim'][0])
1939    else:                                #initial setting at 90% of max Q
1940        data['QScaleLim'][0] = 0.90*data['QScaleLim'][1]
1941    polariz = inst['Polariz.'][1]
1942    azimuth = inst['Azimuth'][1]
1943    itemDict = {}
1944   
1945    def FillFileSizer(fileSizer,key):
1946        #fileSizer is a FlexGridSizer(3,6)
1947       
1948        def OnSelectFile(event):
1949            Obj = event.GetEventObject()
1950            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
1951            if itemKey == 'Name':
1952                value = Obj.GetValue()
1953            Obj.SetValue(fmt%(value))
1954            data[fileKey][itemKey] = value
1955            UpdatePDFGrid(G2frame,data)
1956       
1957        def OnValueChange(event):
1958            Obj = event.GetEventObject()
1959            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
1960            try:
1961                value = float(Obj.GetValue())
1962            except ValueError:
1963                value = -1.0
1964            Obj.SetValue(fmt%(value))
1965            data[fileKey][itemKey] = value
1966            auxPlot = ComputePDF(data)
1967            G2plt.PlotISFG(G2frame,newPlot=True)
1968                       
1969        item = data[key]
1970        fileList = np.array(GetFileList('PWDR')).T[1]
1971        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,wx.ALIGN_CENTER_VERTICAL)
1972        fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
1973            style=wx.CB_READONLY|wx.CB_DROPDOWN)
1974        itemDict[fileName.GetId()] = [key,'Name','%s']
1975        fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)       
1976        fileSizer.Add(fileName,0,)
1977        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,wx.ALIGN_CENTER_VERTICAL)
1978        mult = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(item['Mult']),style=wx.TE_PROCESS_ENTER)
1979        itemDict[mult.GetId()] = [key,'Mult','%.3f']
1980        mult.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
1981        mult.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
1982        fileSizer.Add(mult,0,)
1983        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Add:'),0,wx.ALIGN_CENTER_VERTICAL)
1984        add = wx.TextCtrl(G2frame.dataDisplay,value='%.0f'%(item['Add']),style=wx.TE_PROCESS_ENTER)
1985        itemDict[add.GetId()] = [key,'Add','%.0f']
1986        add.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
1987        add.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
1988        fileSizer.Add(add,0,)
1989       
1990    def SumElementVolumes():
1991        sumVol = 0.
1992        ElList = data['ElList']
1993        for El in ElList:
1994            Avol = (4.*math.pi/3.)*ElList[El]['Drad']**3
1995            sumVol += Avol*ElList[El]['FormulaNo']
1996        return sumVol
1997        auxPlot = ComputePDF(data)
1998        G2plt.PlotISFG(G2frame,newPlot=True)       
1999       
2000    def FillElemSizer(elemSizer,ElData):
2001       
2002        def OnFractionChange(event):
2003            try:
2004                value = max(0.0,float(num.GetValue()))
2005            except ValueError:
2006                value = 0.0
2007            num.SetValue('%.3f'%(value))
2008            ElData['FormulaNo'] = value
2009            data['Form Vol'] = max(10.0,SumElementVolumes())
2010            formVol.SetValue('%.2f'%(data['Form Vol']))
2011            UpdatePDFGrid(G2frame,data)
2012            auxPlot = ComputePDF(data)
2013            G2plt.PlotISFG(G2frame,newPlot=True)       
2014       
2015        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
2016            label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,wx.ALIGN_CENTER_VERTICAL)
2017        num = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(ElData['FormulaNo']),style=wx.TE_PROCESS_ENTER)
2018        num.Bind(wx.EVT_TEXT_ENTER,OnFractionChange)       
2019        num.Bind(wx.EVT_KILL_FOCUS,OnFractionChange)
2020        elemSizer.Add(num,0,wx.ALIGN_CENTER_VERTICAL)
2021        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
2022            label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
2023            0,wx.ALIGN_CENTER_VERTICAL)
2024           
2025    def OnGeometry(event):
2026        data['Geometry'] = geometry.GetValue()
2027        UpdatePDFGrid(G2frame,data)
2028        auxPlot = ComputePDF(data)
2029        G2plt.PlotISFG(G2frame,newPlot=True)       
2030       
2031    def OnDetType(event):
2032        data['DetType'] = detType.GetValue()
2033        UpdatePDFGrid(G2frame,data)
2034        auxPlot = ComputePDF(data)
2035        G2plt.PlotISFG(G2frame,newPlot=True)       
2036       
2037    def OnFormVol(event):
2038        try:
2039            value = float(formVol.GetValue())
2040            if value <= 0.0:
2041                raise ValueError
2042        except ValueError:
2043            value = data['Form Vol']
2044        data['Form Vol'] = value
2045        UpdatePDFGrid(G2frame,data)
2046        auxPlot = ComputePDF(data)
2047        G2plt.PlotISFG(G2frame,newPlot=False)       
2048       
2049    def OnDiameter(event):
2050        try:
2051            value = float(diam.GetValue())
2052            if value <= 0.0:
2053                raise ValueError
2054        except ValueError:
2055            value = data['Diam']
2056        data['Diam'] = value
2057        UpdatePDFGrid(G2frame,data)
2058        auxPlot = ComputePDF(data)
2059        G2plt.PlotISFG(G2frame,newPlot=False)
2060       
2061    def OnPolaVal(event):
2062        try:
2063            value = float(polaVal.GetValue())
2064            if not (0.0 <= value <= 1.0):
2065                raise ValueError
2066        except ValueError:
2067            value = inst['Polariz.'][1]
2068        inst['Polariz.'][1] = value
2069        polaVal.SetValue('%.2f'%(inst['Polariz.'][1]))
2070        UpdatePDFGrid(G2frame,data)
2071        auxPlot = ComputePDF(data)
2072        G2plt.PlotISFG(G2frame,newPlot=False)
2073               
2074    def OnAzimVal(event):
2075        try:
2076            value = float(azimVal.GetValue())
2077            if not (0. <= value <= 360.):
2078                raise ValueError
2079        except ValueError:
2080            value = inst['Azimuth'][1]
2081        inst['Azimuth'][1] = value
2082        azimVal.SetValue('%.1f'%(inst['Azimuth'][1]))
2083        UpdatePDFGrid(G2frame,data)
2084        auxPlot = ComputePDF(data)
2085        G2plt.PlotISFG(G2frame,newPlot=False)
2086                       
2087    def OnObliqCoeff(event):
2088        try:
2089            value = float(obliqCoeff.GetValue())
2090            if value < 0.0:
2091                raise ValueError
2092            elif value > 1.0:
2093                value = 1.0
2094        except ValueError:
2095            value = data['ObliqCoeff']
2096        data['ObliqCoeff'] = value
2097        obliqCoeff.SetValue('%.3f'%(value))
2098        auxPlot = ComputePDF(data)
2099        G2plt.PlotISFG(G2frame,newPlot=False)
2100       
2101    def OnRulandWdt(event):
2102        try:
2103            value = float(rulandWdt.GetValue())
2104            if value <= 0.001:
2105                raise ValueError
2106            elif value > 1.0:
2107                value = 1.0
2108        except ValueError:
2109            value = data['Ruland']
2110        data['Ruland'] = value
2111        rulandWdt.SetValue('%.3f'%(value))
2112        auxPlot = ComputePDF(data)
2113        G2plt.PlotISFG(G2frame,newPlot=False)
2114       
2115    def OnRulSlider(event):
2116        value = int(rulandSldr.GetValue())/1000.
2117        data['Ruland'] = max(0.001,value)
2118        rulandWdt.SetValue('%.3f'%(data['Ruland']))
2119        auxPlot = ComputePDF(data)
2120        G2plt.PlotISFG(G2frame,newPlot=False)
2121       
2122    def OnLorch(event):
2123        data['Lorch'] = lorch.GetValue()
2124        auxPlot = ComputePDF(data)
2125        G2plt.PlotISFG(G2frame,newPlot=False)       
2126                       
2127    def OnPacking(event):
2128        try:
2129            value = float(pack.GetValue())
2130            if value <= 0.0:
2131                raise ValueError
2132        except ValueError:
2133            value = data['Pack']
2134        data['Pack'] = value
2135        UpdatePDFGrid(G2frame,data)
2136        auxPlot = ComputePDF(data)
2137        G2plt.PlotISFG(G2frame,newPlot=False)       
2138               
2139    def OnSQmin(event):
2140        try:
2141            value = float(SQmin.GetValue())
2142            if value < qLimits[0]:
2143                raise ValueError
2144        except ValueError:
2145            value = max(qLimits[0],data['QScaleLim'][0])
2146        data['QScaleLim'][0] = value
2147        SQmin.SetValue('%.1f'%(value))
2148        auxPlot = ComputePDF(data)
2149        G2plt.PlotISFG(G2frame,newPlot=True)       
2150       
2151    def OnSQmax(event):
2152        try:
2153            value = float(SQmax.GetValue())
2154            if value > qLimits[1]:
2155                raise ValueError
2156        except ValueError:
2157            value = min(qLimits[1],data['QScaleLim'][1])
2158        data['QScaleLim'][1] = value
2159        if value < data['QScaleLim'][0]:
2160            data['QScaleLim'][0] = 0.90*value
2161            SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
2162        SQmax.SetValue('%.1f'%(value))
2163        auxPlot = ComputePDF(data)
2164        G2plt.PlotISFG(G2frame,newPlot=True)
2165       
2166    def OnResetQ(event):
2167        resetQ.SetValue(False)
2168        data['QScaleLim'][1] = qLimits[1]
2169        SQmax.SetValue('%.1f'%(data['QScaleLim'][1]))
2170        data['QScaleLim'][0] = 0.9*qLimits[1]
2171        SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
2172        auxPlot = ComputePDF(data)
2173        G2plt.PlotISFG(G2frame,newPlot=True)       
2174
2175    def GetFileList(fileType,skip=None):
2176        fileList = [[False,'',0]]
2177        Source = ''
2178        id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2179        while id:
2180            name = G2frame.PatternTree.GetItemText(id)
2181            if fileType in name:
2182                if id == skip:
2183                    Source = name
2184                else:
2185                    fileList.append([False,name,id])
2186            id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2187        if skip:
2188            return fileList,Source
2189        else:
2190            return fileList
2191       
2192    def OnCopyPDFControls(event):
2193        import copy
2194        TextList,Source = GetFileList('PDF',skip=G2frame.PatternId)
2195        TextList[0] = [False,'All PDF',0]
2196        if len(TextList) == 1:
2197            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
2198            return
2199        dlg = G2frame.CopyDialog(G2frame,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
2200        try:
2201            if dlg.ShowModal() == wx.ID_OK:
2202                result = dlg.GetData()
2203                if result[0][0]:
2204                    result = TextList[1:]
2205                    for item in result: item[0] = True
2206                for i,item in enumerate(result):
2207                    ifcopy,name,id = item
2208                    if ifcopy:
2209                        olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
2210                        sample = olddata['Sample']
2211                        olddata.update(copy.deepcopy(data))
2212                        olddata['Sample'] = sample
2213                        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
2214                Status.SetStatusText('PDF controls copied')
2215        finally:
2216            dlg.Destroy()
2217               
2218    def OnSavePDFControls(event):
2219        print 'save PDF controls?'
2220       
2221    def OnLoadPDFControls(event):
2222        print 'Load PDF controls?'
2223       
2224    def OnAddElement(event):
2225        ElList = data['ElList']
2226        PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
2227        if PE.ShowModal() == wx.ID_OK:
2228            El = PE.Elem
2229            if El not in ElList and El != 'None':
2230                ElemSym = El.strip().upper()               
2231                FpMu = G2elem.FPcalc(G2elem.GetXsectionCoeff(ElemSym), keV)
2232                ElData = G2elem.GetFormFactorCoeff(ElemSym)[0]
2233                ElData['FormulaNo'] = 0.0
2234                ElData.update(G2elem.GetAtomInfo(ElemSym))
2235                ElData.update(dict(zip(['fp','fpp','mu'],FpMu)))
2236                ElData.update(G2elem.GetFFC5(El))
2237                data['ElList'][El] = ElData
2238            data['Form Vol'] = max(10.0,SumElementVolumes())
2239        PE.Destroy()
2240        UpdatePDFGrid(G2frame,data)
2241       
2242    def OnDeleteElement(event):
2243        ElList = data['ElList']
2244        choice = ElList.keys()
2245        dlg = G2elemGUI.DeleteElement(G2frame,choice=choice)
2246        if dlg.ShowModal() == wx.ID_OK:
2247            del ElList[dlg.GetDeleteElement()]
2248        dlg.Destroy()
2249        UpdatePDFGrid(G2frame,data)
2250               
2251    def ComputePDF(Data):
2252        xydata = {}
2253        for key in ['Sample','Sample Bkg.','Container','Container Bkg.']:
2254            name = Data[key]['Name']
2255            if name:
2256                xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
2257                PDFname = name
2258        powName = xydata['Sample'][2]
2259        powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
2260        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))
2261        auxPlot = G2pwd.CalcPDF(Data,inst,xydata)
2262        PDFId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PDF '+powName[4:])
2263        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
2264        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
2265        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
2266        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
2267        return auxPlot
2268       
2269    def OnComputePDF(event):
2270        print 'Calculating PDF:'
2271        auxPlot = ComputePDF(data)
2272        print 'Done calculating PDF:'
2273        Status.SetStatusText('PDF computed')
2274        for plot in auxPlot:
2275            G2plt.PlotXY(G2frame,plot[:2],type=plot[2])
2276       
2277        G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
2278        G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
2279        G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
2280        G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
2281       
2282    def OnComputeAllPDF(event):
2283        print 'Calculating PDFs:'
2284        if G2frame.PatternTree.GetCount():
2285            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2286            while id:
2287                Name = G2frame.PatternTree.GetItemText(id)
2288                if 'PDF' in Name:
2289                    Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
2290                    auxPlot = ComputePDF(Data)                   
2291                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2292            Status.SetStatusText('All PDFs computed')
2293            G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
2294            print ' Done calculating PDFs:'
2295       
2296    def OnShowTip(G2frame,tip):
2297        print tip   
2298               
2299    if G2frame.dataDisplay:
2300        G2frame.dataFrame.Clear()
2301    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PDFMenu)
2302    if not G2frame.dataFrame.GetStatusBar():
2303        Status = G2frame.dataFrame.CreateStatusBar()   
2304    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2305    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
2306    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
2307    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
2308    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
2309    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
2310    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
2311    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
2312    mainSizer = wx.BoxSizer(wx.VERTICAL)
2313    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,wx.ALIGN_CENTER_VERTICAL)
2314    mainSizer.Add((5,5),0)
2315    str = ' Sample file: PWDR %s   Wavelength, A: %.5f  Energy, keV: %.3f  Polariz.: %.2f '%(dataFile[3:],wave,keV,polariz)
2316    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,wx.ALIGN_CENTER_VERTICAL)
2317#    dataSizer = wx.BoxSizer(wx.HORIZONTAL)
2318#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Azimuth'),0,wx.ALIGN_CENTER_VERTICAL)
2319#    azimVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Azimuth']))
2320#    azimVal.Bind(wx.EVT_TEXT_ENTER,OnAzimVal)       
2321#    azimVal.Bind(wx.EVT_KILL_FOCUS,OnAzimVal)
2322#    dataSizer.Add(azimVal,0)   
2323#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Polarization'),0,wx.ALIGN_CENTER_VERTICAL)
2324#    polaVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Polariz.']))
2325#    polaVal.Bind(wx.EVT_TEXT_ENTER,OnPolaVal)       
2326#    polaVal.Bind(wx.EVT_KILL_FOCUS,OnPolaVal)
2327#    dataSizer.Add(polaVal,0)   
2328#    mainSizer.Add(dataSizer,0)
2329    mainSizer.Add((5,5),0)
2330    fileSizer = wx.FlexGridSizer(3,6,5,1)
2331    select = ['Sample Bkg.','Container']
2332    if data['Container']['Name']:
2333        select.append('Container Bkg.')
2334    for key in select:
2335        FillFileSizer(fileSizer,key)
2336    mainSizer.Add(fileSizer,0)
2337    mainSizer.Add((5,5),0)
2338    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,wx.ALIGN_CENTER_VERTICAL)
2339    mainSizer.Add((5,5),0)   
2340
2341    ElList = data['ElList']
2342    Abs = G2lat.CellAbsorption(ElList,data['Form Vol'])
2343    Trans = G2pwd.Transmission(data['Geometry'],Abs*data['Pack'],data['Diam'])
2344    elemSizer = wx.FlexGridSizer(3,3,5,1)
2345    for El in ElList:
2346        FillElemSizer(elemSizer,ElList[El])
2347    mainSizer.Add(elemSizer,0)
2348    mainSizer.Add((5,5),0)   
2349    midSizer = wx.BoxSizer(wx.HORIZONTAL)
2350    midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,wx.ALIGN_CENTER_VERTICAL)
2351    formVol = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Form Vol']))
2352    formVol.Bind(wx.EVT_TEXT_ENTER,OnFormVol)       
2353    formVol.Bind(wx.EVT_KILL_FOCUS,OnFormVol)
2354    midSizer.Add(formVol,0)
2355    midSizer.Add(wx.StaticText(G2frame.dataDisplay,
2356        label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
2357        0,wx.ALIGN_CENTER_VERTICAL)
2358    mainSizer.Add(midSizer,0)
2359    mainSizer.Add((5,5),0)   
2360
2361    geoBox = wx.BoxSizer(wx.HORIZONTAL)
2362    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,wx.ALIGN_CENTER_VERTICAL)
2363    choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
2364    geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
2365            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2366    geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
2367    geoBox.Add(geometry,0)
2368    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,wx.ALIGN_CENTER_VERTICAL)
2369    diam = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Diam']))
2370    diam.Bind(wx.EVT_TEXT_ENTER,OnDiameter)       
2371    diam.Bind(wx.EVT_KILL_FOCUS,OnDiameter)
2372#    diam.Bind(wx.EVT_SET_FOCUS,OnShowTip(G2frame,'tip')) #this doesn't work - what would????
2373    geoBox.Add(diam,0)
2374    mainSizer.Add(geoBox,0)
2375    mainSizer.Add((5,5),0)   
2376    geoBox = wx.BoxSizer(wx.HORIZONTAL)
2377    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,wx.ALIGN_CENTER_VERTICAL)
2378    pack = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Pack']))
2379    pack.Bind(wx.EVT_TEXT_ENTER,OnPacking)       
2380    pack.Bind(wx.EVT_KILL_FOCUS,OnPacking)
2381    geoBox.Add(pack,0)
2382    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,wx.ALIGN_CENTER_VERTICAL)   
2383    mainSizer.Add(geoBox,0)
2384    mainSizer.Add((5,5),0)   
2385       
2386    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,wx.ALIGN_CENTER_VERTICAL)
2387    mainSizer.Add((5,5),0)
2388    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2389    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,wx.ALIGN_CENTER_VERTICAL)
2390    choice = ['Image plate','Point detector']
2391    detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
2392            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2393    detType.Bind(wx.EVT_COMBOBOX, OnDetType)
2394    sqBox.Add(detType,0)
2395    if data['DetType'] == 'Image plate':
2396        sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
2397        obliqCoeff = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['ObliqCoeff']))
2398        obliqCoeff.Bind(wx.EVT_TEXT_ENTER,OnObliqCoeff)       
2399        obliqCoeff.Bind(wx.EVT_KILL_FOCUS,OnObliqCoeff)
2400        sqBox.Add(obliqCoeff,0)
2401    mainSizer.Add(sqBox,0)
2402       
2403    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2404    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,wx.ALIGN_CENTER_VERTICAL)   
2405    rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
2406        value=int(1000*data['Ruland']))
2407    sqBox.Add(rulandSldr,1,wx.EXPAND)
2408    rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
2409    rulandWdt = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Ruland']))
2410    rulandWdt.Bind(wx.EVT_TEXT_ENTER,OnRulandWdt)       
2411    rulandWdt.Bind(wx.EVT_KILL_FOCUS,OnRulandWdt)
2412    sqBox.Add(rulandWdt,0,wx.ALIGN_CENTER_VERTICAL)   
2413    mainSizer.Add(sqBox,0,wx.ALIGN_LEFT|wx.EXPAND)
2414   
2415    sqBox = wx.BoxSizer(wx.HORIZONTAL)
2416    lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
2417    lorch.SetValue(data['Lorch'])
2418    lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
2419    sqBox.Add(lorch,0,wx.ALIGN_CENTER_VERTICAL)
2420    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling q-range: '),0,wx.ALIGN_CENTER_VERTICAL)
2421    SQmin = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][0]))
2422    SQmin.Bind(wx.EVT_TEXT_ENTER,OnSQmin)       
2423    SQmin.Bind(wx.EVT_KILL_FOCUS,OnSQmin)   
2424    sqBox.Add(SQmin,0)
2425    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to '),0,wx.ALIGN_CENTER_VERTICAL)
2426    SQmax = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][1]))
2427    SQmax.Bind(wx.EVT_TEXT_ENTER,OnSQmax)       
2428    SQmax.Bind(wx.EVT_KILL_FOCUS,OnSQmax)
2429    sqBox.Add(SQmax,0)
2430    resetQ = wx.CheckBox(parent=G2frame.dataDisplay,label='Reset?')
2431    sqBox.Add(resetQ,0)
2432    resetQ.Bind(wx.EVT_CHECKBOX, OnResetQ)
2433   
2434    mainSizer.Add(sqBox,0)
2435
2436    mainSizer.Layout()   
2437    G2frame.dataDisplay.SetSizer(mainSizer)
2438    Size = mainSizer.Fit(G2frame.dataFrame)
2439    G2frame.dataDisplay.SetSize(Size)
2440    G2frame.dataFrame.setSizePosLeft(Size)
2441   
Note: See TracBrowser for help on using the repository browser.