source: trunk/GSASIIpwdGUI.py @ 808

Last change on this file since 808 was 808, checked in by vondreele, 9 years ago

Add Babinet modification to form factors - works OK
Use atom Ids for restraints
add 'all' in atom constraint editing routines
New add routines for bond restraints (angle add not done yet)
FindAtomIndexByIDs, FillAtomLookUp?, GetAtomsByID, & GetAtomItemsById? all now in GSASIImath.py
removed from GSASIIphsGUI.py
change phase tick mark colors
get GSASIIstruct.py to recognize protein atoms & do a protein calc.

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