source: trunk/GSASIIpwdGUI.py @ 408

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

add copy to limits menu
more constraint GUI stuff

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