source: trunk/GSASIIpwdGUI.py @ 765

Last change on this file since 765 was 765, checked in by toby, 10 years ago

refactor menus on Mac, clean up main menu generation

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