source: trunk/GSASIIpwdGUI.py @ 335

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

Add delete Pawley list; scratch "leBail" from things
mods to texture display stuff
refactor instrument parameters GUI as sizer based - no grid table
some mods to peak fit output

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