source: trunk/GSASIIpwdGUI.py @ 1283

Last change on this file since 1283 was 1283, checked in by vondreele, 8 years ago

open a SASD gpx file now starts at SASD file & plot
fix 2/a & 2/c lattice codes in CellSizer?
more graceful when SASD least squares fails
add 'Radius' to list of possibel parameters in SASD fit
fix form factor volume calc for monodisperse models

  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Author Revision URL Id
File size: 171.3 KB
Line 
1# -*- coding: utf-8 -*-
2#GSASIIpwdGUI - powder data display routines
3########### SVN repository information ###################
4# $Date: 2014-04-18 16:27:12 +0000 (Fri, 18 Apr 2014) $
5# $Author: vondreele $
6# $Revision: 1283 $
7# $URL: trunk/GSASIIpwdGUI.py $
8# $Id: GSASIIpwdGUI.py 1283 2014-04-18 16:27:12Z vondreele $
9########### SVN repository information ###################
10'''
11*GSASIIpwdGUI: Powder Pattern GUI routines*
12-------------------------------------------
13
14Used to define GUI controls for the routines that interact
15with the powder histogram (PWDR) data tree items.
16
17'''
18import sys
19import os.path
20import wx
21import wx.grid as wg
22import wx.lib.scrolledpanel as wxscroll
23import numpy as np
24import numpy.ma as ma
25import math
26import time
27import copy
28import random as ran
29import cPickle
30import GSASIIpath
31GSASIIpath.SetVersionNumber("$Revision: 1283 $")
32import GSASIImath as G2mth
33import GSASIIpwd as G2pwd
34import GSASIIIO as G2IO
35import GSASIIlattice as G2lat
36import GSASIIspc as G2spc
37import GSASIIindex as G2indx
38import GSASIIplot as G2plt
39import GSASIIgrid as G2gd
40import GSASIIElemGUI as G2elemGUI
41import GSASIIElem as G2elem
42import GSASIIsasd as G2sasd
43VERY_LIGHT_GREY = wx.Colour(235,235,235)
44WACV = wx.ALIGN_CENTER_VERTICAL
45Pwr10 = unichr(0x0b9)+unichr(0x0b0)
46Pwr20 = unichr(0x0b2)+unichr(0x0b0)
47Pwrm1 = unichr(0x207b)+unichr(0x0b9)
48Pwrm2 = unichr(0x207b)+unichr(0x0b2)
49Pwrm4 = unichr(0x207b)+unichr(0x2074)   #really -d but looks like -4 as a superscript
50# trig functions in degrees
51sind = lambda x: math.sin(x*math.pi/180.)
52tand = lambda x: math.tan(x*math.pi/180.)
53cosd = lambda x: math.cos(x*math.pi/180.)
54asind = lambda x: 180.*math.asin(x)/math.pi
55   
56def IsHistogramInAnyPhase(G2frame,histoName):
57    'Needs a doc string'
58    phases = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
59    if phases:
60        item, cookie = G2frame.PatternTree.GetFirstChild(phases)
61        while item:
62            data = G2frame.PatternTree.GetItemPyData(item)
63            histoList = data['Histograms'].keys()
64            if histoName in histoList:
65                return True
66            item, cookie = G2frame.PatternTree.GetNextChild(phases, cookie)
67        return False
68    else:
69        return False
70
71def SetDefaultSample():
72    'Fills in default items for the Sample dictionary'
73    return {
74        'InstrName':'',
75        'ranId':ran.randint(0,sys.maxint),
76        'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],
77        'DisplaceX':[0.0,False],'DisplaceY':[0.0,False],'Diffuse':[],
78        'Temperature':300.,'Pressure':0.1,
79        'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
80        'Gonio. radius':200.0,
81        'Omega':0.0,'Chi':0.0,'Phi':0.0,
82#SASD items
83        'Materials':[{'Name':'vacuum','VolFrac':1.0,},{'Name':'vacuum','VolFrac':0.0,}],
84        'Thick':1.0,'Contrast':[0.0,0.0],       #contrast & anomalous contrast
85        'Trans':1.0,                            #measured transmission
86        }
87def SetupSampleLabels(histName,dataType):
88    '''Setup a list of labels and number formatting for use in
89    labeling sample parameters.
90    :param str histName: Name of histogram, ("PWDR ...")
91    :param str dataType:
92    '''
93    parms = []
94    parms.append(['Scale','Histogram scale factor: ',[10,4]])
95    parms.append(['Gonio. radius','Goniometer radius (mm): ',[10,3]])
96    if 'PWDR' in histName:
97        if dataType == 'Debye-Scherrer':
98            parms += [['DisplaceX',u'Sample X displ. perp. to beam (\xb5m): ',[10,3]],
99                ['DisplaceY',u'Sample Y displ. || to beam (\xb5m): ',[10,3]],
100                ['Absorption',u'Sample absorption (\xb5\xb7r): ',[10,4]],]
101        elif dataType == 'Bragg-Brentano':
102            parms += [['Shift',u'Sample displacement(\xb5m): ',[10,4]],
103                ['Transparency',u'Sample transparency(1/\xb5eff, cm): ',[10,3]],
104                ['SurfRoughA','Surface roughness A: ',[10,4]],
105                ['SurfRoughB','Surface roughness B: ',[10,4]]]
106    elif 'SASD' in histName:
107        parms.append(['Thick','Sample thickness (mm)',[10,3]])
108        parms.append(['Trans','Transmission (meas)',[10,3]])
109    parms.append(['Omega','Goniometer omega:',[10,3]])
110    parms.append(['Chi','Goniometer chi:',[10,3]])
111    parms.append(['Phi','Goniometer phi:',[10,3]])
112    parms.append(['Temperature','Sample temperature (K): ',[10,3]])
113    parms.append(['Pressure','Sample pressure (MPa): ',[10,3]])
114    return parms
115
116def SetDefaultSASDModel():
117    'Fills in default items for the SASD Models dictionary'   
118    return {'Back':[0.0,False],'Size':{'MinDiam':50,'MaxDiam':10000,'Nbins':100,
119        'logBins':True,'Method':'MaxEnt','Distribution':[],
120        'Shape':['Spheroid',1.0],'MaxEnt':{'Niter':100,'Precision':0.01,'Sky':-3},
121        'IPG':{'Niter':100,'Approach':0.8,'Power':-1},'Reg':{},},           
122        'Particle':{'Matrix':{'Name':'vacuum','VolFrac':[0.0,False]},'Levels':[],},
123        'Current':'Size dist.',
124        }
125       
126def SetDefaultSubstances():
127    'Fills in default items for the SASD Substances dictionary'
128    return {'Substances':{'vacuum':{'Elements':{},'Volume':1.0,'Density':0.0,'Scatt density':0.0}}}
129
130def GetHistsLikeSelected(G2frame):
131    '''Get the histograms that match the current selected one:
132    The histogram prefix and data type (PXC etc.), the number of
133    wavelengths and the instrument geometry (Debye-Scherrer etc.)
134    must all match. The current histogram is not included in the list.
135
136    :param wx.Frame G2frame: pointer to main GSAS-II data tree
137    '''
138    histList = []
139    inst,inst2 = G2frame.PatternTree.GetItemPyData(
140        G2gd.GetPatternTreeItemId(
141            G2frame,G2frame.PatternId, 'Instrument Parameters')
142        )
143    hType = inst['Type'][0]
144    if 'Lam1' in inst:
145        hLam = 2
146    elif 'Lam' in inst:
147        hLam = 1
148    else:
149        hLam = 0
150    sample = G2frame.PatternTree.GetItemPyData(
151        G2gd.GetPatternTreeItemId(
152            G2frame,G2frame.PatternId, 'Sample Parameters')
153        )
154    hGeom = sample.get('Type')
155    hstName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
156    hPrefix = hstName.split()[0]+' '
157    # cycle through tree looking for items that match the above
158    item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)       
159    while item:
160        name = G2frame.PatternTree.GetItemText(item)
161        if name.startswith(hPrefix) and name != hstName:
162            cGeom,cType,cLam, = '?','?',-1
163            subitem, subcookie = G2frame.PatternTree.GetFirstChild(item)
164            while subitem:
165                subname = G2frame.PatternTree.GetItemText(subitem)
166                if subname == 'Sample Parameters':
167                    sample = G2frame.PatternTree.GetItemPyData(subitem)
168                    cGeom = sample.get('Type')
169                elif subname == 'Instrument Parameters':
170                    inst,inst2 = G2frame.PatternTree.GetItemPyData(subitem)
171                    cType = inst['Type'][0]
172                    if 'Lam1' in inst:
173                        cLam = 2
174                    elif 'Lam' in inst:
175                        cLam = 1
176                    else:
177                        cLam = 0
178                subitem, subcookie = G2frame.PatternTree.GetNextChild(item, subcookie)
179            if cLam == hLam and cType == hType and cGeom == hGeom:
180                if name not in histList: histList.append(name)
181        item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
182    return histList
183
184def SetCopyNames(histName,dataType,addNames=[]):
185    '''Determine the items in the sample parameters that should be copied,
186    depending on the histogram type and the instrument type.
187    '''
188    copyNames = ['Scale',]
189    histType = 'HKLF'
190    if 'PWDR' in histName:
191        histType = 'PWDR'
192        if 'Debye' in dataType:
193            copyNames += ['DisplaceX','DisplaceY','Absorption']
194        else:       #Bragg-Brentano
195            copyNames += ['Shift','Transparency','SurfRoughA','SurfRoughB']
196    elif 'SASD' in histName:
197        histType = 'SASD'
198        copyNames += ['Materials','Thick',]
199    if len(addNames):
200        copyNames += addNames
201    return histType,copyNames
202
203def CopySelectedHistItems(G2frame):
204    '''Global copy: Copy items from current histogram to others.
205    This is called from the menubar and is available only when the top histogram tree entry
206    is selected.
207    '''
208    hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
209    histList = GetHistsLikeSelected(G2frame)
210    if not histList:
211        G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
212        return
213    choices = ['Limits','Background','Instrument Parameters','Sample Parameters']
214    dlg = G2gd.G2MultiChoiceDialog(
215        G2frame.dataFrame, 
216        'Copy which histogram sections from\n'+str(hst[5:]),
217        'Select copy sections', choices, filterBox=False)
218    dlg.SetSelections(range(len(choices)))
219    choiceList = []
220    if dlg.ShowModal() == wx.ID_OK:
221        choiceList = [choices[i] for i in dlg.GetSelections()]
222    if not choiceList: return
223   
224    dlg = G2gd.G2MultiChoiceDialog(
225        G2frame.dataFrame, 
226        'Copy parameters from\n'+str(hst[5:])+' to...',
227        'Copy parameters', histList)
228    results = []
229    try:
230        if dlg.ShowModal() == wx.ID_OK:
231            results = dlg.GetSelections()
232    finally:
233        dlg.Destroy()
234    copyList = []
235    for i in results: 
236        copyList.append(histList[i])
237
238    if 'Limits' in choiceList: # Limits
239        data = G2frame.PatternTree.GetItemPyData(
240            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Limits'))
241        for item in copyList:
242            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
243            G2frame.PatternTree.SetItemPyData(
244                G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),
245                copy.deepcopy(data))
246    if 'Background' in choiceList:  # Background
247        data = G2frame.PatternTree.GetItemPyData(
248            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Background'))
249        for item in copyList:
250            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
251            G2frame.PatternTree.SetItemPyData(
252                G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),
253                copy.deepcopy(data))
254    if 'Instrument Parameters' in choiceList:  # Instrument Parameters
255        # for now all items in Inst. parms are copied
256        data,data1 = G2frame.PatternTree.GetItemPyData(
257            G2gd.GetPatternTreeItemId(
258                G2frame,G2frame.PatternId,'Instrument Parameters'))
259        for item in copyList:
260            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
261            G2frame.PatternTree.GetItemPyData(
262                G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
263                )[0].update(copy.deepcopy(data))
264            G2frame.PatternTree.GetItemPyData(
265                G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
266                )[1].update(copy.deepcopy(data1))
267    if 'Sample Parameters' in choiceList:  # Sample Parameters
268        data = G2frame.PatternTree.GetItemPyData(
269            G2gd.GetPatternTreeItemId(
270                G2frame,G2frame.PatternId,'Sample Parameters'))
271        # selects items to be copied
272        histType,copyNames = SetCopyNames(hst,data['Type'],
273            addNames = ['Omega','Chi','Phi','Gonio. radius','InstrName'])
274        copyDict = {parm:data[parm] for parm in copyNames}
275        for item in copyList:
276            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
277            G2frame.PatternTree.GetItemPyData(
278                G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters')
279                ).update(copy.deepcopy(copyDict))
280                         
281################################################################################
282#####  Powder Peaks
283################################################################################           
284       
285def UpdatePeakGrid(G2frame, data):
286    '''respond to selection of PWDR powder peaks data tree item.
287    '''
288    if G2frame.dataDisplay:
289        G2frame.dataFrame.Clear()
290       
291    def OnAutoSearch(event):
292        PatternId = G2frame.PatternId
293        PickId = G2frame.PickId
294        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
295        inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
296        profile = G2frame.PatternTree.GetItemPyData(PatternId)[1]
297        x0 = profile[0]
298        iBeg = np.searchsorted(x0,limits[0])
299        iFin = np.searchsorted(x0,limits[1])
300        x = x0[iBeg:iFin]
301        y0 = profile[1][iBeg:iFin]
302        y1 = copy.copy(y0)
303        ysig = np.std(y1)
304        offset = [-1,1]
305        ymask = ma.array(y0,mask=(y0<ysig))
306        for off in offset:
307            ymask = ma.array(ymask,mask=(ymask-np.roll(y0,off)<=0.))
308        indx = ymask.nonzero()
309        mags = ymask[indx]
310        poss = x[indx]
311        refs = zip(poss,mags)
312        refs = G2mth.sortArray(refs,0,reverse=True)
313        for i,ref1 in enumerate(refs):
314            for ref2 in refs[i+1:]:
315                if abs(ref2[0]-ref1[0]) < 0.1*G2pwd.getFWHM(ref1[0],inst):
316                    del(refs[i])   
317        refs = G2mth.sortArray(refs,1,reverse=True)
318        for pos,mag in refs:
319            data.append(G2mth.setPeakparms(inst,inst2,pos,mag))
320        UpdatePeakGrid(G2frame,data)
321        G2plt.PlotPatterns(G2frame,plotType='PWDR')       
322   
323    def OnUnDo(event):
324        DoUnDo()
325        G2frame.dataFrame.UnDo.Enable(False)
326       
327    def DoUnDo():
328        print 'Undo last refinement'
329        file = open(G2frame.undofile,'rb')
330        PatternId = G2frame.PatternId
331        for item in ['Background','Instrument Parameters','Peak List']:
332            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
333            if G2frame.dataDisplay.GetName() == item:
334                if item == 'Background':
335                    UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
336                elif item == 'Instrument Parameters':
337                    UpdateInstrumentGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
338                elif item == 'Peak List':
339                    UpdatePeakGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
340            print item,' recovered'
341        file.close()
342       
343    def SaveState():
344        G2frame.undofile = os.path.join(G2frame.dirname,'GSASII.save')
345        file = open(G2frame.undofile,'wb')
346        PatternId = G2frame.PatternId
347        for item in ['Background','Instrument Parameters','Peak List']:
348            cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
349        file.close()
350        G2frame.dataFrame.UnDo.Enable(True)
351       
352    def OnLSQPeakFit(event):
353        if not G2frame.GSASprojectfile:            #force a save of the gpx file so SaveState can wirte in the same directory
354            G2frame.OnFileSaveas(event)
355        OnPeakFit('LSQ')
356       
357    def OnOneCycle(event):
358        OnPeakFit('LSQ',oneCycle=True)
359       
360    def OnClearPeaks(event):
361        dlg = wx.MessageDialog(G2frame,'Delete all peaks?','Clear peak list',wx.OK|wx.CANCEL)
362        try:
363            if dlg.ShowModal() == wx.ID_OK:
364                peaks = []
365        finally:
366            dlg.Destroy()
367        UpdatePeakGrid(G2frame,peaks)
368        G2plt.PlotPatterns(G2frame,plotType='PWDR')
369       
370    def OnPeakFit(FitPgm,oneCycle=False):
371        SaveState()
372        controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
373        if not controls:
374            controls = {'deriv type':'analytic','min dM/M':0.0001,}     #fill in defaults if needed
375        print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
376        PatternId = G2frame.PatternId
377        PickId = G2frame.PickId
378        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
379        if not peaks:
380            G2frame.ErrorDialog('No peaks!','Nothing to fit!')
381            return
382        background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
383        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
384        inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
385        data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
386        wx.BeginBusyCursor()
387        dlg = wx.ProgressDialog('Residual','Peak fit Rwp = ',101.0, 
388            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE|wx.PD_REMAINING_TIME|wx.PD_CAN_ABORT)
389        screenSize = wx.ClientDisplayRect()
390        Size = dlg.GetSize()
391        dlg.SetPosition(wx.Point(screenSize[2]-Size[0]-305,screenSize[1]+5))
392        try:
393            G2pwd.DoPeakFit(FitPgm,peaks,background,limits,inst,inst2,data,oneCycle,controls,dlg)
394        finally:
395            wx.EndBusyCursor()   
396        UpdatePeakGrid(G2frame,peaks)
397        G2plt.PlotPatterns(G2frame,plotType='PWDR')
398        print 'finished'
399        return
400       
401    def OnResetSigGam(event):
402        PatternId = G2frame.PatternId
403        PickId = G2frame.PickId
404        Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
405        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
406        if not peaks:
407            G2frame.ErrorDialog('No peaks!','Nothing to do!')
408            return
409        newpeaks = []
410        for peak in peaks:
411            newpeaks.append(G2mth.setPeakparms(Inst,Inst2,peak[0],peak[2]))
412        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
413        UpdatePeakGrid(G2frame,newpeaks)
414               
415    def RefreshPeakGrid(event):
416        r,c =  event.GetRow(),event.GetCol()
417       
418        event.StopPropagation()
419        data = G2frame.PeakTable.GetData()
420        T = []
421        for peak in data:T.append(peak[0])
422        D = dict(zip(T,data))
423        T.sort()
424        X = []
425        for key in T: X.append(D[key])
426        data = X       
427       
428    def setBackgroundColors():
429       for r in range(G2frame.dataDisplay.GetNumberRows()):
430           for c in range(G2frame.dataDisplay.GetNumberCols()):
431               if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
432                   if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
433                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
434                   else:
435                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
436                                                 
437    def KeyEditPeakGrid(event):
438        rowList = G2frame.dataDisplay.GetSelectedRows()
439        colList = G2frame.dataDisplay.GetSelectedCols()
440        selectList = G2frame.dataDisplay.GetSelectedCells()
441        data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
442        if event.GetKeyCode() == wx.WXK_RETURN:
443            event.Skip(True)
444        elif event.GetKeyCode() == wx.WXK_CONTROL:
445            event.Skip(True)
446        elif event.GetKeyCode() == wx.WXK_SHIFT:
447            event.Skip(True)
448        elif rowList:
449            G2frame.dataDisplay.ClearSelection()
450            if event.GetKeyCode() == wx.WXK_DELETE:
451                G2frame.dataDisplay.ClearGrid()
452                rowList.sort()
453                rowList.reverse()
454                nDel = 0
455                for row in rowList:
456                    G2frame.PeakTable.DeleteRow(row)
457                    nDel += 1
458                if nDel:
459                    msg = wg.GridTableMessage(G2frame.PeakTable, 
460                        wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
461                    G2frame.dataDisplay.ProcessTableMessage(msg)
462                data = G2frame.PeakTable.GetData()
463                G2frame.PatternTree.SetItemPyData(G2frame.PickId,data[:-nDel])
464                G2frame.dataDisplay.ForceRefresh()
465                setBackgroundColors()
466                if not len(G2frame.PatternTree.GetItemPyData(G2frame.PickId)): 
467                    G2frame.dataFrame.PeakFit.Enable(False)
468                       
469        elif colList:
470            G2frame.dataDisplay.ClearSelection()
471            key = event.GetKeyCode()
472            for col in colList:
473                if G2frame.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
474                    if key == 89: #'Y'
475                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=True
476                    elif key == 78:  #'N'
477                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=False
478        elif selectList:
479            G2frame.dataDisplay.ClearSelection()
480            key = event.GetKeyCode()
481            for row,col in selectList:
482                if G2frame.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
483                    if key == 89: #'Y'
484                        data[row][col]=True
485                    elif key == 78:  #'N'
486                        data[row][col]=False
487        G2plt.PlotPatterns(G2frame,plotType='PWDR')
488           
489    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PeakMenu)
490    if not G2frame.dataFrame.GetStatusBar():
491        Status = G2frame.dataFrame.CreateStatusBar()
492    Status.SetStatusText('Global refine: select refine column & press Y or N')
493    G2frame.Bind(wx.EVT_MENU, OnAutoSearch, id=G2gd.wxID_AUTOSEARCH)
494    G2frame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_UNDO)
495    G2frame.Bind(wx.EVT_MENU, OnLSQPeakFit, id=G2gd.wxID_LSQPEAKFIT)
496    G2frame.Bind(wx.EVT_MENU, OnOneCycle, id=G2gd.wxID_LSQONECYCLE)
497    G2frame.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
498    G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
499    G2frame.dataFrame.PeakFit.Enable(False)
500    if data:
501        G2frame.dataFrame.PeakFit.Enable(True)
502        G2frame.dataFrame.PFOneCycle.Enable(True)
503    G2frame.PickTable = []
504    rowLabels = []
505    PatternId = G2frame.PatternId
506    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))[0]
507    for i in range(len(data)): rowLabels.append(str(i+1))
508    if 'C' in Inst['Type'][0]:
509        colLabels = ['position','refine','intensity','refine','sigma','refine','gamma','refine']
510        Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
511            wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
512            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
513            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
514    else:
515        colLabels = ['position','refine','intensity','refine','alpha','refine',
516            'beta','refine','sigma','refine','gamma','refine']
517        Types = [wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
518            wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
519            wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,
520            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
521            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL,
522            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
523    T = []
524    for peak in data:
525        T.append(peak[0])
526    D = dict(zip(T,data))
527    T.sort()
528    X = []
529    for key in T: X.append(D[key])
530    data = X
531    G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
532    G2frame.PeakTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
533    G2frame.dataFrame.SetLabel('Peak List')
534    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
535    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
536    setBackgroundColors()                         
537    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
538    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
539    G2frame.dataDisplay.SetMargins(0,0)
540    G2frame.dataDisplay.AutoSizeColumns(False)
541    G2frame.dataFrame.setSizePosLeft([535,350])
542       
543################################################################################
544#####  Background
545################################################################################           
546       
547def UpdateBackground(G2frame,data):
548    '''respond to selection of PWDR background data tree item.
549    '''
550    if len(data) < 2:       #add Debye diffuse & peaks scattering here
551        data.append({'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]})
552    if 'nPeaks' not in data[1]:
553        data[1].update({'nPeaks':0,'peaksList':[]})
554    ValObj = {}
555   
556    def OnBackFlagCopy(event):
557        flag = data[0][1]
558        backDict = data[-1]
559        if backDict['nDebye']:
560            DBflags = []
561            for term in backDict['debyeTerms']:
562                DBflags.append(term[1::2])
563        if backDict['nPeaks']:
564            PKflags = []
565            for term in backDict['peaksList']:
566                PKflags.append(term[1::2])           
567        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
568        histList = GetHistsLikeSelected(G2frame)
569        if not histList:
570            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
571            return
572        dlg = G2gd.G2MultiChoiceDialog(
573            G2frame.dataFrame, 
574            'Copy bkg ref. flags from\n'+str(hst[5:])+' to...',
575            'Copy bkg flags', histList)
576        copyList = []
577        try:
578            if dlg.ShowModal() == wx.ID_OK:
579                for i in dlg.GetSelections(): 
580                    copyList.append(histList[i])
581        finally:
582            dlg.Destroy()
583        for item in copyList:
584            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
585            backData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'))
586            backData[0][1] = copy.copy(flag)
587            bkDict = backData[-1]
588            if bkDict['nDebye'] == backDict['nDebye']:
589                for i,term in enumerate(bkDict['debyeTerms']):
590                    term[1::2] = copy.copy(DBflags[i])
591            if bkDict['nPeaks'] == backDict['nPeaks']:
592                for i,term in enumerate(bkDict['peaksList']):
593                    term[1::2] = copy.copy(PKflags[i])                   
594           
595    def OnBackCopy(event):
596        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
597        histList = GetHistsLikeSelected(G2frame)
598        if not histList:
599            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
600            return
601        copyList = []
602        dlg = G2gd.G2MultiChoiceDialog(
603            G2frame.dataFrame, 
604            'Copy bkg params from\n'+str(hst[5:])+' to...',
605            'Copy parameters', histList)
606        try:
607            if dlg.ShowModal() == wx.ID_OK:
608                for i in dlg.GetSelections():
609                    copyList.append(histList[i])
610        finally:
611            dlg.Destroy()
612        for item in copyList:
613            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
614            G2frame.PatternTree.SetItemPyData(
615                G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),copy.copy(data))
616       
617    def BackSizer():
618       
619        def OnNewType(event):
620            data[0][0] = bakType.GetValue()
621           
622        def OnBakRef(event):
623            data[0][1] = bakRef.GetValue()
624           
625        def OnBakTerms(event):
626            data[0][2] = int(bakTerms.GetValue())
627            M = len(data[0])
628            N = data[0][2]+3
629            item = data[0]
630            if N > M:       #add terms
631                for i in range(M,N): 
632                    item.append(0.0)
633            elif N < M:     #delete terms
634                for i in range(N,M):
635                    del(item[-1])
636            G2frame.PatternTree.SetItemPyData(BackId,data)
637            wx.CallAfter(UpdateBackground,G2frame,data)
638           
639        def OnBakVal(event):
640            Obj = event.GetEventObject()
641            item = ValObj[Obj.GetId()][0]
642            try:
643                value = float(Obj.GetValue())
644            except ValueError:
645                value = data[0][item]
646            data[0][item] = value
647            Obj.SetValue('%10.4f'%(value))
648       
649        backSizer = wx.BoxSizer(wx.VERTICAL)
650        topSizer = wx.BoxSizer(wx.HORIZONTAL)
651        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,WACV)
652        bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
653                choices=Choices,style=wx.CB_READONLY|wx.CB_DROPDOWN)
654        bakType.Bind(wx.EVT_COMBOBOX, OnNewType)
655        topSizer.Add(bakType)
656        topSizer.Add((5,0),0)
657        bakRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
658        bakRef.SetValue(bool(data[0][1]))
659        bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
660        topSizer.Add(bakRef,0,WACV)
661        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
662        bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
663            style=wx.CB_READONLY|wx.CB_DROPDOWN)
664        bakTerms.Bind(wx.EVT_COMBOBOX,OnBakTerms)
665        topSizer.Add(bakTerms,0,WACV)
666        topSizer.Add((5,0),0)
667        backSizer.Add(topSizer)
668        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,WACV)
669        bakSizer = wx.FlexGridSizer(1,5,5,5)
670        for i,value in enumerate(data[0][3:]):
671            bakVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(value),style=wx.TE_PROCESS_ENTER)
672            bakSizer.Add(bakVal,0,WACV)
673            ValObj[bakVal.GetId()] = [i+3]
674            bakVal.Bind(wx.EVT_TEXT_ENTER,OnBakVal)
675            bakVal.Bind(wx.EVT_KILL_FOCUS,OnBakVal)
676        backSizer.Add(bakSizer)
677        return backSizer
678       
679    def DebyeSizer():
680       
681        def OnDebTerms(event):
682            data[1]['nDebye'] = int(debTerms.GetValue())
683            M = len(data[1]['debyeTerms'])
684            N = data[1]['nDebye']
685            if N > M:       #add terms
686                for i in range(M,N): 
687                    data[1]['debyeTerms'].append([1.0,False,1.0,False,0.010,False])
688            elif N < M:     #delete terms
689                for i in range(N,M):
690                    del(data[1]['debyeTerms'][-1])
691            wx.CallAfter(UpdateBackground,G2frame,data)
692           
693        def KeyEditPeakGrid(event):
694            colList = debyeGrid.GetSelectedCols()
695            if event.GetKeyCode() == wx.WXK_RETURN:
696                event.Skip(True)
697            elif event.GetKeyCode() == wx.WXK_CONTROL:
698                event.Skip(True)
699            elif event.GetKeyCode() == wx.WXK_SHIFT:
700                event.Skip(True)
701            elif colList:
702                debyeGrid.ClearSelection()
703                key = event.GetKeyCode()
704                for col in colList:
705                    if debyeTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
706                        if key == 89: #'Y'
707                            for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=True
708                        elif key == 78:  #'N'
709                            for row in range(debyeGrid.GetNumberRows()): data[1]['debyeTerms'][row][col]=False
710
711       
712        debSizer = wx.BoxSizer(wx.VERTICAL)
713        topSizer = wx.BoxSizer(wx.HORIZONTAL)
714        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,WACV)
715        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
716        debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
717            style=wx.CB_READONLY|wx.CB_DROPDOWN)
718        debTerms.Bind(wx.EVT_COMBOBOX,OnDebTerms)
719        topSizer.Add(debTerms,0,WACV)
720        topSizer.Add((5,0),0)
721        debSizer.Add(topSizer)
722        if data[1]['nDebye']:
723            debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,WACV)       
724            rowLabels = []
725            for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
726            colLabels = ['A','refine','R','refine','U','refine']
727            Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
728            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
729            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
730            debyeTable = G2gd.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
731            debyeGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
732            debyeGrid.SetTable(debyeTable, True)
733            debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
734            debyeGrid.AutoSizeColumns(False)
735            debSizer.Add(debyeGrid)       
736        return debSizer
737     
738    def PeaksSizer():
739
740        def OnPeaks(event):
741            data[1]['nPeaks'] = int(peaks.GetValue())
742            M = len(data[1]['peaksList'])
743            N = data[1]['nPeaks']
744            if N > M:       #add terms
745                for i in range(M,N): 
746                    data[1]['peaksList'].append([1.0,False,1.0,False,0.10,False,0.10,False])
747            elif N < M:     #delete terms
748                for i in range(N,M):
749                    del(data[1]['peaksList'][-1])
750            wx.CallAfter(UpdateBackground,G2frame,data)
751           
752        def KeyEditPeakGrid(event):
753            colList = peaksGrid.GetSelectedCols()
754            if event.GetKeyCode() == wx.WXK_RETURN:
755                event.Skip(True)
756            elif event.GetKeyCode() == wx.WXK_CONTROL:
757                event.Skip(True)
758            elif event.GetKeyCode() == wx.WXK_SHIFT:
759                event.Skip(True)
760            elif colList:
761                peaksGrid.ClearSelection()
762                key = event.GetKeyCode()
763                for col in colList:
764                    if peaksTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
765                        if key == 89: #'Y'
766                            for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=True
767                        elif key == 78:  #'N'
768                            for row in range(peaksGrid.GetNumberRows()): data[1]['peaksList'][row][col]=False
769
770        peaksSizer = wx.BoxSizer(wx.VERTICAL)
771        topSizer = wx.BoxSizer(wx.HORIZONTAL)
772        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,WACV)
773        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,WACV)
774        peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(12)],
775            style=wx.CB_READONLY|wx.CB_DROPDOWN)
776        peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
777        topSizer.Add(peaks,0,WACV)
778        topSizer.Add((5,0),0)
779        peaksSizer.Add(topSizer)
780        if data[1]['nPeaks']:
781            peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,WACV)       
782            rowLabels = []
783            for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
784            colLabels = ['pos','refine','int','refine','sig','refine','gam','refine']
785            Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL,
786            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
787            wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
788            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
789            peaksTable = G2gd.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
790            peaksGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
791            peaksGrid.SetTable(peaksTable, True)
792            peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
793            peaksGrid.AutoSizeColumns(False)
794            peaksSizer.Add(peaksGrid)       
795        return peaksSizer
796               
797    if G2frame.dataDisplay:
798#        G2frame.dataFrame.Clear()
799        G2frame.dataFrame.DestroyChildren()
800    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
801    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.BackMenu)
802    G2frame.dataFrame.SetLabel('Background')
803    if not G2frame.dataFrame.GetStatusBar():
804        Status = G2frame.dataFrame.CreateStatusBar()
805    G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
806    G2frame.Bind(wx.EVT_MENU,OnBackFlagCopy,id=G2gd.wxID_BACKFLAGCOPY)
807    BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background')
808    Choices = ['chebyschev','cosine','lin interpolate','inv interpolate','log interpolate']
809    mainSizer = wx.BoxSizer(wx.VERTICAL)
810    mainSizer.Add(BackSizer())
811    mainSizer.Add((0,5),0)
812    mainSizer.Add(DebyeSizer())
813    mainSizer.Add((0,5),0)
814    mainSizer.Add(PeaksSizer())
815    mainSizer.Layout()   
816    G2frame.dataDisplay.SetSizer(mainSizer)
817    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
818       
819################################################################################
820#####  Limits
821################################################################################           
822       
823def UpdateLimitsGrid(G2frame, data,plottype):
824    '''respond to selection of PWDR Limits data tree item.
825    '''
826    if G2frame.dataDisplay:
827        G2frame.dataFrame.Clear()
828    G2frame.ifGetExclude = False
829       
830    def KeyEditPeakGrid(event):
831        if event.GetKeyCode() == wx.WXK_DELETE:
832            row = G2frame.dataDisplay.GetSelectedRows()[0]
833            if row > 1: #can't delete limits!
834                del(data[row])
835                wx.CallAfter(UpdateLimitsGrid,G2frame,data,plottype)
836                G2plt.PlotPatterns(G2frame,plotType=plottype)
837                       
838    def RefreshLimitsGrid(event):
839        event.StopPropagation()
840        data = G2frame.LimitsTable.GetData()
841        old = data[0]
842        new = data[1]
843        new[0] = max(old[0],new[0])
844        new[1] = max(new[0],min(old[1],new[1]))
845        excl = []
846        if len(data) > 2:
847            excl = data[2:]
848            for item in excl:
849                item[0] = max(old[0],item[0])
850                item[1] = max(item[0],min(old[1],item[1]))
851        data = [old,new]+excl
852        G2frame.LimitsTable.SetData(data)
853        G2plt.PlotPatterns(G2frame,plotType=plottype)
854       
855    def OnLimitCopy(event):
856        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
857        histList = GetHistsLikeSelected(G2frame)
858        if not histList:
859            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
860            return
861        copyList = []
862        dlg = G2gd.G2MultiChoiceDialog(
863            G2frame.dataFrame, 
864            'Copy limits from\n'+str(hst[5:])+' to...',
865            'Copy limits', histList)
866        try:
867            if dlg.ShowModal() == wx.ID_OK:
868                for i in dlg.GetSelections(): 
869                    item = histList[i]
870                    Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
871                    G2frame.PatternTree.SetItemPyData(
872                        G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),copy.copy(data))
873        finally:
874            dlg.Destroy()
875           
876    def OnAddExcl(event):
877        G2frame.ifGetExclude = True
878        print 'Add excluded region'
879       
880    G2frame.LimitsTable = []
881    colLabels = ['Tmin','Tmax']
882    rowLabels = ['original','changed']
883    for i in range(len(data)-2):
884        rowLabels.append('exclude')
885    Types = 2*[wg.GRID_VALUE_FLOAT+':12,5',]
886    G2frame.LimitsTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
887    G2frame.dataFrame.SetLabel('Limits')
888    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LimitMenu)
889    if not G2frame.dataFrame.GetStatusBar():
890        Status = G2frame.dataFrame.CreateStatusBar()
891    G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
892    G2frame.Bind(wx.EVT_MENU,OnAddExcl,id=G2gd.wxID_ADDEXCLREGION)   
893    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
894    G2frame.dataDisplay.SetTable(G2frame.LimitsTable, True)   
895    G2frame.dataDisplay.SetCellStyle(0,0,VERY_LIGHT_GREY,True)
896    G2frame.dataDisplay.SetCellStyle(0,1,VERY_LIGHT_GREY,True)
897    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshLimitsGrid)               
898    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
899    G2frame.dataDisplay.SetMargins(0,0)
900    G2frame.dataDisplay.AutoSizeColumns(False)
901    G2frame.dataFrame.setSizePosLeft([230,260])
902                               
903   
904################################################################################
905#####  Instrument parameters
906################################################################################           
907       
908def UpdateInstrumentGrid(G2frame,data):
909    '''respond to selection of PWDR/SASD Instrument Parameters
910    data tree item.
911    '''
912    def keycheck(keys):
913        good = []
914        for key in keys:
915            if key in ['Type','U','V','W','X','Y','SH/L','I(L2)/I(L1)','alpha',
916                'beta-0','beta-1','beta-q','sig-0','sig-1','sig-q','Polariz.',
917                'Lam','Azimuth','2-theta','difC','difA','Zero','Lam1','Lam2']:
918                good.append(key)
919        return good
920       
921    keys = keycheck(data.keys())
922    if 'P' in data['Type'][0]:          #powder data
923        insVal = dict(zip(keys,[data[key][1] for key in keys]))
924        insDef = dict(zip(keys,[data[key][0] for key in keys]))
925        insRef = dict(zip(keys,[data[key][2] for key in keys]))
926        if 'NC' in data['Type'][0]:
927            del(insDef['Polariz.'])
928            del(insVal['Polariz.'])
929            del(insRef['Polariz.'])
930    elif 'S' in data['Type'][0]:                               #single crystal data
931        insVal = dict(zip(keys,[data[key][1] for key in keys]))
932        insDef = dict(zip(keys,[data[key][0] for key in keys]))
933        insRef = {}
934    elif 'L' in data['Type'][0]:                               #low angle data
935        insVal = dict(zip(keys,[data[key][1] for key in keys]))
936        insDef = dict(zip(keys,[data[key][0] for key in keys]))
937        insRef = {}
938    ValObj = {}
939    RefObj = {}
940    waves = {'CuKa':[1.54051,1.54433],'TiKa':[2.74841,2.75207],'CrKa':[2.28962,2.29351],
941        'FeKa':[1.93597,1.93991],'CoKa':[1.78892,1.79278],'MoKa':[0.70926,0.713543],
942        'AgKa':[0.559363,0.563775]}
943    Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
944            G2frame.PatternId,'Instrument Parameters'))[1]
945       
946    def inst2data(inst,ref,data):
947        for item in data:
948            try:
949                data[item] = [data[item][0],inst[item],ref[item]]
950            except KeyError:
951                pass        #skip 'Polariz.' for N-data
952        return data
953       
954    def updateData(inst,ref):
955        return inst2data(inst,ref,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
956            G2frame.PatternId,'Instrument Parameters'))[0])       
957   
958    def RefreshInstrumentGrid(event,doAnyway=False):
959        if doAnyway or event.GetRow() == 1:
960            peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
961            newpeaks = []
962            for peak in peaks:
963                newpeaks.append(G2mth.setPeakparms(data,Inst2,peak[0],peak[2]))
964            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),newpeaks)
965                   
966    def OnLoad(event):
967        '''Loads instrument parameters from a G2 .instprm file
968        in response to the Instrument Parameters-Operations/Load Profile menu
969       
970        Note that similar code is found in ReadPowderInstprm (GSASII.py)
971        '''
972        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
973            'instrument parameter files (*.instprm)|*.instprm',wx.OPEN|wx.CHANGE_DIR)
974        try:
975            if dlg.ShowModal() == wx.ID_OK:
976                filename = dlg.GetPath()
977                File = open(filename,'r')
978                S = File.readline()
979                newItems = []
980                newVals = []
981                while S:
982                    if S[0] == '#':
983                        S = File.readline()
984                        continue
985                    [item,val] = S[:-1].split(':')
986                    newItems.append(item)
987                    try:
988                        newVals.append(float(val))
989                    except ValueError:
990                        newVals.append(val)                       
991                    S = File.readline()               
992                File.close()
993                Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'))
994                inst = G2IO.makeInstDict(newItems,newVals,len(newVals)*[False,])
995                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),[inst,Inst2])
996                RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
997                UpdateInstrumentGrid(G2frame,data)
998                G2plt.PlotPeakWidths(G2frame)
999        finally:
1000            dlg.Destroy()
1001       
1002    def OnSave(event):
1003        '''Respond to the Instrument Parameters Operations/Save Profile menu
1004        item: writes current parameters to a .instprm file
1005        '''
1006        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II instrument parameters file', '.', '', 
1007            'instrument parameter files (*.instprm)|*.instprm',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
1008        try:
1009            if dlg.ShowModal() == wx.ID_OK:
1010                filename = dlg.GetPath()
1011                # make sure extension is .instprm
1012                filename = os.path.splitext(filename)[0]+'.instprm'
1013                File = open(filename,'w')
1014                File.write("#GSAS-II instrument parameter file; do not add/delete or change order of items!\n")
1015                for item in data:
1016                    File.write(item+':'+str(data[item][1])+'\n')
1017                File.close()
1018        finally:
1019            dlg.Destroy()
1020                                               
1021    def OnReset(event):
1022        insVal.update(insDef)
1023        data = updateData(insVal,insRef)
1024        RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
1025        UpdateInstrumentGrid(G2frame,data)
1026        G2plt.PlotPeakWidths(G2frame)
1027       
1028    def OnInstFlagCopy(event):
1029        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1030        histList = GetHistsLikeSelected(G2frame)
1031        if not histList:
1032            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
1033            return
1034        keys = data.keys()
1035        flags = dict(zip(keys,[data[key][2] for key in keys]))
1036        instType = data['Type'][0]
1037        copyList = []
1038        dlg = G2gd.G2MultiChoiceDialog(
1039            G2frame.dataFrame, 
1040            'Copy inst ref. flags from\n'+hst[5:],
1041            'Copy refinement flags', histList)
1042        try:
1043            if dlg.ShowModal() == wx.ID_OK:
1044                for i in dlg.GetSelections():
1045                    copyList.append(histList[i])
1046        finally:
1047            dlg.Destroy()
1048        for item in copyList:
1049            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1050            instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
1051            if len(data) == len(instData) and instType == instData['Type'][0]:   #don't mix data types or lam & lam1/lam2 parms!
1052                for item in instData:
1053                    instData[item][2] = copy.copy(flags[item])
1054            else:
1055                print item+' not copied - instrument parameters not commensurate'
1056       
1057    def OnInstCopy(event):
1058        #need fix for dictionary
1059        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1060        histList = GetHistsLikeSelected(G2frame)
1061        if not histList:
1062            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
1063            return
1064        copyList = []
1065        instType = data['Type'][0]
1066        dlg = G2gd.G2MultiChoiceDialog(
1067            G2frame.dataFrame, 
1068            'Copy inst params from\n'+hst,
1069            'Copy parameters', histList)
1070        try:
1071            if dlg.ShowModal() == wx.ID_OK:
1072                for i in dlg.GetSelections(): 
1073                    copyList.append(histList[i])
1074        finally:
1075            dlg.Destroy()
1076        for item in copyList:
1077            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1078            instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
1079            if len(data) == len(instData) and instType == instData['Type'][0]:  #don't mix data types or lam & lam1/lam2 parms!
1080                instData.update(data)
1081            else:
1082                print item+' not copied - instrument parameters not commensurate'
1083       
1084    def OnWaveChange(event):
1085        if 'Lam' in insVal:
1086            data['Lam1'] = [waves['CuKa'][0],waves['CuKa'][0],0]
1087            data['Lam2'] = [waves['CuKa'][1],waves['CuKa'][1],0]
1088            data['I(L2)/I(L1)'] = [0.5,0.5,0]
1089            del(data['Lam'])
1090        else:
1091            data['Lam'] = [data['Lam1'][0],data['Lam1'][0],0]
1092            del(data['Lam1'])
1093        wx.CallAfter(UpdateInstrumentGrid,data)
1094               
1095    def OnLamPick(event):
1096        lamType = lamPick.GetValue()
1097        insVal['Lam1'] = waves[lamType][0]
1098        insVal['Lam2'] = waves[lamType][1]
1099        data = updateData(insVal,insRef)
1100        UpdateInstrumentGrid(G2frame,data)
1101                 
1102    def OnRatValue(event):
1103        try:
1104            value = float(ratVal.GetValue())
1105            if value < 0:
1106                raise ValueError
1107        except ValueError:
1108            value = insVal['I(L2)/I(L1)']
1109        insVal['I(L2)/I(L1)'] = value
1110        ratVal.SetValue('%10.4f'%(value))
1111        data = updateData(insVal,insRef)
1112       
1113    def OnRatRef(event):
1114        insRef['I(L2)/I(L1)'] = ratRef.GetValue()
1115        data = updateData(insVal,insRef)
1116       
1117    def OnWaveValue(event):
1118        try:
1119            value = float(waveVal.GetValue())
1120            if value < 0:
1121                raise ValueError
1122        except ValueError:
1123            value = insVal['Lam']
1124        insVal['Lam'] = value
1125        waveVal.SetValue('%10.6f'%(value))
1126        data = updateData(insVal,insRef)
1127       
1128    def OnWaveRef(event):
1129        insRef['Lam'] = waveRef.GetValue()
1130        data = updateData(insVal,insRef)
1131       
1132    def OnItemValue(event):
1133        Obj = event.GetEventObject()
1134        item,fmt = ValObj[Obj.GetId()]
1135        try:
1136            value = float(Obj.GetValue())
1137        except ValueError:
1138            value = insVal[item]
1139        insVal[item] = value
1140        Obj.SetValue(fmt%(value))
1141        data = updateData(insVal,insRef)
1142        G2plt.PlotPeakWidths(G2frame)
1143       
1144    def OnItemRef(event):
1145        Obj = event.GetEventObject()
1146        item = RefObj[Obj.GetId()]
1147        insRef[item] = Obj.GetValue()
1148        data = updateData(insVal,insRef)
1149               
1150    if G2frame.dataDisplay:
1151        G2frame.dataFrame.Clear()
1152    try:
1153        histoName = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[-1]
1154        ifHisto = IsHistogramInAnyPhase(G2frame,histoName)
1155    except TypeError:       #PKS data never used in a phase as data
1156        ifhisto = False
1157    G2gd.SetDataMenuBar(G2frame)
1158    G2frame.dataFrame.SetLabel('Instrument Parameters')
1159    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
1160    topSizer = wx.FlexGridSizer(1,6,5,5)
1161    instSizer = wx.FlexGridSizer(2,6,5,5)
1162    topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Histogram Type: '+insVal['Type']),0,WACV)
1163#    topSizer.Add((5,5),0)
1164    if 'P' in insVal['Type']:                   #powder data
1165        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.InstMenu)
1166        if not G2frame.dataFrame.GetStatusBar():
1167            Status = G2frame.dataFrame.CreateStatusBar()
1168        G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
1169        G2frame.Bind(wx.EVT_MENU,OnSave,id=G2gd.wxID_INSTSAVE)
1170        G2frame.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
1171        G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
1172        G2frame.Bind(wx.EVT_MENU,OnInstFlagCopy,id=G2gd.wxID_INSTFLAGCOPY)
1173        G2frame.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)       
1174        if 'C' in insVal['Type']:               #constant wavelength
1175            #patch
1176            if 'Azimuth' not in insVal:
1177                insVal['Azimuth'] = 0.0
1178                insDef['Azimuth'] = 0.0
1179                insRef['Azimuth'] = False
1180            #end of patch
1181            topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
1182            if 'Lam1' in insVal:
1183                topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Ka1/Ka2:'),
1184                        0,WACV)
1185                topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u%8.6f/%8.6f\xc5'%(insVal['Lam1'],insVal['Lam2'])),
1186                        0,WACV)
1187                waveSizer = wx.BoxSizer(wx.HORIZONTAL)
1188                waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Select: '),0,WACV)
1189                choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
1190                lamPick = wx.ComboBox(G2frame.dataDisplay,value=' ',choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
1191                lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
1192                waveSizer.Add(lamPick,0)
1193                topSizer.Add(waveSizer,0)
1194                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' I(L2)/I(L1): (%10.4f)'%(insDef['I(L2)/I(L1)'])),
1195                        0,WACV)
1196                ratVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(insVal['I(L2)/I(L1)']),style=wx.TE_PROCESS_ENTER)
1197                ratVal.Bind(wx.EVT_TEXT_ENTER,OnRatValue)
1198                ratVal.Bind(wx.EVT_KILL_FOCUS,OnRatValue)
1199                instSizer.Add(ratVal,0)
1200                ratRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
1201                ratRef.SetValue(bool(insRef['I(L2)/I(L1)']))
1202                ratRef.Bind(wx.EVT_CHECKBOX, OnRatRef)
1203                instSizer.Add(ratRef,0,WACV)
1204               
1205            else:
1206                topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
1207                    0,WACV)
1208                waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
1209                waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
1210                waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
1211                topSizer.Add(waveVal,0,WACV)
1212                if ifHisto:
1213                    waveRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
1214                    waveRef.SetValue(bool(insRef['Lam']))
1215                    waveRef.Bind(wx.EVT_CHECKBOX, OnWaveRef)
1216                    topSizer.Add(waveRef,0,WACV)
1217            for item in ['Zero','Polariz.']:
1218                fmt = '%10.4f'
1219                Fmt = ' %s: ('+fmt+')'
1220                if item in insDef:
1221                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
1222                            0,WACV)
1223                    itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
1224                    ValObj[itemVal.GetId()] = [item,fmt]
1225                    itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
1226                    itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
1227                    instSizer.Add(itemVal,0,WACV)
1228                    if ifHisto:
1229                        itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
1230                        itemRef.SetValue(bool(insRef[item]))
1231                        RefObj[itemRef.GetId()] = item
1232                        itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
1233                        instSizer.Add(itemRef,0,WACV)
1234                    else:
1235                        instSizer.Add((5,5),0)
1236                else:                           #skip Polariz. for neutrons
1237                    instSizer.Add((5,5),0)
1238                    instSizer.Add((5,5),0)
1239                    instSizer.Add((5,5),0)
1240            for item in ['U','V','W','X','Y','SH/L']:
1241                fmt = '%10.3f'
1242                if item == 'SH/L':
1243                    fmt = '%10.5f'
1244                Fmt = ' %s: ('+fmt+')'
1245                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
1246                        0,WACV)
1247                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
1248                ValObj[itemVal.GetId()] = [item,fmt]
1249                itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
1250                itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
1251                instSizer.Add(itemVal,0,WACV)
1252                itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
1253                itemRef.SetValue(bool(insRef[item]))
1254                RefObj[itemRef.GetId()] = item
1255                itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
1256                instSizer.Add(itemRef,0,WACV)
1257        else:                                   #time of flight (neutrons)
1258            topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
1259            topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' 2-theta: %7.2f'%(insVal['2-theta'])),0,WACV)
1260            if 'Pdabc' in Inst2:
1261                Items = ['sig-0','sig-1','X','Y']
1262                topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' difC: %8.2f'%(insVal['difC'])),0,WACV)
1263                topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' alpha, beta: fixed by table'),0,WACV)
1264            else:
1265                Items = ['difC','difA','Zero','alpha','beta-0','beta-1','beta-q','sig-0','sig-1','sig-q','X','Y']
1266            for item in Items:
1267                fmt = '%10.3f'
1268                if 'beta' in item:
1269                    fmt = '%12.4g'
1270                Fmt = ' %s: ('+fmt+')'
1271                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
1272                        0,WACV)
1273                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
1274                ValObj[itemVal.GetId()] = [item,fmt]
1275                itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
1276                itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
1277                instSizer.Add(itemVal,0,WACV)
1278                if not ifHisto and item in ['difC','difA','Zero',]:
1279                    instSizer.Add((5,5),0)
1280                else:
1281                    itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
1282                    itemRef.SetValue(bool(insRef[item]))
1283                    RefObj[itemRef.GetId()] = item
1284                    itemRef.Bind(wx.EVT_CHECKBOX, OnItemRef)
1285                    instSizer.Add(itemRef,0,WACV)
1286       
1287    elif 'S' in insVal['Type']:                       #single crystal data
1288        if 'C' in insVal['Type']:               #constant wavelength
1289            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
1290                0,WACV)
1291            waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
1292            waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
1293            waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
1294            instSizer.Add(waveVal,0,WACV)
1295        else:                                   #time of flight (neutrons)
1296            pass                                #for now
1297    elif 'L' in insVal['Type']:
1298        if 'C' in insVal['Type']:       
1299            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
1300                0,WACV)
1301            waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
1302            waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
1303            waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
1304            instSizer.Add(waveVal,0,WACV)
1305            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
1306        else:                                   #time of flight (neutrons)
1307            pass                                #for now
1308       
1309    mainSizer = wx.BoxSizer(wx.VERTICAL)
1310    mainSizer.Add(topSizer,0)
1311    mainSizer.Add(instSizer,0)
1312    mainSizer.Layout()   
1313    G2frame.dataDisplay.SetSizer(mainSizer)
1314    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
1315   
1316################################################################################
1317#####  Sample parameters
1318################################################################################           
1319       
1320def UpdateSampleGrid(G2frame,data):
1321    '''respond to selection of PWDR/SASD Sample Parameters
1322    data tree item.
1323    '''
1324
1325    def OnSampleSave(event):
1326        '''Respond to the Sample Parameters Operations/Save menu
1327        item: writes current parameters to a .samprm file
1328        '''
1329        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', '.', '', 
1330            'sample parameter files (*.samprm)|*.samprm',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
1331        try:
1332            if dlg.ShowModal() == wx.ID_OK:
1333                filename = dlg.GetPath()
1334                # make sure extension is .samprm
1335                filename = os.path.splitext(filename)[0]+'.samprm'
1336                File = open(filename,'w')
1337                File.write("#GSAS-II sample parameter file\n")
1338                File.write("'Type':'"+str(data['Type'])+"'\n")
1339                File.write("'Gonio. radius':"+str(data['Gonio. radius'])+"\n")
1340                if data.get('InstrName'):
1341                    File.write("'InstrName':'"+str(data['InstrName'])+"'\n")
1342                File.close()
1343        finally:
1344            dlg.Destroy()
1345           
1346    def OnSampleLoad(event):
1347        '''Loads sample parameters from a G2 .samprm file
1348        in response to the Sample Parameters-Operations/Load menu
1349       
1350        Note that similar code is found in ReadPowderInstprm (GSASII.py)
1351        '''
1352        dlg = wx.FileDialog(G2frame, 'Choose GSAS-II sample parameters file', '.', '', 
1353            'sample parameter files (*.samprm)|*.samprm',wx.OPEN|wx.CHANGE_DIR)
1354        try:
1355            if dlg.ShowModal() == wx.ID_OK:
1356                filename = dlg.GetPath()
1357                File = open(filename,'r')
1358                S = File.readline()
1359                newItems = {}
1360                while S:
1361                    if S[0] == '#':
1362                        S = File.readline()
1363                        continue
1364                    [item,val] = S[:-1].split(':')
1365                    newItems[item.strip("'")] = eval(val)
1366                    S = File.readline()               
1367                File.close()
1368                data.update(newItems)
1369                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Sample Parameters'),data)
1370                UpdateSampleGrid(G2frame,data)
1371        finally:
1372            dlg.Destroy()
1373   
1374    def OnSetScale(event):
1375        histList = []
1376        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
1377        while item:
1378            name = G2frame.PatternTree.GetItemText(item)
1379            if 'SASD' in name and name != histName:
1380                histList.append(name)
1381            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
1382        if not len(histList):      #nothing to copy to!
1383            return
1384        dlg = wx.SingleChoiceDialog(G2frame,'Select reference histogram for scaling',
1385            'Reference histogram',histList)
1386        try:
1387            if dlg.ShowModal() == wx.ID_OK:
1388                sel = dlg.GetSelection()
1389                refHist = histList[sel]
1390        finally:
1391            dlg.Destroy()
1392        Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
1393        Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
1394        Data = [Profile,Limits,data]
1395        refId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,refHist)
1396        refSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Sample Parameters'))
1397        refLimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Limits'))
1398        refProfile = G2frame.PatternTree.GetItemPyData(refId)[1]
1399        refData = [refProfile,refLimits,refSample]
1400        G2sasd.SetScale(Data,refData)
1401        UpdateSampleGrid(G2frame,data)       
1402        G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=False)
1403       
1404    def OnSampleCopy(event):
1405        histType,copyNames = SetCopyNames(histName,data['Type'],
1406            addNames = ['Omega','Chi','Phi','Gonio. radius','InstrName'])
1407        copyDict = {}
1408        for parm in copyNames:
1409            copyDict[parm] = data[parm]
1410        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1411        histList = GetHistsLikeSelected(G2frame)
1412        if not histList:
1413            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
1414            return
1415        dlg = G2gd.G2MultiChoiceDialog(
1416            G2frame.dataFrame,
1417            'Copy sample params from\n'+str(hst[5:])+' to...',
1418            'Copy sample parameters', histList)
1419        try:
1420            if dlg.ShowModal() == wx.ID_OK:
1421                result = dlg.GetSelections()
1422                for i in result: 
1423                    item = histList[i]
1424                    Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1425                    sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
1426                    sampleData.update(copy.deepcopy(copyDict))
1427        finally:
1428            dlg.Destroy()
1429
1430    def OnSampleCopySelected(event):
1431        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1432        Controls = G2frame.PatternTree.GetItemPyData(
1433            G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
1434        histList = GetHistsLikeSelected(G2frame)
1435        if not histList:
1436            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
1437            return
1438        # Assemble a list of item labels
1439        TextTable = {key:label for key,label,dig in
1440                     SetupSampleLabels(hst,data.get('Type'))
1441                     }
1442        # get flexible labels
1443        TextTable.update({
1444            key:Controls[key] for key in Controls if key.startswith('FreePrm')
1445            })
1446        # add a few extra
1447        TextTable.update({
1448            'Type':'Diffractometer type',
1449            'InstrName':'Instrument Name',
1450            })
1451        # Assemble a list of dict entries that would be labeled in the Sample
1452        # params data window (drop ranId and items not used).
1453        keyList = [i for i in data.keys() if i in TextTable]
1454        keyText = [TextTable[i] for i in keyList]
1455        # sort both lists together, ordered by keyText
1456        keyText, keyList = zip(*sorted(zip(keyText,keyList))) # sort lists
1457        selectedKeys = []
1458        dlg = G2gd.G2MultiChoiceDialog(
1459            G2frame.dataFrame,
1460            'Select which sample parameters\nto copy',
1461            'Select sample parameters', keyText)
1462        try:
1463            if dlg.ShowModal() == wx.ID_OK:
1464                selectedKeys = [keyList[i] for i in dlg.GetSelections()]
1465        finally:
1466            dlg.Destroy()
1467        if not selectedKeys: return # nothing to copy
1468        copyDict = {}
1469        for parm in selectedKeys:
1470            copyDict[parm] = data[parm]
1471        dlg = G2gd.G2MultiChoiceDialog(
1472            G2frame.dataFrame,
1473            'Copy sample params from\n'+str(hst[5:])+' to...',
1474            'Copy sample parameters', histList)
1475        try:
1476            if dlg.ShowModal() == wx.ID_OK:
1477                result = dlg.GetSelections()
1478                for i in result: 
1479                    item = histList[i]
1480                    Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1481                    sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
1482                    sampleData.update(copy.deepcopy(copyDict))
1483        finally:
1484            dlg.Destroy()
1485
1486    def OnSampleFlagCopy(event):
1487        histType,copyNames = SetCopyNames(histName,data['Type'])
1488        flagDict = {}
1489        for parm in copyNames:
1490            flagDict[parm] = data[parm][1]
1491        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1492        histList = GetHistsLikeSelected(G2frame)
1493        if not histList:
1494            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
1495            return
1496        dlg = G2gd.G2MultiChoiceDialog(
1497            G2frame.dataFrame, 
1498            'Copy sample ref. flags from\n'+str(hst[5:])+' to...',
1499            'Copy sample flags', histList)
1500        try:
1501            if dlg.ShowModal() == wx.ID_OK:
1502                result = dlg.GetSelections()
1503                for i in result: 
1504                    item = histList[i]
1505                    Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
1506                    sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
1507                    for name in copyNames:
1508                        sampleData[name][1] = copy.copy(flagDict[name])
1509        finally:
1510            dlg.Destroy()
1511
1512    def OnHistoType(event):
1513        Obj = event.GetEventObject()
1514        data['Type'] = Obj.GetValue()
1515        if data['Type'] == 'Bragg-Brentano' and 'Shift' not in data:    #set up defaults for new type(s)
1516            data['Shift'] = [0.0,False]
1517            data['Transparency'] = [0.0,False]
1518        wx.CallAfter(UpdateSampleGrid,G2frame,data)
1519       
1520    def SetNameVal():
1521        inst = instNameVal.GetValue()
1522        data['InstrName'] = inst.strip()
1523
1524    def OnNameVal(event):
1525        event.Skip()
1526        wx.CallAfter(SetNameVal)
1527       
1528    def AfterChange(invalid,value,tc):
1529        if invalid:
1530            return
1531        if tc.key == 0 and 'SASD' in histName:          #a kluge for Scale!
1532            G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=True)
1533        elif tc.key == 'Thick':
1534            wx.CallAfter(UpdateSampleGrid,G2frame,data)           
1535           
1536    def OnMaterial(event):
1537        Obj = event.GetEventObject()
1538        id,key = Info[Obj.GetId()]
1539        if key == 'Name':
1540            data['Materials'][id][key] = Obj.GetValue()
1541        elif key == 'VolFrac':
1542            try:
1543                value = min(max(0.,float(Obj.GetValue())),1.)
1544            except ValueError:
1545                value = data['Materials'][id][key]
1546            data['Materials'][id][key] = value
1547            data['Materials'][not id][key] = 1.-value
1548        wx.CallAfter(UpdateSampleGrid,G2frame,data)
1549
1550    ######## DEBUG #######################################################
1551    #import GSASIIpwdGUI
1552    #reload(GSASIIpwdGUI)
1553    #reload(G2gd)
1554    ######################################################################
1555    histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
1556    if G2frame.dataDisplay:
1557        G2frame.dataFrame.Clear()
1558    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SampleMenu)
1559    G2frame.dataFrame.SetLabel('Sample Parameters')
1560    G2frame.Bind(wx.EVT_MENU, OnSetScale, id=G2gd.wxID_SETSCALE)
1561    G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
1562    G2frame.Bind(wx.EVT_MENU, OnSampleCopySelected, id=G2gd.wxID_SAMPLECOPYSOME)
1563    G2frame.Bind(wx.EVT_MENU, OnSampleFlagCopy, id=G2gd.wxID_SAMPLEFLAGCOPY)
1564    G2frame.Bind(wx.EVT_MENU, OnSampleSave, id=G2gd.wxID_SAMPLESAVE)
1565    G2frame.Bind(wx.EVT_MENU, OnSampleLoad, id=G2gd.wxID_SAMPLELOAD)
1566    if 'SASD' in histName:
1567        G2frame.dataFrame.SetScale.Enable(True)
1568    if not G2frame.dataFrame.GetStatusBar():
1569        Status = G2frame.dataFrame.CreateStatusBar()   
1570    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
1571    Controls = G2frame.PatternTree.GetItemPyData(
1572        G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
1573#patch
1574    if 'ranId' not in data:
1575        data['ranId'] = ran.randint(0,sys.maxint)
1576    if not 'Gonio. radius' in data:
1577        data['Gonio. radius'] = 200.0
1578    if not 'Omega' in data:
1579        data.update({'Omega':0.0,'Chi':0.0,'Phi':0.0})
1580    if type(data['Temperature']) is int:
1581        data['Temperature'] = float(data['Temperature'])
1582    if 'FreePrm1' not in Controls:
1583        Controls['FreePrm1'] = 'Sample humidity (%)'
1584    if 'FreePrm2' not in Controls:
1585        Controls['FreePrm2'] = 'Sample voltage (V)'
1586    if 'FreePrm3' not in Controls:
1587        Controls['FreePrm3'] = 'Applied load (MN)'
1588    if 'FreePrm1' not in data:
1589        data['FreePrm1'] = 0.
1590    if 'FreePrm2' not in data:
1591        data['FreePrm2'] = 0.
1592    if 'FreePrm3' not in data:
1593        data['FreePrm3'] = 0.
1594    if 'SurfRoughA' not in data and 'PWDR' in histName:
1595        data['SurfRoughA'] = [0.,False]
1596        data['SurfRoughB'] = [0.,False]
1597    if 'Trans' not in data and 'SASD' in histName:
1598        data['Trans'] = 1.0
1599#patch end
1600   
1601    parms = SetupSampleLabels(histName,data.get('Type'))
1602    mainSizer = wx.BoxSizer(wx.VERTICAL)
1603    topSizer = wx.BoxSizer(wx.HORIZONTAL)
1604    topSizer.Add((-1,-1),1,wx.EXPAND,1)
1605    topSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Sample and Experimental Parameters'))
1606    topSizer.Add((-1,-1),1,wx.EXPAND,1)
1607    mainSizer.Add(topSizer,0,wx.EXPAND,1)
1608    nameSizer = wx.BoxSizer(wx.HORIZONTAL)
1609    nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Instrument Name'),
1610                0,WACV)
1611    nameSizer.Add((-1,-1),1,wx.EXPAND,1)
1612    instNameVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,data.get('InstrName',''),
1613                              size=(200,-1),style=wx.TE_PROCESS_ENTER)       
1614    nameSizer.Add(instNameVal)
1615    instNameVal.Bind(wx.EVT_CHAR,OnNameVal)
1616    mainSizer.Add(nameSizer,0,wx.EXPAND,1)
1617    mainSizer.Add((5,5),0)
1618
1619    if 'PWDR' in histName:
1620        nameSizer = wx.BoxSizer(wx.HORIZONTAL)
1621        nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Diffractometer type: '),
1622                    0,WACV)
1623        choices = ['Debye-Scherrer','Bragg-Brentano',]
1624        histoType = wx.ComboBox(G2frame.dataDisplay,wx.ID_ANY,value=data['Type'],choices=choices,
1625            style=wx.CB_READONLY|wx.CB_DROPDOWN)
1626        histoType.Bind(wx.EVT_COMBOBOX, OnHistoType)
1627        nameSizer.Add(histoType)
1628        mainSizer.Add(nameSizer,0,wx.EXPAND,1)
1629        mainSizer.Add((5,5),0)
1630
1631    parmSizer = wx.FlexGridSizer(10,2,5,0)
1632    for key,lbl,nDig in parms:
1633        if 'list' in str(type(data[key])):
1634            parmRef = G2gd.G2CheckBox(G2frame.dataDisplay,' '+lbl,data[key],1)
1635            parmSizer.Add(parmRef,0,WACV|wx.EXPAND)
1636            parmVal = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,data[key],0,
1637                nDig=nDig,typeHint=float,OnLeave=AfterChange)
1638        else:
1639            parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' '+lbl),
1640                0,WACV|wx.EXPAND)
1641            parmVal = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,
1642                typeHint=float,OnLeave=AfterChange)
1643        parmSizer.Add(parmVal,1,wx.EXPAND)
1644    Info = {}
1645
1646       
1647    for key in ('FreePrm1','FreePrm2','FreePrm3'):
1648        parmVal = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,Controls,key,typeHint=str,
1649                                        notBlank=False)
1650        parmSizer.Add(parmVal,1,wx.EXPAND)
1651        parmVal = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,typeHint=float)
1652        parmSizer.Add(parmVal,1,wx.EXPAND)
1653    mainSizer.Add(parmSizer,1,wx.EXPAND)
1654    mainSizer.Add((0,5),0)   
1655    if 'SASD' in histName:
1656        rho = [0.,0.]
1657        anomrho = [0.,0.]
1658        mu = 0.
1659        subSizer = wx.FlexGridSizer(1,4,5,5)
1660        Substances = G2frame.PatternTree.GetItemPyData(
1661            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
1662        for id,item in enumerate(data['Materials']):
1663            subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
1664            matsel = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=Substances['Substances'].keys(),
1665                style=wx.CB_READONLY|wx.CB_DROPDOWN)
1666            Info[matsel.GetId()] = [id,'Name']
1667            matsel.Bind(wx.EVT_COMBOBOX,OnMaterial)       
1668            subSizer.Add(matsel,0,WACV)
1669            subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
1670            volfrac = wx.TextCtrl(G2frame.dataDisplay,value=str('%.3f'%(item['VolFrac'])),style=wx.TE_PROCESS_ENTER)
1671            Info[volfrac.GetId()] = [id,'VolFrac']
1672            volfrac.Bind(wx.EVT_TEXT_ENTER,OnMaterial)
1673            volfrac.Bind(wx.EVT_KILL_FOCUS,OnMaterial)
1674            subSizer.Add(volfrac,0,WACV)
1675            material = Substances['Substances'][item['Name']]
1676            mu += item['VolFrac']*material.get('XAbsorption',0.)
1677            rho[id] = material['Scatt density']
1678            anomrho[id] = material.get('XAnom density',0.)
1679        data['Contrast'] = [(rho[1]-rho[0])**2,(anomrho[1]-anomrho[0])**2]
1680        mainSizer.Add(subSizer,0)
1681        conSizer = wx.BoxSizer(wx.HORIZONTAL)
1682        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
1683        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
1684        mut =  mu*data['Thick']
1685        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Transmission (calc): %10.3f  '%(np.exp(-mut))),0,WACV)
1686        mainSizer.Add(conSizer,0)
1687   
1688    mainSizer.Layout()   
1689    G2frame.dataDisplay.SetSizer(mainSizer)
1690    Size = mainSizer.Fit(G2frame.dataFrame)
1691    G2frame.dataDisplay.SetSize(Size)
1692    G2frame.dataFrame.setSizePosLeft(Size)
1693               
1694################################################################################
1695#####  Indexing Peaks
1696################################################################################           
1697       
1698def UpdateIndexPeaksGrid(G2frame, data):
1699    '''respond to selection of PWDR Index Peak List data
1700    tree item.
1701    '''
1702    IndexId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
1703    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
1704    wave = G2mth.getWave(Inst)
1705   
1706    def RefreshIndexPeaksGrid(event):
1707        r,c =  event.GetRow(),event.GetCol()
1708        data = G2frame.IndexPeaksTable.GetData()
1709        if c == 2:
1710            if data[r][c]:
1711                data[r][c] = False
1712            else:
1713                data[r][c] = True
1714            G2frame.IndexPeaksTable.SetData(data)
1715            G2frame.PatternTree.SetItemPyData(IndexId,data)
1716            G2frame.dataDisplay.ForceRefresh()
1717           
1718    def OnReload(event):
1719        data = []
1720        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
1721        for peak in peaks:
1722            dsp = wave/(2.0*sind((peak[0]-Inst['Zero'][1])/2.0))
1723            data.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
1724        G2frame.PatternTree.SetItemPyData(IndexId,data)
1725        UpdateIndexPeaksGrid(G2frame,data)
1726       
1727    def KeyEditPickGrid(event):
1728        colList = G2frame.dataDisplay.GetSelectedCols()
1729        rowList = G2frame.dataDisplay.GetSelectedRows()
1730        data = G2frame.PatternTree.GetItemPyData(IndexId)
1731        if event.GetKeyCode() == wx.WXK_RETURN:
1732            event.Skip(True)
1733        elif event.GetKeyCode() == wx.WXK_CONTROL:
1734            event.Skip(True)
1735        elif event.GetKeyCode() == wx.WXK_SHIFT:
1736            event.Skip(True)
1737        elif colList:
1738            G2frame.dataDisplay.ClearSelection()
1739            key = event.GetKeyCode()
1740            for col in colList:
1741                if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
1742                    if key == 89: #'Y'
1743                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=True
1744                    elif key == 78:  #'N'
1745                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=False
1746           
1747    if G2frame.dataDisplay:
1748        G2frame.dataFrame.Clear()
1749    if not G2frame.dataFrame.GetStatusBar():
1750        Status = G2frame.dataFrame.CreateStatusBar()
1751    if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1752        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndPeaksMenu)
1753        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
1754    G2frame.dataFrame.IndexPeaks.Enable(False)
1755    G2frame.IndexPeaksTable = []
1756    if data:
1757        G2frame.dataFrame.IndexPeaks.Enable(True)
1758        cells = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
1759        if cells:
1760            cellist = cells[2]
1761            dmin = cells[3]
1762            G2frame.HKL = []
1763            for i,cell in enumerate(cellist):
1764                if cell[-1]:
1765                    ibrav = cell[2]
1766                    A = G2lat.cell2A(cell[3:9])
1767                    G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
1768                    G2indx.IndexPeaks(data,G2frame.HKL)
1769                    for hkl in G2frame.HKL:
1770                        hkl.append(2.0*asind(wave/(2.*hkl[3]))+Inst['Zero'][1])             
1771    rowLabels = []
1772    for i in range(len(data)): rowLabels.append(str(i+1))
1773    colLabels = ['position','intensity','use','indexed','h','k','l','d-obs','d-calc']
1774    Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
1775        wg.GRID_VALUE_BOOL,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,
1776        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5']
1777    G2frame.PatternTree.SetItemPyData(IndexId,data)
1778    G2frame.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
1779    G2frame.dataFrame.SetLabel('Index Peak List')
1780    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)               
1781    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
1782    for r in range(G2frame.dataDisplay.GetNumberRows()):
1783        for c in range(G2frame.dataDisplay.GetNumberCols()):
1784            if c == 2:
1785                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
1786            else:
1787                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
1788    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
1789    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
1790    G2frame.dataDisplay.SetMargins(0,0)
1791    G2frame.dataDisplay.AutoSizeColumns(False)
1792    G2frame.dataFrame.setSizePosLeft([490,300])
1793 
1794################################################################################
1795#####  Unit cells
1796################################################################################           
1797       
1798def UpdateUnitCellsGrid(G2frame, data):
1799    '''respond to selection of PWDR Unit Cells data tree item.
1800    '''
1801    UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
1802    SPGlist = G2spc.spglist
1803    bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
1804        'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
1805    spaceGroups = ['F m 3 m','I m 3 m','P m 3 m','R 3 m','P 6/m m m','I 4/m m m',
1806        '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']
1807    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
1808    wave = G2mth.getWave(Inst)
1809   
1810    def SetLattice(controls):
1811        ibrav = bravaisSymb.index(controls[5])
1812        if ibrav in [0,1,2]:
1813            controls[7] = controls[8] = controls[6]
1814            controls[9] = controls[10] = controls[11] = 90.
1815        elif ibrav in [3,4,5,6]:
1816            controls[7] = controls[6]
1817            controls[9] = controls[10] = controls[11] = 90.
1818            if ibrav in [3,4]:
1819                controls[11] = 120.
1820        elif ibrav in [7,8,9,10]:
1821            controls[9] = controls[10] = controls[11] = 90.
1822        elif ibrav in [11,12]:
1823            controls[9] = controls[11] = 90.  # b unique
1824        if len(controls) < 13: controls.append(0)
1825        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1826        return ibrav
1827       
1828    def OnNcNo(event):
1829        controls[2] = NcNo.GetValue()
1830       
1831    def OnStartVol(event):
1832        try:
1833            stVol = int(float(startVol.GetValue()))
1834            if stVol < 25:
1835                raise ValueError
1836        except ValueError:
1837            stVol = 25
1838        controls[3] = stVol
1839        startVol.SetValue("%d"%(stVol))
1840       
1841    def OnBravais(event):
1842        Obj = event.GetEventObject()
1843        bravais[bravList.index(Obj.GetId())] = Obj.GetValue()
1844       
1845    def OnZero(event):
1846        try:
1847            Zero = min(5.0,max(-5.0,float(zero.GetValue())))
1848        except ValueError:
1849            Zero = 0.0
1850        controls[1] = Zero
1851        zero.SetValue("%.4f"%(Zero))
1852       
1853    def OnZeroVar(event):
1854        controls[0] = zeroVar.GetValue()
1855       
1856    def OnBravSel(event):
1857        brav = bravSel.GetString(bravSel.GetSelection())
1858        controls[5] = brav
1859        controls[13] = SPGlist[brav][0]       
1860        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1861       
1862    def OnSpcSel(event):
1863        controls[13] = spcSel.GetString(spcSel.GetSelection())       
1864       
1865    def OnCellChange(event):
1866        ibrav = bravaisSymb.index(controls[5])
1867        Obj = event.GetEventObject()
1868        ObjId = cellList.index(Obj.GetId())
1869        try:
1870            value = max(1.0,float(Obj.GetValue()))
1871        except ValueError:
1872            if ObjId < 3:               #bad cell edge - reset
1873                value = controls[6+ObjId]
1874            else:                       #bad angle
1875                value = 90.
1876        if ibrav in [0,1,2]:
1877            controls[6] = controls[7] = controls[8] = value
1878            controls[9] = controls[10] = controls[11] = 90.0
1879            Obj.SetValue("%.5f"%(controls[6]))
1880        elif ibrav in [3,4,5,6]:
1881            if ObjId == 0:
1882                controls[6] = controls[7] = value
1883                Obj.SetValue("%.5f"%(controls[6]))
1884            else:
1885                controls[8] = value
1886                Obj.SetValue("%.5f"%(controls[8]))
1887            controls[9] = controls[10] = controls[11] = 90.0
1888            if ibrav in [3,4]:
1889                controls[11] = 120.
1890        elif ibrav in [7,8,9,10]:
1891            controls[6+ObjId] = value
1892            Obj.SetValue("%.5f"%(controls[6+ObjId]))
1893            controls[9] = controls[10] = controls[11] = 90.0
1894        elif ibrav in [11,12]:
1895            controls[9] = controls[11] = 90.0
1896            if ObjId != 3:
1897                controls[6+ObjId] = value
1898                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1899            else:
1900                controls[10] = value
1901                Obj.SetValue("%.3f"%(controls[10]))
1902        else:
1903            controls[6+ObjId] = value
1904            if ObjId < 3:
1905                Obj.SetValue("%.5f"%(controls[6+ObjId]))
1906            else:
1907                Obj.SetValue("%.3f"%(controls[6+ObjId]))
1908        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1909        volVal.SetValue("%.3f"%(controls[12]))
1910       
1911    def OnHklShow(event):
1912        PatternId = G2frame.PatternId
1913        PickId = G2frame.PickId   
1914        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
1915        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1916        cell = controls[6:12]
1917        A = G2lat.cell2A(cell)
1918        ibrav = bravaisSymb.index(controls[5])
1919        spc = controls[13]
1920        SGData = G2spc.SpcGroup(spc)[1]
1921        dmin = wave/(2.0*sind(limits[1]/2.0))
1922        G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A)
1923        for hkl in G2frame.HKL:
1924            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
1925        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
1926            G2plt.PlotPowderLines(G2frame)
1927        else:
1928            G2plt.PlotPatterns(G2frame)
1929           
1930    def OnSortCells(event):
1931        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1932        c =  event.GetCol()
1933        if colLabels[c] == 'M20':
1934            cells = G2indx.sortM20(cells)
1935        elif colLabels[c] == 'Volume':
1936            cells = G2indx.sortVolume(cells)
1937        else:
1938            return
1939        data = [controls,bravais,cells,dmin]
1940        G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
1941        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
1942       
1943    def CopyUnitCell(event):
1944        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
1945        for Cell in cells:
1946            if Cell[-2]:
1947                break
1948        cell = Cell[2:9]
1949        controls[4] = 1
1950        controls[5] = bravaisSymb[cell[0]]
1951        controls[6:12] = cell[1:8]
1952        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
1953        controls[13] = spaceGroups[bravaisSymb.index(controls[5])]
1954        G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin])
1955        G2frame.dataFrame.RefineCell.Enable(True)
1956        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)       
1957               
1958    def RefineCell(event):
1959        def cellPrint(ibrav,A):
1960            cell = G2lat.A2cell(A)
1961            Vol = G2lat.calc_V(A)
1962            if ibrav in [0,1,2]:
1963                print "%s%10.6f" % ('a =',cell[0])
1964            elif ibrav in [3,4,5,6]:
1965                print "%s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],' c =',cell[2],' volume =',Vol)
1966            elif ibrav in [7,8,9,10]:
1967                print "%s%10.6f %s%10.6f %s%10.6f %s%12.3f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2],' volume =',Vol)
1968            elif ibrav in [11,12]:
1969                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)
1970            else:
1971                print "%s%10.6f %s%10.6f %s%10.6f" % ('a =',cell[0],'b =',cell[1],'c =',cell[2])
1972                print "%s%8.3f %s%8.3f %s%8.3f %s%12.3f" % ('alpha =',cell[3],'beta =',cell[4],'gamma =',cell[5],' volume =',Vol)
1973             
1974        PatternId = G2frame.PatternId
1975        PickId = G2frame.PickId   
1976        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
1977        if not peaks:
1978            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
1979            return       
1980        print 'Refine cell'
1981        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
1982        cell = controls[6:12]
1983        A = G2lat.cell2A(cell)
1984        ibrav = bravaisSymb.index(controls[5])
1985        SGData = G2spc.SpcGroup(controls[13])[1]
1986        dmin = G2indx.getDmin(peaks)-0.005
1987        G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A)
1988        G2indx.IndexPeaks(peaks,G2frame.HKL)
1989        Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks,wave,ibrav,A,controls[1],controls[0])           
1990        controls[1] = Zero
1991        controls[6:12] = G2lat.A2cell(Aref)
1992        controls[12] = G2lat.calc_V(Aref)
1993        data = [controls,bravais,cells,dmin]
1994        cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
1995        for cell in cells:
1996            cell[-2] = False
1997        cells.insert(0,[M20,X20,ibrav]+controls[6:13]+[True,False])
1998        data[2] = cells
1999        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
2000        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
2001        print "%s%10.3f" % ('refinement M20 = ',M20)
2002        print 'unindexed lines = ',X20
2003        cellPrint(ibrav,Aref)
2004        for hkl in G2frame.HKL:
2005            hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
2006        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
2007            G2plt.PlotPowderLines(G2frame)
2008        else:
2009            G2plt.PlotPatterns(G2frame)
2010        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
2011       
2012    def IndexPeaks(event):
2013        PatternId = G2frame.PatternId   
2014        print 'Peak Indexing'
2015        keepcells = []
2016        try:
2017            controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
2018            for cell in cells:
2019                if cell[11]:
2020                    keepcells.append(cell)
2021        except IndexError:
2022            pass
2023        except ValueError:
2024            G2frame.ErrorDialog('Error','Need to set controls in Unit Cell List first')
2025            return
2026        if True not in bravais:
2027            G2frame.ErrorDialog('Error','No Bravais lattices selected')
2028            return
2029        G2frame.dataFrame.CopyCell.Enable(False)
2030        G2frame.dataFrame.RefineCell.Enable(False)
2031        OK,dmin,newcells = G2indx.DoIndexPeaks(peaks,wave,controls,bravais)
2032        cells = keepcells+newcells
2033        cells = G2indx.sortM20(cells)
2034        cells[0][10] = True
2035        if OK:
2036            data = [controls,bravais,cells,dmin]
2037            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
2038            bestCell = cells[0]
2039            if bestCell[0] > 10.:
2040                G2frame.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
2041                for hkl in G2frame.HKL:
2042                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
2043                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
2044                    G2plt.PlotPowderLines(G2frame)
2045                else:
2046                    G2plt.PlotPatterns(G2frame)
2047            G2frame.dataFrame.CopyCell.Enable(True)
2048            G2frame.dataFrame.IndexPeaks.Enable(True)
2049            G2frame.dataFrame.MakeNewPhase.Enable(True)
2050        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
2051               
2052    def RefreshUnitCellsGrid(event):
2053        data =G2frame.PatternTree.GetItemPyData(UnitCellsId)
2054        cells,dmin = data[2:]
2055        r,c =  event.GetRow(),event.GetCol()
2056        if cells:
2057            if c == 2:
2058                for i in range(len(cells)):
2059                    cells[i][-2] = False
2060                    UnitCellsTable.SetValue(i,c,False)
2061                UnitCellsTable.SetValue(r,c,True)
2062                gridDisplay.ForceRefresh()
2063                cells[r][-2] = True
2064                ibrav = cells[r][2]
2065                A = G2lat.cell2A(cells[r][3:9])
2066                G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
2067                for hkl in G2frame.HKL:
2068                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
2069                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
2070                    G2plt.PlotPowderLines(G2frame)
2071                else:
2072                    G2plt.PlotPatterns(G2frame)
2073            elif c == 11:
2074                if UnitCellsTable.GetValue(r,c):
2075                    UnitCellsTable.SetValue(r,c,False)
2076                    cells[r][c] = False
2077                else:
2078                    cells[r][c] = True
2079                    UnitCellsTable.SetValue(r,c,True)
2080                gridDisplay.ForceRefresh()
2081            G2frame.PatternTree.SetItemPyData(UnitCellsId,data)               
2082       
2083    def MakeNewPhase(event):
2084        if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
2085            sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
2086        else:
2087            sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
2088        PhaseName = ''
2089        dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
2090            style=wx.OK)
2091        try:
2092            if dlg.ShowModal() == wx.ID_OK:
2093                PhaseName = dlg.GetValue()
2094                cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
2095                for Cell in cells:
2096                    if Cell[-2]:
2097                        break
2098                cell = Cell[2:10]       
2099                sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
2100                E,SGData = G2spc.SpcGroup(controls[13])
2101                G2frame.PatternTree.SetItemPyData(sub, \
2102                    G2IO.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:]))
2103                Status.SetStatusText('Change space group from '+str(controls[13])+' if needed')
2104        finally:
2105            dlg.Destroy()
2106           
2107    if G2frame.dataDisplay:
2108        G2frame.dataFrame.Clear()
2109    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndexMenu)
2110    if not G2frame.dataFrame.GetStatusBar():
2111        Status = G2frame.dataFrame.CreateStatusBar()
2112    G2frame.Bind(wx.EVT_MENU, IndexPeaks, id=G2gd.wxID_INDEXPEAKS)
2113    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
2114    G2frame.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
2115    G2frame.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
2116   
2117    controls,bravais,cells,dmin = data
2118    if len(controls) < 13:              #add cell volume if missing
2119        controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
2120    if len(controls) < 14:              #add space gropu used in indexing
2121        controls.append(spaceGroups[bravaisSymb.index(controls[5])])
2122    G2frame.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
2123    bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
2124        'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
2125        'Orthorhombic-P','Monoclinic-C','Monoclinic-P','Triclinic']
2126    cellGUIlist = [[[0,1,2],4,zip([" Unit cell: a = "," Vol = "],["%.5f","%.3f"],[True,False],[0,0])],
2127    [[3,4,5,6],6,zip([" Unit cell: a = "," c = "," Vol = "],["%.5f","%.5f","%.3f"],[True,True,False],[0,2,0])],
2128    [[7,8,9,10],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "],["%.5f","%.5f","%.5f","%.3f"],
2129        [True,True,True,False],[0,1,2,0])],
2130    [[11,12],10,zip([" Unit cell: a = "," b = "," c = "," beta = "," Vol = "],
2131        ["%.5f","%.5f","%.5f","%.3f","%.3f"],[True,True,True,True,False],[0,1,2,4,0])],
2132    [[13,],8,zip([" Unit cell: a = "," b = "," c = "," Vol = "," alpha = "," beta = "," gamma = "],
2133        ["%.5f","%.5f","%.5f","%.3f","%.3f","%.3f","%.3f"],
2134        [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
2135   
2136    G2frame.dataFrame.SetLabel('Unit Cells List')
2137    G2frame.sp = wx.SplitterWindow(G2frame.dataFrame)
2138    G2frame.dataDisplay = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
2139    G2frame.dataFrame.IndexPeaks.Enable(False)
2140    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
2141    if peaks:
2142        G2frame.dataFrame.IndexPeaks.Enable(True)
2143    G2frame.dataFrame.RefineCell.Enable(False)
2144    if controls[12] > 1.0:                               #if a "real" volume (i.e. not default)
2145        G2frame.dataFrame.RefineCell.Enable(True)   
2146    G2frame.dataFrame.CopyCell.Enable(False)
2147    G2frame.dataFrame.MakeNewPhase.Enable(False)       
2148    if cells:
2149        G2frame.bottom = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
2150        G2frame.sp.SplitHorizontally(G2frame.dataDisplay,G2frame.bottom,0)
2151        G2frame.dataFrame.CopyCell.Enable(True)
2152        G2frame.dataFrame.MakeNewPhase.Enable(True)       
2153    mainSizer = wx.BoxSizer(wx.VERTICAL)
2154    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,WACV)
2155    mainSizer.Add((5,5),0)
2156    littleSizer = wx.FlexGridSizer(2,5,5,5)
2157    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,WACV)
2158    NcNo = wx.SpinCtrl(G2frame.dataDisplay)
2159    NcNo.SetRange(1,6)
2160    NcNo.SetValue(controls[2])
2161    NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
2162    littleSizer.Add(NcNo,0,WACV)
2163    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start Volume '),0,WACV)
2164    startVol = wx.TextCtrl(G2frame.dataDisplay,value=str('%d'%(controls[3])),style=wx.TE_PROCESS_ENTER)
2165    startVol.Bind(wx.EVT_TEXT_ENTER,OnStartVol)
2166    startVol.Bind(wx.EVT_KILL_FOCUS,OnStartVol)
2167    littleSizer.Add(startVol,0,WACV)
2168    mainSizer.Add(littleSizer,0)
2169    mainSizer.Add((5,5),0)
2170    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
2171        0,WACV)
2172    mainSizer.Add((5,5),0)
2173    littleSizer = wx.FlexGridSizer(2,7,5,5)
2174    bravList = []
2175    bravs = zip(bravais,bravaisNames)
2176    for brav,bravName in bravs:
2177        bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
2178        bravList.append(bravCk.GetId())
2179        bravCk.SetValue(brav)
2180        bravCk.Bind(wx.EVT_CHECKBOX,OnBravais)
2181        littleSizer.Add(bravCk,0,WACV)
2182    mainSizer.Add(littleSizer,0)
2183    mainSizer.Add((5,5),0)
2184   
2185    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Refinement: '),0,WACV)
2186    mainSizer.Add((5,5),0)
2187    littleSizer = wx.BoxSizer(wx.HORIZONTAL)
2188    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,WACV)
2189    bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
2190    bravSel.SetSelection(bravaisSymb.index(controls[5]))
2191    bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
2192    littleSizer.Add(bravSel,0,WACV)
2193    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Space group "),0,WACV)
2194    spcSel = wx.Choice(G2frame.dataDisplay,choices=SPGlist[controls[5]])
2195    spcSel.SetSelection(SPGlist[controls[5]].index(controls[13]))
2196    spcSel.Bind(wx.EVT_CHOICE,OnSpcSel)
2197    littleSizer.Add(spcSel,0,WACV)
2198    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,WACV)
2199    zero = wx.TextCtrl(G2frame.dataDisplay,value="%.4f"%(controls[1]),style=wx.TE_PROCESS_ENTER)
2200    zero.Bind(wx.EVT_TEXT_ENTER,OnZero)
2201    zero.Bind(wx.EVT_KILL_FOCUS,OnZero)
2202    littleSizer.Add(zero,0,WACV)
2203    zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
2204    zeroVar.SetValue(controls[0])
2205    zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
2206    littleSizer.Add(zeroVar,0,WACV)
2207    hklShow = wx.Button(G2frame.dataDisplay,label="Show hkl positions")
2208    hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
2209    littleSizer.Add(hklShow,0,WACV)
2210    mainSizer.Add(littleSizer,0)
2211   
2212    mainSizer.Add((5,5),0)
2213    ibrav = SetLattice(controls)
2214    for cellGUI in cellGUIlist:
2215        if ibrav in cellGUI[0]:
2216            useGUI = cellGUI
2217    cellList = []
2218    littleSizer = wx.FlexGridSizer(2,useGUI[1],5,5)
2219    for txt,fmt,ifEdit,Id in useGUI[2]:
2220        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,WACV)
2221        if ifEdit:          #a,b,c,etc.
2222            cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
2223            cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)       
2224            cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
2225            littleSizer.Add(cellVal,0,WACV)
2226            cellList.append(cellVal.GetId())
2227        else:               #volume
2228            volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
2229            volVal.SetBackgroundColour(VERY_LIGHT_GREY)
2230            littleSizer.Add(volVal,0,WACV)
2231    mainSizer.Add(littleSizer,0)
2232       
2233    mainSizer.Layout()   
2234    G2frame.dataDisplay.SetSizer(mainSizer)
2235    topSize = mainSizer.Fit(G2frame.dataFrame)
2236    G2frame.dataDisplay.SetSize(topSize)
2237    if cells:
2238        if ibrav == 13:
2239            topSize[1] += 230
2240        else:
2241            topSize[1] += 200
2242    G2frame.dataFrame.setSizePosLeft(topSize)   
2243   
2244    if cells:
2245        bottomSize = topSize        #screwy but bottom doesn't have a size in linux!
2246        bottomSize[0] -= 20         #to reveal slider
2247        if ibrav == 13:
2248            bottomSize[1] -= 240
2249        else:
2250            bottomSize[1] -= 210
2251        wx.StaticText(parent=G2frame.bottom,label=' Indexing Result ')
2252        rowLabels = []
2253        colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume','Keep']
2254        Types = [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_NUMBER,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_STRING,]+ \
2255            3*[wg.GRID_VALUE_FLOAT+':10,5',]+3*[wg.GRID_VALUE_FLOAT+':10,3',]+ \
2256            [wg.GRID_VALUE_FLOAT+':10,2',wg.GRID_VALUE_BOOL]
2257        numRows = len(cells)
2258        table = []
2259        for cell in cells:
2260            rowLabels.append('')
2261            row = cell[0:2]+[cell[-2]]+[bravaisSymb[cell[2]]]+cell[3:10]+[cell[11],]
2262            if cell[-2]:
2263                A = G2lat.cell2A(cell[3:9])
2264                G2frame.HKL = G2lat.GenHBravais(dmin,cell[2],A)
2265                for hkl in G2frame.HKL:
2266                    hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'][1])             
2267            table.append(row)
2268        UnitCellsTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
2269        gridDisplay = G2gd.GSGrid(G2frame.bottom)
2270        gridDisplay.SetPosition(wx.Point(0,20))               
2271        gridDisplay.SetTable(UnitCellsTable, True)
2272        G2frame.dataFrame.CopyCell.Enable(True)
2273        gridDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshUnitCellsGrid)
2274        gridDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK,OnSortCells)
2275        gridDisplay.SetMargins(0,0)
2276        gridDisplay.SetRowLabelSize(0)
2277        gridDisplay.AutoSizeColumns(False)
2278        for r in range(gridDisplay.GetNumberRows()):
2279            for c in range(gridDisplay.GetNumberCols()):
2280                if c == 2:
2281                    gridDisplay.SetReadOnly(r,c,isReadOnly=False)
2282                else:
2283                    gridDisplay.SetReadOnly(r,c,isReadOnly=True)
2284        gridDisplay.SetSize(bottomSize)
2285
2286################################################################################
2287#####  Reflection list
2288################################################################################           
2289       
2290def UpdateReflectionGrid(G2frame,data,HKLF=False,Name=''):
2291    '''respond to selection of PWDR Reflections data tree item.
2292    '''
2293    if not data:
2294        print 'No phases, no reflections'
2295        return
2296    if HKLF:
2297        G2frame.RefList = 1
2298        phaseName = Name
2299    else:
2300        phaseName = G2frame.RefList
2301        phases = data.keys()
2302   
2303        def OnSelectPhase(event):
2304            dlg = wx.SingleChoiceDialog(G2frame,'Select','Phase',phases)
2305            try:
2306                if dlg.ShowModal() == wx.ID_OK:
2307                    sel = dlg.GetSelection()
2308                    G2frame.RefList = phases[sel]
2309                    UpdateReflectionGrid(G2frame,data)
2310            finally:
2311                dlg.Destroy()
2312            G2plt.PlotPatterns(G2frame)
2313           
2314        def OnPlotHKL(event):
2315            PlotSngl(self,newPlot=True)           #this isn't going to work; no HKL plot controls!
2316       
2317    if G2frame.dataDisplay:
2318        G2frame.dataFrame.Clear()
2319    rowLabels = []
2320    if HKLF:
2321        G2gd.SetDataMenuBar(G2frame)
2322        refs = data[1]['RefList']
2323    else:       
2324        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
2325        if not G2frame.dataFrame.GetStatusBar():
2326            Status = G2frame.dataFrame.CreateStatusBar()   
2327        G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
2328        G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)   #not work yet
2329        G2frame.dataFrame.SelectPhase.Enable(False)
2330        if len(data) > 1:
2331            G2frame.dataFrame.SelectPhase.Enable(True)
2332        try:            #patch for old reflection lists
2333            refList = np.array(data[G2frame.RefList]['RefList'])
2334            I100 = refList.T[8]*refList.T[11]
2335        except TypeError:
2336            refList = np.array([refl[:11] for refl in data[G2frame.RefList]])
2337            I100 = refList.T[8]*np.array([refl[13] for refl in data[G2frame.RefList]])
2338        Imax = np.max(I100)
2339        if Imax:
2340            I100 *= 100.0/Imax
2341        refs = np.vstack((refList.T[:11],I100)).T
2342    for i in range(len(refs)): rowLabels.append(str(i))
2343    if HKLF:
2344        colLabels = ['H','K','L','mul','d','Fosq','sig','Fcsq','FoTsq','FcTsq','phase',]
2345    else:
2346        colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase','I100',]
2347    Types = 4*[wg.GRID_VALUE_LONG,]+4*[wg.GRID_VALUE_FLOAT+':10,4',]+ \
2348        2*[wg.GRID_VALUE_FLOAT+':10,2',]+[wg.GRID_VALUE_FLOAT+':10,3',]+ \
2349        [wg.GRID_VALUE_FLOAT+':10,2',]
2350    G2frame.PeakTable = G2gd.Table(refs,rowLabels=rowLabels,colLabels=colLabels,types=Types)
2351    G2frame.dataFrame.SetLabel('Reflection List for '+phaseName)
2352    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
2353    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
2354    G2frame.dataDisplay.EnableEditing(False)
2355    G2frame.dataDisplay.SetMargins(0,0)
2356    G2frame.dataDisplay.AutoSizeColumns(False)
2357    G2frame.dataDisplay.Fit()
2358    size = G2frame.dataDisplay.GetSize()
2359    G2frame.dataFrame.setSizePosLeft([size[0]+32,350])
2360   
2361################################################################################
2362#####  SASD Substances
2363################################################################################
2364           
2365def UpdateSubstanceGrid(G2frame,data):
2366    '''respond to selection of SASD Substance data tree item.
2367    '''
2368    import Substances as substFile
2369   
2370    def OnLoadSubstance(event):
2371        names = substFile.Substances.keys()
2372        names.sort()
2373        dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', names, wx.CHOICEDLG_STYLE)
2374        try:
2375            if dlg.ShowModal() == wx.ID_OK:
2376                name = names[dlg.GetSelection()]
2377            else:
2378                return
2379        finally:
2380            dlg.Destroy()
2381        data['Substances'][name] = {'Elements':{},'Volume':1.0,'Density':1.0,
2382            'Scatt density':0.0,'XAnom density':0.0,'XAbsorption':0.0}
2383        subst = substFile.Substances[name]
2384        ElList = subst['Elements'].keys()
2385        for El in ElList:
2386            Info = G2elem.GetAtomInfo(El.strip().upper())
2387            Info.update(subst['Elements'][El])
2388            data['Substances'][name]['Elements'][El] = Info
2389            if 'Volume' in subst:
2390                data['Substances'][name]['Volume'] = subst['Volume']
2391                data['Substances'][name]['Density'] = \
2392                    G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
2393            elif 'Density' in subst:
2394                data['Substances'][name]['Density'] = subst['Density']
2395                data['Substances'][name]['Volume'] = \
2396                    G2mth.Den2Vol(data['Substances'][name]['Elements'],data['Substances'][name]['Density'])
2397            else:
2398                data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
2399                data['Substances'][name]['Density'] = \
2400                    G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
2401            data['Substances'][name]['Scatt density'] = \
2402                G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
2403            contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)         
2404            data['Substances'][name]['XAnom density'] = contrst
2405            data['Substances'][name]['XAbsorption'] = absorb
2406                         
2407        UpdateSubstanceGrid(G2frame,data)
2408       
2409    def OnCopySubstance(event):
2410        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
2411        histList = GetHistsLikeSelected(G2frame)
2412        if not histList:
2413            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
2414            return
2415        copyList = []
2416        dlg = G2gd.G2MultiChoiceDialog(
2417            G2frame.dataFrame, 
2418            'Copy substances from\n'+hst[5:]+' to...',
2419            'Copy substances', histList)
2420        try:
2421            if dlg.ShowModal() == wx.ID_OK:
2422                for i in dlg.GetSelections(): 
2423                    copyList.append(histList[i])
2424        finally:
2425            dlg.Destroy()       
2426        for item in copyList:
2427            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
2428            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Substances'),
2429                copy.copy(data))
2430   
2431    def OnAddSubstance(event):
2432        dlg = wx.TextEntryDialog(None,'Enter a name for this substance','Substance Name Entry','New substance',
2433            style=wx.OK)
2434        if dlg.ShowModal() == wx.ID_OK:
2435            Name = dlg.GetValue()
2436            data['Substances'][Name] = {'Elements':{},'Volume':1.0,'Density':1.0,
2437                'Scatt density':0.0,'XAnom density':0.,'XAbsorption':0.}
2438        dlg.Destroy()
2439        AddElement(Name)
2440        UpdateSubstanceGrid(G2frame,data)
2441       
2442    def OnDeleteSubstance(event):
2443        TextList = []
2444        for name in data['Substances']:
2445            if name != 'vacuum':
2446                TextList += [name,]
2447        if not TextList:
2448            return
2449        dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance to delete', TextList, wx.CHOICEDLG_STYLE)
2450        try:
2451            if dlg.ShowModal() == wx.ID_OK:
2452                name = TextList[dlg.GetSelection()]
2453            else:
2454                return
2455        finally:
2456            dlg.Destroy()
2457        del(data['Substances'][name])
2458        UpdateSubstanceGrid(G2frame,data)       
2459               
2460    def OnAddElement(event):       
2461        TextList = []
2462        for name in data['Substances']:
2463            if name != 'vacuum':
2464                TextList += [name,]
2465        if not TextList:
2466            return
2467        dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', TextList, wx.CHOICEDLG_STYLE)
2468        try:
2469            if dlg.ShowModal() == wx.ID_OK:
2470                name = TextList[dlg.GetSelection()]
2471            else:
2472                return
2473        finally:
2474            dlg.Destroy()
2475        AddElement(name)
2476        UpdateSubstanceGrid(G2frame,data)
2477       
2478    def AddElement(name):
2479        ElList = data['Substances'][name]['Elements'].keys()
2480        dlg = G2elemGUI.PickElements(G2frame,ElList)
2481        if dlg.ShowModal() == wx.ID_OK:
2482            for El in dlg.Elem:
2483                El = El.strip().upper()
2484                Info = G2elem.GetAtomInfo(El)
2485                Info.update({'Num':1})
2486                data['Substances'][name]['Elements'][El] = Info
2487                data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
2488                data['Substances'][name]['Density'] = \
2489                    G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
2490                data['Substances'][name]['Scatt density'] = \
2491                    G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
2492                contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)         
2493                data['Substances'][name]['XAnom density'] = contrst
2494                data['Substances'][name]['XAbsorption'] = absorb
2495        dlg.Destroy()
2496       
2497       
2498    def OnDeleteElement(event):
2499        TextList = []
2500        for name in data['Substances']:
2501            if name != 'vacuum':
2502                TextList += [name,]
2503        if not TextList:
2504            return
2505        dlg = wx.SingleChoiceDialog(G2frame, 'Which substance?', 'Select substance', TextList, wx.CHOICEDLG_STYLE)
2506        try:
2507            if dlg.ShowModal() == wx.ID_OK:
2508                name = TextList[dlg.GetSelection()]
2509            else:
2510                return
2511        finally:
2512            dlg.Destroy()
2513        ElList = data['Substances'][name]['Elements'].keys()
2514        if len(ElList):
2515            DE = G2elemGUI.DeleteElement(G2frame,ElList)
2516            if DE.ShowModal() == wx.ID_OK:
2517                El = DE.GetDeleteElement().strip().upper()
2518                del(data['Substances'][name]['Elements'][El])
2519                data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
2520                data['Substances'][name]['Density'] = \
2521                    G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
2522                data['Substances'][name]['Scatt density'] = \
2523                    G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
2524                contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)         
2525                data['Substances'][name]['XAnom density'] = contrst
2526                data['Substances'][name]['XAbsorption'] = absorb
2527        UpdateSubstanceGrid(G2frame,data)
2528               
2529    def SubstSizer():
2530       
2531        def OnValueChange(event):
2532            Obj = event.GetEventObject()
2533            if len(Indx[Obj.GetId()]) == 3:
2534                name,El,keyId = Indx[Obj.GetId()]
2535                try:
2536                    value = max(0,float(Obj.GetValue()))
2537                except ValueError:
2538                    value = 0
2539                    Obj.SetValue('%.2f'%(value))
2540                data['Substances'][name]['Elements'][El][keyId] = value
2541                data['Substances'][name]['Volume'] = G2mth.El2EstVol(data['Substances'][name]['Elements'])
2542                data['Substances'][name]['Density'] = \
2543                    G2mth.Vol2Den(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])
2544            else:
2545                name,keyId = Indx[Obj.GetId()]
2546                try:
2547                    value = max(0,float(Obj.GetValue()))
2548                except ValueError:
2549                    value = 1.0
2550                data['Substances'][name][keyId] = value
2551                if keyId in 'Volume':
2552                    data['Substances'][name]['Density'] = \
2553                        G2mth.Vol2Den(data['Substances'][name]['Elements'],value)
2554                elif keyId in 'Density':
2555                    data['Substances'][name]['Volume'] = \
2556                        G2mth.Den2Vol(data['Substances'][name]['Elements'],value)
2557            data['Substances'][name]['Scatt density'] = \
2558                G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'])[0]
2559            contrst,absorb = G2mth.XScattDen(data['Substances'][name]['Elements'],data['Substances'][name]['Volume'],wave)         
2560            data['Substances'][name]['XAnom density'] = contrst
2561            data['Substances'][name]['XAbsorption'] = absorb
2562            UpdateSubstanceGrid(G2frame,data)
2563       
2564        Indx = {}
2565        substSizer = wx.BoxSizer(wx.VERTICAL)
2566        substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Substance list: wavelength: %.5fA'%(wave)),
2567            0,WACV)
2568        for name in data['Substances']:
2569            G2gd.HorizontalLine(substSizer,G2frame.dataDisplay)   
2570            substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Data for '+name+':'),
2571                0,WACV)
2572            if name == 'vacuum':
2573                substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='        Not applicable'),
2574                    0,WACV)
2575            else:   
2576                elSizer = wx.FlexGridSizer(1,6,5,5)
2577                Substance = data['Substances'][name]
2578                Elems = Substance['Elements']
2579                for El in Elems:    #do elements as pull downs for isotopes for neutrons
2580                    elSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+El+': '),
2581                        0,WACV)
2582                    num = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(Elems[El]['Num']),style=wx.TE_PROCESS_ENTER)
2583                    Indx[num.GetId()] = [name,El,'Num']
2584                    num.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
2585                    num.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
2586                    elSizer.Add(num,0,WACV)
2587                substSizer.Add(elSizer,0)
2588                vdsSizer = wx.FlexGridSizer(1,4,5,5)
2589                vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Volume: '),
2590                    0,WACV)
2591                vol = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(Substance['Volume']),style=wx.TE_PROCESS_ENTER)
2592                Indx[vol.GetId()] = [name,'Volume']
2593                vol.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
2594                vol.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
2595                vdsSizer.Add(vol,0,WACV)               
2596                vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Density: '),
2597                    0,WACV)
2598                den = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(Substance['Density']),style=wx.TE_PROCESS_ENTER)
2599                Indx[den.GetId()] = [name,'Density']
2600                den.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
2601                den.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
2602                vdsSizer.Add(den,0,WACV)
2603                substSizer.Add(vdsSizer,0)
2604                substSizer.Add(wx.StaticText(G2frame.dataDisplay,
2605                    label=' Scattering density  : %.2f *10%scm%s'%(Substance['Scatt density'],Pwr10,Pwrm2)),
2606                    0,WACV)               
2607                substSizer.Add(wx.StaticText(G2frame.dataDisplay,       #allow neutrons here into NAnom density & NAbsorption
2608                    label=' Anomalous density : %.2f *10%scm%s'%(Substance['XAnom density'],Pwr10,Pwrm2)),
2609                    0,WACV)               
2610                substSizer.Add(wx.StaticText(G2frame.dataDisplay,
2611                    label=' X-ray absorption   : %.2f cm%s'%(Substance['XAbsorption'],Pwrm1)),
2612                    0,WACV)               
2613        return substSizer
2614           
2615    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
2616    wave = G2mth.getWave(Inst)
2617    if G2frame.dataDisplay:
2618        G2frame.dataFrame.DestroyChildren()
2619    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SubstanceMenu)
2620    if not G2frame.dataFrame.GetStatusBar():
2621        Status = G2frame.dataFrame.CreateStatusBar()
2622    G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
2623    G2frame.dataFrame.SetLabel('Substances')
2624    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadSubstance, id=G2gd.wxID_LOADSUBSTANCE)   
2625    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddSubstance, id=G2gd.wxID_ADDSUBSTANCE)
2626    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopySubstance, id=G2gd.wxID_COPYSUBSTANCE)
2627    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteSubstance, id=G2gd.wxID_DELETESUBSTANCE)   
2628    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_ELEMENTADD)
2629    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_ELEMENTDELETE)
2630    mainSizer = wx.BoxSizer(wx.VERTICAL)
2631    mainSizer.Add(SubstSizer(),0)
2632
2633    mainSizer.Layout()   
2634    G2frame.dataDisplay.SetSizer(mainSizer)
2635    G2frame.dataDisplay.SetAutoLayout(1)
2636    G2frame.dataDisplay.SetupScrolling()
2637    Size = mainSizer.Fit(G2frame.dataFrame)
2638    Size[0] += 25
2639    G2frame.dataDisplay.SetSize(Size)
2640    G2frame.dataFrame.setSizePosLeft(Size)   
2641       
2642################################################################################
2643#####  SASD Models
2644################################################################################           
2645       
2646def UpdateModelsGrid(G2frame,data):
2647    '''respond to selection of SASD Models data tree item.
2648    '''
2649    #patches
2650    if 'Current' not in data:
2651        data['Current'] = 'Size dist.'
2652    if 'logBins' not in data['Size']:
2653        data['Size']['logBins'] = True
2654    if 'MinMaxDiam' in data['Size']:
2655        data['Size']['MinDiam'] = 50.
2656        data['Size']['MaxDiam'] = 10000.
2657        del data['Size']['MinMaxDiam']
2658    if isinstance(data['Size']['MaxEnt']['Sky'],float):
2659        data['Size']['MaxEnt']['Sky'] = -3
2660    if 'Power' not in data['Size']['IPG']:
2661        data['Size']['IPG']['Power'] = -1
2662    if 'Matrix' not in data['Particle']:
2663        data['Particle']['Matrix'] = {'Name':'vacuum','VolFrac':[0.0,False]}
2664    #end patches
2665   
2666    def RefreshPlots(newPlot=False):
2667        PlotText = G2frame.G2plotNB.nb.GetPageText(G2frame.G2plotNB.nb.GetSelection())
2668        if 'Powder' in PlotText:
2669            G2plt.PlotPatterns(G2frame,plotType='SASD',newPlot=newPlot)
2670        elif 'Size' in PlotText:
2671            G2plt.PlotSASDSizeDist(G2frame)
2672               
2673    def OnAddModel(event):
2674        if data['Current'] == 'Particle fit':
2675            material = 'vacuum'
2676            if len(data['Particle']['Levels']):
2677                material = data['Particle']['Levels'][-1]['Controls']['Material']
2678            data['Particle']['Levels'].append({
2679                'Controls':{'FormFact':'Sphere','DistType':'LogNormal','Material':material,
2680                    'FFargs':{},'NumPoints':50,'Cutoff':0.01,'AutoDist':True,'logR':True,
2681                    'StrFact':'Dilute'},
2682                'LogNormal':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[0.5,False],'MinSize':[10.,False],},
2683                'Gaussian':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[300.,False],},
2684                'LSW':{'Volume':[0.05,False],'Mean':[1000.0,False],},
2685                'Schulz-Zimm':{'Volume':[0.05,False],'Mean':[1000.,False],'StdDev':[300.,False],},
2686                'Unified':{'G':[100,False],'Rg':[100,False],'B':[1.e-4,False],'P':[4,False],'Cutoff':[1e-5,False],},
2687                'Porod':{'B':[1.e-4,False],'P':[4,False],'Cutoff':[1e-5,False],},
2688                'Monodisperse':{'Volume':[0.05,False],'Radius':[100,False],},   #OK for spheres
2689                'Bragg':{'PkInt':[100,False],'PkPos':[0.2,False],
2690                    'PkSig':[10,False],'PkGam':[10,False],},        #reeasonable 31A peak
2691                })
2692            G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2693            RefreshPlots(True)
2694                   
2695        wx.CallAfter(UpdateModelsGrid,G2frame,data)
2696       
2697    def OnCopyModel(event):
2698        hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
2699        histList = GetHistsLikeSelected(G2frame)
2700        if not histList:
2701            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
2702            return
2703        copyList = []
2704        dlg = G2gd.G2MultiChoiceDialog(
2705            G2frame.dataFrame, 
2706            'Copy models from\n'+hst[5:]+' to...',
2707            'Copy models', histList)
2708        try:
2709            if dlg.ShowModal() == wx.ID_OK:
2710                for i in dlg.GetSelections(): 
2711                    copyList.append(histList[i])
2712        finally:
2713            dlg.Destroy()       
2714        for item in copyList:
2715            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
2716            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Models'),
2717                copy.deepcopy(data))
2718       
2719    def OnFitModel(event):
2720        if data['Current'] == 'Size dist.':
2721            if not any(Sample['Contrast']):
2722                G2frame.ErrorDialog('No contrast; your sample is a vacuum!',
2723                    'You need to define a scattering substance!\n'+    \
2724                    ' Do Substances and then Sample parameters')
2725                return
2726            G2sasd.SizeDistribution(Profile,ProfDict,Limits,Substances,Sample,data)
2727            RefreshPlots(True)
2728           
2729        elif data['Current'] == 'Particle fit':
2730            SaveState()
2731            if not G2sasd.ModelFit(Profile,ProfDict,Limits,Substances,Sample,data):
2732                G2frame.ErrorDialog('Failed refinement',
2733                    'You need to rethink your selection of parameters\n'+    \
2734                    ' Model restored to previous version')
2735            G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2736            RefreshPlots(True)
2737            wx.CallAfter(UpdateModelsGrid,G2frame,data)
2738           
2739    def OnUnDo(event):
2740        DoUnDo()
2741        data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
2742            G2frame.PatternId,'Models'))
2743        G2frame.dataFrame.SasdUndo.Enable(False)
2744        UpdateModelsGrid(G2frame,data)
2745        G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2746        RefreshPlots(True)
2747
2748    def DoUnDo():
2749        print 'Undo last refinement'
2750        file = open(G2frame.undosasd,'rb')
2751        PatternId = G2frame.PatternId
2752        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
2753        print ' Models recovered'
2754        file.close()
2755       
2756    def SaveState():
2757        G2frame.undosasd = os.path.join(G2frame.dirname,'GSASIIsasd.save')
2758        file = open(G2frame.undosasd,'wb')
2759        PatternId = G2frame.PatternId
2760        for item in ['Models']:
2761            cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
2762        file.close()
2763        G2frame.dataFrame.SasdUndo.Enable(True)
2764       
2765    def OnSelectFit(event):
2766        data['Current'] = fitSel.GetValue()
2767        wx.CallAfter(UpdateModelsGrid,G2frame,data)
2768       
2769    def OnValueChange(event):
2770        Obj = event.GetEventObject()
2771        itemKey,ind,fmt = Indx[Obj.GetId()]
2772        try:
2773            value = float(Obj.GetValue())
2774        except ValueError:
2775            value = 0.0
2776        Obj.SetValue(fmt%(value))
2777        data[itemKey][ind] = value
2778        if itemKey == 'Back':
2779            Profile[4][:] = value
2780        RefreshPlots()
2781       
2782    def OnCheckBox(event):
2783        Obj = event.GetEventObject()
2784        item,ind = Indx[Obj.GetId()]
2785        item[ind] = Obj.GetValue()
2786       
2787    def OnIntVal(event):
2788        Obj = event.GetEventObject()
2789        item,ind,minVal = Indx[Obj.GetId()]
2790        try:
2791            value = int(Obj.GetValue())
2792            if value <= minVal:
2793                raise ValueError
2794        except ValueError:
2795            value = item[ind]
2796        Obj.SetValue(str(value))
2797        item[ind] = value
2798
2799    def SizeSizer():
2800       
2801        def OnShape(event):
2802            data['Size']['Shape'][0] = partsh.GetValue()
2803            wx.CallAfter(UpdateModelsGrid,G2frame,data)
2804           
2805        def OnMethod(event):
2806            data['Size']['Method'] = method.GetValue()
2807            wx.CallAfter(UpdateModelsGrid,G2frame,data)
2808           
2809        def OnPartVal(event):
2810            try:
2811                val = max(0.0,float(partprm.GetValue()))
2812            except ValueError:
2813                val = 1
2814            data['Size']['Shape'][1] = val
2815            partprm.SetValue('%.3f'%(val))
2816           
2817        sizeSizer = wx.BoxSizer(wx.VERTICAL)
2818        sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Size distribution parameters: '),0,WACV)
2819        binSizer = wx.FlexGridSizer(1,7,5,5)
2820        binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. size bins: '),0,WACV)
2821        bins = ['50','100','150','200']
2822        nbins = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Nbins']),choices=bins,
2823            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2824        Indx[nbins.GetId()] = [data['Size'],'Nbins',0]
2825        nbins.Bind(wx.EVT_COMBOBOX,OnIntVal)       
2826        binSizer.Add(nbins,0,WACV)
2827        binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min diam.: '),0,WACV)
2828        minDias = ['10','25','50','100','150','200']
2829        mindiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MinDiam']),choices=minDias,
2830            style=wx.CB_DROPDOWN)
2831        mindiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
2832        mindiam.Bind(wx.EVT_TEXT_ENTER,OnIntVal)       
2833        mindiam.Bind(wx.EVT_KILL_FOCUS,OnIntVal)
2834        Indx[mindiam.GetId()] = [data['Size'],'MinDiam',0]
2835        binSizer.Add(mindiam,0,WACV)
2836        binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max diam.: '),0,WACV)
2837        maxDias = [str(1000*(i+1)) for i in range(10)]
2838        maxdiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxDiam']),choices=maxDias,
2839            style=wx.CB_DROPDOWN)
2840        maxdiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
2841        maxdiam.Bind(wx.EVT_TEXT_ENTER,OnIntVal)       
2842        maxdiam.Bind(wx.EVT_KILL_FOCUS,OnIntVal)
2843        Indx[maxdiam.GetId()] = [data['Size'],'MaxDiam',0]
2844        binSizer.Add(maxdiam,0,WACV)
2845        logbins = wx.CheckBox(G2frame.dataDisplay,label='Log bins?')
2846        Indx[logbins.GetId()] = [data['Size'],'logBins']
2847        logbins.SetValue(data['Size']['logBins'])
2848        logbins.Bind(wx.EVT_CHECKBOX, OnCheckBox)
2849        binSizer.Add(logbins,0,WACV)
2850        sizeSizer.Add(binSizer,0)
2851        sizeSizer.Add((5,5),0)
2852        partSizer = wx.BoxSizer(wx.HORIZONTAL)
2853        partSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Particle description: '),0,WACV)
2854        shapes = {'Spheroid':' Aspect ratio: ','Cylinder':' Diameter ','Cylinder AR':' Aspect ratio: ',
2855            'Unified sphere':'','Unified rod':' Diameter: ','Unified rod AR':' Aspect ratio: ',
2856            'Unified disk':' Thickness: '}
2857        partsh = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Shape'][0]),choices=shapes.keys(),
2858            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2859        partsh.Bind(wx.EVT_COMBOBOX,OnShape)       
2860        partSizer.Add(partsh,0,WACV)
2861        if data['Size']['Shape'][0] not in ['Unified sphere',]:
2862            partSizer.Add(wx.StaticText(G2frame.dataDisplay,label=shapes[data['Size']['Shape'][0]]),0,WACV)
2863            partprm = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Size']['Shape'][1]),
2864                style=wx.TE_PROCESS_ENTER)
2865            partprm.Bind(wx.EVT_TEXT_ENTER,OnPartVal)       
2866            partprm.Bind(wx.EVT_KILL_FOCUS,OnPartVal)
2867            partSizer.Add(partprm,0,WACV)
2868        sizeSizer.Add(partSizer,0)
2869        sizeSizer.Add((5,5),0)
2870        fitSizer = wx.BoxSizer(wx.HORIZONTAL)
2871        methods = ['MaxEnt','IPG',]
2872        fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Fitting method: '),0,WACV)
2873        method = wx.ComboBox(G2frame.dataDisplay,value=data['Size']['Method'],choices=methods,
2874            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2875        method.Bind(wx.EVT_COMBOBOX,OnMethod)
2876        fitSizer.Add(method,0,WACV)
2877        iters = ['10','25','50','100','150','200']       
2878        fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. iterations: '),0,WACV)
2879        Method = data['Size']['Method']
2880        iter = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size'][Method]['Niter']),choices=iters,
2881            style=wx.CB_READONLY|wx.CB_DROPDOWN)
2882        Indx[iter.GetId()] = [data['Size'][Method],'Niter',0]
2883        iter.Bind(wx.EVT_COMBOBOX,OnIntVal)
2884        fitSizer.Add(iter,0,WACV)
2885        if 'MaxEnt' in data['Size']['Method']:
2886            fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Log floor factor: '),0,WACV)
2887            floors = [str(-i) for i in range(9)]
2888            floor = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxEnt']['Sky']),choices=floors,
2889                style=wx.CB_READONLY|wx.CB_DROPDOWN)
2890            Indx[floor.GetId()] = [data['Size']['MaxEnt'],'Sky',-10]
2891            floor.Bind(wx.EVT_COMBOBOX,OnIntVal)
2892            fitSizer.Add(floor,0,WACV)
2893        elif 'IPG' in data['Size']['Method']:
2894            fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Q power weight (-1 for sigma): '),0,WACV)
2895            choices = ['-1','0','1','2','3','4']
2896            power = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['IPG']['Power']),choices=choices,
2897                style=wx.CB_READONLY|wx.CB_DROPDOWN)
2898            Indx[power.GetId()] = [data['Size']['IPG'],'Power',-2]
2899            power.Bind(wx.EVT_COMBOBOX,OnIntVal)
2900            fitSizer.Add(power,0,WACV)
2901        sizeSizer.Add(fitSizer,0)
2902
2903        return sizeSizer
2904       
2905    def PartSizer():
2906       
2907        FormFactors = {'Sphere':{},'Spheroid':{'Aspect ratio':[1.0,False]},
2908            'Cylinder':{'Length':[100.,False]},'Cylinder diam':{'Diameter':[100.,False]},
2909            'Cylinder AR':{'Aspect ratio':[1.0,False]},'Unified sphere':{},
2910            'Unified rod':{'Length':[100.,False]},'Unified rod AR':{'Aspect ratio':[1.0,False]},
2911            'Unified disk':{'Thickness':[100.,False]},
2912            'Unified tube':{'Length':[100.,False],'Thickness':[10.,False]},}
2913               
2914        ffDistChoices =  ['Sphere','Spheroid','Cylinder','Cylinder diam',
2915            'Cylinder AR','Unified sphere','Unified rod','Unified rod AR',
2916            'Unified disk','Unified tube',]
2917               
2918        ffMonoChoices = ['Sphere','Spheroid','Cylinder','Cylinder AR',
2919            ]
2920                 
2921        def OnValue(event):
2922            Obj = event.GetEventObject()
2923            item,key,id,sldrObj = Indx[Obj.GetId()]
2924            try:
2925                value = float(Obj.GetValue())
2926                if value <= 0.:
2927                    raise ValueError
2928            except ValueError:
2929                value = item[key][id]
2930            item[key][id] = value
2931            Obj.SetValue('%.3g'%(value))
2932            if key == 'P':
2933                sldrObj.SetValue(1000.*value)
2934            else:
2935                sldrObj.SetRange(1000.*(np.log10(value)-2),1000.*(np.log10(value)+2))
2936                sldrObj.SetValue(1000.*np.log10(value))
2937            G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2938            RefreshPlots()
2939           
2940        def OnSelect(event):
2941            Obj = event.GetEventObject()
2942            item,key = Indx[Obj.GetId()]
2943            item[key] = Obj.GetValue()
2944            if 'Refine' not in Obj.GetLabel():
2945                if 'FormFact' in key :
2946                    item['FFargs'] = FormFactors[Obj.GetValue()]
2947                wx.CallAfter(UpdateModelsGrid,G2frame,data)
2948                G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2949                RefreshPlots()
2950               
2951        def OnDelLevel(event):
2952            Obj = event.GetEventObject()
2953            item = Indx[Obj.GetId()]
2954            del data['Particle']['Levels'][item]
2955            wx.CallAfter(UpdateModelsGrid,G2frame,data)
2956            G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2957            RefreshPlots()
2958           
2959        def OnParmSlider(event):
2960            Obj = event.GetEventObject()
2961            item,key,id,pvObj = Indx[Obj.GetId()]
2962            slide = Obj.GetValue()
2963            if key == 'P':
2964                value = float(slide/1000.)
2965            else:
2966                value = 10.**float(slide/1000.)
2967            item[key][id] = value
2968            pvObj.SetValue('%.3g'%(item[key][id]))
2969            G2sasd.ModelFxn(Profile,ProfDict,Limits,Substances,Sample,data)
2970            RefreshPlots()
2971           
2972        def OnCenterSlider(event):
2973            Obj = event.GetEventObject()
2974            Obj.SetValue(False)
2975            sldrObj,value = Indx[Obj.GetId()]
2976            sldrObj.SetRange(1000*(value-1),1000*(value+1))
2977            sldrObj.SetValue(1000*value)
2978           
2979        def SizeSizer():
2980            sizeSizer = wx.FlexGridSizer(0,4,5,5)
2981            sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Distribution: '),0,WACV)
2982            Distchoice = ['LogNormal','Gaussian','LSW','Schulz-Zimm','Bragg','Unified','Porod','Monodisperse',]
2983            distChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['DistType'],choices=Distchoice,
2984                style=wx.CB_READONLY|wx.CB_DROPDOWN)
2985            Indx[distChoice.GetId()] = [level['Controls'],'DistType']
2986            distChoice.Bind(wx.EVT_COMBOBOX,OnSelect)
2987            sizeSizer.Add(distChoice,0,WACV)
2988            if level['Controls']['DistType'] not in ['Bragg','Unified','Porod',]:
2989                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Form Factor: '),0,WACV)
2990                if 'Mono' not in level['Controls']['DistType']:
2991                    ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffDistChoices,
2992                        style=wx.CB_READONLY|wx.CB_DROPDOWN)
2993                else:
2994                    ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffMonoChoices,
2995                        style=wx.CB_READONLY|wx.CB_DROPDOWN)
2996                Indx[ffChoice.GetId()] = [level['Controls'],'FormFact']
2997                ffChoice.Bind(wx.EVT_COMBOBOX,OnSelect)
2998                sizeSizer.Add(ffChoice,0,WACV)
2999                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
3000                matSel = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['Material'],
3001                    choices=Substances['Substances'].keys(),style=wx.CB_READONLY|wx.CB_DROPDOWN)
3002                Indx[matSel.GetId()] = [level['Controls'],'Material']
3003                matSel.Bind(wx.EVT_COMBOBOX,OnSelect)       
3004                sizeSizer.Add(matSel,0,WACV) #do neutron test here?
3005                rho = Substances['Substances'][level['Controls']['Material']].get('XAnom density',0.0)
3006                contrast = rho**2-rhoMat**2
3007                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Resonant X-ray contrast: '),0,WACV)
3008                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=%.2f 10%scm%s'%(contrast,Pwr20,Pwrm4)),0,WACV)
3009                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Num. radii: '),0,WACV)
3010                radii = ['25','50','75','100','200']
3011                nRadii = wx.ComboBox(G2frame.dataDisplay,value=str(level['Controls']['NumPoints']),choices=radii,
3012                    style=wx.CB_READONLY|wx.CB_DROPDOWN)
3013                Indx[nRadii.GetId()] = [level['Controls'],'NumPoints']
3014                nRadii.Bind(wx.EVT_COMBOBOX,OnSelect)
3015                sizeSizer.Add(nRadii,0,WACV)
3016                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' R dist. cutoff: '),0,WACV)
3017                rCutoff = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,level['Controls'],'Cutoff',
3018                    min=0.001,max=0.1,typeHint=float)
3019                sizeSizer.Add(rCutoff,0,WACV)
3020            elif level['Controls']['DistType']  in ['Unified',]:
3021                Parms = level['Unified']
3022                Best = G2sasd.Bestimate(Parms['G'][0],Parms['Rg'][0],Parms['P'][0])
3023                sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Estimated Dist B: %12.4g'%(Best)),0,WACV)
3024            return sizeSizer
3025           
3026        Indx = {}
3027        partSizer = wx.BoxSizer(wx.VERTICAL)
3028        topSizer = wx.BoxSizer(wx.HORIZONTAL)
3029        topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Particle fit parameters: '),0,WACV)
3030        topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Matrix: '),0,WACV)
3031        matsel = wx.ComboBox(G2frame.dataDisplay,value=data['Particle']['Matrix']['Name'],
3032            choices=Substances['Substances'].keys(),style=wx.CB_READONLY|wx.CB_DROPDOWN)
3033        Indx[matsel.GetId()] = [data['Particle']['Matrix'],'Name'] 
3034        matsel.Bind(wx.EVT_COMBOBOX,OnSelect) #Do neutron test here?
3035        rhoMat = Substances['Substances'][data['Particle']['Matrix']['Name']].get('XAnom density',0.0)       
3036        topSizer.Add(matsel,0,WACV)
3037        topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
3038        volfrac = G2gd.ValidatedTxtCtrl(G2frame.dataDisplay,data['Particle']['Matrix']['VolFrac'],0,
3039                typeHint=float)
3040        topSizer.Add(volfrac,0,WACV)
3041        volVar = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
3042        volVar.SetValue(data['Particle']['Matrix']['VolFrac'][1])
3043        Indx[volVar.GetId()] = [data['Particle']['Matrix']['VolFrac'],1]
3044        volVar.Bind(wx.EVT_CHECKBOX, OnSelect)
3045        topSizer.Add(volVar,0,WACV)
3046        partSizer.Add(topSizer,0,)
3047        for ilev,level in enumerate(data['Particle']['Levels']):
3048            G2gd.HorizontalLine(partSizer,G2frame.dataDisplay)
3049            topLevel = wx.BoxSizer(wx.HORIZONTAL)
3050            topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Model component %d: '%(ilev)),0,WACV)
3051            delBtn = wx.Button(G2frame.dataDisplay,label=' Delete?')
3052            Indx[delBtn.GetId()] = ilev
3053            delBtn.Bind(wx.EVT_BUTTON,OnDelLevel)
3054            topLevel.Add(delBtn,0,WACV)
3055            partSizer.Add(topLevel,0)
3056            partSizer.Add(SizeSizer())
3057           
3058            lvlSizer = wx.BoxSizer(wx.HORIZONTAL)
3059            parmSizer = wx.FlexGridSizer(1,4,5,5)
3060            parmSizer.AddGrowableCol(2,1)
3061            parmSizer.SetFlexibleDirection(wx.HORIZONTAL)
3062            Parms = level[level['Controls']['DistType']]
3063            FFargs = level['Controls']['FFargs']
3064            parmOrder = ['Volume','Radius','Mean','StdDev','MinSize','G','Rg','B','P','Cutoff',
3065                'PkInt','PkPos','PkSig','PkGam',]
3066            for parm in parmOrder:
3067                if parm in Parms:
3068                    if parm == 'MinSize':
3069                        parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Dist '+parm),0,wx.ALIGN_CENTER)
3070                    else:
3071                        parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? Dist '+parm) 
3072                        parmVar.SetValue(Parms[parm][1])
3073                        parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
3074                        parmSizer.Add(parmVar,0,WACV)
3075                        Indx[parmVar.GetId()] = [Parms[parm],1]
3076                    parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(Parms[parm][0]),
3077                        style=wx.TE_PROCESS_ENTER)
3078                    parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)       
3079                    parmValue.Bind(wx.EVT_KILL_FOCUS,OnValue)
3080                    parmSizer.Add(parmValue,0,WACV)
3081                    if parm == 'P':
3082                        value = Parms[parm][0]
3083                        valMinMax = [0.1,4.2]
3084                    else:
3085                        value = np.log10(Parms[parm][0])
3086                        valMinMax = [value-1,value+1]
3087                    parmSldr = wx.Slider(G2frame.dataDisplay,minValue=1000.*valMinMax[0],
3088                        maxValue=1000.*valMinMax[1],value=1000.*value)
3089                    Indx[parmValue.GetId()] = [Parms,parm,0,parmSldr]
3090                    Indx[parmSldr.GetId()] = [Parms,parm,0,parmValue]
3091                    parmSldr.Bind(wx.EVT_SLIDER,OnParmSlider)
3092                    parmSizer.Add(parmSldr,1,wx.EXPAND)
3093                    if parm == 'P':
3094                        parmSizer.Add((5,5),)
3095                    else:
3096                        center = wx.CheckBox(G2frame.dataDisplay,label='Center? ')
3097                        Indx[center.GetId()] = [parmSldr,value]
3098                        center.Bind(wx.EVT_CHECKBOX,OnCenterSlider)
3099                        parmSizer.Add(center,0,WACV)
3100            if level['Controls']['DistType'] not in ['Bragg']:
3101                for parm in list(FFargs):
3102                    parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? FF '+parm) 
3103                    parmVar.SetValue(FFargs[parm][1])
3104                    Indx[parmVar.GetId()] = [FFargs[parm],1]
3105                    parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
3106                    parmSizer.Add(parmVar,0,WACV)
3107                    parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(FFargs[parm][0]),
3108                        style=wx.TE_PROCESS_ENTER)
3109                    parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)       
3110                    parmValue.Bind(wx.EVT_KILL_FOCUS,OnValue)
3111                    parmSizer.Add(parmValue,0,WACV)
3112                    value = np.log10(FFargs[parm][0])
3113                    valMinMax = [value-1,value+1]
3114                    parmSldr = wx.Slider(G2frame.dataDisplay,minValue=1000.*valMinMax[0],
3115                        maxValue=1000.*valMinMax[1],value=1000.*value)
3116                    Indx[parmVar.GetId()] = [FFargs[parm],1]
3117                    Indx[parmValue.GetId()] = [FFargs[parm],0,parmSldr]
3118                    Indx[parmSldr.GetId()] = [FFargs,parm,0,parmValue]
3119                    parmSldr.Bind(wx.EVT_SLIDER,OnParmSlider)
3120                    parmSizer.Add(parmSldr,1,wx.EXPAND)
3121                    center = wx.CheckBox(G2frame.dataDisplay,label='Center? ')
3122                    Indx[center.GetId()] = [parmSldr,value]
3123                    center.Bind(wx.EVT_CHECKBOX,OnCenterSlider)
3124                    parmSizer.Add(center,0,WACV)
3125            lvlSizer.Add(parmSizer,1,wx.EXPAND)
3126            partSizer.Add(lvlSizer,1,wx.EXPAND)
3127        return partSizer
3128       
3129    def OnEsdScale(event):
3130        try:
3131            value = float(esdScale.GetValue())
3132            if value <= 0.:
3133                raise ValueError
3134        except ValueError:
3135            value = 1./np.sqrt(ProfDict['wtFactor'])
3136        ProfDict['wtFactor'] = 1./value**2
3137        esdScale.SetValue('%.3f'%(value))
3138        RefreshPlots(True)
3139       
3140    Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
3141    Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
3142    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
3143    Substances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
3144    ProfDict,Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[:2]
3145
3146    if G2frame.dataDisplay:
3147        G2frame.dataFrame.DestroyChildren()
3148    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ModelMenu)
3149    if not G2frame.dataFrame.GetStatusBar():
3150        Status = G2frame.dataFrame.CreateStatusBar()
3151    G2frame.dataFrame.SetLabel('Modelling')
3152    G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
3153    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyModel, id=G2gd.wxID_MODELCOPY)
3154    G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitModel, id=G2gd.wxID_MODELFIT)
3155    G2frame.dataFrame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_MODELUNDO)
3156    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddModel, id=G2gd.wxID_MODELADD)
3157    Indx = {}
3158    mainSizer = wx.BoxSizer(wx.VERTICAL)
3159    topSizer = wx.BoxSizer(wx.HORIZONTAL)
3160    models = ['Size dist.','Particle fit']
3161    topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Modeling by: '),0,WACV)
3162    fitSel = wx.ComboBox(G2frame.dataDisplay,value=data['Current'],choices=models,
3163        style=wx.CB_READONLY|wx.CB_DROPDOWN)
3164    fitSel.Bind(wx.EVT_COMBOBOX,OnSelectFit)       
3165    topSizer.Add(fitSel,0,WACV)
3166    topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Error multiplier: '),0,WACV)
3167    esdScale = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(1./np.sqrt(ProfDict['wtFactor'])),style=wx.TE_PROCESS_ENTER)
3168    esdScale.Bind(wx.EVT_TEXT_ENTER,OnEsdScale)       
3169    esdScale.Bind(wx.EVT_KILL_FOCUS,OnEsdScale)
3170    topSizer.Add(esdScale,0,WACV)
3171    mainSizer.Add(topSizer)
3172    G2gd.HorizontalLine(mainSizer,G2frame.dataDisplay)
3173    if 'Size' in data['Current']:
3174        if 'MaxEnt' in data['Size']['Method']:
3175            Status.SetStatusText('Size distribution by Maximum entropy')
3176        elif 'IPG' in data['Size']['Method']:
3177            Status.SetStatusText('Size distribution by Interior-Point Gradient')
3178        mainSizer.Add(SizeSizer())       
3179    elif 'Particle' in data['Current']:
3180        mainSizer.Add(PartSizer(),1,wx.ALIGN_LEFT|wx.EXPAND)
3181    G2gd.HorizontalLine(mainSizer,G2frame.dataDisplay)   
3182    backSizer = wx.BoxSizer(wx.HORIZONTAL)
3183    backSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Background:'),0,WACV)
3184    backVal = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(data['Back'][0]),style=wx.TE_PROCESS_ENTER)
3185    Indx[backVal.GetId()] = ['Back',0,'%.3g']
3186    backVal.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
3187    backVal.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
3188    backSizer.Add(backVal,0,WACV)
3189    backVar = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
3190    Indx[backVar.GetId()] = [data['Back'],1]
3191    backVar.SetValue(data['Back'][1])
3192    backVar.Bind(wx.EVT_CHECKBOX, OnCheckBox)
3193    backSizer.Add(backVar,0,WACV)
3194    mainSizer.Add(backSizer)
3195
3196    mainSizer.Layout()   
3197    G2frame.dataDisplay.SetSizer(mainSizer)
3198    G2frame.dataDisplay.SetAutoLayout(1)
3199    G2frame.dataDisplay.SetupScrolling()
3200    Size = mainSizer.Fit(G2frame.dataFrame)
3201    Size[0] += 25
3202    G2frame.dataDisplay.SetSize(Size)
3203    G2frame.dataFrame.setSizePosLeft(Size)   
3204       
3205   
3206################################################################################
3207#####  PDF controls
3208################################################################################           
3209       
3210def UpdatePDFGrid(G2frame,data):
3211    '''respond to selection of PWDR PDF data tree item.
3212    '''
3213    global inst
3214    tth2q = lambda t,w:4.0*math.pi*sind(t/2.0)/w
3215    dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
3216    powName = 'PWDR'+dataFile[4:]
3217    powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
3218    fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))[:2]
3219    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))[0]
3220    if 'Lam' in inst:
3221        keV = 12.397639/inst['Lam'][1]
3222    else:
3223        keV = 12.397639/inst['Lam1'][0]
3224    wave = 12.397639/keV
3225    qLimits = [tth2q(fullLimits[0],wave),tth2q(fullLimits[1],wave)]
3226    data['QScaleLim'][1] = min(qLimits[1],data['QScaleLim'][1])
3227    if data['QScaleLim'][0]:
3228        data['QScaleLim'][0] = max(qLimits[0],data['QScaleLim'][0])
3229    else:                                #initial setting at 90% of max Q
3230        data['QScaleLim'][0] = 0.90*data['QScaleLim'][1]
3231    polariz = inst['Polariz.'][1]
3232    azimuth = inst['Azimuth'][1]
3233    itemDict = {}
3234   
3235    def FillFileSizer(fileSizer,key):
3236        #fileSizer is a FlexGridSizer(3,6)
3237       
3238        def OnSelectFile(event):
3239            Obj = event.GetEventObject()
3240            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
3241            if itemKey == 'Name':
3242                value = Obj.GetValue()
3243            Obj.SetValue(fmt%(value))
3244            data[fileKey][itemKey] = value
3245            UpdatePDFGrid(G2frame,data)
3246       
3247        def OnValueChange(event):
3248            Obj = event.GetEventObject()
3249            fileKey,itemKey,fmt = itemDict[Obj.GetId()]
3250            try:
3251                value = float(Obj.GetValue())
3252            except ValueError:
3253                value = -1.0
3254            Obj.SetValue(fmt%(value))
3255            data[fileKey][itemKey] = value
3256            auxPlot = ComputePDF(data)
3257            G2plt.PlotISFG(G2frame,newPlot=True)
3258                       
3259        item = data[key]
3260        fileList = np.array(GetFileList('PWDR')).T[1]
3261        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,WACV)
3262        fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
3263            style=wx.CB_READONLY|wx.CB_DROPDOWN)
3264        itemDict[fileName.GetId()] = [key,'Name','%s']
3265        fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)       
3266        fileSizer.Add(fileName,0,)
3267        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,WACV)
3268        mult = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(item['Mult']),style=wx.TE_PROCESS_ENTER)
3269        itemDict[mult.GetId()] = [key,'Mult','%.3f']
3270        mult.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
3271        mult.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
3272        fileSizer.Add(mult,0,)
3273        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Add:'),0,WACV)
3274        add = wx.TextCtrl(G2frame.dataDisplay,value='%.0f'%(item['Add']),style=wx.TE_PROCESS_ENTER)
3275        itemDict[add.GetId()] = [key,'Add','%.0f']
3276        add.Bind(wx.EVT_TEXT_ENTER,OnValueChange)       
3277        add.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
3278        fileSizer.Add(add,0,)
3279       
3280    def SumElementVolumes():
3281        sumVol = 0.
3282        ElList = data['ElList']
3283        for El in ElList:
3284            Avol = (4.*math.pi/3.)*ElList[El]['Drad']**3
3285            sumVol += Avol*ElList[El]['FormulaNo']
3286        return sumVol
3287        auxPlot = ComputePDF(data)
3288        G2plt.PlotISFG(G2frame,newPlot=True)       
3289       
3290    def FillElemSizer(elemSizer,ElData):
3291       
3292        def OnFractionChange(event):
3293            try:
3294                value = max(0.0,float(num.GetValue()))
3295            except ValueError:
3296                value = 0.0
3297            num.SetValue('%.3f'%(value))
3298            ElData['FormulaNo'] = value
3299            data['Form Vol'] = max(10.0,SumElementVolumes())
3300            formVol.SetValue('%.2f'%(data['Form Vol']))
3301            wx.CallAfter(UpdatePDFGrid,G2frame,data)
3302            auxPlot = ComputePDF(data)
3303            G2plt.PlotISFG(G2frame,newPlot=True)       
3304       
3305        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
3306            label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,WACV)
3307        num = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(ElData['FormulaNo']),style=wx.TE_PROCESS_ENTER)
3308        num.Bind(wx.EVT_TEXT_ENTER,OnFractionChange)       
3309        num.Bind(wx.EVT_KILL_FOCUS,OnFractionChange)
3310        elemSizer.Add(num,0,WACV)
3311        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
3312            label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
3313            0,WACV)
3314           
3315    def OnGeometry(event):
3316        data['Geometry'] = geometry.GetValue()
3317        UpdatePDFGrid(G2frame,data)
3318        auxPlot = ComputePDF(data)
3319        G2plt.PlotISFG(G2frame,newPlot=True)       
3320       
3321    def OnDetType(event):
3322        data['DetType'] = detType.GetValue()
3323        UpdatePDFGrid(G2frame,data)
3324        auxPlot = ComputePDF(data)
3325        G2plt.PlotISFG(G2frame,newPlot=True)       
3326       
3327    def OnFormVol(event):
3328        try:
3329            value = float(formVol.GetValue())
3330            if value <= 0.0:
3331                raise ValueError
3332        except ValueError:
3333            value = data['Form Vol']
3334        data['Form Vol'] = value
3335        UpdatePDFGrid(G2frame,data)
3336        auxPlot = ComputePDF(data)
3337        G2plt.PlotISFG(G2frame,newPlot=False)       
3338       
3339    def OnDiameter(event):
3340        try:
3341            value = float(diam.GetValue())
3342            if value <= 0.0:
3343                raise ValueError
3344        except ValueError:
3345            value = data['Diam']
3346        data['Diam'] = value
3347        UpdatePDFGrid(G2frame,data)
3348        auxPlot = ComputePDF(data)
3349        G2plt.PlotISFG(G2frame,newPlot=False)
3350       
3351    def OnPolaVal(event):
3352        try:
3353            value = float(polaVal.GetValue())
3354            if not (0.0 <= value <= 1.0):
3355                raise ValueError
3356        except ValueError:
3357            value = inst['Polariz.'][1]
3358        inst['Polariz.'][1] = value
3359        polaVal.SetValue('%.2f'%(inst['Polariz.'][1]))
3360        UpdatePDFGrid(G2frame,data)
3361        auxPlot = ComputePDF(data)
3362        G2plt.PlotISFG(G2frame,newPlot=False)
3363               
3364    def OnAzimVal(event):
3365        try:
3366            value = float(azimVal.GetValue())
3367            if not (0. <= value <= 360.):
3368                raise ValueError
3369        except ValueError:
3370            value = inst['Azimuth'][1]
3371        inst['Azimuth'][1] = value
3372        azimVal.SetValue('%.1f'%(inst['Azimuth'][1]))
3373        UpdatePDFGrid(G2frame,data)
3374        auxPlot = ComputePDF(data)
3375        G2plt.PlotISFG(G2frame,newPlot=False)
3376                       
3377    def OnObliqCoeff(event):
3378        try:
3379            value = float(obliqCoeff.GetValue())
3380            if value < 0.0:
3381                raise ValueError
3382            elif value > 1.0:
3383                value = 1.0
3384        except ValueError:
3385            value = data['ObliqCoeff']
3386        data['ObliqCoeff'] = value
3387        obliqCoeff.SetValue('%.3f'%(value))
3388        auxPlot = ComputePDF(data)
3389        G2plt.PlotISFG(G2frame,newPlot=False)
3390       
3391    def OnRulandWdt(event):
3392        try:
3393            value = float(rulandWdt.GetValue())
3394            if value <= 0.001:
3395                raise ValueError
3396            elif value > 1.0:
3397                value = 1.0
3398        except ValueError:
3399            value = data['Ruland']
3400        data['Ruland'] = value
3401        rulandWdt.SetValue('%.3f'%(value))
3402        auxPlot = ComputePDF(data)
3403        G2plt.PlotISFG(G2frame,newPlot=False)
3404       
3405    def OnRulSlider(event):
3406        value = int(rulandSldr.GetValue())/1000.
3407        data['Ruland'] = max(0.001,value)
3408        rulandWdt.SetValue('%.3f'%(data['Ruland']))
3409        auxPlot = ComputePDF(data)
3410        G2plt.PlotISFG(G2frame,newPlot=False)
3411       
3412    def OnLorch(event):
3413        data['Lorch'] = lorch.GetValue()
3414        auxPlot = ComputePDF(data)
3415        G2plt.PlotISFG(G2frame,newPlot=False)       
3416                       
3417    def OnPacking(event):
3418        try:
3419            value = float(pack.GetValue())
3420            if value <= 0.0:
3421                raise ValueError
3422        except ValueError:
3423            value = data['Pack']
3424        data['Pack'] = value
3425        UpdatePDFGrid(G2frame,data)
3426        auxPlot = ComputePDF(data)
3427        G2plt.PlotISFG(G2frame,newPlot=False)       
3428               
3429    def OnSQmin(event):
3430        try:
3431            value = float(SQmin.GetValue())
3432            if value < qLimits[0]:
3433                raise ValueError
3434        except ValueError:
3435            value = max(qLimits[0],data['QScaleLim'][0])
3436        data['QScaleLim'][0] = value
3437        SQmin.SetValue('%.1f'%(value))
3438        auxPlot = ComputePDF(data)
3439        G2plt.PlotISFG(G2frame,newPlot=True)       
3440       
3441    def OnSQmax(event):
3442        try:
3443            value = float(SQmax.GetValue())
3444            if value > qLimits[1]:
3445                raise ValueError
3446        except ValueError:
3447            value = min(qLimits[1],data['QScaleLim'][1])
3448        data['QScaleLim'][1] = value
3449        if value < data['QScaleLim'][0]:
3450            data['QScaleLim'][0] = 0.90*value
3451            SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
3452        SQmax.SetValue('%.1f'%(value))
3453        auxPlot = ComputePDF(data)
3454        G2plt.PlotISFG(G2frame,newPlot=True)
3455       
3456    def OnResetQ(event):
3457        resetQ.SetValue(False)
3458        data['QScaleLim'][1] = qLimits[1]
3459        SQmax.SetValue('%.1f'%(data['QScaleLim'][1]))
3460        data['QScaleLim'][0] = 0.9*qLimits[1]
3461        SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
3462        auxPlot = ComputePDF(data)
3463        G2plt.PlotISFG(G2frame,newPlot=True)       
3464
3465    def GetFileList(fileType,skip=None):
3466        fileList = [[False,'',0]]
3467        Source = ''
3468        id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3469        while id:
3470            name = G2frame.PatternTree.GetItemText(id)
3471            if fileType in name:
3472                if id == skip:
3473                    Source = name
3474                else:
3475                    fileList.append([False,name,id])
3476            id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3477        if skip:
3478            return fileList,Source
3479        else:
3480            return fileList
3481       
3482    def OnCopyPDFControls(event):
3483        import copy
3484        TextList,Source = GetFileList('PDF',skip=G2frame.PatternId)
3485        TextList[0] = [False,'All PDF',0]
3486        if len(TextList) == 1:
3487            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
3488            return
3489        dlg = G2frame.CopyDialog(G2frame,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
3490        try:
3491            if dlg.ShowModal() == wx.ID_OK:
3492                result = dlg.GetData()
3493                if result[0][0]:
3494                    result = TextList[1:]
3495                    for item in result: item[0] = True
3496                for i,item in enumerate(result):
3497                    ifcopy,name,id = item
3498                    if ifcopy:
3499                        olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
3500                        sample = olddata['Sample']
3501                        olddata.update(copy.deepcopy(data))
3502                        olddata['Sample'] = sample
3503                        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
3504                Status.SetStatusText('PDF controls copied')
3505        finally:
3506            dlg.Destroy()
3507               
3508    def OnSavePDFControls(event):
3509        print 'save PDF controls?'
3510       
3511    def OnLoadPDFControls(event):
3512        print 'Load PDF controls?'
3513       
3514    def OnAddElement(event):
3515        ElList = data['ElList']
3516        PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
3517        if PE.ShowModal() == wx.ID_OK:
3518            El = PE.Elem
3519            if El not in ElList and El != 'None':
3520                ElemSym = El.strip().upper()               
3521                FpMu = G2elem.FPcalc(G2elem.GetXsectionCoeff(ElemSym), keV)
3522                ElData = G2elem.GetFormFactorCoeff(ElemSym)[0]
3523                ElData['FormulaNo'] = 0.0
3524                ElData.update(G2elem.GetAtomInfo(ElemSym))
3525                ElData.update(dict(zip(['fp','fpp','mu'],FpMu)))
3526                ElData.update(G2elem.GetFFC5(El))
3527                data['ElList'][El] = ElData
3528            data['Form Vol'] = max(10.0,SumElementVolumes())
3529        PE.Destroy()
3530        UpdatePDFGrid(G2frame,data)
3531       
3532    def OnDeleteElement(event):
3533        ElList = data['ElList']
3534        choice = ElList.keys()
3535        dlg = G2elemGUI.DeleteElement(G2frame,choice=choice)
3536        if dlg.ShowModal() == wx.ID_OK:
3537            del ElList[dlg.GetDeleteElement()]
3538        dlg.Destroy()
3539        UpdatePDFGrid(G2frame,data)
3540               
3541    def ComputePDF(Data):
3542        xydata = {}
3543        for key in ['Sample','Sample Bkg.','Container','Container Bkg.']:
3544            name = Data[key]['Name']
3545            if name:
3546                xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
3547                PDFname = name
3548        powName = xydata['Sample'][2]
3549        powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
3550        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))[0]
3551        auxPlot = G2pwd.CalcPDF(Data,inst,xydata)
3552        PDFId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PDF '+powName[4:])
3553        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
3554        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
3555        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
3556        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
3557        return auxPlot
3558       
3559    def OnComputePDF(event):
3560        print 'Calculating PDF:'
3561        auxPlot = ComputePDF(data)
3562        print 'Done calculating PDF:'
3563        Status.SetStatusText('PDF computed')
3564        for plot in auxPlot:
3565            G2plt.PlotXY(G2frame,plot[:2],type=plot[2])
3566       
3567        G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
3568        G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
3569        G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
3570        G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
3571       
3572    def OnComputeAllPDF(event):
3573        print 'Calculating PDFs:'
3574        if G2frame.PatternTree.GetCount():
3575            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3576            while id:
3577                Name = G2frame.PatternTree.GetItemText(id)
3578                if 'PDF' in Name:
3579                    Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
3580                    auxPlot = ComputePDF(Data)                   
3581                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3582            Status.SetStatusText('All PDFs computed')
3583            G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
3584            print ' Done calculating PDFs:'
3585       
3586    def OnShowTip(G2frame,tip):
3587        print tip   
3588               
3589    if G2frame.dataDisplay:
3590        G2frame.dataFrame.Clear()
3591    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PDFMenu)
3592    if not G2frame.dataFrame.GetStatusBar():
3593        Status = G2frame.dataFrame.CreateStatusBar()   
3594    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3595    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
3596    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
3597    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
3598    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
3599    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
3600    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
3601    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
3602    mainSizer = wx.BoxSizer(wx.VERTICAL)
3603    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,WACV)
3604    mainSizer.Add((5,5),0)
3605    str = ' Sample file: PWDR %s   Wavelength, A: %.5f  Energy, keV: %.3f  Polariz.: %.2f '%(dataFile[3:],wave,keV,polariz)
3606    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,WACV)
3607#    dataSizer = wx.BoxSizer(wx.HORIZONTAL)
3608#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Azimuth'),0,WACV)
3609#    azimVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Azimuth']))
3610#    azimVal.Bind(wx.EVT_TEXT_ENTER,OnAzimVal)       
3611#    azimVal.Bind(wx.EVT_KILL_FOCUS,OnAzimVal)
3612#    dataSizer.Add(azimVal,0)   
3613#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Polarization'),0,WACV)
3614#    polaVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Polariz.']))
3615#    polaVal.Bind(wx.EVT_TEXT_ENTER,OnPolaVal)       
3616#    polaVal.Bind(wx.EVT_KILL_FOCUS,OnPolaVal)
3617#    dataSizer.Add(polaVal,0)   
3618#    mainSizer.Add(dataSizer,0)
3619    mainSizer.Add((5,5),0)
3620    fileSizer = wx.FlexGridSizer(3,6,5,1)
3621    select = ['Sample Bkg.','Container']
3622    if data['Container']['Name']:
3623        select.append('Container Bkg.')
3624    for key in select:
3625        FillFileSizer(fileSizer,key)
3626    mainSizer.Add(fileSizer,0)
3627    mainSizer.Add((5,5),0)
3628    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,WACV)
3629    mainSizer.Add((5,5),0)   
3630
3631    ElList = data['ElList']
3632    Abs = G2lat.CellAbsorption(ElList,data['Form Vol'])
3633    Trans = G2pwd.Transmission(data['Geometry'],Abs*data['Pack'],data['Diam'])
3634    elemSizer = wx.FlexGridSizer(3,3,5,1)
3635    for El in ElList:
3636        FillElemSizer(elemSizer,ElList[El])
3637    mainSizer.Add(elemSizer,0)
3638    mainSizer.Add((5,5),0)   
3639    midSizer = wx.BoxSizer(wx.HORIZONTAL)
3640    midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,WACV)
3641    formVol = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Form Vol']))
3642    formVol.Bind(wx.EVT_TEXT_ENTER,OnFormVol)       
3643    formVol.Bind(wx.EVT_KILL_FOCUS,OnFormVol)
3644    midSizer.Add(formVol,0)
3645    midSizer.Add(wx.StaticText(G2frame.dataDisplay,
3646        label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
3647        0,WACV)
3648    mainSizer.Add(midSizer,0)
3649    mainSizer.Add((5,5),0)   
3650
3651    geoBox = wx.BoxSizer(wx.HORIZONTAL)
3652    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,WACV)
3653    choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
3654    geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
3655            style=wx.CB_READONLY|wx.CB_DROPDOWN)
3656    geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
3657    geoBox.Add(geometry,0)
3658    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,WACV)
3659    diam = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Diam']))
3660    diam.Bind(wx.EVT_TEXT_ENTER,OnDiameter)       
3661    diam.Bind(wx.EVT_KILL_FOCUS,OnDiameter)
3662#    diam.Bind(wx.EVT_SET_FOCUS,OnShowTip(G2frame,'tip')) #this doesn't work - what would????
3663    geoBox.Add(diam,0)
3664    mainSizer.Add(geoBox,0)
3665    mainSizer.Add((5,5),0)   
3666    geoBox = wx.BoxSizer(wx.HORIZONTAL)
3667    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,WACV)
3668    pack = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Pack']))
3669    pack.Bind(wx.EVT_TEXT_ENTER,OnPacking)       
3670    pack.Bind(wx.EVT_KILL_FOCUS,OnPacking)
3671    geoBox.Add(pack,0)
3672    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,WACV)   
3673    mainSizer.Add(geoBox,0)
3674    mainSizer.Add((5,5),0)   
3675       
3676    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,WACV)
3677    mainSizer.Add((5,5),0)
3678    sqBox = wx.BoxSizer(wx.HORIZONTAL)
3679    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,WACV)
3680    choice = ['Image plate','Point detector']
3681    detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
3682            style=wx.CB_READONLY|wx.CB_DROPDOWN)
3683    detType.Bind(wx.EVT_COMBOBOX, OnDetType)
3684    sqBox.Add(detType,0)
3685    if data['DetType'] == 'Image plate':
3686        sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,WACV)
3687        obliqCoeff = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['ObliqCoeff']))
3688        obliqCoeff.Bind(wx.EVT_TEXT_ENTER,OnObliqCoeff)       
3689        obliqCoeff.Bind(wx.EVT_KILL_FOCUS,OnObliqCoeff)
3690        sqBox.Add(obliqCoeff,0)
3691    mainSizer.Add(sqBox,0)
3692       
3693    sqBox = wx.BoxSizer(wx.HORIZONTAL)
3694    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,WACV)   
3695    rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
3696        value=int(1000*data['Ruland']))
3697    sqBox.Add(rulandSldr,1,wx.EXPAND)
3698    rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
3699    rulandWdt = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Ruland']))
3700    rulandWdt.Bind(wx.EVT_TEXT_ENTER,OnRulandWdt)       
3701    rulandWdt.Bind(wx.EVT_KILL_FOCUS,OnRulandWdt)
3702    sqBox.Add(rulandWdt,0,WACV)   
3703    mainSizer.Add(sqBox,0,wx.ALIGN_LEFT|wx.EXPAND)
3704   
3705    sqBox = wx.BoxSizer(wx.HORIZONTAL)
3706    lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
3707    lorch.SetValue(data['Lorch'])
3708    lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
3709    sqBox.Add(lorch,0,WACV)
3710    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling q-range: '),0,WACV)
3711    SQmin = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][0]))
3712    SQmin.Bind(wx.EVT_TEXT_ENTER,OnSQmin)       
3713    SQmin.Bind(wx.EVT_KILL_FOCUS,OnSQmin)   
3714    sqBox.Add(SQmin,0)
3715    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to '),0,WACV)
3716    SQmax = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][1]))
3717    SQmax.Bind(wx.EVT_TEXT_ENTER,OnSQmax)       
3718    SQmax.Bind(wx.EVT_KILL_FOCUS,OnSQmax)
3719    sqBox.Add(SQmax,0)
3720    resetQ = wx.CheckBox(parent=G2frame.dataDisplay,label='Reset?')
3721    sqBox.Add(resetQ,0)
3722    resetQ.Bind(wx.EVT_CHECKBOX, OnResetQ)
3723   
3724    mainSizer.Add(sqBox,0)
3725
3726    mainSizer.Layout()   
3727    G2frame.dataDisplay.SetSizer(mainSizer)
3728    Size = mainSizer.Fit(G2frame.dataFrame)
3729    G2frame.dataDisplay.SetSize(Size)
3730    G2frame.dataFrame.setSizePosLeft(Size)
3731   
Note: See TracBrowser for help on using the repository browser.