Changeset 2905


Ignore:
Timestamp:
Jul 4, 2017 12:11:29 PM (8 years ago)
Author:
toby
Message:

use GPXtree in place of PatternTree?

Location:
branch/2frame
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified branch/2frame/GSASIIIO.py

    r2900 r2905  
    154154
    155155    '''
    156     Npix,Imagefile,imagetag = G2frame.PatternTree.GetImageLoc(treeId)
     156    Npix,Imagefile,imagetag = G2frame.GPXtree.GetImageLoc(treeId)
    157157    if isinstance(Imagefile,list):
    158158        imagefile,imagetag = Imagefile
    … …  
    170170                print 'found image file '+os.path.join(G2frame.dirname,fil)
    171171                imagefile = os.path.join(G2frame.dirname,fil)
    172                 G2frame.PatternTree.UpdateImageLoc(treeId,imagefile)
     172                G2frame.GPXtree.UpdateImageLoc(treeId,imagefile)
    173173                return Npix,imagefile,imagetag
    174174            pth,enddir = os.path.split(pth)
    … …  
    178178        #      & GPX was  .../A/B/C/refs/fil.gpx but is now .../NEW/TEST/TEST1
    179179        #    will look for .../NEW/TEST/TEST1/imgs/ima.ge, .../NEW/TEST/imgs/ima.ge, .../NEW/imgs/ima.ge and so on
    180         Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     180        Controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    181181        gpxPath = Controls.get('LastSavedAs','').replace('\\','/').split('/') # blank in older .GPX files
    182182        imgPath = imagefile.replace('\\','/').split('/')
    … …  
    194194                print 'found image file '+os.path.join(pth,fil)
    195195                imagefile = os.path.join(pth,fil)
    196                 G2frame.PatternTree.UpdateImageLoc(treeId,imagefile)
     196                G2frame.GPXtree.UpdateImageLoc(treeId,imagefile)
    197197                return Npix,imagefile,imagetag
    198198            pth,enddir = os.path.split(pth)
    … …  
    209209            if dlg.ShowModal() == wx.ID_OK:
    210210                imagefile = dlg.GetPath()
    211                 G2frame.PatternTree.UpdateImageLoc(treeId,imagefile)
     211                G2frame.GPXtree.UpdateImageLoc(treeId,imagefile)
    212212            else:
    213213                imagefile = False
    … …  
    283283    ImageTag (where there is more than one image in the file), if defined.
    284284    '''
    285     ImgNames = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     285    ImgNames = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    286286    TreeLbl = 'IMG '+os.path.basename(imagefile)
    287287    ImageTag = Data.get('ImageTag')
    … …  
    292292        imageInfo = imagefile
    293293    TreeName = G2obj.MakeUniqueLabel(TreeLbl,ImgNames)
    294     Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=TreeName)
    295     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)
     294    Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text=TreeName)
     295    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Comments'),Comments)
    296296    Imax = np.amax(Image)
    297297    if G2frame.imageDefault:
    … …  
    340340    Data['setDefault'] = False
    341341    Data['range'] = [(0,Imax),[0,Imax]]
    342     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Image Controls'),Data)
     342    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Image Controls'),Data)
    343343    Masks = {'Points':[],'Rings':[],'Arcs':[],'Polygons':[],'Frames':[],'Thresholds':[(0,Imax),[0,Imax]]}
    344     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Masks'),Masks)
    345     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Stress/Strain'),
     344    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Masks'),Masks)
     345    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Stress/Strain'),
    346346        {'Type':'True','d-zero':[],'Sample phi':0.0,'Sample z':0.0,'Sample load':0.0})
    347     G2frame.PatternTree.SetItemPyData(Id,[Npix,imageInfo])
     347    G2frame.GPXtree.SetItemPyData(Id,[Npix,imageInfo])
    348348    G2frame.PickId = Id
    349349    G2frame.PickIdText = G2frame.GetTreeItemsList(G2frame.PickId)
    … …  
    496496
    497497def SaveMultipleImg(G2frame):
    498     if not G2frame.PatternTree.GetCount():
     498    if not G2frame.GPXtree.GetCount():
    499499        print 'no images!'
    500500        return
    501     choices = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     501    choices = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    502502    if len(choices) == 1:
    503503        names = choices
    … …  
    511511    if not names: return
    512512    for name in names:
    513         Id = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, name)
    514         Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(Id)
     513        Id = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, name)
     514        Npix,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(Id)
    515515        imroot = os.path.splitext(imagefile)[0]
    516516        if imagetag:
    517517            imroot += '_' + str(imagetag)
    518         Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Image Controls'))
     518        Data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Image Controls'))
    519519        print('Writing '+imroot+'.imctrl')
    520520        File = open(imroot+'.imctrl','w')
    … …  
    528528            File.write(key+':'+str(Data[key])+'\n')
    529529        File.close()
    530         mask = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Masks'))
     530        mask = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Masks'))
    531531        G2imG.CleanupMasks(mask)
    532532        print('Writing '+imroot+'.immask')
    … …  
    563563            datum = data[0]
    564564           
    565             Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=datum[0])
     565            Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text=datum[0])
    566566            if datum[0].startswith('PWDR'):               
    567567                if 'ranId' not in datum[1][0]: # patch: add random Id if not present
    568568                    datum[1][0]['ranId'] = ran.randint(0,sys.maxint)
    569                 G2frame.PatternTree.SetItemPyData(Id,datum[1][:3])  #temp. trim off junk (patch?)
     569                G2frame.GPXtree.SetItemPyData(Id,datum[1][:3])  #temp. trim off junk (patch?)
    570570            elif datum[0].startswith('HKLF'):
    571571                if 'ranId' not in datum[1][0]: # patch: add random Id if not present
    572572                    datum[1][0]['ranId'] = ran.randint(0,sys.maxint)
    573                 G2frame.PatternTree.SetItemPyData(Id,datum[1])
     573                G2frame.GPXtree.SetItemPyData(Id,datum[1])
    574574            else:
    575                 G2frame.PatternTree.SetItemPyData(Id,datum[1])             
     575                G2frame.GPXtree.SetItemPyData(Id,datum[1])             
    576576                if datum[0] == 'Controls' and 'LastSavedUsing' in datum[1]:
    577577                    LastSavedUsing = datum[1]['LastSavedUsing']
    … …  
    592592                    continue
    593593#end PDF cleanup
    594                 sub = G2frame.PatternTree.AppendItem(Id,datus[0])
     594                sub = G2frame.GPXtree.AppendItem(Id,datus[0])
    595595#patch
    596596                if datus[0] == 'Instrument Parameters' and len(datus[1]) == 1:
    … …  
    602602                        datus[1][0][item] = list(datus[1][0][item])
    603603#end patch
    604                 G2frame.PatternTree.SetItemPyData(sub,datus[1])
     604                G2frame.GPXtree.SetItemPyData(sub,datus[1])
    605605            if 'PDF ' in datum[0][:4] and oldPDF:
    606                 sub = G2frame.PatternTree.AppendItem(Id,'PDF Peaks')
    607                 G2frame.PatternTree.SetItemPyData(sub,{'Limits':[1.,5.],'Background':[2,[0.,-0.2*np.pi],False],'Peaks':[]})
     606                sub = G2frame.GPXtree.AppendItem(Id,'PDF Peaks')
     607                G2frame.GPXtree.SetItemPyData(sub,{'Limits':[1.,5.],'Background':[2,[0.,-0.2*np.pi],False],'Peaks':[]})
    608608            if datum[0].startswith('IMG'):                   #retrieve image default flag & data if set
    609                 Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
     609                Data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls'))
    610610                if Data['setDefault']:
    611611                    G2frame.imageDefault = Data               
    … …  
    627627def ProjFileSave(G2frame):
    628628    'Save a GSAS-II project file'
    629     if not G2frame.PatternTree.IsEmpty():
     629    if not G2frame.GPXtree.IsEmpty():
    630630        file = open(G2frame.GSASprojectfile,'wb')
    631631        print 'save to file: ',G2frame.GSASprojectfile
    … …  
    633633        # (Controls should always be created at this point)
    634634        try:
    635             Controls = G2frame.PatternTree.GetItemPyData(
    636                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     635            Controls = G2frame.GPXtree.GetItemPyData(
     636                G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    637637            Controls['LastSavedAs'] = os.path.abspath(G2frame.GSASprojectfile)
    638638            Controls['LastSavedUsing'] = str(GSASIIpath.GetVersionNumber())
    … …  
    642642        wx.BeginBusyCursor()
    643643        try:
    644             item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     644            item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    645645            while item:
    646646                data = []
    647                 name = G2frame.PatternTree.GetItemText(item)
    648                 data.append([name,G2frame.PatternTree.GetItemPyData(item)])
    649                 item2, cookie2 = G2frame.PatternTree.GetFirstChild(item)
     647                name = G2frame.GPXtree.GetItemText(item)
     648                data.append([name,G2frame.GPXtree.GetItemPyData(item)])
     649                item2, cookie2 = G2frame.GPXtree.GetFirstChild(item)
    650650                while item2:
    651                     name = G2frame.PatternTree.GetItemText(item2)
    652                     data.append([name,G2frame.PatternTree.GetItemPyData(item2)])
    653                     item2, cookie2 = G2frame.PatternTree.GetNextChild(item, cookie2)                           
    654                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                           
     651                    name = G2frame.GPXtree.GetItemText(item2)
     652                    data.append([name,G2frame.GPXtree.GetItemPyData(item2)])
     653                    item2, cookie2 = G2frame.GPXtree.GetNextChild(item, cookie2)                           
     654                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)                           
    655655                cPickle.dump(data,file,1)
    656656            file.close()
    … …  
    667667    X = G2frame.Integrate[2][:-1]
    668668    N = len(X)
    669     Id = G2frame.PatternTree.GetItemParent(PickId)
    670     name = G2frame.PatternTree.GetItemText(Id)
     669    Id = G2frame.GPXtree.GetItemParent(PickId)
     670    name = G2frame.GPXtree.GetItemText(Id)
    671671    name = name.replace('IMG ',data['type']+' ')
    672     Comments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Comments'))
     672    Comments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Comments'))
    673673    if 'PWDR' in name:
    674674        names = ['Type','Lam','Zero','Polariz.','U','V','W','X','Y','SH/L','Azimuth']
    … …  
    693693    for i,azm in enumerate(azms[:-1]):
    694694        Aname = name+" Azm= %.2f"%((azm+dazm)%360.)
    695         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     695        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    696696        # if Overwrite delete any duplicate
    697         if Overwrite and G2gd.GetPatternTreeItemId(G2frame,G2frame.root,Aname):
     697        if Overwrite and G2gd.GetGPXtreeItemId(G2frame,G2frame.root,Aname):
    698698            print('Replacing '+Aname)
    699             item = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,Aname)
    700             G2frame.PatternTree.Delete(item)
     699            item = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,Aname)
     700            G2frame.GPXtree.Delete(item)
    701701        else:
    702702            nOcc = 0
    703703            while item:
    704                 Name = G2frame.PatternTree.GetItemText(item)
     704                Name = G2frame.GPXtree.GetItemText(item)
    705705                if Aname in Name:
    706706                    nOcc += 1
    707                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     707                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    708708            if nOcc:
    709709                Aname += '(%d)'%(nOcc)
    … …  
    730730        Ymax = np.max(Y)
    731731        W = np.where(Y>0.,1./Y,1.e-6)                    #probably not true
    732         Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=Aname)
     732        Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text=Aname)
    733733        G2frame.IntgOutList.append(Id)
    734         G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)                   
    735         G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
     734        G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Comments'),Comments)                   
     735        G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
    736736        if 'PWDR' in Aname:
    737             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Background'),[['chebyschev',1,3,1.0,0.0,0.0],
     737            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Background'),[['chebyschev',1,3,1.0,0.0,0.0],
    738738                {'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
    739739        inst = [dict(zip(names,zip(parms,parms,codes))),{}]
    740740        for item in inst[0]:
    741741            inst[0][item] = list(inst[0][item])
    742         G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),inst)
     742        G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Instrument Parameters'),inst)
    743743        if 'PWDR' in Aname:
    744             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
    745             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Peak List'),{'sigDict':{},'peaks':[]})
    746             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Index Peak List'),[[],[]])
    747             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Unit Cells List'),[])
    748             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Reflection Lists'),{})
     744            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Sample Parameters'),Sample)
     745            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Peak List'),{'sigDict':{},'peaks':[]})
     746            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Index Peak List'),[[],[]])
     747            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Unit Cells List'),[])
     748            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Reflection Lists'),{})
    749749        elif 'SASD' in Aname:             
    750             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
    751             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
    752             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Models'),G2pdG.SetDefaultSASDModel())
     750            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
     751            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Sample Parameters'),Sample)
     752            G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='Models'),G2pdG.SetDefaultSASDModel())
    753753        valuesdict = {
    754754            'wtFactor':1.0,
    … …  
    758758            'qPlot':False,'dPlot':False,'sqrtPlot':False,'Yminmax':[Ymin,Ymax]
    759759            }
    760         G2frame.PatternTree.SetItemPyData(
     760        G2frame.GPXtree.SetItemPyData(
    761761            Id,[valuesdict,
    762762                [np.array(X),np.array(Y),np.array(W),np.zeros(N),np.zeros(N),np.zeros(N)]])
    … …  
    795795    import scipy.interpolate as scintp
    796796    for export in exports:
    797         PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
    798         PDFControls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame, PickId,'PDF Controls'))
     797        PickId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, export)
     798        PDFControls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame, PickId,'PDF Controls'))
    799799        if PDFsaves[0]:     #I(Q)
    800800            iqfilename = ospath.join(G2frame.dirname,export.replace(' ','_')[5:]+'.iq')
    … …  
    854854       
    855855        if PDFsaves[4]: #pdfGUI file for G(R)
    856             pId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, 'PWDR'+export[4:])
    857             Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame, pId,'Instrument Parameters'))[0]
    858             Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame, pId,'Limits'))
     856            pId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, 'PWDR'+export[4:])
     857            Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame, pId,'Instrument Parameters'))[0]
     858            Limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame, pId,'Limits'))
    859859            grfilename = ospath.join(G2frame.dirname,export.replace(' ','_')[5:]+'.gr')
    860860            grdata = PDFControls['G(R)'][1]
    … …  
    14641464        consDict = {}
    14651465        Histograms,Phases = self.G2frame.GetUsedHistogramsAndPhasesfromTree()
    1466         if self.G2frame.PatternTree.IsEmpty(): return # nothing to do
    1467         item, cookie = self.G2frame.PatternTree.GetFirstChild(self.G2frame.root)
     1466        if self.G2frame.GPXtree.IsEmpty(): return # nothing to do
     1467        item, cookie = self.G2frame.GPXtree.GetFirstChild(self.G2frame.root)
    14681468        while item:
    1469             name = self.G2frame.PatternTree.GetItemText(item)
     1469            name = self.G2frame.GPXtree.GetItemText(item)
    14701470            if name == 'Rigid bodies':
    1471                  rigidbodyDict = self.G2frame.PatternTree.GetItemPyData(item)
     1471                 rigidbodyDict = self.G2frame.GPXtree.GetItemPyData(item)
    14721472            elif name == 'Covariance':
    1473                  covDict = self.G2frame.PatternTree.GetItemPyData(item)
     1473                 covDict = self.G2frame.GPXtree.GetItemPyData(item)
    14741474            elif name == 'Constraints':
    1475                  consDict = self.G2frame.PatternTree.GetItemPyData(item)
    1476             item, cookie = self.G2frame.PatternTree.GetNextChild(self.G2frame.root, cookie)
     1475                 consDict = self.G2frame.GPXtree.GetItemPyData(item)
     1476            item, cookie = self.G2frame.GPXtree.GetNextChild(self.G2frame.root, cookie)
    14771477        rbVary,rbDict =  G2stIO.GetRigidBodyModels(rigidbodyDict,Print=False)
    14781478        self.parmDict.update(rbDict)
    … …  
    15441544        self.SeqRefdata = None
    15451545        self.SeqRefhist = None
    1546         if self.G2frame.PatternTree.IsEmpty(): return # nothing to do
     1546        if self.G2frame.GPXtree.IsEmpty(): return # nothing to do
    15471547        histType = None       
    15481548        if self.currentExportType == 'phase':
    15491549            # if exporting phases load them here
    1550             sub = G2gd.GetPatternTreeItemId(self.G2frame,self.G2frame.root,'Phases')
     1550            sub = G2gd.GetGPXtreeItemId(self.G2frame,self.G2frame.root,'Phases')
    15511551            if not sub:
    15521552                print 'no phases found'
    15531553                return True
    1554             item, cookie = self.G2frame.PatternTree.GetFirstChild(sub)
     1554            item, cookie = self.G2frame.GPXtree.GetFirstChild(sub)
    15551555            while item:
    1556                 phaseName = self.G2frame.PatternTree.GetItemText(item)
    1557                 self.Phases[phaseName] =  self.G2frame.PatternTree.GetItemPyData(item)
    1558                 item, cookie = self.G2frame.PatternTree.GetNextChild(sub, cookie)
     1556                phaseName = self.G2frame.GPXtree.GetItemText(item)
     1557                self.Phases[phaseName] =  self.G2frame.GPXtree.GetItemPyData(item)
     1558                item, cookie = self.G2frame.GPXtree.GetNextChild(sub, cookie)
    15591559            return
    15601560        elif self.currentExportType == 'single':
    … …  
    15661566
    15671567        if histType: # Loading just one kind of tree entry
    1568             item, cookie = self.G2frame.PatternTree.GetFirstChild(self.G2frame.root)
     1568            item, cookie = self.G2frame.GPXtree.GetFirstChild(self.G2frame.root)
    15691569            while item:
    1570                 name = self.G2frame.PatternTree.GetItemText(item)
     1570                name = self.G2frame.GPXtree.GetItemText(item)
    15711571                if name.startswith(histType):
    15721572                    if self.Histograms.get(name): # there is already an item with this name
    … …  
    15821582                    # element contains refinement results, carry
    15831583                    # that over too now.
    1584                     self.Histograms[name]['Data'] = self.G2frame.PatternTree.GetItemPyData(item)[1]
    1585                     self.Histograms[name][0] = self.G2frame.PatternTree.GetItemPyData(item)[0]
    1586                     item2, cookie2 = self.G2frame.PatternTree.GetFirstChild(item)
     1584                    self.Histograms[name]['Data'] = self.G2frame.GPXtree.GetItemPyData(item)[1]
     1585                    self.Histograms[name][0] = self.G2frame.GPXtree.GetItemPyData(item)[0]
     1586                    item2, cookie2 = self.G2frame.GPXtree.GetFirstChild(item)
    15871587                    while item2:
    1588                         child = self.G2frame.PatternTree.GetItemText(item2)
    1589                         self.Histograms[name][child] = self.G2frame.PatternTree.GetItemPyData(item2)
    1590                         item2, cookie2 = self.G2frame.PatternTree.GetNextChild(item, cookie2)
    1591                 item, cookie = self.G2frame.PatternTree.GetNextChild(self.G2frame.root, cookie)
     1588                        child = self.G2frame.GPXtree.GetItemText(item2)
     1589                        self.Histograms[name][child] = self.G2frame.GPXtree.GetItemPyData(item2)
     1590                        item2, cookie2 = self.G2frame.GPXtree.GetNextChild(item, cookie2)
     1591                item, cookie = self.G2frame.GPXtree.GetNextChild(self.G2frame.root, cookie)
    15921592            # index powder and single crystal histograms by number
    15931593            for hist in self.Histograms:
    … …  
    16071607        # else standard load: using all interlinked phases and histograms
    16081608        self.Histograms,self.Phases = self.G2frame.GetUsedHistogramsAndPhasesfromTree()
    1609         item, cookie = self.G2frame.PatternTree.GetFirstChild(self.G2frame.root)
     1609        item, cookie = self.G2frame.GPXtree.GetFirstChild(self.G2frame.root)
    16101610        while item:
    1611             name = self.G2frame.PatternTree.GetItemText(item)
    1612             item2, cookie2 = self.G2frame.PatternTree.GetFirstChild(item)
     1611            name = self.G2frame.GPXtree.GetItemText(item)
     1612            item2, cookie2 = self.G2frame.GPXtree.GetFirstChild(item)
    16131613            if not item2:
    1614                 self.OverallParms[name] = self.G2frame.PatternTree.GetItemPyData(item)
    1615             item, cookie = self.G2frame.PatternTree.GetNextChild(self.G2frame.root, cookie)
     1614                self.OverallParms[name] = self.G2frame.GPXtree.GetItemPyData(item)
     1615            item, cookie = self.G2frame.GPXtree.GetNextChild(self.G2frame.root, cookie)
    16161616        # index powder and single crystal histograms
    16171617        for hist in self.Histograms:

  • TabularUnified branch/2frame/GSASIIconstrGUI.py

    r2900 r2905  
    224224            print str(key) + ': '+str(j)+' variable(s) as strings converted to objects'
    225225    ##################################################################################
    226     rigidbodyDict = G2frame.PatternTree.GetItemPyData(
    227         G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     226    rigidbodyDict = G2frame.GPXtree.GetItemPyData(
     227        G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    228228    rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
    229229    rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,Print=False)
    … …  
    12071207    oAcof = G2lat.cell2A(oldPhase['General']['Cell'][1:7])
    12081208    nAcof = G2lat.cell2A(newPhase['General']['Cell'][1:7])
    1209     item = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Constraints')
    1210     constraints = G2frame.PatternTree.GetItemPyData(item)
     1209    item = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
     1210    constraints = G2frame.GPXtree.GetItemPyData(item)
    12111211#    GSASIIpath.IPyBreak()
    12121212    parmDict = {}

  • TabularUnified branch/2frame/GSASIIctrlGUI.py

    r2900 r2905  
    15881588    # SelectEdit1Var execution begins here
    15891589    saveArray = copy.deepcopy(array) # keep original values
    1590     TreeItemType = G2frame.PatternTree.GetItemText(G2frame.PickId)
     1590    TreeItemType = G2frame.GPXtree.GetItemText(G2frame.PickId)
    15911591    copyopts = {'InTable':False,"startvalue":None,'currentsel':None}       
    1592     hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1592    hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    15931593    histList = G2pdG.GetHistsLikeSelected(G2frame)
    15941594    if not histList:
    … …  
    16681668    else:
    16691669        refdictlst = None
    1670     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hst)
    1671     hstData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
     1670    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hst)
     1671    hstData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))[0]
    16721672    for h in copyList:
    1673         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,h)
    1674         instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
     1673        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,h)
     1674        instData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))[0]
    16751675        if len(hstData) != len(instData) or hstData['Type'][0] != instData['Type'][0]:  #don't mix data types or lam & lam1/lam2 parms!
    16761676            print h+' not copied - instrument parameters not commensurate'
    16771677            continue
    1678         hData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,TreeItemType))
     1678        hData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,TreeItemType))
    16791679        if TreeItemType == 'Instrument Parameters':
    16801680            hData = hData[0]

  • TabularUnified branch/2frame/GSASIIdataGUI.py

    r2900 r2905  
    744744        contents of the Controls 'Seq Data' item (if present)
    745745        '''
    746         controls = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,self.root, 'Controls'))
     746        controls = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,self.root, 'Controls'))
    747747        if controls.get('Seq Data'):
    748748            for i in self.SeqRefine: i.Enable(True)
    … …  
    10701070            newPhaseList.append(PhaseName)
    10711071            print(u'Read phase {} from file {}'.format(PhaseName,self.lastimport))
    1072             if not GetPatternTreeItemId(self,self.root,'Phases'):
    1073                 sub = self.PatternTree.AppendItem(parent=self.root,text='Phases')
     1072            if not GetGPXtreeItemId(self,self.root,'Phases'):
     1073                sub = self.GPXtree.AppendItem(parent=self.root,text='Phases')
    10741074            else:
    1075                 sub = GetPatternTreeItemId(self,self.root,'Phases')
    1076             psub = self.PatternTree.AppendItem(parent=sub,text=PhaseName)
    1077             self.PatternTree.SetItemPyData(psub,rd.Phase)
    1078             self.PatternTree.Expand(self.root) # make sure phases are seen
    1079             self.PatternTree.Expand(sub)
    1080             self.PatternTree.Expand(psub)
     1075                sub = GetGPXtreeItemId(self,self.root,'Phases')
     1076            psub = self.GPXtree.AppendItem(parent=sub,text=PhaseName)
     1077            self.GPXtree.SetItemPyData(psub,rd.Phase)
     1078            self.GPXtree.Expand(self.root) # make sure phases are seen
     1079            self.GPXtree.Expand(sub)
     1080            self.GPXtree.Expand(psub)
    10811081            wx.CallAfter(SelectDataTreeItem,self,psub) #bring up new phase General tab
    10821082
    10831083            if rd.Constraints:
    1084                 sub = GetPatternTreeItemId(self,self.root,'Constraints') # was created in CheckNotebook if needed
    1085                 Constraints = self.PatternTree.GetItemPyData(sub)               
     1084                sub = GetGPXtreeItemId(self,self.root,'Constraints') # was created in CheckNotebook if needed
     1085                Constraints = self.GPXtree.GetItemPyData(sub)               
    10861086                # TODO: make sure that NEWVAR names are unique here?
    10871087                for i in rd.Constraints:
    … …  
    10961096        PWDRlist = []
    10971097        HKLFlist = []
    1098         if self.PatternTree.GetCount():
    1099             item, cookie = self.PatternTree.GetFirstChild(self.root)
     1098        if self.GPXtree.GetCount():
     1099            item, cookie = self.GPXtree.GetFirstChild(self.root)
    11001100            while item:
    1101                 name = self.PatternTree.GetItemText(item)
     1101                name = self.GPXtree.GetItemText(item)
    11021102                if name.startswith('PWDR ') and name not in PWDRlist:
    11031103                    PWDRlist.append(name)
    11041104                if name.startswith('HKLF ') and name not in HKLFlist:
    11051105                    HKLFlist.append(name)
    1106                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     1106                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    11071107        TextList = PWDRlist + HKLFlist
    11081108        if not TextList:
    … …  
    11311131                notOK = False
    11321132        # connect new phases to histograms
    1133         sub = GetPatternTreeItemId(self,self.root,'Phases')
     1133        sub = GetGPXtreeItemId(self,self.root,'Phases')
    11341134        if not sub:
    11351135            raise Exception('ERROR -- why are there no phases here?')
    11361136        wx.BeginBusyCursor()
    1137         item, cookie = self.PatternTree.GetFirstChild(sub)
     1137        item, cookie = self.GPXtree.GetFirstChild(sub)
    11381138        while item: # loop over (new) phases
    1139             phaseName = self.PatternTree.GetItemText(item)
    1140             data = self.PatternTree.GetItemPyData(item)
    1141             item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     1139            phaseName = self.GPXtree.GetItemText(item)
     1140            data = self.GPXtree.GetItemPyData(item)
     1141            item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    11421142            if phaseName not in newPhaseList: continue
    11431143            generalData = data['General']
    … …  
    11541154                if histoName in HKLFlist:
    11551155                    #redo UpdateHKLFdata(histoName) here:
    1156                     Id = GetPatternTreeItemId(self,self.root,histoName)
    1157                     refDict,reflData = self.PatternTree.GetItemPyData(Id)
     1156                    Id = GetGPXtreeItemId(self,self.root,histoName)
     1157                    refDict,reflData = self.GPXtree.GetItemPyData(Id)
    11581158                    G,g = G2lat.cell2Gmat(generalData['Cell'][1:7])
    11591159                    Super = reflData.get('Super',0)
    … …  
    11761176                    UseList[histoName] = SetDefaultDData(reflData['Type'],histoName)
    11771177                elif histoName in PWDRlist:
    1178                     Id = GetPatternTreeItemId(self,self.root,histoName)
    1179                     refList = self.PatternTree.GetItemPyData(
    1180                         GetPatternTreeItemId(self,Id,'Reflection Lists'))
     1178                    Id = GetGPXtreeItemId(self,self.root,histoName)
     1179                    refList = self.GPXtree.GetItemPyData(
     1180                        GetGPXtreeItemId(self,Id,'Reflection Lists'))
    11811181                    refList[generalData['Name']] = {}
    11821182                    UseList[histoName] = SetDefaultDData('PWDR',histoName,NShkl=NShkl,NDij=NDij)
    … …  
    12191219            'image',multiple=True,Preview=False,load2Tree=True)
    12201220        if rdlist:
    1221             self.PatternTree.SelectItem(GetPatternTreeItemId(self,self.Image,'Image Controls'))             #show last image to have beeen read
     1221            self.GPXtree.SelectItem(GetGPXtreeItemId(self,self.Image,'Image Controls'))             #show last image to have beeen read
    12221222                   
    12231223    def _Add_ImportMenu_Sfact(self,parent):
    … …  
    12481248        # get a list of existing histograms
    12491249        HKLFlist = []
    1250         if self.PatternTree.GetCount():
    1251             item, cookie = self.PatternTree.GetFirstChild(self.root)
     1250        if self.GPXtree.GetCount():
     1251            item, cookie = self.GPXtree.GetFirstChild(self.root)
    12521252            while item:
    1253                 name = self.PatternTree.GetItemText(item)
     1253                name = self.GPXtree.GetItemText(item)
    12541254                if name.startswith('HKLF ') and name not in HKLFlist:
    12551255                    HKLFlist.append(name)
    1256                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     1256                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    12571257        # look up which format was requested
    12581258        reqrdr = self.ImportMenuId.get(event.GetId())
    … …  
    12801280                    HistName = G2obj.MakeUniqueLabel(HistName,HKLFlist)
    12811281                    print 'Read structure factor table '+HistName+' from file '+self.lastimport
    1282                     Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     1282                    Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
    12831283                    if not Bank['RefDict'].get('FF'):
    12841284                        Bank['RefDict']['FF'] = {}
    1285                     self.PatternTree.SetItemPyData(Id,[valuesdict,Bank['RefDict']])
    1286                     Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
    1287                     self.PatternTree.SetItemPyData(Sub,copy.copy(rd.Parameters))
    1288                     self.PatternTree.SetItemPyData(
    1289                         self.PatternTree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
     1285                    self.GPXtree.SetItemPyData(Id,[valuesdict,Bank['RefDict']])
     1286                    Sub = self.GPXtree.AppendItem(Id,text='Instrument Parameters')
     1287                    self.GPXtree.SetItemPyData(Sub,copy.copy(rd.Parameters))
     1288                    self.GPXtree.SetItemPyData(
     1289                        self.GPXtree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
    12901290                    newHistList.append(HistName)
    12911291            else:
    … …  
    12951295                if not rd.RefDict.get('FF'):
    12961296                    rd.RefDict['FF'] = {}
    1297                 Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
    1298                 self.PatternTree.SetItemPyData(Id,[valuesdict,rd.RefDict])
    1299                 Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
    1300                 self.PatternTree.SetItemPyData(Sub,rd.Parameters)
    1301                 self.PatternTree.SetItemPyData(
    1302                     self.PatternTree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
     1297                Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
     1298                self.GPXtree.SetItemPyData(Id,[valuesdict,rd.RefDict])
     1299                Sub = self.GPXtree.AppendItem(Id,text='Instrument Parameters')
     1300                self.GPXtree.SetItemPyData(Sub,rd.Parameters)
     1301                self.GPXtree.SetItemPyData(
     1302                    self.GPXtree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
    13031303                newHistList.append(HistName)
    13041304               
    1305             self.PatternTree.SelectItem(Id)
    1306             self.PatternTree.Expand(Id)
     1305            self.GPXtree.SelectItem(Id)
     1306            self.GPXtree.Expand(Id)
    13071307            self.Sngl = True
    13081308
    … …  
    13181318        if not result: return
    13191319        # connect new phases to histograms
    1320         sub = GetPatternTreeItemId(self,self.root,'Phases')
     1320        sub = GetGPXtreeItemId(self,self.root,'Phases')
    13211321        if not sub:
    13221322            raise Exception('ERROR -- why are there no phases here?')
    13231323        wx.BeginBusyCursor()
    1324         item, cookie = self.PatternTree.GetFirstChild(sub)
     1324        item, cookie = self.GPXtree.GetFirstChild(sub)
    13251325        iph = -1
    13261326        while item: # loop over (new) phases
    13271327            iph += 1
    1328             data = self.PatternTree.GetItemPyData(item)
    1329             item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     1328            data = self.GPXtree.GetItemPyData(item)
     1329            item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    13301330            if iph not in result: continue
    13311331            generalData = data['General']
    … …  
    13381338            for histoName in newHistList:
    13391339                #redo UpdateHKLFdata(histoName) here:
    1340                 Id = GetPatternTreeItemId(self,self.root,histoName)
    1341                 refDict,reflData = self.PatternTree.GetItemPyData(Id)
     1340                Id = GetGPXtreeItemId(self,self.root,histoName)
     1341                refDict,reflData = self.GPXtree.GetItemPyData(Id)
    13421342                UseList[histoName] = SetDefaultDData(reflData['Type'],histoName)
    13431343                G,g = G2lat.cell2Gmat(generalData['Cell'][1:7])
    … …  
    18841884        haveData = False
    18851885        # check for phases connected to histograms
    1886         sub = GetPatternTreeItemId(self,self.root,'Phases')
     1886        sub = GetGPXtreeItemId(self,self.root,'Phases')
    18871887        if not sub: return
    1888         item, cookie = self.PatternTree.GetFirstChild(sub)
     1888        item, cookie = self.GPXtree.GetFirstChild(sub)
    18891889        while item: # loop over phases
    1890             data = self.PatternTree.GetItemPyData(item)
    1891             item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     1890            data = self.GPXtree.GetItemPyData(item)
     1891            item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    18921892            UseList = data['Histograms']
    18931893            if UseList: haveData = True
    … …  
    19121912        # get a list of existing histograms
    19131913        PWDRlist = []
    1914         if self.PatternTree.GetCount():
    1915             item, cookie = self.PatternTree.GetFirstChild(self.root)
     1914        if self.GPXtree.GetCount():
     1915            item, cookie = self.GPXtree.GetFirstChild(self.root)
    19161916            while item:
    1917                 name = self.PatternTree.GetItemText(item)
     1917                name = self.GPXtree.GetItemText(item)
    19181918                if name.startswith('PWDR ') and name not in PWDRlist:
    19191919                    PWDRlist.append(name)
    1920                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     1920                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    19211921        # look up which format was requested
    19221922        reqrdr = self.ImportMenuId.get(event.GetId()) 
    … …  
    19681968                '). Inst parameters from '+rd.instmsg)
    19691969            # data are read, now store them in the tree
    1970             Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     1970            Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
    19711971            if 'T' in Iparm1['Type'][0]:
    19721972                if not rd.clockWd and rd.GSAS:
    … …  
    20182018                    del Iparm1['CorrectionCode']
    20192019            rd.Sample['ranId'] = valuesdict['ranId'] # this should be removed someday
    2020             self.PatternTree.SetItemPyData(Id,[valuesdict,rd.powderdata])
    2021             self.PatternTree.SetItemPyData(
    2022                 self.PatternTree.AppendItem(Id,text='Comments'),
     2020            self.GPXtree.SetItemPyData(Id,[valuesdict,rd.powderdata])
     2021            self.GPXtree.SetItemPyData(
     2022                self.GPXtree.AppendItem(Id,text='Comments'),
    20232023                rd.comments)
    20242024            Tmin = min(rd.powderdata[0])
    … …  
    20272027            if 'NT' in Iparm1['Type'][0] and G2lat.Pos2dsp(Iparm1,Tmin) < 0.4:               
    20282028                Tmin1 = G2lat.Dsp2pos(Iparm1,0.4)
    2029             self.PatternTree.SetItemPyData(
    2030                 self.PatternTree.AppendItem(Id,text='Limits'),
     2029            self.GPXtree.SetItemPyData(
     2030                self.GPXtree.AppendItem(Id,text='Limits'),
    20312031                rd.pwdparms.get('Limits',[(Tmin,Tmax),[Tmin1,Tmax]])
    20322032                )
    2033             self.PatternId = GetPatternTreeItemId(self,Id,'Limits')
    2034             self.PatternTree.SetItemPyData(
    2035                 self.PatternTree.AppendItem(Id,text='Background'),
     2033            self.PatternId = GetGPXtreeItemId(self,Id,'Limits')
     2034            self.GPXtree.SetItemPyData(
     2035                self.GPXtree.AppendItem(Id,text='Background'),
    20362036                rd.pwdparms.get('Background',
    20372037                    [['chebyschev',True,3,1.0,0.0,0.0],{'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
    20382038                    )
    2039             self.PatternTree.SetItemPyData(
    2040                 self.PatternTree.AppendItem(Id,text='Instrument Parameters'),
     2039            self.GPXtree.SetItemPyData(
     2040                self.GPXtree.AppendItem(Id,text='Instrument Parameters'),
    20412041                [Iparm1,Iparm2])
    2042             self.PatternTree.SetItemPyData(
    2043                 self.PatternTree.AppendItem(Id,text='Sample Parameters'),
     2042            self.GPXtree.SetItemPyData(
     2043                self.GPXtree.AppendItem(Id,text='Sample Parameters'),
    20442044                rd.Sample)
    2045             self.PatternTree.SetItemPyData(
    2046                 self.PatternTree.AppendItem(Id,text='Peak List')
     2045            self.GPXtree.SetItemPyData(
     2046                self.GPXtree.AppendItem(Id,text='Peak List')
    20472047                ,{'peaks':[],'sigDict':{}})
    2048             self.PatternTree.SetItemPyData(
    2049                 self.PatternTree.AppendItem(Id,text='Index Peak List'),
     2048            self.GPXtree.SetItemPyData(
     2049                self.GPXtree.AppendItem(Id,text='Index Peak List'),
    20502050                [[],[]])
    2051             self.PatternTree.SetItemPyData(
    2052                 self.PatternTree.AppendItem(Id,text='Unit Cells List'),
     2051            self.GPXtree.SetItemPyData(
     2052                self.GPXtree.AppendItem(Id,text='Unit Cells List'),
    20532053                [])
    2054             self.PatternTree.SetItemPyData(
    2055                 self.PatternTree.AppendItem(Id,text='Reflection Lists'),
     2054            self.GPXtree.SetItemPyData(
     2055                self.GPXtree.AppendItem(Id,text='Reflection Lists'),
    20562056                {})
    20572057            # if any Control values have been set, move them into tree
    2058             Controls = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,self.root, 'Controls'))
     2058            Controls = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,self.root, 'Controls'))
    20592059            Controls.update(rd.Controls)
    20602060            newHistList.append(HistName)
    … …  
    20632063            self.EnablePlot = True
    20642064            if Id:
    2065                 self.PatternTree.Expand(Id)
    2066                 self.PatternTree.SelectItem(Id)
     2065                self.GPXtree.Expand(Id)
     2066                self.GPXtree.SelectItem(Id)
    20672067
    20682068        if not newHistList: return # somehow, no new histograms
    … …  
    20782078        if not result: return
    20792079        # connect new phases to histograms
    2080         sub = GetPatternTreeItemId(self,self.root,'Phases')
     2080        sub = GetGPXtreeItemId(self,self.root,'Phases')
    20812081        if not sub:
    20822082            raise Exception('ERROR -- why are there no phases here?')
    2083         item, cookie = self.PatternTree.GetFirstChild(sub)
     2083        item, cookie = self.GPXtree.GetFirstChild(sub)
    20842084        iph = -1
    20852085        while item: # loop over (new) phases
    20862086            iph += 1
    2087             data = self.PatternTree.GetItemPyData(item)
    2088             item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     2087            data = self.GPXtree.GetItemPyData(item)
     2088            item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    20892089            if iph not in result: continue
    20902090            generalData = data['General']
    … …  
    20952095            for histoName in newHistList:
    20962096                UseList[histoName] = SetDefaultDData('PWDR',histoName,NShkl=NShkl,NDij=NDij)
    2097                 Id = GetPatternTreeItemId(self,self.root,histoName)
    2098                 refList = self.PatternTree.GetItemPyData(
    2099                     GetPatternTreeItemId(self,Id,'Reflection Lists'))
     2097                Id = GetGPXtreeItemId(self,self.root,histoName)
     2098                refList = self.GPXtree.GetItemPyData(
     2099                    GetGPXtreeItemId(self,Id,'Reflection Lists'))
    21002100                refList[generalData['Name']] = []
    21012101        self.EnableRefineCommand()
    … …  
    21102110        # get a list of existing histograms
    21112111        PWDRlist = []
    2112         if self.PatternTree.GetCount():
    2113             item, cookie = self.PatternTree.GetFirstChild(self.root)
     2112        if self.GPXtree.GetCount():
     2113            item, cookie = self.GPXtree.GetFirstChild(self.root)
    21142114            while item:
    2115                 name = self.PatternTree.GetItemText(item)
     2115                name = self.GPXtree.GetItemText(item)
    21162116                if name.startswith('PWDR ') and name not in PWDRlist:
    21172117                    PWDRlist.append(name)
    2118                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     2118                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    21192119        # Initialize a base class reader
    21202120        rd = G2obj.ImportPowderData(
    … …  
    21912191        HistName = 'PWDR '+HistName
    21922192        HistName = G2obj.MakeUniqueLabel(HistName,PWDRlist)  # make new histogram names unique
    2193         Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     2193        Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
    21942194        Ymin = np.min(rd.powderdata[1])
    21952195        Ymax = np.max(rd.powderdata[1])
    … …  
    22012201            'qPlot':False,'dPlot':False,'sqrtPlot':False,'Yminmax':[Ymin,Ymax]
    22022202            }
    2203         self.PatternTree.SetItemPyData(Id,[valuesdict,rd.powderdata])
    2204         self.PatternTree.SetItemPyData(
    2205             self.PatternTree.AppendItem(Id,text='Comments'),
     2203        self.GPXtree.SetItemPyData(Id,[valuesdict,rd.powderdata])
     2204        self.GPXtree.SetItemPyData(
     2205            self.GPXtree.AppendItem(Id,text='Comments'),
    22062206            rd.comments)
    2207         self.PatternTree.SetItemPyData(
    2208             self.PatternTree.AppendItem(Id,text='Limits'),
     2207        self.GPXtree.SetItemPyData(
     2208            self.GPXtree.AppendItem(Id,text='Limits'),
    22092209            [(Tmin,Tmax),[Tmin,Tmax]])
    2210         self.PatternId = GetPatternTreeItemId(self,Id,'Limits')
    2211         self.PatternTree.SetItemPyData(
    2212             self.PatternTree.AppendItem(Id,text='Background'),
     2210        self.PatternId = GetGPXtreeItemId(self,Id,'Limits')
     2211        self.GPXtree.SetItemPyData(
     2212            self.GPXtree.AppendItem(Id,text='Background'),
    22132213            [['chebyschev',True,3,1.0,0.0,0.0],
    22142214             {'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
    2215         self.PatternTree.SetItemPyData(
    2216             self.PatternTree.AppendItem(Id,text='Instrument Parameters'),
     2215        self.GPXtree.SetItemPyData(
     2216            self.GPXtree.AppendItem(Id,text='Instrument Parameters'),
    22172217            [Iparm1,Iparm2])
    2218         self.PatternTree.SetItemPyData(
    2219             self.PatternTree.AppendItem(Id,text='Sample Parameters'),
     2218        self.GPXtree.SetItemPyData(
     2219            self.GPXtree.AppendItem(Id,text='Sample Parameters'),
    22202220            rd.Sample)
    2221         self.PatternTree.SetItemPyData(
    2222             self.PatternTree.AppendItem(Id,text='Peak List')
     2221        self.GPXtree.SetItemPyData(
     2222            self.GPXtree.AppendItem(Id,text='Peak List')
    22232223            ,{'peaks':[],'sigDict':{}})
    2224         self.PatternTree.SetItemPyData(
    2225             self.PatternTree.AppendItem(Id,text='Index Peak List'),
     2224        self.GPXtree.SetItemPyData(
     2225            self.GPXtree.AppendItem(Id,text='Index Peak List'),
    22262226            [[],[]])
    2227         self.PatternTree.SetItemPyData(
    2228             self.PatternTree.AppendItem(Id,text='Unit Cells List'),
     2227        self.GPXtree.SetItemPyData(
     2228            self.GPXtree.AppendItem(Id,text='Unit Cells List'),
    22292229            [])
    2230         self.PatternTree.SetItemPyData(
    2231             self.PatternTree.AppendItem(Id,text='Reflection Lists'),
     2230        self.GPXtree.SetItemPyData(
     2231            self.GPXtree.AppendItem(Id,text='Reflection Lists'),
    22322232            {})
    2233         self.PatternTree.Expand(Id)
    2234         self.PatternTree.SelectItem(Id)
     2233        self.GPXtree.Expand(Id)
     2234        self.GPXtree.SelectItem(Id)
    22352235        print(u'Added simulation powder data {}'.format(HistName)+
    22362236              ' with parameters from {}'.format(rd.instmsg))
    … …  
    22442244        if not result: return
    22452245        # connect new phases to histograms
    2246         sub = GetPatternTreeItemId(self,self.root,'Phases')
     2246        sub = GetGPXtreeItemId(self,self.root,'Phases')
    22472247        if not sub:
    22482248            raise Exception('ERROR -- why are there no phases here?')
    2249         item, cookie = self.PatternTree.GetFirstChild(sub)
     2249        item, cookie = self.GPXtree.GetFirstChild(sub)
    22502250        iph = -1
    22512251        while item: # loop over (new) phases
    22522252            iph += 1
    2253             data = self.PatternTree.GetItemPyData(item)
    2254             item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     2253            data = self.GPXtree.GetItemPyData(item)
     2254            item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    22552255            if iph not in result: continue
    22562256            generalData = data['General']
    … …  
    22602260            NDij = len(G2spc.HStrainNames(SGData))
    22612261            UseList[HistName] = SetDefaultDData('PWDR',HistName,NShkl=NShkl,NDij=NDij)
    2262             Id = GetPatternTreeItemId(self,self.root,HistName)
    2263             refList = self.PatternTree.GetItemPyData(
    2264                 GetPatternTreeItemId(self,Id,'Reflection Lists'))
     2262            Id = GetGPXtreeItemId(self,self.root,HistName)
     2263            refList = self.GPXtree.GetItemPyData(
     2264                GetGPXtreeItemId(self,Id,'Reflection Lists'))
    22652265            refList[generalData['Name']] = []
    22662266        self.EnableRefineCommand()
    … …  
    23072307        # get a list of existing histograms
    23082308        SASDlist = []
    2309         if self.PatternTree.GetCount():
    2310             item, cookie = self.PatternTree.GetFirstChild(self.root)
     2309        if self.GPXtree.GetCount():
     2310            item, cookie = self.GPXtree.GetFirstChild(self.root)
    23112311            while item:
    2312                 name = self.PatternTree.GetItemText(item)
     2312                name = self.GPXtree.GetItemText(item)
    23132313                if name.startswith('SASD ') and name not in SASDlist:
    23142314                    SASDlist.append(name)
    2315                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     2315                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    23162316        # look up which format was requested
    23172317        reqrdr = self.ImportMenuId.get(event.GetId()) 
    … …  
    23302330                ' from file '+self.lastimport
    23312331            # data are read, now store them in the tree
    2332             Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     2332            Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
    23332333            Iparm1,Iparm2 = GetSASDIparm(rd)
    23342334#            if 'T' in Iparm1['Type'][0]:
    … …  
    23612361                }
    23622362            rd.Sample['ranId'] = valuesdict['ranId'] # this should be removed someday
    2363             self.PatternTree.SetItemPyData(Id,[valuesdict,rd.smallangledata])
    2364             self.PatternTree.SetItemPyData(
    2365                 self.PatternTree.AppendItem(Id,text='Comments'),
     2363            self.GPXtree.SetItemPyData(Id,[valuesdict,rd.smallangledata])
     2364            self.GPXtree.SetItemPyData(
     2365                self.GPXtree.AppendItem(Id,text='Comments'),
    23662366                rd.comments)
    2367             self.PatternTree.SetItemPyData(
    2368                 self.PatternTree.AppendItem(Id,text='Limits'),
     2367            self.GPXtree.SetItemPyData(
     2368                self.GPXtree.AppendItem(Id,text='Limits'),
    23692369                [(Tmin,Tmax),[Tmin,Tmax]])
    2370             self.PatternId = GetPatternTreeItemId(self,Id,'Limits')
    2371             self.PatternTree.SetItemPyData(
    2372                 self.PatternTree.AppendItem(Id,text='Instrument Parameters'),
     2370            self.PatternId = GetGPXtreeItemId(self,Id,'Limits')
     2371            self.GPXtree.SetItemPyData(
     2372                self.GPXtree.AppendItem(Id,text='Instrument Parameters'),
    23732373                [Iparm1,Iparm2])
    2374             self.PatternTree.SetItemPyData(
    2375                 self.PatternTree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
    2376             self.PatternTree.SetItemPyData(
    2377                 self.PatternTree.AppendItem(Id,text='Sample Parameters'),
     2374            self.GPXtree.SetItemPyData(
     2375                self.GPXtree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
     2376            self.GPXtree.SetItemPyData(
     2377                self.GPXtree.AppendItem(Id,text='Sample Parameters'),
    23782378                rd.Sample)
    2379             self.PatternTree.SetItemPyData(
    2380                 self.PatternTree.AppendItem(Id,text='Models'),G2pdG.SetDefaultSASDModel())
     2379            self.GPXtree.SetItemPyData(
     2380                self.GPXtree.AppendItem(Id,text='Models'),G2pdG.SetDefaultSASDModel())
    23812381            newHistList.append(HistName)
    23822382        else:
    23832383            self.EnablePlot = True
    2384             self.PatternTree.Expand(Id)
    2385             self.PatternTree.SelectItem(Id)
     2384            self.GPXtree.Expand(Id)
     2385            self.GPXtree.SelectItem(Id)
    23862386           
    23872387        if not newHistList: return # somehow, no new histograms
    … …  
    24222422        # get a list of existing histograms
    24232423        REFDlist = []
    2424         if self.PatternTree.GetCount():
    2425             item, cookie = self.PatternTree.GetFirstChild(self.root)
     2424        if self.GPXtree.GetCount():
     2425            item, cookie = self.GPXtree.GetFirstChild(self.root)
    24262426            while item:
    2427                 name = self.PatternTree.GetItemText(item)
     2427                name = self.GPXtree.GetItemText(item)
    24282428                if name.startswith('REFD ') and name not in REFDlist:
    24292429                    REFDlist.append(name)
    2430                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     2430                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    24312431        # look up which format was requested
    24322432        reqrdr = self.ImportMenuId.get(event.GetId()) 
    … …  
    24452445                ' from file '+self.lastimport
    24462446            # data are read, now store them in the tree
    2447             Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     2447            Id = self.GPXtree.AppendItem(parent=self.root,text=HistName)
    24482448            Iparm1,Iparm2 = GetREFDIparm(rd)
    24492449#            if 'T' in Iparm1['Type'][0]:
    … …  
    24782478                }
    24792479            rd.Sample['ranId'] = valuesdict['ranId'] # this should be removed someday
    2480             self.PatternTree.SetItemPyData(Id,[valuesdict,rd.reflectometrydata])
    2481             self.PatternTree.SetItemPyData(
    2482                 self.PatternTree.AppendItem(Id,text='Comments'),
     2480            self.GPXtree.SetItemPyData(Id,[valuesdict,rd.reflectometrydata])
     2481            self.GPXtree.SetItemPyData(
     2482                self.GPXtree.AppendItem(Id,text='Comments'),
    24832483                rd.comments)
    2484             self.PatternTree.SetItemPyData(
    2485                 self.PatternTree.AppendItem(Id,text='Limits'),
     2484            self.GPXtree.SetItemPyData(
     2485                self.GPXtree.AppendItem(Id,text='Limits'),
    24862486                [(Tmin,Tmax),[Tmin,Tmax]])
    2487             self.PatternId = GetPatternTreeItemId(self,Id,'Limits')
    2488             self.PatternTree.SetItemPyData(
    2489                 self.PatternTree.AppendItem(Id,text='Instrument Parameters'),
     2487            self.PatternId = GetGPXtreeItemId(self,Id,'Limits')
     2488            self.GPXtree.SetItemPyData(
     2489                self.GPXtree.AppendItem(Id,text='Instrument Parameters'),
    24902490                [Iparm1,Iparm2])
    2491             self.PatternTree.SetItemPyData(
    2492                 self.PatternTree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
    2493             self.PatternTree.SetItemPyData(
    2494                 self.PatternTree.AppendItem(Id,text='Sample Parameters'),
     2491            self.GPXtree.SetItemPyData(
     2492                self.GPXtree.AppendItem(Id,text='Substances'),G2pdG.SetDefaultSubstances())
     2493            self.GPXtree.SetItemPyData(
     2494                self.GPXtree.AppendItem(Id,text='Sample Parameters'),
    24952495                rd.Sample)
    2496             self.PatternTree.SetItemPyData(
    2497                 self.PatternTree.AppendItem(Id,text='Models'),G2pdG.SetDefaultREFDModel())
     2496            self.GPXtree.SetItemPyData(
     2497                self.GPXtree.AppendItem(Id,text='Models'),G2pdG.SetDefaultREFDModel())
    24982498            newHistList.append(HistName)
    24992499        else:
    25002500            self.EnablePlot = True
    2501             self.PatternTree.Expand(Id)
    2502             self.PatternTree.SelectItem(Id)
     2501            self.GPXtree.Expand(Id)
     2502            self.GPXtree.SelectItem(Id)
    25032503           
    25042504        if not newHistList: return # somehow, no new histograms
    … …  
    25332533        # get a list of existing histograms
    25342534        PDFlist = []
    2535         if self.PatternTree.GetCount():
    2536             item, cookie = self.PatternTree.GetFirstChild(self.root)
     2535        if self.GPXtree.GetCount():
     2536            item, cookie = self.GPXtree.GetFirstChild(self.root)
    25372537            while item:
    2538                 name = self.PatternTree.GetItemText(item)
     2538                name = self.GPXtree.GetItemText(item)
    25392539                if name.startswith('PDF ') and name not in PDFlist:
    25402540                    PDFlist.append(name)
    2541                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     2541                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    25422542        # look up which format was requested
    25432543        reqrdr = self.ImportMenuId.get(event.GetId()) 
    … …  
    25562556                ' from file '+self.lastimport
    25572557            # data are read, now store them in the tree
    2558             Id = self.PatternTree.AppendItem(self.root,text=HistName)
     2558            Id = self.GPXtree.AppendItem(self.root,text=HistName)
    25592559            Ymin = np.min(rd.pdfdata[1])                 
    25602560            Ymax = np.max(rd.pdfdata[1])                 
    … …  
    25642564                'qPlot':False,'dPlot':False,'sqrtPlot':False,'Yminmax':[Ymin,Ymax]
    25652565                }
    2566             self.PatternTree.SetItemPyData(
    2567                 self.PatternTree.AppendItem(Id,text='PDF Controls'),
     2566            self.GPXtree.SetItemPyData(
     2567                self.GPXtree.AppendItem(Id,text='PDF Controls'),
    25682568                    {'G(R)':[valuesdict,rd.pdfdata,HistName],'diffGRname':'','diffMult':1.0})
    2569             self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='PDF Peaks'),
     2569            self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='PDF Peaks'),
    25702570                {'Limits':[1.,5.],'Background':[2,[0.,-0.2*np.pi],False],'Peaks':[]})
    25712571        else:
    25722572            self.EnablePlot = True
    2573             self.PatternTree.Expand(Id)
    2574             self.PatternTree.SelectItem(Id)
     2573            self.GPXtree.Expand(Id)
     2574            self.GPXtree.SelectItem(Id)
    25752575           
    25762576        if not newHistList: return # somehow, no new histograms
    … …  
    28952895            #     # make a list of used phase ranId's
    28962896            # phaseRIdList = []
    2897             # sub = GetPatternTreeItemId(self,self.root,'Phases')
     2897            # sub = GetGPXtreeItemId(self,self.root,'Phases')
    28982898            # if sub:
    2899             #     item, cookie = self.PatternTree.GetFirstChild(sub)
     2899            #     item, cookie = self.GPXtree.GetFirstChild(sub)
    29002900            #     while item:
    2901             #         phaseName = self.PatternTree.GetItemText(item)
    2902             #         ranId = self.PatternTree.GetItemPyData(item).get('ranId')
     2901            #         phaseName = self.GPXtree.GetItemText(item)
     2902            #         ranId = self.GPXtree.GetItemPyData(item).get('ranId')
    29032903            #         if ranId: phaseRIdList.append(ranId)
    2904             #         item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     2904            #         item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    29052905            # if rd.Reader(filename,fp,usedRanIdList=phaseRIdList):
    29062906            #     print 'read OK'
    … …  
    29252925    def _init_ctrls(self, parent):
    29262926        wx.Frame.__init__(self, name='GSASII', parent=parent,
    2927             size=wx.Size(700, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
    2928             #size=wx.Size(400, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
     2927            #size=wx.Size(700, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
     2928            # DEBUG
     2929            size=wx.Size(400, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
    29292930        clientSize = wx.ClientDisplayRect()
    29302931        Size = self.GetSize()
    … …  
    29672968        treeSizer = wx.BoxSizer()
    29682969        self.treePanel.SetSizer(treeSizer)
    2969         self.PatternTree = G2G.G2TreeCtrl(id=wxID_PATTERNTREE,
     2970        self.GPXtree = G2G.G2TreeCtrl(id=wxID_PATTERNTREE,
    29702971            parent=self.treePanel, size=self.treePanel.GetClientSize(),style=wx.TR_DEFAULT_STYLE )
    2971         treeSizer.Add(self.PatternTree,1,wx.EXPAND|wx.ALL,0)
    2972         self.PatternTree.Bind(wx.EVT_TREE_SEL_CHANGED,self.OnDataTreeSelChanged)
    2973         self.PatternTree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK,self.OnDataTreeSelChanged)
    2974         self.PatternTree.Bind(wx.EVT_TREE_ITEM_COLLAPSED,
    2975             self.OnPatternTreeItemCollapsed, id=wxID_PATTERNTREE)
    2976         self.PatternTree.Bind(wx.EVT_TREE_ITEM_EXPANDED,
    2977             self.OnPatternTreeItemExpanded, id=wxID_PATTERNTREE)
    2978         self.PatternTree.Bind(wx.EVT_TREE_DELETE_ITEM,
    2979             self.OnPatternTreeItemDelete, id=wxID_PATTERNTREE)
    2980         self.PatternTree.Bind(wx.EVT_TREE_KEY_DOWN,
    2981             self.OnPatternTreeKeyDown, id=wxID_PATTERNTREE)
    2982         self.PatternTree.Bind(wx.EVT_TREE_BEGIN_RDRAG,
    2983             self.OnPatternTreeBeginRDrag, id=wxID_PATTERNTREE)       
    2984         self.PatternTree.Bind(wx.EVT_TREE_END_DRAG,
    2985             self.OnPatternTreeEndDrag, id=wxID_PATTERNTREE)       
    2986         self.root = self.PatternTree.root       
     2972        treeSizer.Add(self.GPXtree,1,wx.EXPAND|wx.ALL,0)
     2973        self.GPXtree.Bind(wx.EVT_TREE_SEL_CHANGED,self.OnDataTreeSelChanged)
     2974        self.GPXtree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK,self.OnDataTreeSelChanged)
     2975        self.GPXtree.Bind(wx.EVT_TREE_ITEM_COLLAPSED,
     2976            self.OnGPXtreeItemCollapsed, id=wxID_PATTERNTREE)
     2977        self.GPXtree.Bind(wx.EVT_TREE_ITEM_EXPANDED,
     2978            self.OnGPXtreeItemExpanded, id=wxID_PATTERNTREE)
     2979        self.GPXtree.Bind(wx.EVT_TREE_DELETE_ITEM,
     2980            self.OnGPXtreeItemDelete, id=wxID_PATTERNTREE)
     2981        self.GPXtree.Bind(wx.EVT_TREE_KEY_DOWN,
     2982            self.OnGPXtreeKeyDown, id=wxID_PATTERNTREE)
     2983        self.GPXtree.Bind(wx.EVT_TREE_BEGIN_RDRAG,
     2984            self.OnGPXtreeBeginRDrag, id=wxID_PATTERNTREE)       
     2985        self.GPXtree.Bind(wx.EVT_TREE_END_DRAG,
     2986            self.OnGPXtreeEndDrag, id=wxID_PATTERNTREE)       
     2987        self.root = self.GPXtree.root       
    29872988       
    29882989        # def FillWindow(panel,sizer,size=1.):
    … …  
    31103111
    31113112    def GetTreeItemsList(self,item):
    3112         return self.PatternTree._getTreeItemsList(item)
     3113        return self.GPXtree._getTreeItemsList(item)
    31133114
    31143115    # def OnSize(self,event):
    3115     #     'Called to make PatternTree fill mainPanel'
     3116    #     'Called to make GPXtree fill mainPanel'
    31163117    #     print 'OnSize'
    31173118    #     event.Skip()
    … …  
    31193120        # self.dataWindow.SetupScrolling()
    31203121        # self.mainPanel.SetSize(wx.Size(w,h))
    3121         # self.PatternTree.SetSize(wx.Size(w,h))
     3122        # self.GPXtree.SetSize(wx.Size(w,h))
    31223123        # self.dataWindow.SetSize(self.dataPanel.GetClientSize())
    31233124       
    … …  
    31473148            #    wx.CallAfter(self.oldFocus.SetFocus)
    31483149       
    3149     def OnPatternTreeItemCollapsed(self, event):
     3150    def OnGPXtreeItemCollapsed(self, event):
    31503151        'Called when a tree item is collapsed - all children will be collapsed'
    3151         self.PatternTree.CollapseAllChildren(event.GetItem())
    3152 
    3153     def OnPatternTreeItemExpanded(self, event):
     3152        self.GPXtree.CollapseAllChildren(event.GetItem())
     3153
     3154    def OnGPXtreeItemExpanded(self, event):
    31543155        'Called when a tree item is expanded'
    31553156        self.OnDataTreeSelChanged(event)
    31563157        event.Skip()
    31573158       
    3158     def OnPatternTreeItemDelete(self, event):
     3159    def OnGPXtreeItemDelete(self, event):
    31593160        'Called when a tree item is deleted -- not sure what this does'
    31603161        self.TreeItemDelete = True
    31613162
    3162     def OnPatternTreeItemActivated(self, event):
     3163    def OnGPXtreeItemActivated(self, event):
    31633164        'Called when a tree item is activated'
    31643165        event.Skip()
    31653166       
    3166     def OnPatternTreeBeginRDrag(self,event):
     3167    def OnGPXtreeBeginRDrag(self,event):
    31673168        event.Allow()
    31683169        self.BeginDragId = event.GetItem()
    3169         self.ParentId = self.PatternTree.GetItemParent(self.BeginDragId)
    3170         DragText = self.PatternTree.GetItemText(self.BeginDragId)
    3171         self.DragData = [[DragText,self.PatternTree.GetItemPyData(self.BeginDragId)],]
    3172         item, cookie = self.PatternTree.GetFirstChild(self.BeginDragId)
     3170        self.ParentId = self.GPXtree.GetItemParent(self.BeginDragId)
     3171        DragText = self.GPXtree.GetItemText(self.BeginDragId)
     3172        self.DragData = [[DragText,self.GPXtree.GetItemPyData(self.BeginDragId)],]
     3173        item, cookie = self.GPXtree.GetFirstChild(self.BeginDragId)
    31733174        while item:     #G2 data tree has no sub children under a child of a tree item
    3174             name = self.PatternTree.GetItemText(item)
    3175             self.DragData.append([name,self.PatternTree.GetItemPyData(item)])
    3176             item, cookie = self.PatternTree.GetNextChild(self.BeginDragId, cookie)                           
    3177        
    3178     def OnPatternTreeEndDrag(self,event):
     3175            name = self.GPXtree.GetItemText(item)
     3176            self.DragData.append([name,self.GPXtree.GetItemPyData(item)])
     3177            item, cookie = self.GPXtree.GetNextChild(self.BeginDragId, cookie)                           
     3178       
     3179    def OnGPXtreeEndDrag(self,event):
    31793180        event.Allow()
    31803181        self.EndDragId = event.GetItem()
    31813182        try:
    3182             NewParent = self.PatternTree.GetItemParent(self.EndDragId)
     3183            NewParent = self.GPXtree.GetItemParent(self.EndDragId)
    31833184        except:
    3184             self.EndDragId = self.PatternTree.GetLastChild(self.root)
     3185            self.EndDragId = self.GPXtree.GetLastChild(self.root)
    31853186            NewParent = self.root
    31863187        if self.ParentId != NewParent:
    … …  
    31883189        else:
    31893190            Name,Item = self.DragData[0]
    3190             NewId = self.PatternTree.InsertItem(self.ParentId,self.EndDragId,Name,data=None)
    3191             self.PatternTree.SetItemPyData(NewId,Item)
     3191            NewId = self.GPXtree.InsertItem(self.ParentId,self.EndDragId,Name,data=None)
     3192            self.GPXtree.SetItemPyData(NewId,Item)
    31923193            for name,item in self.DragData[1:]:     #loop over children
    3193                 Id = self.PatternTree.AppendItem(parent=NewId,text=name)
    3194                 self.PatternTree.SetItemPyData(Id,item)
    3195             self.PatternTree.Delete(self.BeginDragId)
     3194                Id = self.GPXtree.AppendItem(parent=NewId,text=name)
     3195                self.GPXtree.SetItemPyData(Id,item)
     3196            self.GPXtree.Delete(self.BeginDragId)
    31963197            SelectDataTreeItem(self,NewId)
    31973198       
    3198     def OnPatternTreeKeyDown(self,event): #doesn't exactly work right with Shift key down
     3199    def OnGPXtreeKeyDown(self,event): #doesn't exactly work right with Shift key down
    31993200        'Allows stepping through the tree with the up/down arrow keys'
    32003201        self.oldFocus = wx.Window.FindFocus()
    32013202        keyevt = event.GetKeyEvent()
    32023203        key = event.GetKeyCode()
    3203         item = self.PatternTree.GetSelection()
     3204        item = self.GPXtree.GetSelection()
    32043205        if type(item) is int: return # is this the toplevel in tree?
    3205         name = self.PatternTree.GetItemText(item)
    3206         parent = self.PatternTree.GetItemParent(item)
     3206        name = self.GPXtree.GetItemText(item)
     3207        parent = self.GPXtree.GetItemParent(item)
    32073208        if key == wx.WXK_UP:
    32083209            if keyevt.GetModifiers() == wx.MOD_SHIFT and parent != self.root:
    32093210                if type(parent) is int: return # is this the toplevel in tree?
    3210                 prev = self.PatternTree.GetPrevSibling(parent)
    3211                 NewId = GetPatternTreeItemId(self,prev,name)
     3211                prev = self.GPXtree.GetPrevSibling(parent)
     3212                NewId = GetGPXtreeItemId(self,prev,name)
    32123213                if NewId:
    3213                     self.PatternTree.Collapse(parent)
    3214                     self.PatternTree.Expand(prev)
     3214                    self.GPXtree.Collapse(parent)
     3215                    self.GPXtree.Expand(prev)
    32153216                    self.oldFocus = wx.Window.FindFocus()
    3216                     wx.CallAfter(self.PatternTree.SelectItem,NewId)
     3217                    wx.CallAfter(self.GPXtree.SelectItem,NewId)
    32173218                else:
    3218                     wx.CallAfter(self.PatternTree.SelectItem,item)
     3219                    wx.CallAfter(self.GPXtree.SelectItem,item)
    32193220            elif sys.platform == "win32":   
    3220                 self.PatternTree.GetPrevSibling(item)
    3221                 self.PatternTree.SelectItem(item)
     3221                self.GPXtree.GetPrevSibling(item)
     3222                self.GPXtree.SelectItem(item)
    32223223            else:
    3223                 item = self.PatternTree.GetPrevSibling(item)
    3224                 if item.IsOk(): self.PatternTree.SelectItem(item)
     3224                item = self.GPXtree.GetPrevSibling(item)
     3225                if item.IsOk(): self.GPXtree.SelectItem(item)
    32253226        elif key == wx.WXK_DOWN:
    32263227            if keyevt.GetModifiers() == wx.MOD_SHIFT and parent != self.root:
    3227                 next = self.PatternTree.GetNextSibling(parent)
    3228                 NewId = GetPatternTreeItemId(self,next,name)
     3228                next = self.GPXtree.GetNextSibling(parent)
     3229                NewId = GetGPXtreeItemId(self,next,name)
    32293230                if NewId:
    3230                     self.PatternTree.Collapse(parent)
    3231                     self.PatternTree.Expand(next)
     3231                    self.GPXtree.Collapse(parent)
     3232                    self.GPXtree.Expand(next)
    32323233                    self.oldFocus = wx.Window.FindFocus()
    3233                     wx.CallAfter(self.PatternTree.SelectItem,NewId)
     3234                    wx.CallAfter(self.GPXtree.SelectItem,NewId)
    32343235                else:
    3235                     wx.CallAfter(self.PatternTree.SelectItem,item)
     3236                    wx.CallAfter(self.GPXtree.SelectItem,item)
    32363237            elif sys.platform == "win32":   
    3237                 self.PatternTree.GetNextSibling(item)
    3238                 self.PatternTree.SelectItem(item)
     3238                self.GPXtree.GetNextSibling(item)
     3239                self.GPXtree.SelectItem(item)
    32393240            else:   
    3240                 item = self.PatternTree.GetNextSibling(item)
    3241                 if item.IsOk(): self.PatternTree.SelectItem(item)
     3241                item = self.GPXtree.GetNextSibling(item)
     3242                if item.IsOk(): self.GPXtree.SelectItem(item)
    32423243               
    32433244    def OnReadPowderPeaks(self,event):
    … …  
    32533254                self.powderfile = dlg.GetPath()
    32543255                comments,peaks,limits,wave = G2IO.GetPowderPeaks(self.powderfile)
    3255                 Id = self.PatternTree.AppendItem(parent=self.root,text='PKS '+os.path.basename(self.powderfile))
     3256                Id = self.GPXtree.AppendItem(parent=self.root,text='PKS '+os.path.basename(self.powderfile))
    32563257                data = ['PKS',wave,0.0]
    32573258                names = ['Type','Lam','Zero']
    32583259                codes = [0,0,0]
    32593260                inst = [G2IO.makeInstDict(names,data,codes),{}]
    3260                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Instrument Parameters'),inst)
    3261                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),comments)
    3262                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Limits'),[tuple(limits),limits])
    3263                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[peaks,[]])
    3264                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    3265                 self.PatternTree.Expand(Id)
    3266                 self.PatternTree.SelectItem(Id)
     3261                self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Instrument Parameters'),inst)
     3262                self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Comments'),comments)
     3263                self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Limits'),[tuple(limits),limits])
     3264                self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Index Peak List'),[peaks,[]])
     3265                self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Unit Cells List'),[])             
     3266                self.GPXtree.Expand(Id)
     3267                self.GPXtree.SelectItem(Id)
    32673268                os.chdir(dlg.GetDirectory())           # to get Mac/Linux to change directory!
    32683269        finally:
    32693270            dlg.Destroy()
    32703271                       
    3271     # def OnImageRead(self,event):
    3272     #     '''Called to read in an image in any known format. *** Depreciated. ***
    3273     #     '''
    3274     #     G2G.G2MessageBox(self,'Please use the Import/Image/... menu item rather than this','depreciating menu item')
    3275 
    32763272    def CheckNotebook(self):
    32773273        '''Make sure the data tree has the minimally expected controls.
    32783274        '''
    3279         if not GetPatternTreeItemId(self,self.root,'Notebook'):
    3280             sub = self.PatternTree.AppendItem(parent=self.root,text='Notebook')
    3281             self.PatternTree.SetItemPyData(sub,[''])
    3282         if not GetPatternTreeItemId(self,self.root,'Controls'):
    3283             sub = self.PatternTree.AppendItem(parent=self.root,text='Controls')
    3284             self.PatternTree.SetItemPyData(sub,copy.copy(G2obj.DefaultControls))
    3285         if not GetPatternTreeItemId(self,self.root,'Covariance'):
    3286             sub = self.PatternTree.AppendItem(parent=self.root,text='Covariance')
    3287             self.PatternTree.SetItemPyData(sub,{})
    3288         if not GetPatternTreeItemId(self,self.root,'Constraints'):
    3289             sub = self.PatternTree.AppendItem(parent=self.root,text='Constraints')
    3290             self.PatternTree.SetItemPyData(sub,{'Hist':[],'HAP':[],'Phase':[]})
    3291         if not GetPatternTreeItemId(self,self.root,'Restraints'):
    3292             sub = self.PatternTree.AppendItem(parent=self.root,text='Restraints')
    3293             self.PatternTree.SetItemPyData(sub,{})
    3294         if not GetPatternTreeItemId(self,self.root,'Rigid bodies'):
    3295             sub = self.PatternTree.AppendItem(parent=self.root,text='Rigid bodies')
    3296             self.PatternTree.SetItemPyData(sub,{'Vector':{'AtInfo':{}},
     3275        if not GetGPXtreeItemId(self,self.root,'Notebook'):
     3276            sub = self.GPXtree.AppendItem(parent=self.root,text='Notebook')
     3277            self.GPXtree.SetItemPyData(sub,[''])
     3278        if not GetGPXtreeItemId(self,self.root,'Controls'):
     3279            sub = self.GPXtree.AppendItem(parent=self.root,text='Controls')
     3280            self.GPXtree.SetItemPyData(sub,copy.copy(G2obj.DefaultControls))
     3281        if not GetGPXtreeItemId(self,self.root,'Covariance'):
     3282            sub = self.GPXtree.AppendItem(parent=self.root,text='Covariance')
     3283            self.GPXtree.SetItemPyData(sub,{})
     3284        if not GetGPXtreeItemId(self,self.root,'Constraints'):
     3285            sub = self.GPXtree.AppendItem(parent=self.root,text='Constraints')
     3286            self.GPXtree.SetItemPyData(sub,{'Hist':[],'HAP':[],'Phase':[]})
     3287        if not GetGPXtreeItemId(self,self.root,'Restraints'):
     3288            sub = self.GPXtree.AppendItem(parent=self.root,text='Restraints')
     3289            self.GPXtree.SetItemPyData(sub,{})
     3290        if not GetGPXtreeItemId(self,self.root,'Rigid bodies'):
     3291            sub = self.GPXtree.AppendItem(parent=self.root,text='Rigid bodies')
     3292            self.GPXtree.SetItemPyData(sub,{'Vector':{'AtInfo':{}},
    32973293                'Residue':{'AtInfo':{}},'RBIds':{'Vector':[],'Residue':[]}})
    32983294               
    … …  
    35233519        Inst = None
    35243520        Comments = ['Sum equals: \n']
    3525         if self.PatternTree.GetCount():
    3526             item, cookie = self.PatternTree.GetFirstChild(self.root)
     3521        if self.GPXtree.GetCount():
     3522            item, cookie = self.GPXtree.GetFirstChild(self.root)
    35273523            while item:
    3528                 name = self.PatternTree.GetItemText(item)
     3524                name = self.GPXtree.GetItemText(item)
    35293525                Names.append(name)
    35303526                if 'PWDR' in name:
    35313527                    TextList.append([0.0,name])
    3532                     DataList.append(self.PatternTree.GetItemPyData(item)[1])    # (x,y,w,yc,yb,yd)
     3528                    DataList.append(self.GPXtree.GetItemPyData(item)[1])    # (x,y,w,yc,yb,yd)
    35333529                    if not Inst:
    3534                         Inst = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,item, 'Instrument Parameters'))
    3535                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3530                        Inst = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,item, 'Instrument Parameters'))
     3531                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    35363532            if len(TextList) < 2:
    35373533                self.ErrorDialog('Not enough data to sum','There must be more than one "PWDR" pattern')
    … …  
    35503546                        try:
    35513547                            if dlg2.ShowModal() == wx.ID_OK:
    3552                                 Id = GetPatternTreeItemId(self,self.root,name)
    3553                                 self.PatternTree.Delete(Id)
     3548                                Id = GetGPXtreeItemId(self,self.root,name)
     3549                                self.GPXtree.Delete(Id)
    35543550                        finally:
    35553551                            dlg2.Destroy()
    3556                     Id = self.PatternTree.AppendItem(parent=self.root,text=outname)
     3552                    Id = self.GPXtree.AppendItem(parent=self.root,text=outname)
    35573553                    if Id:
    35583554                        Sample = G2obj.SetDefaultSample()
    … …  
    35663562                            'qPlot':False,'dPlot':False,'sqrtPlot':False,'Yminmax':[Ymin,Ymax]
    35673563                            }
    3568                         self.PatternTree.SetItemPyData(Id,[valuesdict,[np.array(Xsum),np.array(Ysum),np.array(Wsum),
     3564                        self.GPXtree.SetItemPyData(Id,[valuesdict,[np.array(Xsum),np.array(Ysum),np.array(Wsum),
    35693565                            np.array(YCsum),np.array(YBsum),np.array(YDsum)]])
    3570                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),Comments)                   
    3571                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
    3572                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Background'),[['chebyschev',True,3,1.0,0.0,0.0],
     3566                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Comments'),Comments)                   
     3567                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
     3568                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Background'),[['chebyschev',True,3,1.0,0.0,0.0],
    35733569                            {'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
    3574                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
    3575                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
    3576                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Peak List'),{'peaks':[],'sigDict':{}})
    3577                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[[],[]])
    3578                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    3579                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Reflection Lists'),{})             
    3580                         self.PatternTree.SelectItem(Id)
    3581                         self.PatternTree.Expand(Id)
     3570                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Instrument Parameters'),Inst)
     3571                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Sample Parameters'),Sample)
     3572                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Peak List'),{'peaks':[],'sigDict':{}})
     3573                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Index Peak List'),[[],[]])
     3574                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Unit Cells List'),[])             
     3575                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Reflection Lists'),{})             
     3576                        self.GPXtree.SelectItem(Id)
     3577                        self.GPXtree.Expand(Id)
    35823578            finally:
    35833579                dlg.Destroy()
    … …  
    35903586        Names = []
    35913587        Comments = ['Sum equals: \n']
    3592         if self.PatternTree.GetCount():
    3593             item, cookie = self.PatternTree.GetFirstChild(self.root)
     3588        if self.GPXtree.GetCount():
     3589            item, cookie = self.GPXtree.GetFirstChild(self.root)
    35943590            while item:
    3595                 name = self.PatternTree.GetItemText(item)
     3591                name = self.GPXtree.GetItemText(item)
    35963592                Names.append(name)
    35973593                if 'IMG' in name:
    35983594                    TextList.append([0.0,name])
    3599                     DataList.append(self.PatternTree.GetImageLoc(item))        #Size,Image,Tag
     3595                    DataList.append(self.GPXtree.GetImageLoc(item))        #Size,Image,Tag
    36003596                    IdList.append(item)
    3601                     Data = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,item,'Image Controls'))
    3602                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3597                    Data = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,item,'Image Controls'))
     3598                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    36033599            if len(TextList) < 2:
    36043600                self.ErrorDialog('Not enough data to sum','There must be more than one "IMG" pattern')
    … …  
    36463642                        try:
    36473643                            if dlg2.ShowModal() == wx.ID_OK:
    3648                                 Id = GetPatternTreeItemId(self,self.root,name)
     3644                                Id = GetGPXtreeItemId(self,self.root,name)
    36493645                        finally:
    36503646                            dlg2.Destroy()
    36513647                    else:
    3652                         Id = self.PatternTree.AppendItem(parent=self.root,text=outname)
     3648                        Id = self.GPXtree.AppendItem(parent=self.root,text=outname)
    36533649                    if Id:
    36543650                        pth = G2G.GetExportPath(self)
    … …  
    36633659                            Imin = np.amin(newImage)
    36643660                            newImage = []
    3665                             self.PatternTree.SetItemPyData(Id,[imSize,newimagefile])
    3666                             self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),Comments)
     3661                            self.GPXtree.SetItemPyData(Id,[imSize,newimagefile])
     3662                            self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Comments'),Comments)
    36673663                        del(newImage)
    36683664                        if self.imageDefault:
    … …  
    36773673                        Data['calibrant'] = ''
    36783674                        Data['range'] = [(Imin,Imax),[Imin,Imax]]
    3679                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Image Controls'),Data)                                           
     3675                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Image Controls'),Data)                                           
    36803676                        Masks = {'Points':[],'Rings':[],'Arcs':[],'Polygons':[],'Frames':[],'Thresholds':[(Imin,Imax),[Imin,Imax]]}
    3681                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Masks'),Masks)
    3682                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Stress/Strain'),
     3677                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Masks'),Masks)
     3678                        self.GPXtree.SetItemPyData(self.GPXtree.AppendItem(Id,text='Stress/Strain'),
    36833679                            {'Type':'True','d-zero':[],'Sample phi':0.0,'Sample z':0.0,'Sample load':0.0})
    3684                         self.PatternTree.SelectItem(Id)
    3685                         self.PatternTree.Expand(Id)
    3686                         self.PickId = GetPatternTreeItemId(self,self.root,outname)
     3680                        self.GPXtree.SelectItem(Id)
     3681                        self.GPXtree.Expand(Id)
     3682                        self.PickId = GetGPXtreeItemId(self,self.root,outname)
    36873683                        self.Image = self.PickId
    36883684            finally:
    … …  
    36913687    def OnAddPhase(self,event):
    36923688        'Add a new, empty phase to the tree. Called by Data/Add Phase menu'
    3693         if not GetPatternTreeItemId(self,self.root,'Phases'):
    3694             sub = self.PatternTree.AppendItem(parent=self.root,text='Phases')
     3689        if not GetGPXtreeItemId(self,self.root,'Phases'):
     3690            sub = self.GPXtree.AppendItem(parent=self.root,text='Phases')
    36953691        else:
    3696             sub = GetPatternTreeItemId(self,self.root,'Phases')
     3692            sub = GetGPXtreeItemId(self,self.root,'Phases')
    36973693        PhaseName = ''
    36983694        dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
    … …  
    37013697            PhaseName = dlg.GetValue()
    37023698        dlg.Destroy()
    3703         sub = self.PatternTree.AppendItem(parent=sub,text=PhaseName)
     3699        sub = self.GPXtree.AppendItem(parent=sub,text=PhaseName)
    37043700        E,SGData = G2spc.SpcGroup('P 1')
    3705         self.PatternTree.SetItemPyData(sub,G2obj.SetNewPhase(Name=PhaseName,SGData=SGData))
     3701        self.GPXtree.SetItemPyData(sub,G2obj.SetNewPhase(Name=PhaseName,SGData=SGData))
    37063702        SelectDataTreeItem(self,sub) #bring up new phase General tab
    37073703       
    … …  
    37143710        DelList = []
    37153711        DelItemList = []
    3716         if GetPatternTreeItemId(self,self.root,'Phases'):
    3717             sub = GetPatternTreeItemId(self,self.root,'Phases')
     3712        if GetGPXtreeItemId(self,self.root,'Phases'):
     3713            sub = GetGPXtreeItemId(self,self.root,'Phases')
    37183714        else:
    37193715            return
    37203716        if sub:
    3721             item, cookie = self.PatternTree.GetFirstChild(sub)
     3717            item, cookie = self.GPXtree.GetFirstChild(sub)
    37223718            while item:
    3723                 TextList.append(self.PatternTree.GetItemText(item))
    3724                 item, cookie = self.PatternTree.GetNextChild(sub, cookie)               
     3719                TextList.append(self.GPXtree.GetItemText(item))
     3720                item, cookie = self.GPXtree.GetNextChild(sub, cookie)               
    37253721            dlg = wx.MultiChoiceDialog(self, 'Which phase to delete?', 'Delete phase', TextList, wx.CHOICEDLG_STYLE)
    37263722            try:
    … …  
    37283724                    result = dlg.GetSelections()
    37293725                    for i in result: DelList.append([i,TextList[i]])
    3730                     item, cookie = self.PatternTree.GetFirstChild(sub)
     3726                    item, cookie = self.GPXtree.GetFirstChild(sub)
    37313727                    i = 0
    37323728                    while item:
    3733                         if [i,self.PatternTree.GetItemText(item)] in DelList: DelItemList.append(item)
    3734                         item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     3729                        if [i,self.GPXtree.GetItemText(item)] in DelList: DelItemList.append(item)
     3730                        item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    37353731                        i += 1
    37363732                    for item in DelItemList:
    3737                         name = self.PatternTree.GetItemText(item)
    3738                         self.PatternTree.Delete(item)
     3733                        name = self.GPXtree.GetItemText(item)
     3734                        self.GPXtree.Delete(item)
    37393735                        self.G2plotNB.Delete(name)
    3740                     item, cookie = self.PatternTree.GetFirstChild(self.root)
     3736                    item, cookie = self.GPXtree.GetFirstChild(self.root)
    37413737                    while item:
    3742                         name = self.PatternTree.GetItemText(item)
     3738                        name = self.GPXtree.GetItemText(item)
    37433739                        if 'PWDR' in name:
    3744                             Id = GetPatternTreeItemId(self,item, 'Reflection Lists')
    3745                             refList = self.PatternTree.GetItemPyData(Id)
     3740                            Id = GetGPXtreeItemId(self,item, 'Reflection Lists')
     3741                            refList = self.GPXtree.GetItemPyData(Id)
    37463742                            if len(refList):
    37473743                                for i,item in DelList:
    37483744                                    if item in refList:
    37493745                                        del(refList[item])
    3750 #                            self.PatternTree.SetItemPyData(Id,refList)
     3746#                            self.GPXtree.SetItemPyData(Id,refList)
    37513747                        elif 'HKLF' in name:
    3752                             data = self.PatternTree.GetItemPyData(item)
     3748                            data = self.GPXtree.GetItemPyData(item)
    37533749                            data[0] = {}
    3754 #                            self.PatternTree.SetItemPyData(item,data)
     3750#                            self.GPXtree.SetItemPyData(item,data)
    37553751                           
    3756                         item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3752                        item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    37573753            finally:
    37583754                dlg.Destroy()
    … …  
    37603756    def OnRenameData(self,event):
    37613757        'Renames an existing phase. Called by Data/Rename Phase menu'
    3762         name = self.PatternTree.GetItemText(self.PickId)     
     3758        name = self.GPXtree.GetItemText(self.PickId)     
    37633759        if 'PWDR' in name or 'HKLF' in name or 'IMG' in name:
    37643760            if 'Bank' in name:
    … …  
    37763772                if dlg.ShowModal() == wx.ID_OK:
    37773773                    name = dataType+dlg.GetValue()+names[1]
    3778                     self.PatternTree.SetItemText(self.PickId,name)
     3774                    self.GPXtree.SetItemText(self.PickId,name)
    37793775            finally:
    37803776                dlg.Destroy()
    … …  
    37843780        fileList = []
    37853781        Source = ''
    3786         id, cookie = self.PatternTree.GetFirstChild(self.root)
     3782        id, cookie = self.GPXtree.GetFirstChild(self.root)
    37873783        while id:
    3788             name = self.PatternTree.GetItemText(id)
     3784            name = self.GPXtree.GetItemText(id)
    37893785            if fileType in name:
    37903786                if id == skip:
    … …  
    37923788                else:
    37933789                    fileList.append([False,name,id])
    3794             id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3790            id, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    37953791        if skip:
    37963792            return fileList,Source
    … …  
    38073803        nItems = {'PWDR':0,'SASD':0,'REFD':0,'IMG':0,'HKLF':0,'PDF':0}
    38083804        PDFnames = []
    3809         if self.PatternTree.GetCount():
    3810             item, cookie = self.PatternTree.GetFirstChild(self.root)
     3805        if self.GPXtree.GetCount():
     3806            item, cookie = self.GPXtree.GetFirstChild(self.root)
    38113807            while item:
    3812                 name = self.PatternTree.GetItemText(item)
     3808                name = self.GPXtree.GetItemText(item)
    38133809                if name not in ['Notebook','Controls','Covariance','Constraints',
    38143810                    'Restraints','Phases','Rigid bodies'] and 'Sequential' not in name:
    … …  
    38223818                        nItems['PDF'] += 1
    38233819                    TextList.append(name)
    3824                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3820                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    38253821            for pdfName in PDFnames:
    38263822                try:
    … …  
    38333829                    result = dlg.GetSelections()
    38343830                    for i in result: DelList.append(TextList[i])
    3835                     item, cookie = self.PatternTree.GetFirstChild(self.root)
     3831                    item, cookie = self.GPXtree.GetFirstChild(self.root)
    38363832                    while item:
    3837                         itemName = self.PatternTree.GetItemText(item)
     3833                        itemName = self.GPXtree.GetItemText(item)
    38383834                        if itemName in DelList:
    38393835                            if 'PWDR' in itemName[:4]: nItems['PWDR'] -= 1
    … …  
    38443840                            elif 'PDF' in itemName[:3]: nItems['PDF'] -= 1
    38453841                            DelItemList.append(item)
    3846                         item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3842                        item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    38473843                    for item in DelItemList:
    3848                         self.PatternTree.Delete(item)
     3844                        self.GPXtree.Delete(item)
    38493845                    self.PickId = 0
    38503846                    self.PickIdText = None
    … …  
    38693865        result = wx.ID_OK
    38703866        self.EnablePlot = False
    3871         if self.PatternTree.GetChildrenCount(self.root,False):
     3867        if self.GPXtree.GetChildrenCount(self.root,False):
    38723868            if self.dataFrame:
    38733869                self.dataFrame.ClearData()
    … …  
    38803876                result = dlg.ShowModal()
    38813877                if result == wx.ID_OK:
    3882                     self.PatternTree.DeleteChildren(self.root)
     3878                    self.GPXtree.DeleteChildren(self.root)
    38833879                    self.GSASprojectfile = ''
    38843880                    self.HKL = []
    … …  
    39223918        phaseId = None
    39233919        G2IO.ProjFileOpen(self)
    3924         self.PatternTree.SetItemText(self.root,'Loaded Data: '+self.GSASprojectfile)
    3925         self.PatternTree.Expand(self.root)
     3920        self.GPXtree.SetItemText(self.root,'Loaded Data: '+self.GSASprojectfile)
     3921        self.GPXtree.Expand(self.root)
    39263922        self.HKL = []
    3927         item, cookie = self.PatternTree.GetFirstChild(self.root)
     3923        item, cookie = self.GPXtree.GetFirstChild(self.root)
    39283924        while item and not Id:
    3929             name = self.PatternTree.GetItemText(item)
     3925            name = self.GPXtree.GetItemText(item)
    39303926            if name[:4] in ['PWDR','HKLF','IMG ','PDF ','SASD','REFD']:
    39313927                Id = item
    … …  
    39333929                phaseId = item
    39343930            elif name == 'Controls':
    3935                 data = self.PatternTree.GetItemPyData(item)
     3931                data = self.GPXtree.GetItemPyData(item)
    39363932                if data:
    39373933                    for item in self.Refine: item.Enable(True)
    39383934                    self.EnableSeqRefineMenu()
    3939             item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     3935            item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    39403936        if phaseId: # show all phases
    3941             self.PatternTree.Expand(phaseId)
     3937            self.GPXtree.Expand(phaseId)
    39423938        if Id:
    39433939            self.EnablePlot = True
    3944             self.PatternTree.SelectItem(Id)
    3945             self.PatternTree.Expand(Id)
     3940            self.GPXtree.SelectItem(Id)
     3941            self.GPXtree.Expand(Id)
    39463942        elif phaseId:
    3947             self.PatternTree.SelectItem(phaseId)
     3943            self.GPXtree.SelectItem(phaseId)
    39483944        self.CheckNotebook()
    39493945        if self.dirname: os.chdir(self.dirname)           # to get Mac/Linux to change directory!
    … …  
    39643960            if result != wx.ID_CANCEL:
    39653961                self.GSASprojectfile = ''
    3966                 self.PatternTree.SetItemText(self.root,'Loaded Data: ')
    3967                 self.PatternTree.DeleteChildren(self.root)
     3962                self.GPXtree.SetItemText(self.root,'Loaded Data: ')
     3963                self.GPXtree.DeleteChildren(self.root)
    39683964                if self.HKL: self.HKL = []
    39693965                if self.G2plotNB.plotList:
    … …  
    39783974       
    39793975        if self.GSASprojectfile:
    3980             self.PatternTree.SetItemText(self.root,'Loaded Data: '+self.GSASprojectfile)
     3976            self.GPXtree.SetItemText(self.root,'Loaded Data: '+self.GSASprojectfile)
    39813977            self.CheckNotebook()
    39823978            G2IO.ProjFileSave(self)
    … …  
    40013997                self.GSASprojectfile = dlg.GetPath()
    40023998                self.GSASprojectfile = G2IO.FileDlgFixExt(dlg,self.GSASprojectfile)
    4003                 self.PatternTree.SetItemText(self.root,'Saving project as'+self.GSASprojectfile)
     3999                self.GPXtree.SetItemText(self.root,'Saving project as'+self.GSASprojectfile)
    40044000                self.SetTitle("GSAS-II data tree: "+os.path.split(self.GSASprojectfile)[1])
    40054001                self.CheckNotebook()
    … …  
    40164012            self.ExpandingAll = True
    40174013            try:
    4018                 self.PatternTree.ExpandAll()
     4014                self.GPXtree.ExpandAll()
    40194015            finally:
    40204016                self.ExpandingAll = False
    … …  
    40224018            self.ExpandingAll = True
    40234019            try:
    4024                 item, cookie = self.PatternTree.GetFirstChild(self.root)
     4020                item, cookie = self.GPXtree.GetFirstChild(self.root)
    40254021                while item:
    4026                     name = self.PatternTree.GetItemText(item)
    4027                     if name.startswith(txt+' '): self.PatternTree.Expand(item)
    4028                     item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     4022                    name = self.GPXtree.GetItemText(item)
     4023                    if name.startswith(txt+' '): self.GPXtree.Expand(item)
     4024                    item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    40294025            finally:
    40304026                self.ExpandingAll = False
    … …  
    40364032        # make a list of items to copy
    40374033        copyList = []
    4038         item, cookie = self.PatternTree.GetFirstChild(self.root)
     4034        item, cookie = self.GPXtree.GetFirstChild(self.root)
    40394035        while item:
    4040             if self.PatternTree.GetItemText(item).startswith(txt+' '):
     4036            if self.GPXtree.GetItemText(item).startswith(txt+' '):
    40414037                copyList.append(item)
    4042             item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     4038            item, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    40434039       
    40444040        self.ExpandingAll = True
    40454041        try:
    40464042            for item in copyList:
    4047                 name = self.PatternTree.GetItemText(item)
    4048                 newId = self.PatternTree.AppendItem(self.root,name)
    4049                 self.PatternTree.SetItemPyData(newId,self.PatternTree.GetItemPyData(item))
    4050                 chld, chldcookie = self.PatternTree.GetFirstChild(item)
     4043                name = self.GPXtree.GetItemText(item)
     4044                newId = self.GPXtree.AppendItem(self.root,name)
     4045                self.GPXtree.SetItemPyData(newId,self.GPXtree.GetItemPyData(item))
     4046                chld, chldcookie = self.GPXtree.GetFirstChild(item)
    40514047                while chld:
    4052                     chname = self.PatternTree.GetItemText(chld)
    4053                     newCh = self.PatternTree.AppendItem(newId,chname)
    4054                     self.PatternTree.SetItemPyData(newCh,self.PatternTree.GetItemPyData(chld))
    4055                     chld, chldcookie = self.PatternTree.GetNextChild(item, chldcookie)
    4056                 self.PatternTree.Delete(item)
     4048                    chname = self.GPXtree.GetItemText(chld)
     4049                    newCh = self.GPXtree.AppendItem(newId,chname)
     4050                    self.GPXtree.SetItemPyData(newCh,self.GPXtree.GetItemPyData(chld))
     4051                    chld, chldcookie = self.GPXtree.GetNextChild(item, chldcookie)
     4052                self.GPXtree.Delete(item)
    40574053        finally:
    40584054            self.ExpandingAll = False
    … …  
    40874083                self.peaklistfile = G2IO.FileDlgFixExt(dlg,self.peaklistfile)
    40884084                file = open(self.peaklistfile,'w')               
    4089                 item, cookie = self.PatternTree.GetFirstChild(self.root)
     4085                item, cookie = self.GPXtree.GetFirstChild(self.root)
    40904086                while item:
    4091                     name = self.PatternTree.GetItemText(item)
     4087                    name = self.GPXtree.GetItemText(item)
    40924088                    if 'PWDR' in name:
    4093                         item2, cookie2 = self.PatternTree.GetFirstChild(item)
     4089                        item2, cookie2 = self.GPXtree.GetFirstChild(item)
    40944090                        wave = 0.0
    40954091                        while item2:
    4096                             name2 = self.PatternTree.GetItemText(item2)
     4092                            name2 = self.GPXtree.GetItemText(item2)
    40974093                            if name2 == 'Instrument Parameters':
    4098                                 Inst = self.PatternTree.GetItemPyData(item2)[0]
     4094                                Inst = self.GPXtree.GetItemPyData(item2)[0]
    40994095                                Type = Inst['Type'][0]
    41004096                                if 'T' not in Type:
    41014097                                    wave = G2mth.getWave(Inst)
    41024098                            elif name2 == 'Peak List':
    4103                                 pkdata = self.PatternTree.GetItemPyData(item2)
     4099                                pkdata = self.GPXtree.GetItemPyData(item2)
    41044100                                peaks = pkdata['peaks']
    41054101                                sigDict = pkdata['sigDict']
    4106                             item2, cookie2 = self.PatternTree.GetNextChild(item, cookie2)                           
     4102                            item2, cookie2 = self.GPXtree.GetNextChild(item, cookie2)                           
    41074103                        file.write("#%s \n" % (name+' Peak List'))
    41084104                        if wave:
    … …  
    41354131                                file.write("%10.4f %10.5f %10.5f %12.2f %10.5f %10.5f %10.5f \n" % \
    41364132                                    (peak[0],dsp,esddsp,peak[2],np.sqrt(max(0.0001,peak[4]))/100.,peak[6]/100.,FWHM/100.)) #convert to deg
    4137                     item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                           
     4133                    item, cookie = self.GPXtree.GetNextChild(self.root, cookie)                           
    41384134                file.close()
    41394135        finally:
    … …  
    41494145                self.peaklistfile = G2IO.FileDlgFixExt(dlg,self.peaklistfile)
    41504146                file = open(self.peaklistfile,'w')               
    4151                 item, cookie = self.PatternTree.GetFirstChild(self.root)
     4147                item, cookie = self.GPXtree.GetFirstChild(self.root)
    41524148                while item:
    4153                     name = self.PatternTree.GetItemText(item)
     4149                    name = self.GPXtree.GetItemText(item)
    41544150                    if 'PWDR' in name:
    4155                         item2, cookie2 = self.PatternTree.GetFirstChild(item)
     4151                        item2, cookie2 = self.GPXtree.GetFirstChild(item)
    41564152                        while item2:
    4157                             name2 = self.PatternTree.GetItemText(item2)
     4153                            name2 = self.GPXtree.GetItemText(item2)
    41584154                            if name2 == 'Reflection Lists':
    4159                                 data = self.PatternTree.GetItemPyData(item2)
     4155                                data = self.GPXtree.GetItemPyData(item2)
    41604156                                phases = data.keys()
    41614157                                for phase in phases:
    … …  
    41854181                                                (int(peak[0]),int(peak[1]),int(peak[2]),int(peak[3]),peak[4],peak[5],FWHM/100.,
    41864182                                                peak[8],peak[9],peak[11],peak[12],peak[13],peak[14],I100[ipk]))
    4187                             item2, cookie2 = self.PatternTree.GetNextChild(item, cookie2)                           
    4188                     item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                           
     4183                            item2, cookie2 = self.GPXtree.GetNextChild(item, cookie2)                           
     4184                    item, cookie = self.GPXtree.GetNextChild(self.root, cookie)                           
    41894185                file.close()
    41904186        finally:
    … …  
    42204216        Qlimits = []
    42214217        Names = []
    4222         if self.PatternTree.GetCount():
    4223             id, cookie = self.PatternTree.GetFirstChild(self.root)
     4218        if self.GPXtree.GetCount():
     4219            id, cookie = self.GPXtree.GetFirstChild(self.root)
    42244220            while id:
    4225                 name = self.PatternTree.GetItemText(id)
     4221                name = self.GPXtree.GetItemText(id)
    42264222                Names.append(name)
    42274223                if 'PWDR' in name:
    42284224                    TextList.append(name)
    4229                     Data = self.PatternTree.GetItemPyData(id)[1]
     4225                    Data = self.GPXtree.GetItemPyData(id)[1]
    42304226                    pwdrMin = np.min(Data[1])
    4231                     Comments = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,id,'Comments'))
    4232                     Parms = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,id,'Instrument Parameters'))[0]
    4233                     fullLimits = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,id,'Limits'))[0]
     4227                    Comments = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,id,'Comments'))
     4228                    Parms = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,id,'Instrument Parameters'))[0]
     4229                    fullLimits = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,id,'Limits'))[0]
    42344230                    if 'C' in Parms['Type'][0]:
    42354231                        wave = G2mth.getWave(Parms)
    … …  
    42594255                                ElList[elem] = ElData
    42604256                    ElLists.append(ElList)
    4261                 id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
     4257                id, cookie = self.GPXtree.GetNextChild(self.root, cookie)
    42624258            if len(TextList) < 1:
    42634259                self.ErrorDialog('Nothing to make PDFs for','There must be at least one "PWDR" pattern')
    … …  
    42674263                if dlg.ShowModal() == wx.ID_OK:
    42684264                    for i in dlg.GetSelections():
    4269                         PDFnames = GetPatternTreeDataNames(self,['PDF ',])
     4265                        PDFnames = GetGPXtreeDataNames(self,['PDF ',])
    42704266                        G2obj.CreatePDFitems(self,TextList[i],ElLists[i],Qlimits[i],sumnum,pwdrMin,PDFnames)
    42714267                for item in self.ExportPDF: item.Enable(True)
    … …  
    42854281        PWDRdata = {}
    42864282        try:
    4287             PWDRdata.update(self.PatternTree.GetItemPyData(PWDRname)[0])            #wtFactor + ?
     4283            PWDRdata.update(self.GPXtree.GetItemPyData(PWDRname)[0])            #wtFactor + ?
    42884284        except ValueError:
    42894285            PWDRdata['wtFactor'] = 1.0
    4290         PWDRdata['Data'] = self.PatternTree.GetItemPyData(PWDRname)[1]          #powder data arrays
    4291         PWDRdata['Limits'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,PWDRname,'Limits'))
    4292         PWDRdata['Background'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,PWDRname,'Background'))
    4293         PWDRdata['Instrument Parameters'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,PWDRname,'Instrument Parameters'))
    4294         PWDRdata['Sample Parameters'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,PWDRname,'Sample Parameters'))
    4295         PWDRdata['Reflection Lists'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,PWDRname,'Reflection Lists'))
     4286        PWDRdata['Data'] = self.GPXtree.GetItemPyData(PWDRname)[1]          #powder data arrays
     4287        PWDRdata['Limits'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,PWDRname,'Limits'))
     4288        PWDRdata['Background'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,PWDRname,'Background'))
     4289        PWDRdata['Instrument Parameters'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,PWDRname,'Instrument Parameters'))
     4290        PWDRdata['Sample Parameters'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,PWDRname,'Sample Parameters'))
     4291        PWDRdata['Reflection Lists'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,PWDRname,'Reflection Lists'))
    42964292        if 'ranId' not in PWDRdata:  # patch, add a random Id
    42974293            PWDRdata['ranId'] = ran.randint(0,sys.maxint)
    … …  
    43114307        '''
    43124308        HKLFdata = {}
    4313         HKLFdata.update(self.PatternTree.GetItemPyData(HKLFname)[0])            #wtFactor + ?
     4309        HKLFdata.update(self.GPXtree.GetItemPyData(HKLFname)[0])            #wtFactor + ?
    43144310#        try:
    4315 #            HKLFdata.update(self.PatternTree.GetItemPyData(HKLFname)[0])            #wtFactor + ?
     4311#            HKLFdata.update(self.GPXtree.GetItemPyData(HKLFname)[0])            #wtFactor + ?
    43164312#        except ValueError:
    43174313#            HKLFdata['wtFactor'] = 1.0
    4318         HKLFdata['Data'] = self.PatternTree.GetItemPyData(HKLFname)[1]
    4319         HKLFdata['Instrument Parameters'] = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,HKLFname,'Instrument Parameters'))
     4314        HKLFdata['Data'] = self.GPXtree.GetItemPyData(HKLFname)[1]
     4315        HKLFdata['Instrument Parameters'] = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,HKLFname,'Instrument Parameters'))
    43204316        return HKLFdata
    43214317       
    … …  
    43264322        '''
    43274323        phaseData = {}
    4328         if GetPatternTreeItemId(self,self.root,'Phases'):
    4329             sub = GetPatternTreeItemId(self,self.root,'Phases')
     4324        if GetGPXtreeItemId(self,self.root,'Phases'):
     4325            sub = GetGPXtreeItemId(self,self.root,'Phases')
    43304326        else:
    43314327            print 'no phases found in GetPhaseData'
    43324328            sub = None
    43334329        if sub:
    4334             item, cookie = self.PatternTree.GetFirstChild(sub)
     4330            item, cookie = self.GPXtree.GetFirstChild(sub)
    43354331            while item:
    4336                 phaseName = self.PatternTree.GetItemText(item)
    4337                 phaseData[phaseName] =  self.PatternTree.GetItemPyData(item)
     4332                phaseName = self.GPXtree.GetItemText(item)
     4333                phaseData[phaseName] =  self.GPXtree.GetItemPyData(item)
    43384334                if 'ranId' not in phaseData[phaseName]:
    43394335                    phaseData[phaseName]['ranId'] = ran.randint(0,sys.maxint)         
    4340                 item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     4336                item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    43414337        return phaseData
    43424338
    … …  
    43544350        phaseRIdList = []
    43554351        usedHistograms = {}
    4356         sub = GetPatternTreeItemId(self,self.root,'Phases')
     4352        sub = GetGPXtreeItemId(self,self.root,'Phases')
    43574353        if sub:
    4358             item, cookie = self.PatternTree.GetFirstChild(sub)
     4354            item, cookie = self.GPXtree.GetFirstChild(sub)
    43594355            while item:
    4360                 phaseName = self.PatternTree.GetItemText(item)
    4361                 ranId = self.PatternTree.GetItemPyData(item).get('ranId')
     4356                phaseName = self.GPXtree.GetItemText(item)
     4357                ranId = self.GPXtree.GetItemPyData(item).get('ranId')
    43624358                if ranId: phaseRIdList.append(ranId)
    4363                 data = self.PatternTree.GetItemPyData(item)
     4359                data = self.GPXtree.GetItemPyData(item)
    43644360                UseList = data['Histograms']
    43654361                usedHistograms[phaseName] = UseList.keys()
    4366                 item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     4362                item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    43674363        return phaseRIdList,usedHistograms
    43684364
    … …  
    43734369        '''
    43744370        phaseNames = []
    4375         if GetPatternTreeItemId(self,self.root,'Phases'):
    4376             sub = GetPatternTreeItemId(self,self.root,'Phases')
     4371        if GetGPXtreeItemId(self,self.root,'Phases'):
     4372            sub = GetGPXtreeItemId(self,self.root,'Phases')
    43774373        else:
    43784374            print 'no phases found in GetPhaseNames'
    43794375            sub = None
    43804376        if sub:
    4381             item, cookie = self.PatternTree.GetFirstChild(sub)
     4377            item, cookie = self.GPXtree.GetFirstChild(sub)
    43824378            while item:
    4383                 phase = self.PatternTree.GetItemText(item)
     4379                phase = self.GPXtree.GetItemText(item)
    43844380                phaseNames.append(phase)
    4385                 item, cookie = self.PatternTree.GetNextChild(sub, cookie)
     4381                item, cookie = self.GPXtree.GetNextChild(sub, cookie)
    43864382        return phaseNames
    43874383   
    … …  
    43964392        """
    43974393        HistogramNames = []
    4398         if self.PatternTree.GetCount():
    4399             item, cookie = self.PatternTree.GetFirstChild(self.root)
     4394        if self.GPXtree.GetCount():
     4395            item, cookie = self.GPXtree.GetFirstChild(self.root)
    44004396            while item:
    4401                 name = self.PatternTree.GetItemText(item)
     4397                name = self.GPXtree.GetItemText(item)
    44024398                if name[:4] in hType:
    44034399                    HistogramNames.append(name)       
    4404                 item, cookie = self.PatternTree.GetNextChild(self.root, cookie)               
     4400                item, cookie = self.GPXtree.GetNextChild(self.root, cookie)               
    44054401
    44064402        return HistogramNames
    … …  
    44364432                        Phase['Histograms'][hist]['Use'] = True         
    44374433                    if hist not in Histograms and Phase['Histograms'][hist]['Use']:
    4438                         item = GetPatternTreeItemId(self,self.root,hist)
     4434                        item = GetGPXtreeItemId(self,self.root,hist)
    44394435                        if item:
    44404436                            if 'PWDR' in hist[:4]:
    … …  
    44744470                self.ErrorDialog('View parameter error','You must run least squares at least once')
    44754471                raise Exception,'No pId for phase '+phase
    4476         rigidbodyDict = self.PatternTree.GetItemPyData(   
    4477             GetPatternTreeItemId(self,self.root,'Rigid bodies'))
     4472        rigidbodyDict = self.GPXtree.GetItemPyData(   
     4473            GetGPXtreeItemId(self,self.root,'Rigid bodies'))
    44784474        rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,Print=False)
    44794475        rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
    … …  
    45194515        try:
    45204516            # process constraints
    4521             sub = GetPatternTreeItemId(self,self.root,'Constraints')
    4522             Constraints = self.PatternTree.GetItemPyData(sub)
     4517            sub = GetGPXtreeItemId(self,self.root,'Constraints')
     4518            Constraints = self.GPXtree.GetItemPyData(sub)
    45234519            constList = []
    45244520            for item in Constraints:
    … …  
    45404536        Called from the Calculate/Refine menu.
    45414537        '''
    4542         Id = GetPatternTreeItemId(self,self.root,'Sequential results')
     4538        Id = GetGPXtreeItemId(self,self.root,'Sequential results')
    45434539        if Id:
    45444540            dlg = wx.MessageDialog(
    … …  
    45474543                'Remove sequential results?',wx.OK|wx.CANCEL)
    45484544            if dlg.ShowModal() == wx.ID_OK:
    4549                 self.PatternTree.Delete(Id)
     4545                self.GPXtree.Delete(Id)
    45504546                dlg.Destroy()
    45514547            else:
    … …  
    45744570        Rw = 100.00
    45754571        self.SaveTreeSetting()
    4576         self.PatternTree.SaveExposedItems()       
     4572        self.GPXtree.SaveExposedItems()       
    45774573        try:
    45784574            OK,Msg = G2stMn.Refine(self.GSASprojectfile,dlg)    #Msg is Rvals dict if Ok=True
    … …  
    45934589            try:
    45944590                if dlg2.ShowModal() == wx.ID_OK:
    4595                     self.PatternTree.DeleteChildren(self.root)
     4591                    self.GPXtree.DeleteChildren(self.root)
    45964592                    self.HKL = []
    45974593                    G2IO.ProjFileOpen(self,False)
    4598                     self.PatternTree.RestoreExposedItems()       
     4594                    self.GPXtree.RestoreExposedItems()       
    45994595                    self.ResetPlots()
    46004596            finally:
    … …  
    46054601    def SaveTreeSetting(self):
    46064602        'Save the last tree setting'
    4607         oldId =  self.PatternTree.GetSelection()        #retain current selection
     4603        oldId =  self.GPXtree.GetSelection()        #retain current selection
    46084604        oldPath = self.GetTreeItemsList(oldId)
    46094605        self.lastTreeSetting = oldPath
    … …  
    46114607        #parentName = ''
    46124608        #tabId = None
    4613         # parentId = self.PatternTree.GetItemParent(oldId)
     4609        # parentId = self.GPXtree.GetItemParent(oldId)
    46144610        # if parentId:
    4615         #     parentName = self.PatternTree.GetItemText(parentId)     #find the current data tree name
     4611        #     parentName = self.GPXtree.GetItemText(parentId)     #find the current data tree name
    46164612        #     if 'Phases' in parentName:
    46174613        #         tabId = self.dataDisplay.GetSelection()
    … …  
    46444640        Id = self.root
    46454641        for txt in oldPath:
    4646             Id = GetPatternTreeItemId(self, Id, txt)
     4642            Id = GetGPXtreeItemId(self, Id, txt)
    46474643        self.PickIdText = None  #force reload of page
    46484644        if Id:
    46494645            self.PickId = Id
    4650             self.PatternTree.SelectItem(Id)
     4646            self.GPXtree.SelectItem(Id)
    46514647        # update other self-updating plots
    46524648#        for lbl,frame in zip(self.G2plotNB.plotList,self.G2plotNB.panelList):
    … …  
    46654661        Called from the Calculate/Sequential refine menu.
    46664662        '''
    4667         Id = GetPatternTreeItemId(self,self.root,'Sequential results')
     4663        Id = GetGPXtreeItemId(self,self.root,'Sequential results')
    46684664        if not Id:
    4669             Id = self.PatternTree.AppendItem(self.root,text='Sequential results')
    4670             self.PatternTree.SetItemPyData(Id,{})           
     4665            Id = self.GPXtree.AppendItem(self.root,text='Sequential results')
     4666            self.GPXtree.SetItemPyData(Id,{})           
    46714667        self.G2plotNB.Delete('Sequential refinement')    #clear away probably invalid plot
    4672         Controls = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,self.root, 'Controls'))
     4668        Controls = self.GPXtree.GetItemPyData(GetGPXtreeItemId(self,self.root, 'Controls'))
    46734669        if not Controls.get('Seq Data'):
    46744670            print('Error: a sequential refinement has not been set up')
    … …  
    46884684                             warnmsg+'\nRefinement not possible')
    46894685            return
    4690         self.PatternTree.SaveExposedItems()       
     4686        self.GPXtree.SaveExposedItems()       
    46914687        dlg = wx.ProgressDialog('Residual for histogram 0','Powder profile Rwp =',101.0,
    46924688            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE|wx.PD_CAN_ABORT,
    … …  
    47074703                if dlg.ShowModal() == wx.ID_OK:
    47084704                    self.PickIdText = None  #force reload of PickId contents
    4709                     self.PatternTree.DeleteChildren(self.root)
     4705                    self.GPXtree.DeleteChildren(self.root)
    47104706                    if len(self.HKL): self.HKL = []
    47114707                    if self.G2plotNB.plotList:
    47124708                        self.G2plotNB.clear()
    47134709                    G2IO.ProjFileOpen(self,False)
    4714                     self.PatternTree.RestoreExposedItems()
     4710                    self.GPXtree.RestoreExposedItems()
    47154711                    self.ResetPlots()
    4716                     Id = GetPatternTreeItemId(self,self.root,'Sequential results')
    4717                     self.PatternTree.SelectItem(Id)
     4712                    Id = GetGPXtreeItemId(self,self.root,'Sequential results')
     4713                    self.GPXtree.SelectItem(Id)
    47184714            finally:
    47194715                dlg.Destroy()
    … …  
    57865782#        '''Keep track of size changes for Phase windows
    57875783#        '''
    5788 #        id = self.G2frame.PatternTree.GetSelection()
     5784#        id = self.G2frame.GPXtree.GetSelection()
    57895785#        try:
    5790 #            parent = self.G2frame.PatternTree.GetItemParent(id)
     5786#            parent = self.G2frame.GPXtree.GetItemParent(id)
    57915787#        except:         #avoid bad tree item on start via gpx file selection
    57925788#            parent = 0
    5793 #        if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases":
     5789#        if self.userReSize and parent and self.G2frame.GPXtree.GetItemText(parent) == "Phases":
    57945790#            newSize = event.EventObject.GetSize()
    57955791#            if newSize[1] < 200: return             #avois spurious small window after Refine
    … …  
    58265822        event.Skip()
    58275823        data = text.GetValue().split('\n')
    5828         G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
     5824        G2frame.GPXtree.SetItemPyData(GetGPXtreeItemId(G2frame,G2frame.root,'Notebook'),data)
    58295825        if 'nt' not in os.name:
    58305826            text.AppendText('\n')
    … …  
    59175913       
    59185914        def OnSelectData(event):
    5919             choices = GetPatternTreeDataNames(G2frame,['PWDR','HKLF',])
     5915            choices = GetGPXtreeDataNames(G2frame,['PWDR','HKLF',])
    59205916            sel = []
    59215917            try:
    … …  
    61256121                'FreePrm1':[],'FreePrm2':[],'FreePrm3':[],'Omega':[],
    61266122                'Chi':[],'Phi':[],'Azimuth':[],}
    6127         Controls = G2frame.PatternTree.GetItemPyData(
    6128             GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     6123        Controls = G2frame.GPXtree.GetItemPyData(
     6124            GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    61296125        sampleParm = {}
    61306126        for name in histNames:
    … …  
    61376133                if 'PDF' in name:
    61386134                    name = 'PWDR' + name[4:]
    6139                 Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
     6135                Id = GetGPXtreeItemId(G2frame,G2frame.root,name)
    61406136                if Id:
    6141                     sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     6137                    sampleData = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    61426138                    for item in sampleParmDict:
    61436139                        sampleParmDict[item].append(sampleData.get(item,0))
    … …  
    61766172            if not name.startswith('PWDR'): return
    61776173            pickId = G2frame.PickId
    6178             G2frame.PickId = G2frame.PatternId = GetPatternTreeItemId(G2frame, G2frame.root, name)
     6174            G2frame.PickId = G2frame.PatternId = GetGPXtreeItemId(G2frame, G2frame.root, name)
    61796175            G2plt.PlotPatterns(G2frame,newPlot=True,plotType='PWDR')
    61806176            G2frame.PickId = pickId
    … …  
    69066902    data['variableLabels'] = variableLabels
    69076903    Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
    6908     Controls = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
     6904    Controls = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,G2frame.root,'Controls'))
    69096905    # create a place to store Pseudo Vars & Parametric Fit functions, if not present
    69106906    if 'SeqPseudoVars' not in data: data['SeqPseudoVars'] = {}
    … …  
    73817377        Tmin = newdata[0]
    73827378        Tmax = newdata[-1]
    7383         G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,item,'Limits'),
     7379        G2frame.GPXtree.SetItemPyData(GetGPXtreeItemId(G2frame,item,'Limits'),
    73847380            [(Tmin,Tmax),[Tmin,Tmax]])
    73857381        UpdatePWHKPlot(G2frame,kind,item) # redisplay data screen
    … …  
    73987394       
    73997395    def OnPlotAll3DHKL(event):
    7400         choices = GetPatternTreeDataNames(G2frame,['HKLF',])
     7396        choices = GetGPXtreeDataNames(G2frame,['HKLF',])
    74017397        dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to plot',
    74027398            'Use data',choices)
    … …  
    74107406        refList = np.zeros(0)
    74117407        for name in refNames:
    7412             Id = GetPatternTreeItemId(G2frame,G2frame.root, name)
    7413             reflData = G2frame.PatternTree.GetItemPyData(Id)[1]
     7408            Id = GetGPXtreeItemId(G2frame,G2frame.root, name)
     7409            reflData = G2frame.GPXtree.GetItemPyData(Id)[1]
    74147410            if len(refList):
    74157411                refList = np.concatenate((refList,reflData['RefList']))
    … …  
    74287424                 
    74297425    def OnMergeHKL(event):
    7430         Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
    7431         Inst = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,
     7426        Name = G2frame.GPXtree.GetItemText(G2frame.PatternId)
     7427        Inst = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,
    74327428            G2frame.PatternId,'Instrument Parameters'))
    7433         CId = GetPatternTreeItemId(G2frame,G2frame.PatternId,'Comments')
     7429        CId = GetGPXtreeItemId(G2frame,G2frame.PatternId,'Comments')
    74347430        if CId:
    7435             Comments = G2frame.PatternTree.GetItemPyData(CId)
     7431            Comments = G2frame.GPXtree.GetItemPyData(CId)
    74367432        else:
    74377433            Comments = []
    … …  
    75007496        HKLFlist = []
    75017497        newName = Name+' '+Laue
    7502         if G2frame.PatternTree.GetCount():
    7503             item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     7498        if G2frame.GPXtree.GetCount():
     7499            item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    75047500            while item:
    7505                 name = G2frame.PatternTree.GetItemText(item)
     7501                name = G2frame.GPXtree.GetItemText(item)
    75067502                if name.startswith('HKLF ') and name not in HKLFlist:
    75077503                    HKLFlist.append(name)
    7508                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     7504                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    75097505        newName = G2obj.MakeUniqueLabel(newName,HKLFlist)
    75107506        newData = copy.deepcopy(data)
    75117507        newData[0]['ranId'] = ran.randint(0,sys.maxint)
    75127508        newData[1]['RefList'] = mergeRef
    7513         Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=newName)
    7514         G2frame.PatternTree.SetItemPyData(
    7515             G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)
    7516         G2frame.PatternTree.SetItemPyData(Id,newData)
    7517         G2frame.PatternTree.SetItemPyData(
    7518             G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
    7519         G2frame.PatternTree.SetItemPyData(
    7520             G2frame.PatternTree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
     7509        Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text=newName)
     7510        G2frame.GPXtree.SetItemPyData(
     7511            G2frame.GPXtree.AppendItem(Id,text='Comments'),Comments)
     7512        G2frame.GPXtree.SetItemPyData(Id,newData)
     7513        G2frame.GPXtree.SetItemPyData(
     7514            G2frame.GPXtree.AppendItem(Id,text='Instrument Parameters'),Inst)
     7515        G2frame.GPXtree.SetItemPyData(
     7516            G2frame.GPXtree.AppendItem(Id,text='Reflection List'),{})  #dummy entry for GUI use
    75217517                   
    75227518    def OnErrorAnalysis(event):
    … …  
    75387534        G2pdG.CopySelectedHistItems(G2frame)
    75397535           
    7540     data = G2frame.PatternTree.GetItemPyData(item)
    7541     G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+G2frame.PatternTree.GetItemText(item))
     7536    data = G2frame.GPXtree.GetItemPyData(item)
     7537    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+G2frame.GPXtree.GetItemText(item))
    75427538#patches
    75437539    if not data:
    … …  
    75547550            RefData['FF'].append(ref[14])
    75557551        data[1] = RefData
    7556         G2frame.PatternTree.SetItemPyData(item,data)
     7552        G2frame.GPXtree.SetItemPyData(item,data)
    75577553#end patches
    75587554    if kind in ['PWDR','SASD','REFD']:
    … …  
    76307626    G2frame.SetDataSize()
    76317627   
    7632     G2frame.PatternTree.SetItemPyData(item,data)
     7628    G2frame.GPXtree.SetItemPyData(item,data)
    76337629    G2frame.PatternId = item
    76347630    if kind in ['PWDR','SASD','REFD',]:
    … …  
    76387634        G2plt.PlotPatterns(G2frame,plotType=kind,newPlot=NewPlot)
    76397635    elif kind == 'HKLF':
    7640         Name = G2frame.PatternTree.GetItemText(item)
     7636        Name = G2frame.GPXtree.GetItemText(item)
    76417637        phaseName = G2pdG.IsHistogramInAnyPhase(G2frame,Name)
    76427638        if phaseName:
    7643             pId = GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
    7644             phaseId =  GetPatternTreeItemId(G2frame,pId,phaseName)
    7645             General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
     7639            pId = GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
     7640            phaseId =  GetGPXtreeItemId(G2frame,pId,phaseName)
     7641            General = G2frame.GPXtree.GetItemPyData(phaseId)['General']
    76467642            Super = General.get('Super',0)
    76477643            SuperVec = General.get('SuperVec',[])
    … …  
    76717667################################################################################           
    76727668       
    7673 def GetPatternTreeDataNames(G2frame,dataTypes):
     7669def GetGPXtreeDataNames(G2frame,dataTypes):
    76747670    '''Finds all items in tree that match a 4 character prefix
    76757671   
    … …  
    76807676    '''
    76817677    names = []
    7682     item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)       
     7678    item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)       
    76837679    while item:
    7684         name = G2frame.PatternTree.GetItemText(item)
     7680        name = G2frame.GPXtree.GetItemText(item)
    76857681        if name[:4] in dataTypes:
    76867682            names.append(name)
    7687         item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     7683        item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    76887684    return names
    76897685                         
    7690 def GetPatternTreeItemId(G2frame, parentId, itemText):
     7686def GetGPXtreeItemId(G2frame, parentId, itemText):
    76917687    '''Find the tree item that matches the text in itemText starting with parentId
    76927688
    … …  
    76957691    :param str itemText: text for tree item
    76967692    '''
    7697     item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
     7693    item, cookie = G2frame.GPXtree.GetFirstChild(parentId)
    76987694    while item:
    7699         if G2frame.PatternTree.GetItemText(item) == itemText:
     7695        if G2frame.GPXtree.GetItemText(item) == itemText:
    77007696            return item
    7701         item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
     7697        item, cookie = G2frame.GPXtree.GetNextChild(parentId, cookie)
    77027698    return 0               
    77037699
    77047700def SelectDataTreeItem(G2frame,item,oldFocus=None):
    77057701    '''Called from :meth:`GSASII.GSASII.OnDataTreeSelChanged` when a item is selected on the tree.
    7706     Also called from GSASII.OnPatternTreeEndDrag, OnAddPhase -- might be better to select item, triggering
     7702    Also called from GSASII.OnGPXtreeEndDrag, OnAddPhase -- might be better to select item, triggering
    77077703    the the bind to SelectDataTreeItem
    77087704
    … …  
    77277723                data = [G2frame.dataDisplay.GetValue()]
    77287724                G2frame.dataDisplay.Clear()
    7729                 Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
    7730                 if Id: G2frame.PatternTree.SetItemPyData(Id,data)
     7725                Id = GetGPXtreeItemId(G2frame,G2frame.root, 'Comments')
     7726                if Id: G2frame.GPXtree.SetItemPyData(Id,data)
    77317727            except:     #clumsy but avoids dead window problem when opening another project
    77327728                pass
    … …  
    77357731                data = [G2frame.dataDisplay.GetValue()]
    77367732                G2frame.dataDisplay.Clear()
    7737                 Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
    7738                 if Id: G2frame.PatternTree.SetItemPyData(Id,data)
     7733                Id = GetGPXtreeItemId(G2frame,G2frame.root, 'Notebook')
     7734                if Id: G2frame.GPXtree.SetItemPyData(Id,data)
    77397735            except:     #clumsy but avoids dead window problem when opening another project
    77407736                pass
    … …  
    77557751    else:
    77567752        try:    #don't know why here when opening new project  from inside phase data!
    7757             parentID = G2frame.PatternTree.GetItemParent(item)
     7753            parentID = G2frame.GPXtree.GetItemParent(item)
    77587754            # save name of calling tree item for help. N.B. may want to override this later
    7759             prfx = G2frame.PatternTree.GetItemText(item).split()[0]
    7760             prfx1 = G2frame.PatternTree.GetItemText(parentID).split()[0]
     7755            prfx = G2frame.GPXtree.GetItemText(item).split()[0]
     7756            prfx1 = G2frame.GPXtree.GetItemText(parentID).split()[0]
    77617757            if prfx in ('IMG','PKS','PWDR','SASD','HKLF','PDF','refd',):
    77627758                G2frame.dataFrame.helpKey = prfx
    77637759            elif prfx1 in ('IMG','PKS','PWDR','SASD','HKLF','PDF','REFD',):
    7764                 suffix = G2frame.PatternTree.GetItemText(item)
     7760                suffix = G2frame.GPXtree.GetItemText(item)
    77657761                suffix1 = suffix.split()[0]
    77667762                if '(Q)' in suffix1 or '(R)' in suffix1: suffix = suffix1
    77677763                G2frame.dataFrame.helpKey = prfx1 + '_' + suffix
    77687764            else:
    7769                 G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # save name of calling tree item for help
     7765                G2frame.dataFrame.helpKey = G2frame.GPXtree.GetItemText(item) # save name of calling tree item for help
    77707766        except IndexError:
    77717767            print 'bug: why here?'
    77727768            return
    7773     if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
     7769    if G2frame.GPXtree.GetItemParent(item) == G2frame.root:
    77747770        G2frame.PatternId = 0
    7775         if G2frame.PatternTree.GetItemText(item) == 'Notebook':
     7771        if G2frame.GPXtree.GetItemText(item) == 'Notebook':
    77767772            SetDataMenuBar(G2frame,G2frame.dataWindow.DataNotebookMenu)
    7777             data = G2frame.PatternTree.GetItemPyData(item)
     7773            data = G2frame.GPXtree.GetItemPyData(item)
    77787774            UpdateNotebook(G2frame,data)
    7779         elif G2frame.PatternTree.GetItemText(item) == 'Controls':
    7780             data = G2frame.PatternTree.GetItemPyData(item)
     7775        elif G2frame.GPXtree.GetItemText(item) == 'Controls':
     7776            data = G2frame.GPXtree.GetItemPyData(item)
    77817777            if not data:           #fill in defaults
    77827778                data = copy.copy(G2obj.DefaultControls)    #least squares controls
    7783                 G2frame.PatternTree.SetItemPyData(item,data)                             
     7779                G2frame.GPXtree.SetItemPyData(item,data)                             
    77847780            for i in G2frame.Refine: i.Enable(True)
    77857781            G2frame.EnableSeqRefineMenu()
    77867782            UpdateControls(G2frame,data)
    7787         elif G2frame.PatternTree.GetItemText(item).startswith('Sequential '):
     7783        elif G2frame.GPXtree.GetItemText(item).startswith('Sequential '):
    77887784            G2frame.dataFrame.helpKey = 'Sequential'  # for now all sequential refinements are documented in one place
    7789             data = G2frame.PatternTree.GetItemPyData(item)
     7785            data = G2frame.GPXtree.GetItemPyData(item)
    77907786            UpdateSeqResults(G2frame,data)
    7791         elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
    7792             data = G2frame.PatternTree.GetItemPyData(item)
     7787        elif G2frame.GPXtree.GetItemText(item) == 'Covariance':
     7788            data = G2frame.GPXtree.GetItemPyData(item)
    77937789            text = ''
    77947790            if 'Rvals' in data:
    … …  
    78047800                value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
    78057801            G2plt.PlotCovariance(G2frame,data)
    7806         elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
    7807             data = G2frame.PatternTree.GetItemPyData(item)
     7802        elif G2frame.GPXtree.GetItemText(item) == 'Constraints':
     7803            data = G2frame.GPXtree.GetItemPyData(item)
    78087804            G2cnstG.UpdateConstraints(G2frame,data)
    7809         elif G2frame.PatternTree.GetItemText(item) == 'Rigid bodies':
    7810             data = G2frame.PatternTree.GetItemPyData(item)
     7805        elif G2frame.GPXtree.GetItemText(item) == 'Rigid bodies':
     7806            data = G2frame.GPXtree.GetItemPyData(item)
    78117807            G2cnstG.UpdateRigidBodies(G2frame,data)
    7812         elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
    7813             data = G2frame.PatternTree.GetItemPyData(item)
     7808        elif G2frame.GPXtree.GetItemText(item) == 'Restraints':
     7809            data = G2frame.GPXtree.GetItemPyData(item)
    78147810            Phases = G2frame.GetPhaseData()
    78157811            phaseName = ''
    … …  
    78177813                phaseName = Phases.keys()[0]
    78187814            G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
    7819         elif G2frame.PatternTree.GetItemText(item).startswith('IMG '):
     7815        elif G2frame.GPXtree.GetItemText(item).startswith('IMG '):
    78207816            G2frame.Image = item
    78217817            G2frame.SetTitle('Image Data')
    7822             data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(
     7818            data = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(
    78237819                G2frame,item,'Image Controls'))
    78247820            G2imG.UpdateImageData(G2frame,data)
    78257821            G2plt.PlotImage(G2frame,newPlot=True)
    7826         elif G2frame.PatternTree.GetItemText(item).startswith('PKS '):
     7822        elif G2frame.GPXtree.GetItemText(item).startswith('PKS '):
    78277823            G2plt.PlotPowderLines(G2frame)
    7828         elif G2frame.PatternTree.GetItemText(item).startswith('PWDR '):
     7824        elif G2frame.GPXtree.GetItemText(item).startswith('PWDR '):
    78297825            G2frame.PatternId = item
    78307826            #for i in G2frame.ExportPattern: i.Enable(True)
    78317827            if G2frame.EnablePlot:
    78327828                UpdatePWHKPlot(G2frame,'PWDR',item)
    7833         elif G2frame.PatternTree.GetItemText(item).startswith('SASD '):
     7829        elif G2frame.GPXtree.GetItemText(item).startswith('SASD '):
    78347830            G2frame.PatternId = item
    78357831            #for i in G2frame.ExportPattern: i.Enable(True)
    78367832            if G2frame.EnablePlot:
    78377833                UpdatePWHKPlot(G2frame,'SASD',item)
    7838         elif G2frame.PatternTree.GetItemText(item).startswith('REFD '):
     7834        elif G2frame.GPXtree.GetItemText(item).startswith('REFD '):
    78397835            G2frame.PatternId = item
    78407836            #for i in G2frame.ExportPattern: i.Enable(True)
    78417837            if G2frame.EnablePlot:
    78427838                UpdatePWHKPlot(G2frame,'REFD',item)
    7843         elif G2frame.PatternTree.GetItemText(item).startswith('HKLF '):
     7839        elif G2frame.GPXtree.GetItemText(item).startswith('HKLF '):
    78447840            G2frame.Sngl = True
    78457841            UpdatePWHKPlot(G2frame,'HKLF',item)
    7846         elif G2frame.PatternTree.GetItemText(item).startswith('PDF '):
     7842        elif G2frame.GPXtree.GetItemText(item).startswith('PDF '):
    78477843            G2frame.PatternId = item
    78487844            for i in G2frame.ExportPDF: i.Enable(True) # this should be done on .gpx load; is done on OnMakePDFs (GSASII.py)
    7849             data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,item,'PDF Controls'))
     7845            data = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,item,'PDF Controls'))
    78507846            G2pdG.UpdatePDFGrid(G2frame,data)
    78517847            if len(data['G(R)']):
    78527848                G2plt.PlotISFG(G2frame,data,plotType='G(R)')
    7853         elif G2frame.PatternTree.GetItemText(item) == 'Phases':
     7849        elif G2frame.GPXtree.GetItemText(item) == 'Phases':
    78547850            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    78557851                value='Select one phase to see its parameters')           
    7856     elif G2frame.PatternTree.GetItemText(item) == 'PDF Peaks':
    7857         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7858         peaks = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Peaks'))
    7859         data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
     7852    elif G2frame.GPXtree.GetItemText(item) == 'PDF Peaks':
     7853        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7854        peaks = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,G2frame.PatternId,'PDF Peaks'))
     7855        data = G2frame.GPXtree.GetItemPyData(GetGPXtreeItemId(G2frame,G2frame.PatternId,'PDF Controls'))
    78607856        G2pdG.UpdatePDFPeaks(G2frame,peaks,data)
    78617857        if len(data['G(R)']):
    78627858            G2plt.PlotISFG(G2frame,data,plotType='G(R)',newPlot=True,peaks=peaks)           
    7863     elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
     7859    elif G2frame.GPXtree.GetItemText(item) == 'PDF Controls':
    78647860        for i in G2frame.ExportPDF: i.Enable(True) # this should be done on .gpx load; is done on OnMakePDFs (GSASII.py)
    7865         G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # special treatment to avoid PDF_PDF Controls
    7866         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7867         data = G2frame.PatternTree.GetItemPyData(item)
     7861        G2frame.dataFrame.helpKey = G2frame.GPXtree.GetItemText(item) # special treatment to avoid PDF_PDF Controls
     7862        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7863        data = G2frame.GPXtree.GetItemPyData(item)
    78687864        G2pdG.UpdatePDFGrid(G2frame,data)
    78697865        if len(data['G(R)']):
    … …  
    78727868            if 'F(Q)' in data:  G2plt.PlotISFG(G2frame,data,plotType='F(Q)')
    78737869            G2plt.PlotISFG(G2frame,data,plotType='G(R)')
    7874     elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
    7875         data = G2frame.PatternTree.GetItemPyData(item)
     7870    elif G2frame.GPXtree.GetItemText(parentID) == 'Phases':
     7871        data = G2frame.GPXtree.GetItemPyData(item)
    78767872        G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
    7877     elif G2frame.PatternTree.GetItemText(item) == 'Comments':
     7873    elif G2frame.GPXtree.GetItemText(item) == 'Comments':
    78787874        SetDataMenuBar(G2frame,G2frame.dataWindow.DataCommentsMenu)
    7879         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7880         data = G2frame.PatternTree.GetItemPyData(item)
     7875        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7876        data = G2frame.GPXtree.GetItemPyData(item)
    78817877        UpdateComments(G2frame,data)
    7882     elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
     7878    elif G2frame.GPXtree.GetItemText(item) == 'Image Controls':
    78837879        G2frame.SetTitle('Image Controls')
    7884         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    7885         masks = G2frame.PatternTree.GetItemPyData(
    7886             GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
    7887         data = G2frame.PatternTree.GetItemPyData(item)
     7880        G2frame.Image = G2frame.GPXtree.GetItemParent(item)
     7881        masks = G2frame.GPXtree.GetItemPyData(
     7882            GetGPXtreeItemId(G2frame,G2frame.Image, 'Masks'))
     7883        data = G2frame.GPXtree.GetItemPyData(item)
    78887884        G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
    78897885        G2imG.UpdateImageControls(G2frame,data,masks)
    78907886        G2plt.PlotImage(G2frame,newPlot=False)
    7891     elif G2frame.PatternTree.GetItemText(item) == 'Masks':
     7887    elif G2frame.GPXtree.GetItemText(item) == 'Masks':
    78927888        G2frame.SetTitle('Masks')
    7893         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    7894         masks = G2frame.PatternTree.GetItemPyData(item)
    7895         data = G2frame.PatternTree.GetItemPyData(
    7896             GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     7889        G2frame.Image = G2frame.GPXtree.GetItemParent(item)
     7890        masks = G2frame.GPXtree.GetItemPyData(item)
     7891        data = G2frame.GPXtree.GetItemPyData(
     7892            GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    78977893        G2frame.ImageZ = G2imG.GetImageZ(G2frame,data)
    78987894        G2imG.UpdateMasks(G2frame,masks)
    78997895        G2plt.PlotImage(G2frame,newPlot=False)
    7900     elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
     7896    elif G2frame.GPXtree.GetItemText(item) == 'Stress/Strain':
    79017897        G2frame.SetTitle('Stress/Strain')
    7902         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    7903         data = G2frame.PatternTree.GetItemPyData(
    7904             GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     7898        G2frame.Image = G2frame.GPXtree.GetItemParent(item)
     7899        data = G2frame.GPXtree.GetItemPyData(
     7900            GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    79057901        G2frame.ImageZ = G2imG.GetImageZ(G2frame,data,newRange=False)
    7906         strsta = G2frame.PatternTree.GetItemPyData(item)
     7902        strsta = G2frame.GPXtree.GetItemPyData(item)
    79077903        G2plt.PlotStrain(G2frame,strsta,newPlot=True)
    79087904        G2plt.PlotImage(G2frame,newPlot=False)
    79097905        G2imG.UpdateStressStrain(G2frame,strsta)
    7910     elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
    7911         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
     7906    elif G2frame.GPXtree.GetItemText(item) == 'Peak List':
     7907        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
    79127908        for i in G2frame.ExportPeakList: i.Enable(True)
    7913         data = G2frame.PatternTree.GetItemPyData(item)
     7909        data = G2frame.GPXtree.GetItemPyData(item)
    79147910#patch
    79157911        if 'list' in str(type(data)):
    79167912            data = {'peaks':data,'sigDict':{}}
    7917             G2frame.PatternTree.SetItemPyData(item,data)
     7913            G2frame.GPXtree.SetItemPyData(item,data)
    79187914#end patch
    79197915        G2pdG.UpdatePeakGrid(G2frame,data)
    79207916        G2plt.PlotPatterns(G2frame)
    7921     elif G2frame.PatternTree.GetItemText(item) == 'Background':
    7922         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7923         data = G2frame.PatternTree.GetItemPyData(item)
     7917    elif G2frame.GPXtree.GetItemText(item) == 'Background':
     7918        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7919        data = G2frame.GPXtree.GetItemPyData(item)
    79247920        G2pdG.UpdateBackground(G2frame,data)
    79257921        G2plt.PlotPatterns(G2frame)
    7926     elif G2frame.PatternTree.GetItemText(item) == 'Limits':
    7927         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7928         datatype = G2frame.PatternTree.GetItemText(G2frame.PatternId)[:4]
    7929         data = G2frame.PatternTree.GetItemPyData(item)
     7922    elif G2frame.GPXtree.GetItemText(item) == 'Limits':
     7923        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7924        datatype = G2frame.GPXtree.GetItemText(G2frame.PatternId)[:4]
     7925        data = G2frame.GPXtree.GetItemPyData(item)
    79307926        G2pdG.UpdateLimitsGrid(G2frame,data,datatype)
    79317927        G2plt.PlotPatterns(G2frame,plotType=datatype)
    7932     elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
    7933         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7934         data = G2frame.PatternTree.GetItemPyData(item)[0]
     7928    elif G2frame.GPXtree.GetItemText(item) == 'Instrument Parameters':
     7929        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7930        data = G2frame.GPXtree.GetItemPyData(item)[0]
    79357931        G2pdG.UpdateInstrumentGrid(G2frame,data)
    79367932        if 'P' in data['Type'][0]:          #powder data only
    79377933            G2plt.PlotPeakWidths(G2frame)
    7938     elif G2frame.PatternTree.GetItemText(item) == 'Models':
    7939         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7940         data = G2frame.PatternTree.GetItemPyData(item)
     7934    elif G2frame.GPXtree.GetItemText(item) == 'Models':
     7935        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7936        data = G2frame.GPXtree.GetItemPyData(item)
    79417937        if prfx1 == 'SASD':
    79427938            G2pdG.UpdateModelsGrid(G2frame,data)
    … …  
    79467942        if prfx1 == 'SASD' and len(data['Size']['Distribution']):
    79477943            G2plt.PlotSASDSizeDist(G2frame)
    7948     elif G2frame.PatternTree.GetItemText(item) == 'Substances':
    7949         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7950         data = G2frame.PatternTree.GetItemPyData(item)
     7944    elif G2frame.GPXtree.GetItemText(item) == 'Substances':
     7945        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7946        data = G2frame.GPXtree.GetItemPyData(item)
    79517947        G2pdG.UpdateSubstanceGrid(G2frame,data)
    7952     elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
    7953         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7954         data = G2frame.PatternTree.GetItemPyData(item)
    7955         datatype = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[2][:4]
     7948    elif G2frame.GPXtree.GetItemText(item) == 'Sample Parameters':
     7949        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7950        data = G2frame.GPXtree.GetItemPyData(item)
     7951        datatype = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[2][:4]
    79567952
    79577953        if 'Temperature' not in data:           #temp fix for old gpx files
    … …  
    79607956                    'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
    79617957                    'Gonio. radius':200.0}
    7962             G2frame.PatternTree.SetItemPyData(item,data)
     7958            G2frame.GPXtree.SetItemPyData(item,data)
    79637959   
    79647960        G2pdG.UpdateSampleGrid(G2frame,data)
    79657961        G2plt.PlotPatterns(G2frame,plotType=datatype)
    7966     elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
    7967         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
     7962    elif G2frame.GPXtree.GetItemText(item) == 'Index Peak List':
     7963        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
    79687964        for i in G2frame.ExportPeakList: i.Enable(True)
    7969         data = G2frame.PatternTree.GetItemPyData(item)
     7965        data = G2frame.GPXtree.GetItemPyData(item)
    79707966#patch
    79717967        if len(data) != 2:
    79727968            data = [data,[]]
    7973             G2frame.PatternTree.SetItemPyData(item,data)
     7969            G2frame.GPXtree.SetItemPyData(item,data)
    79747970#end patch
    79757971        G2pdG.UpdateIndexPeaksGrid(G2frame,data)
    7976         if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     7972        if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    79777973            G2plt.PlotPowderLines(G2frame)
    79787974        else:
    79797975            G2plt.PlotPatterns(G2frame)
    7980     elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
    7981         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    7982         data = G2frame.PatternTree.GetItemPyData(item)
     7976    elif G2frame.GPXtree.GetItemText(item) == 'Unit Cells List':
     7977        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7978        data = G2frame.GPXtree.GetItemPyData(item)
    79837979        if not data:
    79847980            data.append([0,0.0,4,25.0,0,'P1',1,1,1,90,90,90]) #zero error flag, zero value, max Nc/No, start volume
    … …  
    79877983            data.append([])                                 #empty dmin
    79887984            data.append({})                                 #empty superlattice stuff
    7989             G2frame.PatternTree.SetItemPyData(item,data)                             
     7985            G2frame.GPXtree.SetItemPyData(item,data)                             
    79907986#patch
    79917987        if len(data) < 5:
    79927988            data.append({'Use':False,'ModVec':[0,0,0.1],'maxH':1,'ssSymb':''})                                 #empty superlattice stuff
    7993             G2frame.PatternTree.SetItemPyData(item,data) 
     7989            G2frame.GPXtree.SetItemPyData(item,data) 
    79947990#end patch
    79957991        G2pdG.UpdateUnitCellsGrid(G2frame,data)
    7996         if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     7992        if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    79977993            G2plt.PlotPowderLines(G2frame)
    79987994        else:
    79997995            G2plt.PlotPatterns(G2frame)
    8000     elif G2frame.PatternTree.GetItemText(item) == 'Reflection Lists':   #powder reflections
    8001         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    8002         data = G2frame.PatternTree.GetItemPyData(item)
     7996    elif G2frame.GPXtree.GetItemText(item) == 'Reflection Lists':   #powder reflections
     7997        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     7998        data = G2frame.GPXtree.GetItemPyData(item)
    80037999        G2frame.RefList = ''
    80048000        if len(data):
    … …  
    80068002        G2pdG.UpdateReflectionGrid(G2frame,data)
    80078003        G2plt.PlotPatterns(G2frame)
    8008     elif G2frame.PatternTree.GetItemText(item) == 'Reflection List':    #HKLF reflections
    8009         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    8010         name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
    8011         data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     8004    elif G2frame.GPXtree.GetItemText(item) == 'Reflection List':    #HKLF reflections
     8005        G2frame.PatternId = G2frame.GPXtree.GetItemParent(item)
     8006        name = G2frame.GPXtree.GetItemText(G2frame.PatternId)
     8007        data = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    80128008        G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True,Name=name)
    80138009
    … …  
    80298025    else:
    80308026        G2frame.SetMenuBar(menu)
    8031 
    8032 def HowDidIgetHere():
    8033     '''Show a traceback with calls that brought us to the current location.
    8034     Used for debugging.
    8035     '''
    8036     import traceback
    8037     print 70*'*'   
    8038     for i in traceback.format_list(traceback.extract_stack()[:-1]): print(i.strip().rstrip())
    8039     print 70*'*'   
    8040        

  • TabularUnified branch/2frame/GSASIIimgGUI.py

    r2900 r2905  
    7171        darkImg,darkScale = data['dark image']
    7272        if darkImg:
    73             Did = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, darkImg)
     73            Did = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, darkImg)
    7474            if Did:
    75                 Ddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Did,'Image Controls'))
     75                Ddata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Did,'Image Controls'))
    7676                dformatName = Ddata.get('formatName','')
    7777                Npix,darkfile,imagetag = G2IO.GetCheckImageFile(G2frame,Did)
    … …  
    8282        backImg,backScale = data['background image']           
    8383        if backImg:     #ignores any transmission effect in the background image
    84             Bid = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, backImg)
     84            Bid = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, backImg)
    8585            if Bid:
    8686                Npix,backfile,imagetag = G2IO.GetCheckImageFile(G2frame,Bid)
    87                 Bdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Bid,'Image Controls'))
     87                Bdata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Bid,'Image Controls'))
    8888                bformatName = Bdata.get('formatName','')
    8989                backImage = G2IO.GetImageData(G2frame,backfile,True,ImageTag=imagetag,FormatName=bformatName)
    … …  
    176176       
    177177    def OnRecalibAll(event):
    178         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     178        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    179179        dlg = G2G.G2MultiChoiceDialog(G2frame,'Image calibration controls','Select images to recalibrate:',Names)
    180180        try:
    181181            if dlg.ShowModal() == wx.ID_OK:
    182                 Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential image calibration results')
     182                Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential image calibration results')
    183183                if Id:
    184                     SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     184                    SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    185185                else:
    186                     Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential image calibration results')
     186                    Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential image calibration results')
    187187                SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
    188188                items = dlg.GetSelections()
    … …  
    191191                    name = Names[item]
    192192                    print 'calibrating',name
    193                     G2frame.Image = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    194                     Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls'))
     193                    G2frame.Image = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     194                    Data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Image Controls'))
    195195                    G2frame.ImageZ = GetImageZ(G2frame,Data)
    196196                    Data['setRings'] = True
    197                     Mid = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Masks')
    198                     Masks = G2frame.PatternTree.GetItemPyData(Mid)
     197                    Mid = G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Masks')
     198                    Masks = G2frame.GPXtree.GetItemPyData(Mid)
    199199                    vals,varyList,sigList,parmDict = G2img.ImageRecalibrate(G2frame,Data,Masks)
    200200                    sigList = list(sigList)
    … …  
    209209                        'covMatrix':np.eye(len(varyList)),'title':name,'parmDict':parmDict}
    210210                SeqResult['histNames'] = Names               
    211                 G2frame.PatternTree.SetItemPyData(Id,SeqResult)
     211                G2frame.GPXtree.SetItemPyData(Id,SeqResult)
    212212        finally:
    213213            dlg.Destroy()
    … …  
    215215        G2frame.G2plotNB.Delete('Sequential refinement')    #clear away probably invalid plot
    216216        G2plt.PlotExposedImage(G2frame,event=None)
    217         G2frame.PatternTree.SelectItem(Id)
     217        G2frame.GPXtree.SelectItem(Id)
    218218       
    219219    def OnClearCalib(event):
    … …  
    247247        Id = G2IO.SaveIntegration(G2frame,G2frame.PickId,data,(event is None))
    248248        G2frame.PatternId = Id
    249         G2frame.PatternTree.SelectItem(Id)
    250         G2frame.PatternTree.Expand(Id)
     249        G2frame.GPXtree.SelectItem(Id)
     250        G2frame.GPXtree.Expand(Id)
    251251        for item in G2frame.MakePDF: item.Enable(True)
    252252       
    253253    def OnIntegrateAll(event):
    254         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     254        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    255255        dlg = G2G.G2MultiChoiceDialog(G2frame,'Image integration controls','Select images to integrate:',Names)
    256256        try:
    … …  
    266266                            break
    267267                        name = Names[item]
    268                         G2frame.Image = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    269                         CId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls')
    270                         Data = G2frame.PatternTree.GetItemPyData(CId)
    271                         Masks = G2frame.PatternTree.GetItemPyData(
    272                             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Masks'))
     268                        G2frame.Image = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     269                        CId = G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Image Controls')
     270                        Data = G2frame.GPXtree.GetItemPyData(CId)
     271                        Masks = G2frame.GPXtree.GetItemPyData(
     272                            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Masks'))
    273273                        image = GetImageZ(G2frame,Data)
    274274                        blkSize = 128   #this seems to be optimal; will break in polymask if >1024
    … …  
    279279                    dlgp.Destroy()
    280280                    G2frame.EnablePlot = True
    281                     G2frame.PatternTree.SelectItem(pId)
    282                     G2frame.PatternTree.Expand(pId)
     281                    G2frame.GPXtree.SelectItem(pId)
     282                    G2frame.GPXtree.Expand(pId)
    283283                    G2frame.PatternId = pId
    284284        finally:
    … …  
    286286       
    287287    def OnCopyControls(event):
    288         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     288        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    289289        if len(Names) == 1:
    290290            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
    291291            return
    292         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     292        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    293293        Names.pop(Names.index(Source))
    294294# select targets & do copy
    … …  
    300300                for item in items:
    301301                    name = Names[item]
    302                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    303                     CId = G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls')
    304                     oldData = copy.deepcopy(G2frame.PatternTree.GetItemPyData(CId))
     302                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     303                    CId = G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls')
     304                    oldData = copy.deepcopy(G2frame.GPXtree.GetItemPyData(CId))
    305305                    Data = copy.deepcopy(data)
    306306                    Data['range'][0] = oldData['range'][0]
    … …  
    314314                    if name == Data['background image'][0]:
    315315                        Data['background image'] = ['',-1.]
    316                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Image Controls'),Data)
     316                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Image Controls'),Data)
    317317        finally:
    318318            dlg.Destroy()
    319             G2frame.PatternTree.SelectItem(G2frame.PickId)
     319            G2frame.GPXtree.SelectItem(G2frame.PickId)
    320320           
    321321    def OnCopySelected(event):
    322         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     322        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    323323        if len(Names) == 1:
    324324            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
    325325            return
    326         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     326        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    327327        # Assemble a list of item labels
    328328        keyList = ['type','wavelength','calibrant','distance','center','Oblique',
    … …  
    353353                for i in result:
    354354                    item = Names[i]
    355                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    356                     Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
     355                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     356                    Controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls'))
    357357                    Controls.update(copy.deepcopy(copyDict))
    358358        finally:
    … …  
    390390        '''
    391391        imglist = []
    392         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     392        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    393393        while item:
    394             name = G2frame.PatternTree.GetItemText(item)
     394            name = G2frame.GPXtree.GetItemText(item)
    395395            if name.startswith('IMG '):
    396396                imglist.append(name)               
    397             item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     397            item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    398398        if not imglist:
    399399            print('No images!')
    … …  
    423423            return
    424424        for img in treeEntries:
    425             item = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
    426             data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     425            item = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,img)
     426            data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    427427                G2frame,item,'Image Controls'))
    428             Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(item)
     428            Npix,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(item)
    429429            filename = os.path.join(outdir,
    430430                                    os.path.splitext(os.path.split(imagefile)[1])[0]
    … …  
    472472                # makes a copy of data, puts it into tree and "disconnects" data
    473473                # from tree contents (later changes to data are lost!)
    474                 #G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'),copy.deepcopy(data))
     474                #G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'),copy.deepcopy(data))
    475475                File.close()
    476476        finally:
    … …  
    484484        '''Sets the integration range for the selected Images based on the difference in detector distance
    485485        '''
    486         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     486        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    487487        if len(Names) == 1:
    488488            G2frame.ErrorDialog('No images to transfer integration angles to','Need more "IMG"s')
    489489            return
    490         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     490        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    491491        Names.pop(Names.index(Source))
    492492        # select targets & do copy
    … …  
    507507                items = dlg.GetSelections()
    508508                G2frame.EnablePlot = False
    509                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,Source)
    510                 data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
     509                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,Source)
     510                data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls'))
    511511                ttmin0,ttmax0 = data['IOtth']
    512512                dist0 = data['distance']
    … …  
    517517                for item in items:
    518518                    name = Names[item]
    519                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    520                     data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
     519                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     520                    data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls'))
    521521                    dist1 = data['distance']
    522522                    if extraopts["value_2"]:
    … …  
    534534        finally:
    535535            dlg.Destroy()
    536             G2frame.PatternTree.SelectItem(G2frame.PickId)       
     536            G2frame.GPXtree.SelectItem(G2frame.PickId)       
    537537           
    538538    def OnResetDist(event):
    … …  
    542542            return
    543543        dlg.Destroy()
    544         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     544        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    545545        dlg = G2G.G2MultiChoiceDialog(G2frame,'Reset dist','Reset dist to set dist for:',Names)
    546546        try:
    … …  
    549549                for item in items:
    550550                    name = Names[item]
    551                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    552                     Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
     551                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     552                    Data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Image Controls'))
    553553                    Data['distance'] = Data['setdist']
    554554        finally:
    … …  
    10021002
    10031003        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Dark image'),0,WACV)
    1004         Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
    1005         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     1004        Choices = ['',]+G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
     1005        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    10061006        Choices.pop(Choices.index(Source))
    10071007        darkImage = wx.ComboBox(parent=G2frame.dataWindow,value=data['dark image'][0],choices=Choices,
    … …  
    11091109            Names = []
    11101110            Items = []
    1111             if G2frame.PatternTree.GetCount():
    1112                 id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     1111            if G2frame.GPXtree.GetCount():
     1112                id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    11131113                while id:
    1114                     name = G2frame.PatternTree.GetItemText(id)
     1114                    name = G2frame.GPXtree.GetItemText(id)
    11151115                    if 'IMG' in name:
    1116                         ctrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'Image Controls'))
     1116                        ctrls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id,'Image Controls'))
    11171117                        Names.append(name)
    11181118                        Items.append(ctrls['GonioAngles'])
    1119                     id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     1119                    id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    11201120                if len(Names) == 1:
    11211121                    G2frame.ErrorDialog('Nothing for global editing','There must be more than one "IMG" pattern')
    … …  
    11251125                try:
    11261126                    if dlg.ShowModal() == wx.ID_OK:
    1127                         id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     1127                        id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    11281128                        while id:
    1129                             name = G2frame.PatternTree.GetItemText(id)
     1129                            name = G2frame.GPXtree.GetItemText(id)
    11301130                            if 'IMG' in name:
    1131                                 ctrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'Image Controls'))
     1131                                ctrls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id,'Image Controls'))
    11321132                                vals = Items[Names.index(name)]
    11331133                                ctrls['GonioAngles'] = vals
    1134                             id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     1134                            id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    11351135                finally:
    11361136                    dlg.Destroy()
    1137                     G2frame.PatternTree.SelectItem(G2frame.PickId)
     1137                    G2frame.GPXtree.SelectItem(G2frame.PickId)
    11381138       
    11391139        gonioSizer = wx.BoxSizer(wx.HORIZONTAL)
    … …  
    12801280
    12811281    def OnCopyMask(event):
    1282         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     1282        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    12831283        if len(Names) == 1:
    12841284            G2frame.ErrorDialog('Nothing to copy masks to','There must be more than one "IMG" pattern')
    12851285            return
    1286         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     1286        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    12871287        Names.pop(Names.index(Source))
    12881288        Data = copy.deepcopy(data)
    … …  
    12941294                for item in items:
    12951295                    name = Names[item]
    1296                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    1297                     MId = G2gd.GetPatternTreeItemId(G2frame,Id,'Masks')
    1298                     Mask = G2frame.PatternTree.GetItemPyData(MId)
     1296                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     1297                    MId = G2gd.GetGPXtreeItemId(G2frame,Id,'Masks')
     1298                    Mask = G2frame.GPXtree.GetItemPyData(MId)
    12991299                    Mask.update(copy.deepcopy(Data))
    13001300                    Mask['Thresholds'][1][0] = Thresh[1][0]  #copy only lower threshold
    1301                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Masks'),Mask)
     1301                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Masks'),Mask)
    13021302        finally:
    13031303            dlg.Destroy()
    … …  
    13621362        if wx.MessageDialog(G2frame.dataWindow,'NB: This will clear any old spot masks',
    13631363            'Auto Spot Masks', wx.OK|wx.CANCEL).ShowModal() == wx.ID_OK:
    1364             Controls = copy.deepcopy(G2frame.PatternTree.GetItemPyData(
    1365                 G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls')))
     1364            Controls = copy.deepcopy(G2frame.GPXtree.GetItemPyData(
     1365                G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Image Controls')))
    13661366            Error = G2img.AutoSpotMasks(G2frame.ImageZ,data,Controls)
    13671367            if not Error is None:
    … …  
    15951595
    15961596    ######################################################################
    1597     CId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls')
    1598     controlData = G2frame.PatternTree.GetItemPyData(CId)
     1597    CId = G2gd.GetGPXtreeItemId(G2frame,G2frame.Image,'Image Controls')
     1598    controlData = G2frame.GPXtree.GetItemPyData(CId)
    15991599    Range = controlData['range']
    16001600    MaxSizer = MaxSizer()               #keep this so it can be changed in BackSizer   
    … …  
    17521752           
    17531753    def OnCopyStrSta(event):
    1754         Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     1754        Names = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    17551755        if len(Names) == 1:
    17561756            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
    17571757            return
    1758         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
     1758        Source = G2frame.GPXtree.GetItemText(G2frame.Image)
    17591759        Names.pop(Names.index(Source))
    17601760        dlg = G2G.G2MultiChoiceDialog(G2frame,'Copy stress/strain controls','Copy controls from '+Source+' to:',Names)
    … …  
    17641764                for item in items:
    17651765                    name = Names[item]
    1766                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    1767                     CId = G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain')
    1768                     oldData = G2frame.PatternTree.GetItemPyData(CId)
     1766                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     1767                    CId = G2gd.GetGPXtreeItemId(G2frame,Id,'Stress/Strain')
     1768                    oldData = G2frame.GPXtree.GetItemPyData(CId)
    17691769                    load = oldData.get('Sample load',0.0)
    17701770                    Data = copy.deepcopy(data)
    17711771                    Data['Sample load'] = load
    1772                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain'),Data)
     1772                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Stress/Strain'),Data)
    17731773        finally:
    17741774            dlg.Destroy()
    1775             G2frame.PatternTree.SelectItem(G2frame.PickId)
     1775            G2frame.GPXtree.SelectItem(G2frame.PickId)
    17761776
    17771777    def OnLoadStrSta(event):
    … …  
    17861786                S = File.read()
    17871787                data = eval(S)
    1788                 Controls = G2frame.PatternTree.GetItemPyData(
    1789                     G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     1788                Controls = G2frame.GPXtree.GetItemPyData(
     1789                    G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    17901790                G2img.FitStrSta(G2frame.ImageZ,data,Controls)
    17911791                UpdateStressStrain(G2frame,data)
    … …  
    18711871            return
    18721872        histList = []
    1873         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)       
     1873        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)       
    18741874        while item:
    1875             name = G2frame.PatternTree.GetItemText(item)
     1875            name = G2frame.GPXtree.GetItemText(item)
    18761876            if name.startswith('IMG'):
    18771877                histList.append(name)
    1878             item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     1878            item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    18791879        colIds = {}
    18801880        for i,name in enumerate(colNames):
    … …  
    18871887                for item in colIds:
    18881888                    newItems[item] = float(dataDict[name][colIds[item]])
    1889                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    1890                 stsrData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain'))
     1889                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     1890                stsrData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Stress/Strain'))
    18911891                stsrData.update(newItems)       
    18921892        UpdateStressStrain(G2frame,data)       
    18931893   
    18941894    def OnPlotStrSta(event):
    1895         Controls = G2frame.PatternTree.GetItemPyData(
    1896             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     1895        Controls = G2frame.GPXtree.GetItemPyData(
     1896            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    18971897        RingInt = G2img.IntStrSta(G2frame.ImageZ,data,Controls)
    18981898        Names = ['d=%.3f'%(ring['Dcalc']) for ring in data['d-zero']]
    … …  
    19041904       
    19051905    def OnSaveStrRing(event):
    1906         Controls = G2frame.PatternTree.GetItemPyData(
    1907             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     1906        Controls = G2frame.GPXtree.GetItemPyData(
     1907            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    19081908        RingInt = G2img.IntStrSta(G2frame.ImageZ,data,Controls)
    19091909        Names = ['d=%.3f'%(ring['Dcalc']) for ring in data['d-zero']]
    … …  
    19271927               
    19281928    def OnFitStrSta(event):
    1929         Controls = G2frame.PatternTree.GetItemPyData(
    1930             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     1929        Controls = G2frame.GPXtree.GetItemPyData(
     1930            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    19311931        G2img.FitStrSta(G2frame.ImageZ,data,Controls)
    19321932        print 'Strain fitting finished'
    … …  
    19361936       
    19371937    def OnFitAllStrSta(event):
    1938         choices = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
     1938        choices = G2gd.GetGPXtreeDataNames(G2frame,['IMG ',])
    19391939        dlg = G2G.G2MultiChoiceDialog(G2frame,'Stress/Strain fitting','Select images to fit:',choices)
    19401940        names = []
    … …  
    19421942            for sel in dlg.GetSelections():
    19431943                names.append(choices[sel])
    1944             Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential strain fit results')
     1944            Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential strain fit results')
    19451945            if Id:
    1946                 SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     1946                SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    19471947            else:
    19481948                SeqResult = {}
    1949                 Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential strain fit results')
     1949                Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential strain fit results')
    19501950            SeqResult.update({'SeqPseudoVars':{},'SeqParFitEqList':[]})
    19511951        else:
    … …  
    19781978                if not GoOn:
    19791979                    break
    1980                 sId =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
     1980                sId =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
    19811981                G2frame.Image = sId
    1982                 Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Image Controls'))
    1983                 StaCtrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Stress/Strain'))
     1982                Controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Image Controls'))
     1983                StaCtrls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Stress/Strain'))
    19841984                if not len(StaCtrls['d-zero']):
    19851985                    continue
    19861986                goodnames.append(name)
    1987                 Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(sId)
     1987                Npix,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(sId)
    19881988                image = GetImageZ(G2frame,Controls)
    19891989                sig = []
    … …  
    20252025            wx.EndBusyCursor()   
    20262026        SeqResult['histNames'] = choices
    2027         G2frame.PatternTree.SetItemPyData(Id,SeqResult)
    2028         G2frame.PatternTree.SelectItem(Id)
     2027        G2frame.GPXtree.SetItemPyData(Id,SeqResult)
     2028        G2frame.GPXtree.SelectItem(Id)
    20292029        print 'All images fitted'
    20302030       
    … …  
    21412141   
    21422142    G2frame.dataWindow.ClearData()
    2143     Controls = G2frame.PatternTree.GetItemPyData(
    2144         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))       
     2143    Controls = G2frame.GPXtree.GetItemPyData(
     2144        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))       
    21452145    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.StrStaMenu)
    21462146    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAppendDzero, id=G2gd.wxID_APPENDDZERO)
    … …  
    24022402                self.imageBase = G2frame.Image
    24032403                self.useActive.SetLabel("Active Image: "+
    2404                         G2frame.PatternTree.GetItemText(self.imageBase))
     2404                        G2frame.GPXtree.GetItemText(self.imageBase))
    24052405                self.editTable.Enable(False)
    24062406            else:
    … …  
    24262426                    self.imageBase = G2frame.Image
    24272427                    self.useActive.SetLabel("Active Image: "+
    2428                             G2frame.PatternTree.GetItemText(self.imageBase))
     2428                            G2frame.GPXtree.GetItemText(self.imageBase))
    24292429                    self.editTable.Enable(False)
    24302430            finally:
    … …  
    24862486        self.Scale = [1.0,]
    24872487
    2488         G2frame.PatternTree.GetSelection()
    2489         size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(self.imageBase)
     2488        G2frame.GPXtree.GetSelection()
     2489        size,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(self.imageBase)
    24902490        self.imagedir,fileroot = os.path.split(imagefile)
    2491         Comments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2491        Comments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    24922492            G2frame,self.imageBase, 'Comments'))
    24932493        DefaultAutoScaleNames = GSASIIpath.GetConfigValue('Autoscale_ParmNames')
    … …  
    25212521        self.useActive.Bind(wx.EVT_RADIOBUTTON, OnRadioSelect)
    25222522        self.useActive.SetLabel("Active Image: "+
    2523                                 G2frame.PatternTree.GetItemText(self.imageBase))
     2523                                G2frame.GPXtree.GetItemText(self.imageBase))
    25242524        lblsizr.Add(self.useActive,1,wx.EXPAND,1)
    25252525        self.useActive.SetValue(True)
    … …  
    26782678            if not name: continue
    26792679            msg += '\n{}: {:.2f} * "{}"'.format(key,mult,name)
    2680             if not G2gd.GetPatternTreeItemId(self.G2frame,self.G2frame.root,name):
     2680            if not G2gd.GetGPXtreeItemId(self.G2frame,self.G2frame.root,name):
    26812681                msg += ' *** missing ***'
    26822682        return msg
    … …  
    26892689        self.PreventReEntryShowMatch = True
    26902690        imageFileList = []
    2691         for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
    2692             imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
    2693             size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
     2691        for img in G2gd.GetGPXtreeDataNames(G2frame,['IMG ']):
     2692            imgId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,img)
     2693            size,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(imgId)
    26942694            if imagefile not in imageFileList: imageFileList.append(imagefile)
    26952695            if img not in G2frame.IntegratedList:
    … …  
    27372737        '''
    27382738        G2frame = self.G2frame
    2739         imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
     2739        imgId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,img)
    27402740        G2frame.Image = imgId
    2741         G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls')
     2741        G2frame.PickId = G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls')
    27422742        # do integration
    2743         size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
     2743        size,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(imgId)
    27442744        if self.AutoScale:
    2745             Comments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2745            Comments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    27462746                G2frame,imgId, 'Comments'))
    27472747            for comment in Comments:
    … …  
    27532753                            Scale = self.Scale[0]/val
    27542754                        break
    2755         masks = G2frame.PatternTree.GetItemPyData(
    2756             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
    2757         data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
     2755        masks = G2frame.GPXtree.GetItemPyData(
     2756            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Masks'))
     2757        data = G2frame.GPXtree.GetItemPyData(G2frame.PickId)
    27582758        # simulate a Image Controls press, since that is where the
    27592759        # integration is hidden
    … …  
    27702770            # save the created PWDR tree names so that a reset can delete them
    27712771            G2frame.Image = Id
    2772             treename = G2frame.PatternTree.GetItemText(Id)
     2772            treename = G2frame.GPXtree.GetItemText(Id)
    27732773            G2frame.AutointPWDRnames.append(treename)
    27742774            # write out the images in the selected formats
    2775             Sdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Sample Parameters'))
     2775            Sdata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Sample Parameters'))
    27762776            if self.AutoScale:
    27772777                print 'Rescale by %.4f'%(Scale)
    2778                 y,w = G2frame.PatternTree.GetItemPyData(Id)[1][1:3]
     2778                y,w = G2frame.GPXtree.GetItemPyData(Id)[1][1:3]
    27792779                y *= Scale
    27802780                w /= Scale**2
    … …  
    28442844        if self.params['Mode'] != 'table':
    28452845            self.useActive.SetLabel("Active Image: "+
    2846                                     G2frame.PatternTree.GetItemText(self.imageBase))
     2846                                    G2frame.GPXtree.GetItemText(self.imageBase))
    28472847            # load copy of Image Controls from current image and clean up
    28482848            # items that should not be copied
    28492849            self.ImageControls = copy.deepcopy(
    2850                 G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2850                G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    28512851                    G2frame,self.imageBase, 'Image Controls')))
    28522852            self.ImageControls['showLines'] = True
    … …  
    28602860            # load copy of Image Masks, keep thresholds
    28612861            self.ImageMasks = copy.deepcopy(
    2862                 G2frame.PatternTree.GetItemPyData(
    2863                     G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Masks')))
     2862                G2frame.GPXtree.GetItemPyData(
     2863                    G2gd.GetGPXtreeItemId(G2frame,self.imageBase, 'Masks')))
    28642864            self.Thresholds = self.ImageMasks['Thresholds'][:]
    28652865            if list(self.Thresholds[0]) == self.Thresholds[1]:     #avoid copy of unchanged thresholds
    … …  
    28782878           
    28792879            if self.params['Mode'] != 'table': # reset controls and masks for all IMG items in tree to master
    2880                 for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
     2880                for img in G2gd.GetGPXtreeDataNames(G2frame,['IMG ']):
    28812881                    # update controls from master
    2882                     controlsDict = G2frame.PatternTree.GetItemPyData(
    2883                         G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Image Controls'))
     2882                    controlsDict = G2frame.GPXtree.GetItemPyData(
     2883                        G2gd.GetGPXtreeItemId(G2frame,self.imageBase, 'Image Controls'))
    28842884                    controlsDict.update(self.ImageControls)
    28852885                    # update masks from master
    2886                     ImageMasks = G2frame.PatternTree.GetItemPyData(
    2887                         G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Masks'))
     2886                    ImageMasks = G2frame.GPXtree.GetItemPyData(
     2887                        G2gd.GetGPXtreeItemId(G2frame,self.imageBase, 'Masks'))
    28882888                    ImageMasks.update(self.ImageMasks)
    28892889            # delete all PWDR items created after last Start was pressed
    28902890            idlist = []
    2891             item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     2891            item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    28922892            while item:
    2893                 itemName = G2frame.PatternTree.GetItemText(item)
     2893                itemName = G2frame.GPXtree.GetItemText(item)
    28942894                if itemName in G2frame.AutointPWDRnames:
    28952895                    idlist.append(item)
    2896                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     2896                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    28972897            for item in idlist:
    2898                 G2frame.PatternTree.Delete(item)
     2898                G2frame.GPXtree.Delete(item)
    28992899            wx.Yield()
    29002900            self.Reset = False
    … …  
    29092909                return True
    29102910            fileList = []
    2911             id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     2911            id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    29122912            while id:
    2913                 name = G2frame.PatternTree.GetItemText(id)
     2913                name = G2frame.GPXtree.GetItemText(id)
    29142914                if name.startswith('PWDR '): fileList.append(name)
    2915                 id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     2915                id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    29162916            if not fileList:
    29172917                print(msg)
    … …  
    29212921                name = self.pdfControls[key]['Name']
    29222922                if not name: continue
    2923                 if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name):
     2923                if not G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name):
    29242924                    indx = G2G.ItemSelector(fileList, self, header='Select PDWR item',
    29252925                                    title='Select a PDWR tree item for '+key+'\n(or cancel to quit)')
    … …  
    29402940            AutoInt window.
    29412941            '''
    2942             img = G2frame.PatternTree.GetItemText(imgId)
    2943             controlsDict = G2frame.PatternTree.GetItemPyData(
    2944                 G2gd.GetPatternTreeItemId(G2frame,imgId, 'Image Controls'))
    2945             ImageMasks = G2frame.PatternTree.GetItemPyData(
    2946                 G2gd.GetPatternTreeItemId(G2frame,imgId, 'Masks'))
     2942            img = G2frame.GPXtree.GetItemText(imgId)
     2943            controlsDict = G2frame.GPXtree.GetItemPyData(
     2944                G2gd.GetGPXtreeItemId(G2frame,imgId, 'Image Controls'))
     2945            ImageMasks = G2frame.GPXtree.GetItemPyData(
     2946                G2gd.GetGPXtreeItemId(G2frame,imgId, 'Masks'))
    29472947            if self.params['Mode'] == 'table': # look up parameter values from table
    29482948                self.ResetFromTable(controlsDict['setdist'])
    … …  
    29672967                if not pwdr.startswith('PWDR '): continue
    29682968                if pwdr in G2frame.AutointPDFnames: continue
    2969                 PWid = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,pwdr)
    2970                 controlsDict = G2frame.PatternTree.GetItemPyData(
    2971                     G2gd.GetPatternTreeItemId(G2frame,imgId, 'Image Controls'))
     2969                PWid = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,pwdr)
     2970                controlsDict = G2frame.GPXtree.GetItemPyData(
     2971                    G2gd.GetGPXtreeItemId(G2frame,imgId, 'Image Controls'))
    29722972                if self.params['pdfDmax'] != 0 and controlsDict['distance'] > self.params['pdfDmax']:
    29732973                    print('Skipping PDF for '+pwdr+' due to detector position')
    29742974                    continue
    29752975                # Setup PDF
    2976                 Data = G2frame.PatternTree.GetItemPyData(PWid)[1]
     2976                Data = G2frame.GPXtree.GetItemPyData(PWid)[1]
    29772977                pwdrMin = np.min(Data[1])
    2978                 Parms = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2978                Parms = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    29792979                    G2frame,PWid,'Instrument Parameters'))[0]
    2980                 fullLimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2980                fullLimits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    29812981                    G2frame,PWid,'Limits'))[0]
    29822982                if 'C' in Parms['Type'][0]:
    … …  
    29872987
    29882988                item = pwdr
    2989                 Comments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2989                Comments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    29902990                    G2frame,imgId, 'Comments'))
    29912991                ElList = {}
    … …  
    30033003                            sumnum += float(num)
    30043004                            ElList[elem] = ElData
    3005                 PDFnames = G2gd.GetPatternTreeDataNames(G2frame,['PDF ',])
     3005                PDFnames = G2gd.GetGPXtreeDataNames(G2frame,['PDF ',])
    30063006                PDFid = G2obj.CreatePDFitems(G2frame,pwdr,ElList.copy(),Qlimits,sumnum,pwdrMin,PDFnames)
    30073007                if not PDFid: continue
    3008                 PDFdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     3008                PDFdata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    30093009                    G2frame,PDFid, 'PDF Controls'))
    30103010                PDFdata.update(self.pdfControls)
    … …  
    30233023                G2frame.AutointPDFnames.append(pwdr)
    30243024                # save names of PDF entry to be deleted later if needed
    3025                 G2frame.AutointPWDRnames.append(G2frame.PatternTree.GetItemText(PDFid))
     3025                G2frame.AutointPWDRnames.append(G2frame.GPXtree.GetItemText(PDFid))
    30263026           
    30273027        G2frame = self.G2frame
    … …  
    30393039        # integrate the images that have already been read in, but
    30403040        # have not yet been processed           
    3041         for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
    3042             imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
    3043             size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
     3041        for img in G2gd.GetGPXtreeDataNames(G2frame,['IMG ']):
     3042            imgId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,img)
     3043            size,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(imgId)
    30443044            # Create a list of image files that have been read in
    30453045            if imagefile not in imageFileList: imageFileList.append(imagefile)

  • TabularUnified branch/2frame/GSASIIlog.py

    r2900 r2905  
    208208            elif i == 1 and type(txt) is int and self.treeItemList[0] == "Phases":
    209209                txt = LogInfo['Tree'].ConvertRelativePhaseNum(txt)
    210             item = G2gd.GetPatternTreeItemId(LogInfo['Tree'].G2frame,parent,txt)
     210            item = G2gd.GetGPXtreeItemId(LogInfo['Tree'].G2frame,parent,txt)
    211211            if not item:
    212212                print 'Not found',txt

  • TabularUnified branch/2frame/GSASIIobj.py

    r2895 r2905  
    26222622        return repr(self.msg)
    26232623
     2624def HowDidIgetHere():
     2625    '''Show a traceback with calls that brought us to the current location.
     2626    Used for debugging.
     2627    '''
     2628    import traceback
     2629    print 70*'*'   
     2630    for i in traceback.format_list(traceback.extract_stack()[:-1]): print(i.strip().rstrip())
     2631    print 70*'*'   
     2632       
    26242633def CreatePDFitems(G2frame,PWDRtree,ElList,Qlimits,numAtm=1,FltBkg=0,PDFnames=[]):
    26252634    '''Create and initialize a new set of PDF tree entries
    … …  
    26402649        return None
    26412650    #PDFname = MakeUniqueLabel(PDFname,PDFnames)
    2642     Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=PDFname)
     2651    Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text=PDFname)
    26432652    Data = {
    26442653        'Sample':{'Name':PWDRtree,'Mult':1.0},
    … …  
    26502659        'Lorch':False,'BackRatio':0.0,'Rmax':100.,'noRing':False,'IofQmin':1.0,
    26512660        'I(Q)':[],'S(Q)':[],'F(Q)':[],'G(R)':[]}
    2652     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='PDF Controls'),Data)
    2653     G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='PDF Peaks'),
     2661    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='PDF Controls'),Data)
     2662    G2frame.GPXtree.SetItemPyData(G2frame.GPXtree.AppendItem(Id,text='PDF Peaks'),
    26542663        {'Limits':[1.,5.],'Background':[2,[0.,-0.2*np.pi],False],'Peaks':[]})
    26552664    return Id       

  • TabularUnified branch/2frame/GSASIIpath.py

    r2895 r2905  
    627627else:                                                  # try loading them
    628628    print('Attempting to download GSAS-II binary files...')
    629     binpath = DownloadG2Binaries(g2home)
    630     if TestSPG(binpath):
     629    try:
     630        binpath = DownloadG2Binaries(g2home)
     631    except AttributeError:   # this happens when building in Read The Docs
     632        print('Problem with download')
     633    if binpath and TestSPG(binpath):
    631634        print('GSAS-II binary directory: {}'.format(binpath))
    632635        sys.path.insert(0,binpath)

  • TabularUnified branch/2frame/GSASIIphsGUI.py

    r2900 r2905  
    10871087        for reflName in reflNames:
    10881088            if 'PWDR' in reflName:
    1089                 PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    1090                 reflSets = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
     1089                PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     1090                reflSets = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists'))
    10911091                reflData = reflSets[phaseName]
    10921092            elif 'HKLF' in reflName:
    1093                 PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    1094                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     1093                PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     1094                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    10951095                if 'Type' not in reflData:
    10961096                    reflData['Type'] = 'SXC'
    … …  
    12821282                    G2frame.G2plotNB.Rename(oldName,generalData['Name'])
    12831283                    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+generalData['Name'])
    1284                     G2frame.PatternTree.SetItemText(Item,generalData['Name'])
     1284                    G2frame.GPXtree.SetItemText(Item,generalData['Name'])
    12851285                    # change phase name key in Reflection Lists for each histogram
    12861286                    for hist in data['Histograms']:
    1287                         ht = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    1288                         rt = G2gd.GetPatternTreeItemId(G2frame,ht,'Reflection Lists')
     1287                        ht = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     1288                        rt = G2gd.GetGPXtreeItemId(G2frame,ht,'Reflection Lists')
    12891289                        if not rt: continue
    1290                         RfList = G2frame.PatternTree.GetItemPyData(rt)
     1290                        RfList = G2frame.GPXtree.GetItemPyData(rt)
    12911291                        if oldName not in RfList:
    12921292                            print('Warning: '+oldName+' not in Reflection List for '+
    … …  
    23712371                UseList[hist]['HStrain'] = [NDij*[0.0,],NDij*[False,]]
    23722372            newPhase['General']['Map'] = mapDefault.copy()
    2373             sub = G2frame.PatternTree.AppendItem(parent=
    2374                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
    2375             G2frame.PatternTree.SetItemPyData(sub,newPhase)
     2373            sub = G2frame.GPXtree.AppendItem(parent=
     2374                G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
     2375            G2frame.GPXtree.SetItemPyData(sub,newPhase)
    23762376            newPhase['Drawing'] = []
    23772377           
    … …  
    23792379                G2frame.GetUsedHistogramsAndPhasesfromTree()
    23802380                G2cnstG.MagConstraints(G2frame,data,newPhase,Trans,Vec,atCodes)     #data is old phase
    2381             G2frame.PatternTree.SelectItem(sub)
     2381            G2frame.GPXtree.SelectItem(sub)
    23822382       
    23832383################################################################################
    … …  
    34893489            if 'pId' in data:
    34903490                DisAglData['pId'] = data['pId']
    3491                 DisAglData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     3491                DisAglData['covData'] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    34923492            try:
    34933493                if fp:
    … …  
    35443544        Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree() # init for constraint
    35453545        # make a lookup table for constraints
    3546         sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Constraints')
    3547         Constraints = G2frame.PatternTree.GetItemPyData(sub)
     3546        sub = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
     3547        Constraints = G2frame.GPXtree.GetItemPyData(sub)
    35483548        constDict = {}
    35493549        for item in Constraints:
    … …  
    44434443                return
    44444444            dlg.Destroy()
    4445             G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
    4446             sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4445            G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistName)
     4446            sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    44474447                G2frame,G2frame.PatternId, 'Sample Parameters'))
    44484448            scale = sample['Scale'][0]
    4449             background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4449            background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    44504450                G2frame,G2frame.PatternId, 'Background'))       
    4451             limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4451            limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    44524452                G2frame,G2frame.PatternId, 'Limits'))[1]
    4453             inst = G2frame.PatternTree.GetItemPyData(
    4454                 G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     4453            inst = G2frame.GPXtree.GetItemPyData(
     4454                G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    44554455            if 'T' in inst['Type'][0]:
    44564456                wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
    44574457                return           
    4458             profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
     4458            profile = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1]
    44594459            G2pwd.CalcStackingPWDR(data['Layers'],scale,background,limits,inst,profile,debug)
    44604460            if debug:
    … …  
    45334533            return
    45344534        dlg.Destroy()
    4535         G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
    4536         sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4535        G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistName)
     4536        sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    45374537            G2frame,G2frame.PatternId, 'Sample Parameters'))
    45384538        scale = sample['Scale'][0]
    4539         background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4539        background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    45404540            G2frame,G2frame.PatternId, 'Background'))       
    4541         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4541        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    45424542            G2frame,G2frame.PatternId, 'Limits'))[1]
    4543         inst = G2frame.PatternTree.GetItemPyData(
    4544             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     4543        inst = G2frame.GPXtree.GetItemPyData(
     4544            G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    45454545        if 'T' in inst['Type'][0]:
    45464546            wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
    45474547            return           
    4548         profile = np.copy(G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1])
     4548        profile = np.copy(G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1])
    45494549        resultXY2 = []
    45504550        resultXY = [np.vstack((profile[0],profile[1])),]    #observed data
    … …  
    48984898    def OnRestraint(event):       
    48994899        indx = drawAtoms.GetSelectedRows()
    4900         restData = G2frame.PatternTree.GetItemPyData(   
    4901             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Restraints'))
     4900        restData = G2frame.GPXtree.GetItemPyData(   
     4901            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Restraints'))
    49024902        drawingData = data['Drawing']
    49034903        generalData = data['General']
    … …  
    49474947            print '**** ERROR wrong number of atoms selected for this restraint'
    49484948            return
    4949         G2frame.PatternTree.SetItemPyData(   
    4950             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Restraints'),restData)
     4949        G2frame.GPXtree.SetItemPyData(   
     4950            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Restraints'),restData)
    49514951
    49524952    def OnDefineRB(event):
    49534953        indx = drawAtoms.GetSelectedRows()
    49544954        indx.sort()
    4955         RBData = G2frame.PatternTree.GetItemPyData(   
    4956             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     4955        RBData = G2frame.GPXtree.GetItemPyData(   
     4956            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    49574957        drawingData = data['Drawing']
    49584958        generalData = data['General']
    … …  
    56895689        if 'pId' in data:
    56905690            DATData['pId'] = data['pId']
    5691             DATData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     5691            DATData['covData'] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    56925692        G2stMn.DisAglTor(DATData)
    56935693                       
    … …  
    64826482        keyList = data['Histograms'].keys()
    64836483        TextList = []
    6484         if not G2frame.PatternTree.GetCount():
     6484        if not G2frame.GPXtree.GetCount():
    64856485            return
    64866486       
    6487         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     6487        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    64886488        while item:
    6489             name = G2frame.PatternTree.GetItemText(item)
     6489            name = G2frame.GPXtree.GetItemText(item)
    64906490            if name not in keyList and 'HKLF' in name:
    64916491                TextList.append(name)
    6492             item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                       
     6492            item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)                       
    64936493            if not TextList:
    64946494                G2G.G2MessageBox(G2frame.dataFrame,'No reflections')
    … …  
    65266526        for i in result:
    65276527            histoName = TextList[i]
    6528             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    6529             refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6528            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6529            refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    65306530            data['Histograms'][histoName] = {'Histogram':histoName,'Show':False,'Scale':[1.0,True],
    65316531                'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]},
    … …  
    65666566    # def UpdateHKLFdata(histoName):
    65676567    #     generalData = data['General']
    6568     #     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    6569     #     refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6568    #     Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6569    #     refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    65706570    #     SGData = generalData['SGData']
    65716571    #     Cell = generalData['Cell'][1:7]
    … …  
    65856585    def UpdateHKLFdata(histoName):
    65866586        generalData = data['General']
    6587         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    6588         refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6587        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6588        refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    65896589        SGData = generalData['SGData']
    65906590        Cell = generalData['Cell'][1:7]
    … …  
    67396739        keyList = data['Histograms'].keys()
    67406740        TextList = []
    6741         if G2frame.PatternTree.GetCount():
    6742             item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     6741        if G2frame.GPXtree.GetCount():
     6742            item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    67436743            while item:
    6744                 name = G2frame.PatternTree.GetItemText(item)
     6744                name = G2frame.GPXtree.GetItemText(item)
    67456745                if name not in keyList and 'PWDR' in name:
    67466746                    TextList.append(name)
    6747                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     6747                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    67486748            if not TextList:
    67496749                G2G.G2MessageBox(G2frame.dataFrame,'No histograms')
    … …  
    67586758                        newList = TextList[1:]
    67596759                    for histoName in newList:
    6760                         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
     6760                        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
    67616761                        data['Histograms'][histoName] = {'Histogram':histoName,'Show':False,'LeBail':False,'newLeBail':True,
    67626762                            'Scale':[1.0,False],'Pref.Ori.':['MD',1.0,False,[0,0,1],0,{},['',],0.1],
    … …  
    67676767                            'HStrain':[NDij*[0.0,],NDij*[False,]],                         
    67686768                            'Extinction':[0.0,False],'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]}}
    6769                         refList = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists'))
     6769                        refList = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Reflection Lists'))
    67706770                        refList[generalData['Name']] = {}                       
    67716771                    wx.CallAfter(G2ddG.UpdateDData,G2frame,DData,data)
    … …  
    71037103        AtLookUp = G2mth.FillAtomLookUp(data['Atoms'],cia+8)
    71047104        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    7105         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     7105        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies')
    71067106        if not Id:
    71077107            return
    7108         RBData = G2frame.PatternTree.GetItemPyData(Id)
     7108        RBData = G2frame.GPXtree.GetItemPyData(Id)
    71097109        Indx = {}
    71107110        atomStyle = 'balls & sticks'
    … …  
    71807180       
    71817181        G2frame.GetStatusBar().SetStatusText('')
    7182         RBData = G2frame.PatternTree.GetItemPyData(   
    7183             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7182        RBData = G2frame.GPXtree.GetItemPyData(   
     7183            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    71847184        rbNames = {}
    71857185        for rbVec in RBData['Vector']:
    … …  
    74797479       
    74807480    def OnAutoFindResRB(event):
    7481         RBData = G2frame.PatternTree.GetItemPyData(   
    7482             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7481        RBData = G2frame.GPXtree.GetItemPyData(   
     7482            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    74837483        rbKeys = RBData['Residue'].keys()
    74847484        rbKeys.remove('AtInfo')
    … …  
    75677567        data['RBModels']['Residue'] = []
    75687568        data['RBModels']['Vector'] = []
    7569         RBData = G2frame.PatternTree.GetItemPyData(   
    7570             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7569        RBData = G2frame.GPXtree.GetItemPyData(   
     7570            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    75717571        for RBType in ['Vector','Residue']:
    75727572            for rbId in RBData[RBType]:
    … …  
    79997999        general = data['General']
    80008000        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    8001         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     8001        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies')
    80028002        if not Id:
    80038003            return
    8004         RBData = G2frame.PatternTree.GetItemPyData(Id)
     8004        RBData = G2frame.GPXtree.GetItemPyData(Id)
    80058005        Indx = {}
    80068006#        atomStyle = 'balls & sticks'
    … …  
    80828082        covData = {}
    80838083        if 'PWDR' in reflName:
    8084             PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    8085             reflSets = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
     8084            PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     8085            reflSets = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists'))
    80868086            try:        #patch for old reflection data
    80878087                reflData = reflSets[phaseName]['RefList']
    … …  
    80908090            reflType = 'PWDR'
    80918091        elif 'HKLF' in reflName:
    8092             PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
     8092            PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
    80938093            try:
    8094                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]['RefList']
     8094                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]['RefList']
    80958095            except TypeError:
    8096                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     8096                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    80978097            reflType = 'HKLF'
    80988098        elif reflName == 'Pawley reflections':
    80998099            reflData = data['Pawley ref']
    8100             covData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     8100            covData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    81018101            reflType = 'Pawley'
    81028102        else:
    … …  
    81058105        print 'MC/SA run:'
    81068106        print 'Reflection type:',reflType,' Total No. reflections: ',len(reflData)
    8107         RBdata = G2frame.PatternTree.GetItemPyData(   
    8108             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     8107        RBdata = G2frame.GPXtree.GetItemPyData(   
     8108            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    81098109        MCSAmodels = MCSAdata['Models']
    81108110        if not len(MCSAmodels):
    … …  
    81648164       
    81658165    def OnMCSAaddRB(event):
    8166         rbData = G2frame.PatternTree.GetItemPyData(   
    8167             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     8166        rbData = G2frame.GPXtree.GetItemPyData(   
     8167            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    81688168        rbNames = {}
    81698169        for rbVec in rbData['Vector']:
    … …  
    83638363        for hist in histograms:
    83648364            if 'PWDR' in hist[:4]:
    8365                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    8366                 inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     8365                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     8366                inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    83678367                    G2frame,Id, 'Instrument Parameters'))[0]
    8368                 limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Limits'))
     8368                limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Limits'))
    83698369                Tmin = G2lat.Dsp2pos(inst,dmin)
    83708370                if 'T' in inst['Type'][0]:
    … …  
    84198419            G2frame.ErrorDialog('Pawley estimate','No histograms defined for this phase')
    84208420            return
    8421         PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistoNames[0])       #only use 1st histogram
    8422         xdata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
    8423         Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Instrument Parameters'))[0]
    8424         Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Sample Parameters'))
     8421        PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistoNames[0])       #only use 1st histogram
     8422        xdata = G2frame.GPXtree.GetItemPyData(PatternId)[1]
     8423        Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Instrument Parameters'))[0]
     8424        Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Sample Parameters'))
    84258425        wave = G2mth.getWave(Inst)
    84268426        const = 9.e-2/(np.pi*Sample['Gonio. radius'])                  #shifts in microns
    … …  
    84698469            return
    84708470        HistoNames = Histograms.keys()
    8471         PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistoNames[0])
    8472         refData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,  \
     8471        PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistoNames[0])
     8472        refData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,  \
    84738473            PatternId,'Reflection Lists'))[PhaseName]['RefList']
    84748474        im = 0
    … …  
    88908890                it = 0
    88918891                histNames.append(name)
    8892                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    8893                 Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
    8894                 Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     8892                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     8893                Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))
     8894                Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    88958895                Gangls[name] = copy.copy([Sample[item] for item in['Phi','Chi','Omega','Azimuth']])
    8896                 RefDict = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists'))[phaseName]
     8896                RefDict = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Reflection Lists'))[phaseName]
    88978897                Refs = RefDict['RefList'].T  #np.array!
    88988898                if RefDict['Super']: im = 1     #(3+1) offset for m
    … …  
    91569156    global rbAtmDict   
    91579157    rbAtmDict = {}
    9158     PhaseName = G2frame.PatternTree.GetItemText(Item)
     9158    PhaseName = G2frame.GPXtree.GetItemText(Item)
    91599159    G2gd.SetDataMenuBar(G2frame)
    91609160    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+PhaseName)

  • TabularUnified branch/2frame/GSASIIplot.py

    r2900 r2905  
    368368        '''
    369369        self.allowZoomReset = False
    370         if pid: self.G2frame.PatternTree.SelectItem(pid)
     370        if pid: self.G2frame.GPXtree.SelectItem(pid)
    371371        self.allowZoomReset = True
    372372        if plotDebug: print 'invoke',str(self).split('0x')[1],str(pid)
    … …  
    555555        G2frame.G2plotNB.status.SetStatusText('H = '+HKLtext,0)
    556556                                 
    557     Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     557    Name = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    558558    if not Title:
    559559        Title = Name
    … …  
    809809        Draw('key')
    810810           
    811     Name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     811    Name = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    812812    if Title and Title in G2frame.GetPhaseData(): #NB: save image as e.g. jpeg will fail if False; MyDir is unknown
    813813        generalData = G2frame.GetPhaseData()[Title]['General']
    … …  
    11911191    if not histogram.startswith('PWDR'): return
    11921192    pickId = G2frame.PickId
    1193     G2frame.PickId = G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, histogram)
    1194     treedata = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     1193    G2frame.PickId = G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, histogram)
     1194    treedata = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    11951195    PlotPatterns(G2frame,newPlot=True,plotType='PWDR',data=[treedata[0],refdata])
    11961196    wx.Yield() # force a plot update (needed on Windows?)
    … …  
    12031203    '''
    12041204    if PatternName:
    1205         G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, PatternName)
     1205        G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, PatternName)
    12061206    if PickName == PatternName:
    12071207        G2frame.PickId = G2frame.PatternId
    12081208    elif PickName:
    1209         G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.PatternId, PickName)
     1209        G2frame.PickId = G2gd.GetGPXtreeItemId(G2frame, G2frame.PatternId, PickName)
    12101210    # for now I am not sure how to regenerate G2frame.HKL
    12111211    G2frame.HKL = [] # TODO
    … …  
    12371237#patch
    12381238    if data is None:
    1239         data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     1239        data = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    12401240    if 'Offset' not in data[0] and plotType in ['PWDR','SASD','REFD']:     #plot offset data
    12411241        Ymax = max(data[1][1])
    12421242        data[0].update({'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-0.1*Ymax,
    12431243            'refDelt':0.1*Ymax,})
    1244         G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
     1244        G2frame.GPXtree.SetItemPyData(G2frame.PickId,data)
    12451245#end patch
    12461246    def OnPlotKeyPress(event):
    12471247        try:        #one way to check if key stroke will work on plot
    1248             Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     1248            Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
    12491249        except TypeError:
    12501250            G2frame.G2plotNB.status.SetStatusText('Select '+plottype+' pattern first',1)
    … …  
    13351335            newPlot = True
    13361336        elif event.key == 'f' and not G2frame.SinglePlot:
    1337             choices = G2gd.GetPatternTreeDataNames(G2frame,plotType)
     1337            choices = G2gd.GetGPXtreeDataNames(G2frame,plotType)
    13381338            dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,'Select dataset to plot',
    13391339                'Multidata plot selection',choices)
    … …  
    13731373            Page.canvas.SetCursor(wx.CROSS_CURSOR)
    13741374            try:
    1375                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters')
     1375                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters')
    13761376                if not Id: return
    1377                 Parms,Parms2 = G2frame.PatternTree.GetItemPyData(Id)
     1377                Parms,Parms2 = G2frame.GPXtree.GetItemPyData(Id)
    13781378                if G2frame.plotStyle['qPlot'] and 'PWDR' in plottype:
    13791379                    q = xpos
    … …  
    14221422                if G2frame.PickId:
    14231423                    found = []
    1424                     pickIdText = G2frame.PatternTree.GetItemText(G2frame.PickId)
     1424                    pickIdText = G2frame.GPXtree.GetItemText(G2frame.PickId)
    14251425                    if pickIdText in ['Index Peak List','Unit Cells List','Reflection Lists'] or \
    14261426                        'PWDR' in pickIdText:
    … …  
    15461546
    15471547        try:
    1548             Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     1548            Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
    15491549        except TypeError:
    15501550            return
    … …  
    15701570        PatternId = G2frame.PatternId
    15711571        PickId = G2frame.PickId
    1572         if G2frame.PatternTree.GetItemText(PickId) == 'Peak List':
     1572        if G2frame.GPXtree.GetItemText(PickId) == 'Peak List':
    15731573            if ind.all() != [0] and ObsLine[0].get_label() in str(pick):    #picked a data point, add a new peak
    1574                 data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
     1574                data = G2frame.GPXtree.GetItemPyData(G2frame.PickId)
    15751575                XY = G2mth.setPeakparms(Parms,Parms2,xy[0],xy[1])
    15761576                data['peaks'].append(XY)
    … …  
    15881588                G2frame.cid = Page.canvas.mpl_connect('motion_notify_event', OnDragLine)
    15891589                pick.set_linestyle('--') # back to dashed
    1590         elif G2frame.PatternTree.GetItemText(PickId) == 'Limits':
     1590        elif G2frame.GPXtree.GetItemText(PickId) == 'Limits':
    15911591            if ind.all() != [0]:                                    #picked a data point
    1592                 LimitId = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
    1593                 data = G2frame.PatternTree.GetItemPyData(LimitId)
     1592                LimitId = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits')
     1593                data = G2frame.GPXtree.GetItemPyData(LimitId)
    15941594                if G2frame.plotStyle['qPlot']:                              #qplot - convert back to 2-theta
    15951595                    xy[0] = G2lat.Dsp2pos(Parms,2*np.pi/xy[0])
    … …  
    16071607                    if mouse.button==3:
    16081608                        data[1][1] = max(xy[0],data[1][0])
    1609                 G2frame.PatternTree.SetItemPyData(LimitId,data)
     1609                G2frame.GPXtree.SetItemPyData(LimitId,data)
    16101610                G2pdG.UpdateLimitsGrid(G2frame,data,plottype)
    16111611                wx.CallAfter(PlotPatterns,G2frame,plotType=plottype)
    … …  
    16211621                pick.set_linestyle('--') # back to dashed
    16221622               
    1623         elif G2frame.PatternTree.GetItemText(PickId) == 'Models':
     1623        elif G2frame.GPXtree.GetItemText(PickId) == 'Models':
    16241624            if ind.all() != [0]:                                    #picked a data point
    1625                 LimitId = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
    1626                 data = G2frame.PatternTree.GetItemPyData(LimitId)
     1625                LimitId = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits')
     1626                data = G2frame.GPXtree.GetItemPyData(LimitId)
    16271627                if mouse.button==1:
    16281628                    data[1][0] = min(xy[0],data[1][1])
    16291629                if mouse.button==3:
    16301630                    data[1][1] = max(xy[0],data[1][0])
    1631                 G2frame.PatternTree.SetItemPyData(LimitId,data)
     1631                G2frame.GPXtree.SetItemPyData(LimitId,data)
    16321632                wx.CallAfter(PlotPatterns,G2frame,plotType=plottype)
    16331633            else:                                                   #picked a limit line
    16341634                G2frame.itemPicked = pick
    1635         elif (G2frame.PatternTree.GetItemText(PickId) == 'Reflection Lists' or
    1636                 'PWDR' in G2frame.PatternTree.GetItemText(PickId)
     1635        elif (G2frame.GPXtree.GetItemText(PickId) == 'Reflection Lists' or
     1636                'PWDR' in G2frame.GPXtree.GetItemText(PickId)
    16371637                ):
    16381638            G2frame.itemPicked = pick
    … …  
    16641664                G2frame.cid = Page.canvas.mpl_connect('motion_notify_event', OnDragTickmarks)
    16651665           
    1666         elif G2frame.PatternTree.GetItemText(PickId) == 'Background':
     1666        elif G2frame.GPXtree.GetItemText(PickId) == 'Background':
    16671667            # selected a fixed background point. Can move it or delete it.
    16681668            for mode,id in G2frame.dataFrame.wxID_BackPts.iteritems(): # what menu is selected?
    … …  
    16721672            if pick.get_marker() == 'D':
    16731673                # find the closest point
    1674                 backDict = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
     1674                backDict = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
    16751675                d2 = [(x-xy[0])**2+(y-xy[1])**2 for x,y in backDict['FixedPoints']]
    16761676                G2frame.fixPtMarker = d2.index(min(d2))
    … …  
    17081708       
    17091709        PickId = G2frame.PickId                             # points to item in tree
    1710         if G2frame.PatternTree.GetItemText(PickId) == 'Background' and event.xdata:
     1710        if G2frame.GPXtree.GetItemText(PickId) == 'Background' and event.xdata:
    17111711            if Page.toolbar._active:    # prevent ops. if a toolbar zoom button pressed
    17121712                return
    … …  
    17141714            if G2frame.SubBack or G2frame.Weight or G2frame.Contour or not G2frame.SinglePlot:
    17151715                return
    1716             backDict = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
     1716            backDict = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
    17171717            if 'FixedPoints' not in backDict: backDict['FixedPoints'] = []
    17181718            try:
    1719                 Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     1719                Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
    17201720            except TypeError:
    17211721                return
    … …  
    17451745        if G2frame.itemPicked is None: return
    17461746        if DifLine[0] is G2frame.itemPicked:   # respond to dragging of the difference curve
    1747             data = G2frame.PatternTree.GetItemPyData(PickId)
     1747            data = G2frame.GPXtree.GetItemPyData(PickId)
    17481748            ypos = event.ydata
    17491749            Pattern[0]['delOffset'] = -ypos
    … …  
    17511751            wx.CallAfter(PlotPatterns,G2frame,plotType=plottype)
    17521752            return
    1753         Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     1753        Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
    17541754        xpos = event.xdata
    1755         if G2frame.PatternTree.GetItemText(PickId) in ['Peak List','Limits'] and xpos:
     1755        if G2frame.GPXtree.GetItemText(PickId) in ['Peak List','Limits'] and xpos:
    17561756            lines = []
    17571757            for line in G2frame.Lines:
    … …  
    17631763            nxcl = len(exclLines)
    17641764            if  lineNo in [0,1] or lineNo in exclLines:
    1765                 LimitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits')
    1766                 limits = G2frame.PatternTree.GetItemPyData(LimitId)
     1765                LimitId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits')
     1766                limits = G2frame.GPXtree.GetItemPyData(LimitId)
    17671767                id = lineNo/2+1
    17681768                id2 = lineNo%2
    … …  
    17771777                limits[1][0] = min(max(limits[0][0],limits[1][0]),limits[1][1])
    17781778                limits[1][1] = max(min(limits[0][1],limits[1][1]),limits[1][0])
    1779                 if G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Limits':
     1779                if G2frame.GPXtree.GetItemText(G2frame.PickId) == 'Limits':
    17801780                    G2pdG.UpdateLimitsGrid(G2frame,limits,plottype)
    17811781            elif lineNo > 1+nxcl:
    1782                 PeakId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List')
    1783                 peaks = G2frame.PatternTree.GetItemPyData(PeakId)
     1782                PeakId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Peak List')
     1783                peaks = G2frame.GPXtree.GetItemPyData(PeakId)
    17841784                if event.button == 3:
    17851785                    del peaks['peaks'][lineNo-2-nxcl]
    … …  
    17931793                    peaks['sigDict'] = {}        #no longer valid
    17941794                G2pdG.UpdatePeakGrid(G2frame,peaks)
    1795         elif G2frame.PatternTree.GetItemText(PickId) in ['Models',] and xpos:
     1795        elif G2frame.GPXtree.GetItemText(PickId) in ['Models',] and xpos:
    17961796            lines = []
    17971797            for line in G2frame.Lines:
    … …  
    18021802                lineNo = -1
    18031803            if  lineNo in [0,1]:
    1804                 LimitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits')
    1805                 data = G2frame.PatternTree.GetItemPyData(LimitId)
     1804                LimitId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits')
     1805                data = G2frame.GPXtree.GetItemPyData(LimitId)
    18061806                data[1][lineNo] = xpos
    18071807                data[1][0] = min(max(data[0][0],data[1][0]),data[1][1])
    18081808                data[1][1] = max(min(data[0][1],data[1][1]),data[1][0])
    1809         elif (G2frame.PatternTree.GetItemText(PickId) == 'Reflection Lists' or \
    1810             'PWDR' in G2frame.PatternTree.GetItemText(PickId)) and xpos:
    1811             Id = G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists')
     1809        elif (G2frame.GPXtree.GetItemText(PickId) == 'Reflection Lists' or \
     1810            'PWDR' in G2frame.GPXtree.GetItemText(PickId)) and xpos:
     1811            Id = G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists')
    18121812#            GSASIIpath.IPyBreak()
    18131813            if Id:     
    1814                 #Phases = G2frame.PatternTree.GetItemPyData(Id)
     1814                #Phases = G2frame.GPXtree.GetItemPyData(Id)
    18151815                pick = str(G2frame.itemPicked).split('(',1)[1][:-1]
    18161816                if 'line' not in pick:       #avoid data points, etc.
    1817                     data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     1817                    data = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    18181818                    num = Page.phaseList.index(pick)
    18191819                    if num:
    … …  
    18401840        Page.canvas.mpl_connect('button_release_event', OnRelease)
    18411841        Page.canvas.mpl_connect('button_press_event',OnPress)
    1842     if 'PWDR' in G2frame.PatternTree.GetItemText(G2frame.PickId):
     1842    if 'PWDR' in G2frame.GPXtree.GetItemText(G2frame.PickId):
    18431843        Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
    18441844        refColors=['b','r','c','g','m','k']
    18451845        Page.phaseColors = {p:refColors[i%len(refColors)] for i,p in enumerate(Phases)}
    1846         Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Reflection Lists'))
     1846        Phases = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Reflection Lists'))
    18471847        Page.phaseList = sorted(Phases.keys()) # define an order for phases (once!)
    18481848        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveDiffCurve, id=G2frame.dataWindow.moveDiffCurve.GetId())
    … …  
    18521852        G2frame.dataWindow.moveTickLoc.Enable(False)
    18531853        G2frame.dataWindow.moveTickSpc.Enable(False)
    1854     elif G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Peak List':
     1854    elif G2frame.GPXtree.GetItemText(G2frame.PickId) == 'Peak List':
    18551855        G2frame.dataFrame.Bind(wx.EVT_MENU, onMovePeak, id=G2frame.dataWindow.movePeak.GetId())
    18561856    # save information needed to reload from tree and redraw
    1857     kwargs={'PatternName':G2frame.PatternTree.GetItemText(G2frame.PatternId)}
     1857    kwargs={'PatternName':G2frame.GPXtree.GetItemText(G2frame.PatternId)}
    18581858    if G2frame.PickId:
    1859         kwargs['PickName'] = G2frame.PatternTree.GetItemText(G2frame.PickId)
     1859        kwargs['PickName'] = G2frame.GPXtree.GetItemText(G2frame.PickId)
    18601860    #G2frame.G2plotNB.RegisterRedrawRoutine('Powder Patterns',ReplotPattern,
    18611861    G2frame.G2plotNB.RegisterRedrawRoutine(G2frame.G2plotNB.lastRaisedPlotTab,ReplotPattern,
    … …  
    19161916    exclLines = []
    19171917    if G2frame.SinglePlot and PatternId:
    1918         Pattern = G2frame.PatternTree.GetItemPyData(PatternId)
    1919         Pattern.append(G2frame.PatternTree.GetItemText(PatternId))
     1918        Pattern = G2frame.GPXtree.GetItemPyData(PatternId)
     1919        Pattern.append(G2frame.GPXtree.GetItemText(PatternId))
    19201920        PlotList = [Pattern,]
    1921         Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1921        Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    19221922            G2frame.PatternId, 'Instrument Parameters'))
    1923         Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
     1923        Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
    19241924        ParmList = [Parms,]
    19251925        SampleList = [Sample,]
    … …  
    19311931        SampleList = []
    19321932        if G2frame.selections is None:
    1933             choices = G2gd.GetPatternTreeDataNames(G2frame,plotType)
     1933            choices = G2gd.GetGPXtreeDataNames(G2frame,plotType)
    19341934        else:
    19351935            choices = G2frame.selections
    19361936        for item in choices:
    1937             id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, item)
    1938             Pattern = G2frame.PatternTree.GetItemPyData(id)
     1937            id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, item)
     1938            Pattern = G2frame.GPXtree.GetItemPyData(id)
    19391939            if len(Pattern) < 3:                    # put name on end if needed
    1940                 Pattern.append(G2frame.PatternTree.GetItemText(id))
     1940                Pattern.append(G2frame.GPXtree.GetItemText(id))
    19411941            if 'Offset' not in Pattern[0]:     #plot offset data
    19421942                Ymax = max(Pattern[1][1])
    19431943                Pattern[0].update({'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-0.1*Ymax,'refDelt':0.1*Ymax,})
    19441944            PlotList.append(Pattern)
    1945             ParmList.append(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1945            ParmList.append(G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    19461946                id,'Instrument Parameters'))[0])
    1947             SampleList.append(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1947            SampleList.append(G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    19481948                id, 'Sample Parameters')))
    19491949    lenX = 0
    … …  
    20112011        xye = ma.array(ma.getdata(Pattern[1]))
    20122012        if PickId:
    2013             ifpicked = Pattern[2] == G2frame.PatternTree.GetItemText(PatternId)
    2014             LimitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Limits')
    2015             limits = G2frame.PatternTree.GetItemPyData(LimitId)
     2013            ifpicked = Pattern[2] == G2frame.GPXtree.GetItemText(PatternId)
     2014            LimitId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Limits')
     2015            limits = G2frame.GPXtree.GetItemPyData(LimitId)
    20162016            excls = limits[2:]
    20172017            for excl in excls:
    … …  
    20422042                Y = xye[1]*Sample['Scale'][0]*(1.05)**(offsetY*N)
    20432043        if LimitId and ifpicked:
    2044             limits = np.array(G2frame.PatternTree.GetItemPyData(LimitId))
     2044            limits = np.array(G2frame.GPXtree.GetItemPyData(LimitId))
    20452045            lims = limits[1]
    20462046            if G2frame.plotStyle['qPlot'] and 'PWDR' in plottype:
    … …  
    21692169                Page.canvas.SetToolTipString('')
    21702170                if PickId:
    2171                     if G2frame.PatternTree.GetItemText(PickId) == 'Peak List':
     2171                    if G2frame.GPXtree.GetItemText(PickId) == 'Peak List':
    21722172                        tip = 'On data point: Pick peak - L or R MB. On line: L-move, R-delete'
    21732173                        Page.canvas.SetToolTipString(tip)
    2174                         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
     2174                        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'))
    21752175                        selectedPeaks = list(set(
    21762176                            [row for row,col in G2frame.reflGrid.GetSelectedCells()] +
    … …  
    21902190                            if Ni == N+1:
    21912191                                Lines[-1].set_lw(Lines[-1].get_lw()+1)
    2192                     if G2frame.PatternTree.GetItemText(PickId) == 'Limits':
     2192                    if G2frame.GPXtree.GetItemText(PickId) == 'Limits':
    21932193                        tip = 'On data point: Lower limit - L MB; Upper limit - R MB. On limit: MB down to move'
    21942194                        Page.canvas.SetToolTipString(tip)
    2195                         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))
     2195                        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))
    21962196                       
    21972197            else:   #not picked
    … …  
    22112211                    Plot.set_ylim(bottom=np.min(np.trim_zeros(Y))/2.,top=np.max(Y)*2.)
    22122212    if PickId and not G2frame.Contour:
    2213         Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    2214         if G2frame.PatternTree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
    2215             peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
     2213        Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     2214        if G2frame.GPXtree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
     2215            peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'))
    22162216            if not len(peaks): return # are there any peaks?
    22172217            for peak in peaks[0]:
    … …  
    22332233                else:
    22342234                    Plot.axvline(hkl[-2],color=clr,dashes=(5,5))
    2235         elif G2frame.PatternTree.GetItemText(PickId) in ['Reflection Lists'] or \
    2236             'PWDR' in G2frame.PatternTree.GetItemText(PickId):
    2237             Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
     2235        elif G2frame.GPXtree.GetItemText(PickId) in ['Reflection Lists'] or \
     2236            'PWDR' in G2frame.GPXtree.GetItemText(PickId):
     2237            Phases = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists'))
    22382238            l = GSASIIpath.GetConfigValue('Tick_length',8.0)
    22392239            w = GSASIIpath.GetConfigValue('Tick_width',1.)
    … …  
    22682268    else:
    22692269        G2frame.Lines = Lines
    2270     if PickId and G2frame.PatternTree.GetItemText(PickId) == 'Background':
     2270    if PickId and G2frame.GPXtree.GetItemText(PickId) == 'Background':
    22712271        # plot fixed background points
    2272         backDict = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
     2272        backDict = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Background'))[1]
    22732273        try:
    2274             Parms,Parms2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     2274            Parms,Parms2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
    22752275        except TypeError:
    22762276            Parms = None
    … …  
    23102310    # and sqrt(-ve) in np.where usage               
    23112311#    G2frame.Pwdr = True
    2312     if 'PWDR' in G2frame.PatternTree.GetItemText(G2frame.PickId):
     2312    if 'PWDR' in G2frame.GPXtree.GetItemText(G2frame.PickId):
    23132313        if len(Page.tickDict.keys()) == 1:
    23142314            G2frame.dataWindow.moveTickLoc.Enable(True)
    … …  
    23262326    'Produces normal probability plot for a powder or single crystal histogram'
    23272327    if PatternName:
    2328         G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, PatternName)
     2328        G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, PatternName)
    23292329    new,plotNum,Page,Plot,lim = G2frame.G2plotNB.FindPlotTab('Error analysis','mpl')
    23302330    if new:
    … …  
    23352335                                           PlotDeltSig,(
    23362336                                               G2frame,kind,
    2337                                                G2frame.PatternTree.GetItemText(G2frame.PatternId))
     2337                                               G2frame.GPXtree.GetItemText(G2frame.PatternId))
    23382338                                           )
    23392339    Page.Choice = None
    23402340    PatternId = G2frame.PatternId
    2341     Pattern = G2frame.PatternTree.GetItemPyData(PatternId)
    2342     Pattern.append(G2frame.PatternTree.GetItemText(PatternId))
     2341    Pattern = G2frame.GPXtree.GetItemPyData(PatternId)
     2342    Pattern.append(G2frame.GPXtree.GetItemText(PatternId))
    23432343    wtFactor = Pattern[0]['wtFactor']
    23442344    if kind == 'PWDR':
    2345         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
     2345        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))[1]
    23462346        xye = np.array(Pattern[1])
    23472347        xmin = np.searchsorted(xye[0],limits[0])
    … …  
    24462446            G2frame.Waterfall = not G2frame.Waterfall
    24472447        elif event.key == 'f' and not G2frame.SinglePlot:
    2448             choices = G2gd.GetPatternTreeDataNames(G2frame,'PDF ')
     2448            choices = G2gd.GetGPXtreeDataNames(G2frame,'PDF ')
    24492449            dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,'Select dataset to plot',
    24502450                'Multidata plot selection',choices)
    … …  
    25962596    PatternId = G2frame.PatternId
    25972597    if not PatternId:  return
    2598     pId = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'PDF Controls')
     2598    pId = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'PDF Controls')
    25992599    if not pId:  return
    2600     PDFdata = G2frame.PatternTree.GetItemPyData(pId)
     2600    PDFdata = G2frame.GPXtree.GetItemPyData(pId)
    26012601    numbDen = 0.
    26022602    if 'ElList' in PDFdata:
    … …  
    26102610        PlotList = []
    26112611        if G2frame.PDFselections is None:
    2612             choices = G2gd.GetPatternTreeDataNames(G2frame,'PDF ')
     2612            choices = G2gd.GetGPXtreeDataNames(G2frame,'PDF ')
    26132613        else:
    26142614            choices = G2frame.PDFselections
    26152615        for item in choices:
    2616             Pid = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    2617             Id = G2gd.GetPatternTreeItemId(G2frame,Pid,'PDF Controls')
    2618             Pattern = G2frame.PatternTree.GetItemPyData(Id)
     2616            Pid = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     2617            Id = G2gd.GetGPXtreeItemId(G2frame,Pid,'PDF Controls')
     2618            Pattern = G2frame.GPXtree.GetItemPyData(Id)
    26192619            if Pattern:
    26202620                PlotList.append(Pattern[plotType])
    … …  
    31553155    Page.Choice = None
    31563156    PatternId = G2frame.PatternId
    3157     data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Models'))
     3157    data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Models'))
    31583158    Bins,Dbins,BinMag = data['Size']['Distribution']
    31593159    Plot.set_title('Size Distribution')
    … …  
    31853185            Page.canvas.SetCursor(wx.CROSS_CURSOR)
    31863186            G2frame.G2plotNB.status.SetStatusText('2-theta =%9.3f '%(xpos,),1)
    3187             if G2frame.PickId and G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Index Peak List','Unit Cells List']:
     3187            if G2frame.PickId and G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Index Peak List','Unit Cells List']:
    31883188                found = []
    31893189                if len(G2frame.HKL):
    … …  
    32043204    Plot.set_xlabel(r'$\mathsf{2\theta}$',fontsize=14)
    32053205    PatternId = G2frame.PatternId
    3206     peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))[0]
     3206    peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'))[0]
    32073207    for peak in peaks:
    32083208        Plot.axvline(peak[0],color='b')
    … …  
    32323232#    gamFW2 = lambda s,g: math.sqrt(s**2+(0.4654996*g)**2)+.5345004*g  #Ubaldo Bafile - private communication
    32333233    if PatternName:
    3234         G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, PatternName)
     3234        G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame, G2frame.root, PatternName)
    32353235    PatternId = G2frame.PatternId
    3236     limitID = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
     3236    limitID = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits')
    32373237    if limitID:
    3238         limits = G2frame.PatternTree.GetItemPyData(limitID)[:2]
     3238        limits = G2frame.GPXtree.GetItemPyData(limitID)[:2]
    32393239    else:
    32403240        return
    3241     Parms,Parms2 = G2frame.PatternTree.GetItemPyData( \
    3242         G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     3241    Parms,Parms2 = G2frame.GPXtree.GetItemPyData( \
     3242        G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    32433243    if 'PKS' in Parms['Type'][0]:
    32443244        return
    … …  
    32483248        lam = G2mth.getWave(Parms)
    32493249    try:  # PATCH: deal with older peak lists, before changed to dict to implement TOF
    3250         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))['peaks']
     3250        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'))['peaks']
    32513251    except TypeError:
    32523252        print "Your peak list needs reformatting...",
    3253         item = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List')
    3254         G2frame.PatternTree.SelectItem(item) 
    3255         item = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters')
    3256         G2frame.PatternTree.SelectItem(item)
     3253        item = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List')
     3254        G2frame.GPXtree.SelectItem(item) 
     3255        item = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters')
     3256        G2frame.GPXtree.SelectItem(item)
    32573257        print "done"
    32583258        return
    … …  
    32643264    # save information needed to reload from tree and redraw
    32653265    G2frame.G2plotNB.RegisterRedrawRoutine(G2frame.G2plotNB.lastRaisedPlotTab,
    3266             PlotPeakWidths,(G2frame,G2frame.PatternTree.GetItemText(G2frame.PatternId))
     3266            PlotPeakWidths,(G2frame,G2frame.GPXtree.GetItemText(G2frame.PatternId))
    32673267            )
    32683268
    3269     TreeItemText = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     3269    TreeItemText = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    32703270    G2frame.G2plotNB.status.SetStatusText('histogram: '+TreeItemText,1)
    32713271    Page.Choice = None
    … …  
    35713571            Plot.set_ylabel('MRD',fontsize=14)
    35723572    elif plotType in ['Inv. pole figure',]:
    3573         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    3574         rId = G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists')
    3575         RefData = G2frame.PatternTree.GetItemPyData(rId)[phase]
     3573        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     3574        rId = G2gd.GetGPXtreeItemId(G2frame,Id,'Reflection Lists')
     3575        RefData = G2frame.GPXtree.GetItemPyData(rId)[phase]
    35763576        Type = RefData['Type']
    35773577        Refs = RefData['RefList'].T
    … …  
    43584358    :param wx.Frame G2frame: The main GSAS-II tree "window"
    43594359    '''
    4360     Masks = G2frame.PatternTree.GetItemPyData(
    4361         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
     4360    Masks = G2frame.GPXtree.GetItemPyData(
     4361        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Masks'))
    43624362    if G2frame.MaskKey == 'f':
    43634363        new,plotNum,Page,Plot,lim = G2frame.G2plotNB.FindPlotTab('2D Powder Image','mpl',newImage=False)
    … …  
    43964396    '''
    43974397    G2frame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value',0)
    4398     G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Stress/Strain')
    4399     data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
     4398    G2frame.PickId = G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Stress/Strain')
     4399    data = G2frame.GPXtree.GetItemPyData(G2frame.PickId)
    44004400    return data
    44014401
    … …  
    44674467    global Data,Masks,StrSta  # RVD: these are needed for multiple image controls/masks
    44684468    colors=['b','g','r','c','m','k']
    4469     Data = G2frame.PatternTree.GetItemPyData(
    4470         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     4469    Data = G2frame.GPXtree.GetItemPyData(
     4470        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    44714471# patch
    44724472    if 'invert_x' not in Data:
    … …  
    44744474        Data['invert_y'] = True
    44754475# end patch
    4476     Masks = G2frame.PatternTree.GetItemPyData(
    4477         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
     4476    Masks = G2frame.GPXtree.GetItemPyData(
     4477        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Masks'))
    44784478    try:    #may be absent
    4479         StrSta = G2frame.PatternTree.GetItemPyData(
    4480             G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Stress/Strain'))
     4479        StrSta = G2frame.GPXtree.GetItemPyData(
     4480            G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Stress/Strain'))
    44814481    except TypeError:   #is missing
    44824482        StrSta = {}
    … …  
    44924492            scalex = 1000./pixelSize[0]         #microns --> 1/mm
    44934493            scaley = 1000./pixelSize[1]
    4494             if item and G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Image Controls':
     4494            if item and G2frame.GPXtree.GetItemText(G2frame.PickId) == 'Image Controls':
    44954495                if 'Text' in str(item):
    44964496                    Page.canvas.SetToolTipString('%8.3f %8.3fmm'%(event.xdata,event.ydata))
    … …  
    45264526    def OnImPlotKeyPress(event):
    45274527        try:
    4528             treeItem = G2frame.PatternTree.GetItemText(G2frame.PickId)
     4528            treeItem = G2frame.GPXtree.GetItemText(G2frame.PickId)
    45294529        except TypeError:
    45304530            return
    … …  
    47924792
    47934793        if G2frame.itemPicked is not None: return
    4794         if G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Image Controls':
     4794        if G2frame.GPXtree.GetItemText(G2frame.PickId) == 'Image Controls':
    47954795            G2frame.itemPicked = pick = event.artist
    47964796            G2frame.mousePicked = event.mouseevent
    … …  
    48044804            G2frame.cid = Page.canvas.mpl_connect('motion_notify_event', OnDragIntBound)
    48054805            pick.set_linestyle(saveLinestyle) # back to original
    4806         elif G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Masks':
     4806        elif G2frame.GPXtree.GetItemText(G2frame.PickId) == 'Masks':
    48074807            # prepare to animate dragging of mask
    48084808            G2frame.itemPicked = pick = event.artist
    … …  
    48394839        '''
    48404840        try:
    4841             treeItem = G2frame.PatternTree.GetItemText(G2frame.PickId)
     4841            treeItem = G2frame.GPXtree.GetItemText(G2frame.PickId)
    48424842        except TypeError:
    48434843            return
    … …  
    50795079        Page.canvas.mpl_connect('button_release_event', OnImRelease)
    50805080    Page.Choice = None
    5081     Title = G2frame.PatternTree.GetItemText(G2frame.Image)[4:]
     5081    Title = G2frame.GPXtree.GetItemText(G2frame.Image)[4:]
    50825082    G2frame.G2plotNB.status.DestroyChildren()
    50835083    if G2frame.logPlot:
    … …  
    50855085    Plot.set_title(Title)
    50865086    try:
    5087         if G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Image Controls',]:
     5087        if G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Image Controls',]:
    50885088            Page.Choice = (' key press','l: log(I) on','d: set dmin','x: flip x','y: flip y',)
    50895089            if G2frame.logPlot:
    50905090                Page.Choice[1] = 'l: log(I) off'
    50915091            Page.keyPress = OnImPlotKeyPress
    5092         elif G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Masks',]:
     5092        elif G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Masks',]:
    50935093            Page.Choice = [' key press','l: log(I) on','a: arc mask','r: ring mask',
    50945094                'p: polygon mask','f: frame mask',
    … …  
    50995099                Page.Choice[1] = 'l: log(I) off'
    51005100            Page.keyPress = OnImPlotKeyPress
    5101         elif G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Stress/Strain',]:
     5101        elif G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Stress/Strain',]:
    51025102            Page.Choice = (' key press','a: add new ring',)
    51035103            Page.keyPress = OnImPlotKeyPress
    51045104    except TypeError:
    51055105        pass
    5106     size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(G2frame.Image)
     5106    size,imagefile,imagetag = G2frame.GPXtree.GetImageLoc(G2frame.Image)
    51075107
    51085108    imScale = 1
    … …  
    51425142           
    51435143        Plot.plot(xcent,ycent,'x')
    5144         #G2frame.PatternTree.GetItemText(item)
     5144        #G2frame.GPXtree.GetItemText(item)
    51455145        if Data['showLines']: # draw integration range arc/circles/lines
    51465146            LRAzim = Data['LRazimuth']                  #NB: integers
    … …  
    51855185                Plot.plot([arcxI[ind],arcxO[ind]],[arcyI[ind],arcyO[ind]],color='k',dashes=(5,5))
    51865186                   
    5187         if G2frame.PickId and G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Image Controls',]:
     5187        if G2frame.PickId and G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Image Controls',]:
    51885188            for xring,yring in Data['ring']:
    51895189                Plot.plot(xring,yring,'r+',picker=3)
    … …  
    51995199                    Plot.add_artist(Ellipse([cent[0],cent[1]],2*width,2*height,phi,ec=col,fc='none'))
    52005200                    Plot.text(cent[0],cent[1],'+',color=col,ha='center',va='center')
    5201         if G2frame.PickId and G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Stress/Strain',]:
     5201        if G2frame.PickId and G2frame.GPXtree.GetItemText(G2frame.PickId) in ['Stress/Strain',]:
    52025202            for N,ring in enumerate(StrSta['d-zero']):
    52035203                if 'ImxyCalc' in ring:
    … …  
    53275327    Page.Choice = None
    53285328       
    5329     Data = G2frame.PatternTree.GetItemPyData(
    5330         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     5329    Data = G2frame.GPXtree.GetItemPyData(
     5330        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    53315331    image = G2frame.Integrate[0]
    53325332    xsc = G2frame.Integrate[1]
    … …  
    53345334    Imin,Imax = Data['range'][1]
    53355335    acolor = mpl.cm.get_cmap(Data['color'])
    5336     Plot.set_title(G2frame.PatternTree.GetItemText(G2frame.Image)[4:])
     5336    Plot.set_title(G2frame.GPXtree.GetItemText(G2frame.Image)[4:])
    53375337    Plot.set_ylabel('azimuth',fontsize=12)
    53385338    Plot.set_xlabel('2-theta',fontsize=12)
    … …  
    53815381        Page.views = False
    53825382    Page.Choice = None
    5383     Data = G2frame.PatternTree.GetItemPyData(
    5384         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     5383    Data = G2frame.GPXtree.GetItemPyData(
     5384        G2gd.GetGPXtreeItemId(G2frame,G2frame.Image, 'Image Controls'))
    53855385    Imin,Imax = Data['range'][1]
    53865386    step = (Imax-Imin)/5.
    53875387    V = np.arange(Imin,Imax,step)
    53885388    acolor = mpl.cm.get_cmap(Data['color'])
    5389     Plot.set_title(G2frame.PatternTree.GetItemText(G2frame.Image)[4:])
     5389    Plot.set_title(G2frame.GPXtree.GetItemText(G2frame.Image)[4:])
    53905390    Plot.set_xlabel('azimuth',fontsize=12)
    53915391    Plot.set_ylabel('2-theta',fontsize=12)

  • TabularUnified branch/2frame/GSASIIpwdGUI.py

    r2900 r2905  
    136136def IsHistogramInAnyPhase(G2frame,histoName):
    137137    'Needs a doc string'
    138     phases = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
     138    phases = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
    139139    if phases:
    140         item, cookie = G2frame.PatternTree.GetFirstChild(phases)
     140        item, cookie = G2frame.GPXtree.GetFirstChild(phases)
    141141        while item:
    142             data = G2frame.PatternTree.GetItemPyData(item)
     142            data = G2frame.GPXtree.GetItemPyData(item)
    143143            histoList = data['Histograms'].keys()
    144144            if histoName in histoList:
    145                 return G2frame.PatternTree.GetItemText(item)
    146             item, cookie = G2frame.PatternTree.GetNextChild(phases, cookie)
     145                return G2frame.GPXtree.GetItemText(item)
     146            item, cookie = G2frame.GPXtree.GetNextChild(phases, cookie)
    147147        return False
    148148    else:
    … …  
    221221def GetFileList(G2frame,fileType):
    222222    fileList = []
    223     id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     223    id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    224224    while id:
    225         name = G2frame.PatternTree.GetItemText(id)
     225        name = G2frame.GPXtree.GetItemText(id)
    226226        if fileType in name.split()[0]:
    227227            fileList.append(name)
    228         id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     228        id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    229229    return fileList
    230230       
    … …  
    238238    '''
    239239    histList = []
    240     inst,inst2 = G2frame.PatternTree.GetItemPyData(
    241         G2gd.GetPatternTreeItemId(
     240    inst,inst2 = G2frame.GPXtree.GetItemPyData(
     241        G2gd.GetGPXtreeItemId(
    242242            G2frame,G2frame.PatternId, 'Instrument Parameters')
    243243        )
    … …  
    249249    else:
    250250        hLam = 0
    251     sample = G2frame.PatternTree.GetItemPyData(
    252         G2gd.GetPatternTreeItemId(
     251    sample = G2frame.GPXtree.GetItemPyData(
     252        G2gd.GetGPXtreeItemId(
    253253            G2frame,G2frame.PatternId, 'Sample Parameters')
    254254        )
    255255    hGeom = sample.get('Type')
    256     hstName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     256    hstName = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    257257    hPrefix = hstName.split()[0]+' '
    258258    # cycle through tree looking for items that match the above
    259     item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)       
     259    item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)       
    260260    while item:
    261         name = G2frame.PatternTree.GetItemText(item)
     261        name = G2frame.GPXtree.GetItemText(item)
    262262        if name.startswith(hPrefix) and name != hstName:
    263263            cGeom,cType,cLam, = '?','?',-1
    264             subitem, subcookie = G2frame.PatternTree.GetFirstChild(item)
     264            subitem, subcookie = G2frame.GPXtree.GetFirstChild(item)
    265265            while subitem:
    266                 subname = G2frame.PatternTree.GetItemText(subitem)
     266                subname = G2frame.GPXtree.GetItemText(subitem)
    267267                if subname == 'Sample Parameters':
    268                     sample = G2frame.PatternTree.GetItemPyData(subitem)
     268                    sample = G2frame.GPXtree.GetItemPyData(subitem)
    269269                    cGeom = sample.get('Type')
    270270                elif subname == 'Instrument Parameters':
    271                     inst,inst2 = G2frame.PatternTree.GetItemPyData(subitem)
     271                    inst,inst2 = G2frame.GPXtree.GetItemPyData(subitem)
    272272                    cType = inst['Type'][0]
    273273                    if 'Lam1' in inst:
    … …  
    277277                    else:
    278278                        cLam = 0
    279                 subitem, subcookie = G2frame.PatternTree.GetNextChild(item, subcookie)
     279                subitem, subcookie = G2frame.GPXtree.GetNextChild(item, subcookie)
    280280            if cLam == hLam and cType == hType and cGeom == hGeom:
    281281                if name not in histList: histList.append(name)
    282         item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     282        item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    283283    return histList
    284284
    … …  
    305305    '''Global copy: Copy plot controls from current histogram to others.
    306306    '''
    307     hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     307    hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    308308    histList = GetHistsLikeSelected(G2frame)
    309309    if not histList:
    310310        G2frame.ErrorDialog('No match','No other histograms match '+hst,G2frame.dataFrame)
    311311        return
    312     sourceData = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     312    sourceData = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    313313   
    314314    if 'Offset' not in sourceData[0]:    #patch for old data
    315315        sourceData[0].update({'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,
    316316            'refDelt':0.01,'qPlot':False,'dPlot':False,'sqrtPlot':False})
    317         G2frame.PatternTree.SetItemPyData(G2frame.PatternId,sourceData)
     317        G2frame.GPXtree.SetItemPyData(G2frame.PatternId,sourceData)
    318318       
    319319    dlg = G2G.G2MultiChoiceDialog(
    … …  
    334334    source = dict(zip(keys,[sourceData[0][item] for item in keys]))
    335335    for hist in copyList:
    336         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    337         data = G2frame.PatternTree.GetItemPyData(Id)
     336        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     337        data = G2frame.GPXtree.GetItemPyData(Id)
    338338        data[0].update(source)
    339         G2frame.PatternTree.SetItemPyData(Id,data)
     339        G2frame.GPXtree.SetItemPyData(Id,data)
    340340    print 'Copy of plot controls successful'
    341341
    … …  
    343343    '''Global copy: Copy items from current histogram to others.
    344344    '''
    345     hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     345    hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    346346    histList = GetHistsLikeSelected(G2frame)
    347347    if not histList:
    … …  
    374374
    375375    if 'Limits' in choiceList: # Limits
    376         data = G2frame.PatternTree.GetItemPyData(
    377             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Limits'))
     376        data = G2frame.GPXtree.GetItemPyData(
     377            G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Limits'))
    378378        for item in copyList:
    379             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    380             G2frame.PatternTree.SetItemPyData(
    381                 G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),
     379            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     380            G2frame.GPXtree.SetItemPyData(
     381                G2gd.GetGPXtreeItemId(G2frame,Id,'Limits'),
    382382                copy.deepcopy(data))
    383383    if 'Background' in choiceList:  # Background
    384         data = G2frame.PatternTree.GetItemPyData(
    385             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Background'))
     384        data = G2frame.GPXtree.GetItemPyData(
     385            G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Background'))
    386386        for item in copyList:
    387             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    388             G2frame.PatternTree.SetItemPyData(
    389                 G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),
     387            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     388            G2frame.GPXtree.SetItemPyData(
     389                G2gd.GetGPXtreeItemId(G2frame,Id,'Background'),
    390390                copy.deepcopy(data))
    391391    if 'Instrument Parameters' in choiceList:  # Instrument Parameters
    392392        # for now all items in Inst. parms are copied
    393         data,data1 = G2frame.PatternTree.GetItemPyData(
    394             G2gd.GetPatternTreeItemId(
     393        data,data1 = G2frame.GPXtree.GetItemPyData(
     394            G2gd.GetGPXtreeItemId(
    395395                G2frame,G2frame.PatternId,'Instrument Parameters'))
    396396        for item in copyList:
    397             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    398             G2frame.PatternTree.GetItemPyData(
    399                 G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
     397            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     398            G2frame.GPXtree.GetItemPyData(
     399                G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters')
    400400                )[0].update(copy.deepcopy(data))
    401             G2frame.PatternTree.GetItemPyData(
    402                 G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters')
     401            G2frame.GPXtree.GetItemPyData(
     402                G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters')
    403403                )[1].update(copy.deepcopy(data1))
    404404    if 'Sample Parameters' in choiceList:  # Sample Parameters
    405         data = G2frame.PatternTree.GetItemPyData(
    406             G2gd.GetPatternTreeItemId(
     405        data = G2frame.GPXtree.GetItemPyData(
     406            G2gd.GetGPXtreeItemId(
    407407                G2frame,G2frame.PatternId,'Sample Parameters'))
    408408        # selects items to be copied
    … …  
    411411        copyDict = {parm:data[parm] for parm in copyNames}
    412412        for item in copyList:
    413             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    414             G2frame.PatternTree.GetItemPyData(
    415                 G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters')
     413            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     414            G2frame.GPXtree.GetItemPyData(
     415                G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters')
    416416                ).update(copy.deepcopy(copyDict))
    417417                         
    … …  
    425425    def OnAutoSearch(event):
    426426        PatternId = G2frame.PatternId
    427         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    428         inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    429         profile = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     427        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))[1]
     428        inst,inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     429        profile = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    430430        x0 = profile[0]
    431431        iBeg = np.searchsorted(x0,limits[0])
    … …  
    460460       
    461461    def OnCopyPeaks(event):
    462         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     462        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    463463        histList = GetHistsLikeSelected(G2frame)
    464464        if not histList:
    … …  
    477477            dlg.Destroy()
    478478        for item in copyList:
    479             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    480             G2frame.PatternTree.SetItemPyData(
    481                 G2gd.GetPatternTreeItemId(G2frame,Id,'Peak List'),copy.deepcopy(data))
     479            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     480            G2frame.GPXtree.SetItemPyData(
     481                G2gd.GetGPXtreeItemId(G2frame,Id,'Peak List'),copy.deepcopy(data))
    482482   
    483483    def OnUnDo(event):
    … …  
    490490        PatternId = G2frame.PatternId
    491491        for item in ['Background','Instrument Parameters','Peak List']:
    492             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
     492            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, item),cPickle.load(file))
    493493            if G2frame.dataWindow.GetName() == item:
    494494                if item == 'Background':
    495                     UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
     495                    UpdateBackground(G2frame,G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, item)))
    496496                elif item == 'Instrument Parameters':
    497                     UpdateInstrumentGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
     497                    UpdateInstrumentGrid(G2frame,G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, item)))
    498498                elif item == 'Peak List':
    499                     UpdatePeakGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
     499                    UpdatePeakGrid(G2frame,G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, item)))
    500500            print item,' recovered'
    501501        file.close()
    … …  
    506506        PatternId = G2frame.PatternId
    507507        for item in ['Background','Instrument Parameters','Peak List']:
    508             cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
     508            cPickle.dump(G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,item)),file,1)
    509509        file.close()
    510510        G2frame.dataFrame.UnDo.Enable(True)
    … …  
    525525       
    526526    def OnSeqPeakFit(event):
    527         histList = G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
     527        histList = G2gd.GetGPXtreeDataNames(G2frame,['PWDR',])
    528528        dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential peak fits',
    529529             'Select dataset to include',histList)
    … …  
    535535        if not names:
    536536            return
    537         Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential peak fit results')
     537        Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential peak fit results')
    538538        if Id:
    539             SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     539            SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    540540        else:
    541541            SeqResult = {}
    542             Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential peak fit results')
     542            Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential peak fit results')
    543543        SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
    544544        SeqResult['histNames'] = names
    … …  
    572572                    dlg.Destroy()
    573573                    break
    574                 PatternId =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
     574                PatternId =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
    575575                if i and CopyForward:
    576                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
     576                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
    577577                    prevVaryList = varyList[:]
    578                 peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
    579                 background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
    580                 limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    581                 inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    582                 data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     578                peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'))
     579                background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Background'))
     580                limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))[1]
     581                inst,inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     582                data = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    583583                peaks['sigDict'],result,sig,Rvals,varyList,parmDict,fullvaryList,badVary = G2pwd.DoPeakFit(FitPgm,peaks['peaks'],
    584584                    background,limits,inst,inst2,data,prevVaryList,oneCycle,controls)
    … …  
    588588                    break
    589589                else:
    590                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
     590                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'),copy.deepcopy(peaks))
    591591                    SeqResult[name] = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
    592592                        'covMatrix':np.eye(len(result[0])),'title':name,'parmDict':parmDict,
    … …  
    596596            dlg.Destroy()
    597597        SeqResult['histNames'] = histList
    598         G2frame.PatternTree.SetItemPyData(Id,SeqResult)
     598        G2frame.GPXtree.SetItemPyData(Id,SeqResult)
    599599        G2frame.G2plotNB.Delete('Sequential refinement')    #clear away probably invalid plot
    600         G2frame.PatternTree.SelectItem(Id)
     600        G2frame.GPXtree.SelectItem(Id)
    601601       
    602602    def OnClearPeaks(event):
    … …  
    612612    def OnPeakFit(FitPgm,oneCycle=False):
    613613        SaveState()
    614         controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     614        controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    615615        if not controls:
    616616            controls = {'deriv type':'analytic','min dM/M':0.001,}     #fill in defaults if needed
    617617        print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
    618618        PatternId = G2frame.PatternId
    619         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
     619        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'))
    620620        if not peaks:
    621621            G2frame.ErrorDialog('No peaks!','Nothing to fit!')
    622622            return
    623         background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
    624         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    625         inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    626         data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     623        background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Background'))
     624        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))[1]
     625        inst,inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     626        data = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    627627        dlg = wx.ProgressDialog('Residual','Peak fit Rwp = ',101.0,
    628628            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE|wx.PD_REMAINING_TIME|wx.PD_CAN_ABORT)
    … …  
    638638            dlg.Destroy()
    639639        newpeaks = copy.copy(peaks)
    640         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
     640        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
    641641        G2plt.PlotPatterns(G2frame,plotType='PWDR')
    642642        wx.CallAfter(UpdatePeakGrid,G2frame,newpeaks)
    … …  
    644644    def OnResetSigGam(event):
    645645        PatternId = G2frame.PatternId
    646         Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    647         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
     646        Inst,Inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     647        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'))
    648648        if not peaks['peaks']:
    649649            G2frame.ErrorDialog('No peaks!','Nothing to do!')
    … …  
    652652        for peak in peaks['peaks']:
    653653            newpeaks['peaks'].append(G2mth.setPeakparms(Inst,Inst2,peak[0],peak[2]))
    654         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
     654        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
    655655        UpdatePeakGrid(G2frame,newpeaks)
    656656               
    … …  
    683683        colList = reflGrid.GetSelectedCols()
    684684        selectList = reflGrid.GetSelectedCells()
    685         data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
     685        data = G2frame.GPXtree.GetItemPyData(G2frame.PickId)
    686686        if event.GetKeyCode() == wx.WXK_RETURN:
    687687            event.Skip(True)
    … …  
    705705                reflGrid.ProcessTableMessage(msg)
    706706            data['peaks'] = G2frame.PeakTable.GetData()[:-nDel]
    707             G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
     707            G2frame.GPXtree.SetItemPyData(G2frame.PickId,data)
    708708            wx.CallAfter(reflGrid.ForceRefresh)
    709709            setBackgroundColors()
    … …  
    840840    rowLabels = []
    841841    PatternId = G2frame.PatternId
    842     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))[0]
     842    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))[0]
    843843    for i in range(len(data['peaks'])): rowLabels.append(str(i+1))
    844844    if 'C' in Inst['Type'][0]:
    … …  
    867867    for key in T: X.append(D[key])
    868868    data['peaks'] = X
    869     G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
     869    G2frame.GPXtree.SetItemPyData(G2frame.PickId,data)
    870870    G2frame.PeakTable = G2G.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    871871    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Peak List')
    … …  
    914914            for term in backDict['peaksList']:
    915915                PKflags.append(term[1::2])           
    916         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     916        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    917917        histList = GetHistsLikeSelected(G2frame)
    918918        if not histList:
    … …  
    931931            dlg.Destroy()
    932932        for item in copyList:
    933             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    934             backData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'))
     933            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     934            backData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Background'))
    935935            backData[0][1] = copy.copy(flag)
    936936            bkDict = backData[-1]
    … …  
    943943           
    944944    def OnBackCopy(event):
    945         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     945        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    946946        histList = GetHistsLikeSelected(G2frame)
    947947        if not histList:
    … …  
    958958            dlg.Destroy()
    959959        for item in copyList:
    960             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    961             G2frame.PatternTree.SetItemPyData(
    962                 G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),copy.copy(data))
     960            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     961            G2frame.GPXtree.SetItemPyData(
     962                G2gd.GetGPXtreeItemId(G2frame,Id,'Background'),copy.copy(data))
    963963
    964964    def OnBkgFit(event):
    … …  
    984984   
    985985        PatternId = G2frame.PatternId       
    986         controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
    987         background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
    988         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    989         inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     986        controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
     987        background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Background'))
     988        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Limits'))[1]
     989        inst,inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    990990        # sort the points for convenience and then separate them; extend the range if needed
    991991        background[1]['FixedPoints'] = sorted(background[1]['FixedPoints'],key=lambda pair:pair[0])       
    … …  
    999999            Y += [Y[-1]]
    10001000        # interpolate the fixed points onto the grid of data points within limits
    1001         pwddata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     1001        pwddata = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    10021002        xBeg = np.searchsorted(pwddata[0],limits[0])
    10031003        xFin = np.searchsorted(pwddata[0],limits[1])
    … …  
    10541054        for peak in data[1]['peaksList']:
    10551055            Peaks['peaks'].append([peak[0],0,peak[2],0,peak[4],0,peak[6],0])
    1056         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),Peaks)
     1056        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Peak List'),Peaks)
    10571057       
    10581058    def OnMakeRDF(event):
    … …  
    10661066            dlg.Destroy()
    10671067        PatternId = G2frame.PatternId       
    1068         background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
    1069         inst,inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    1070         pwddata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     1068        background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Background'))
     1069        inst,inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     1070        pwddata = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    10711071        auxPlot = G2pwd.MakeRDF(RDFcontrols,background,inst,pwddata)
    10721072#        GSASIIpath.IPyBreak()
    … …  
    11011101                for i in range(N,M):
    11021102                    del(item[-1])
    1103             G2frame.PatternTree.SetItemPyData(BackId,data)
     1103            G2frame.GPXtree.SetItemPyData(BackId,data)
    11041104            #wx.CallAfter(UpdateBackground,G2frame,data)
    11051105            wx.CallLater(100,UpdateBackground,G2frame,data)
    … …  
    12611261    G2frame.Bind(wx.EVT_MENU,OnBkgFit,id=G2frame.dataFrame.wxID_BackPts['Fit'])
    12621262    G2frame.Bind(wx.EVT_MENU,OnBkgClear,id=G2frame.dataFrame.wxID_BackPts['Clear'])   
    1263     BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background')
     1263    BackId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Background')
    12641264    Choices = ['chebyschev','cosine','Q^2 power series','Q^-2 power series','lin interpolate','inv interpolate','log interpolate']
    12651265    mainSizer = wx.BoxSizer(wx.VERTICAL)
    … …  
    12831283    def AfterChange(invalid,value,tc):
    12841284        if invalid: return
    1285         plottype = G2frame.PatternTree.GetItemText(G2frame.PatternId)[:4]
     1285        plottype = G2frame.GPXtree.GetItemText(G2frame.PatternId)[:4]
    12861286#        print 'new plot'
    12871287        wx.CallAfter(G2plt.PlotPatterns,G2frame,newPlot=False,plotType=plottype)  #unfortunately this resets the plot width
    … …  
    13261326       
    13271327    def OnLimitCopy(event):
    1328         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1328        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    13291329        histList = GetHistsLikeSelected(G2frame)
    13301330        if not histList:
    … …  
    13391339                for i in dlg.GetSelections():
    13401340                    item = histList[i]
    1341                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    1342                     G2frame.PatternTree.SetItemPyData(
    1343                         G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),copy.copy(data))
     1341                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     1342                    G2frame.GPXtree.SetItemPyData(
     1343                        G2gd.GetGPXtreeItemId(G2frame,Id,'Limits'),copy.copy(data))
    13441344        finally:
    13451345            dlg.Destroy()
    … …  
    13751375    '''
    13761376    if 'Bank' not in data:  #get it from name; absent for default parms selection
    1377         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1377        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    13781378        if 'Bank' in hst:
    13791379            bank = int(hst.split('Bank')[1].split('_')[0])
    … …  
    13921392       
    13931393    def updateData(inst,ref):
    1394         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1394        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    13951395            G2frame.PatternId,'Instrument Parameters'))[0]
    13961396        for item in data:
    … …  
    14051405    def RefreshInstrumentGrid(event,doAnyway=False):
    14061406        if doAnyway or event.GetRow() == 1:
    1407             peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
     1407            peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
    14081408            newpeaks = []
    14091409            for peak in peaks['peaks']:
    14101410                newpeaks.append(G2mth.setPeakparms(data,Inst2,peak[0],peak[2]))
    14111411            peaks['peaks'] = newpeaks
    1412             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),peaks)
     1412            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Peak List'),peaks)
    14131413           
    14141414    def OnCalibrate(event):
    1415         Pattern = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
     1415        Pattern = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)
    14161416        xye = ma.array(ma.getdata(Pattern[1]))
    14171417        cw = np.diff(xye[0])
    1418         IndexPeaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
     1418        IndexPeaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
    14191419        if not len(IndexPeaks[0]):
    14201420            G2frame.ErrorDialog('Can not calibrate','Index Peak List empty')
    … …  
    14531453        Note that similar code is found in ReadPowderInstprm (GSASII.py)
    14541454        '''
    1455         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1455        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    14561456            G2frame.PatternId,'Instrument Parameters'))[0]
    14571457        bank = data['Bank'][0]
    … …  
    14941494                File.close()
    14951495                if Found:
    1496                     Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'))
     1496                    Inst,Inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'))
    14971497                    if 'Bank' not in Inst:  #patch for old .instprm files - may cause faults for TOF data
    14981498                        Inst['Bank'] = [1,1,0]
    14991499                    data = G2IO.makeInstDict(newItems,newVals,len(newVals)*[False,])
    1500                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),[data,Inst2])
     1500                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Instrument Parameters'),[data,Inst2])
    15011501                    RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
    15021502                else:
    … …  
    15351535        item: writes parameters from selected PWDR entries to a .instprm file
    15361536        '''
    1537         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1537        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    15381538        histList = GetHistsLikeSelected(G2frame)
    15391539        histList.insert(0,hst)
    … …  
    15591559                File = open(filename,'w')
    15601560                for hist in saveList:
    1561                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    1562                     inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
     1561                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     1562                    inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))[0]
    15631563                    if 'Bank' not in inst:  #patch
    15641564                        bank = 1
    … …  
    15821582       
    15831583    def OnInstFlagCopy(event):
    1584         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1584        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    15851585        histList = GetHistsLikeSelected(G2frame)
    15861586        if not histList:
    … …  
    16061606            dlg.Destroy()
    16071607        for item in copyList:
    1608             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    1609             instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
     1608            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     1609            instData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))[0]
    16101610            if 'Bank' not in instData:
    16111611                instData['Bank'] = [1,1,0]
    … …  
    16201620    def OnInstCopy(event):
    16211621        #need fix for dictionary
    1622         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     1622        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    16231623        histList = GetHistsLikeSelected(G2frame)
    16241624        if not histList:
    … …  
    16381638            dlg.Destroy()
    16391639        for item in copyList:
    1640             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    1641             instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))[0]
     1640            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     1641            instData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))[0]
    16421642            if 'Bank' not in instData:
    16431643                instData['Bank'] = [1,1,0]
    … …  
    19681968    meanwaves = {'CuKa':1.5418,'TiKa':2.7496,'CrKa':2.2909,'FeKa':1.9373,
    19691969        'CoKa':1.7902,'MoKa':0.7107,'AgKa':0.5608}
    1970     Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     1970    Inst2 = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    19711971            G2frame.PatternId,'Instrument Parameters'))[1]       
    19721972    G2gd.SetDataMenuBar(G2frame)
    … …  
    20592059                File.close()
    20602060                data.update(newItems)
    2061                 G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Sample Parameters'),data)
     2061                G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId,'Sample Parameters'),data)
    20622062                UpdateSampleGrid(G2frame,data)
    20632063        finally:
    … …  
    20962096        dataDict = dict(zip(itemNames,newItems))
    20972097        ifany = False
    2098         Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Controls'))
     2098        Controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Controls'))
    20992099        Names = [' ','Phi','Chi','Omega','Time','Temperature','Pressure']
    21002100        freeNames = {}
    … …  
    21162116            G2frame.ErrorDialog('Nothing to do','No columns identified')
    21172117            return
    2118         histList = [G2frame.PatternTree.GetItemText(G2frame.PatternId),]
     2118        histList = [G2frame.GPXtree.GetItemText(G2frame.PatternId),]
    21192119        histList += GetHistsLikeSelected(G2frame)
    21202120        colIds = {}
    … …  
    21282128                key = freeNames.get(item,item)
    21292129                newItems[key] = float(dataDict[name][colIds[item]])
    2130             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    2131             sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     2130            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     2131            sampleData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    21322132            sampleData.update(newItems)       
    21332133        UpdateSampleGrid(G2frame,data)       
    … …  
    21392139            try:
    21402140                if dlg.ShowModal() == wx.ID_OK:
    2141                     pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histName)
    2142                     y,w = G2frame.PatternTree.GetItemPyData(pId)[1][1:3]
     2141                    pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histName)
     2142                    y,w = G2frame.GPXtree.GetItemPyData(pId)[1][1:3]
    21432143                    y *= Scale
    21442144                    w /= Scale**2
    … …  
    21512151        #SASD rescaliing               
    21522152        histList = []
    2153         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     2153        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    21542154        while item:
    2155             name = G2frame.PatternTree.GetItemText(item)
     2155            name = G2frame.GPXtree.GetItemText(item)
    21562156            if 'SASD' in name and name != histName:
    21572157                histList.append(name)
    2158             item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     2158            item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    21592159        if not len(histList):      #nothing to copy to!
    21602160            return
    … …  
    21672167        finally:
    21682168            dlg.Destroy()
    2169         Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
    2170         Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
     2169        Limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits'))
     2170        Profile = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1]
    21712171        Data = [Profile,Limits,data]
    2172         refId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,refHist)
    2173         refSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Sample Parameters'))
    2174         refLimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,refId, 'Limits'))
    2175         refProfile = G2frame.PatternTree.GetItemPyData(refId)[1]
     2172        refId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,refHist)
     2173        refSample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,refId, 'Sample Parameters'))
     2174        refLimits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,refId, 'Limits'))
     2175        refProfile = G2frame.GPXtree.GetItemPyData(refId)[1]
    21762176        refData = [refProfile,refLimits,refSample]
    21772177        G2sasd.SetScale(Data,refData)
    … …  
    21802180       
    21812181    def OnRescaleAll(event):
    2182         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     2182        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    21832183        histList = GetHistsLikeSelected(G2frame)
    2184         x0,y0,w0 = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1][:3]
     2184        x0,y0,w0 = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1][:3]
    21852185        if not histList:
    21862186            G2frame.ErrorDialog('No match','No histograms match '+hst,G2frame.dataFrame)
    … …  
    22022202                    for i in result:
    22032203                        item = histList[i]
    2204                         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    2205                         xi,yi,wi = G2frame.PatternTree.GetItemPyData(Id)[1][:3]
     2204                        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     2205                        xi,yi,wi = G2frame.GPXtree.GetItemPyData(Id)[1][:3]
    22062206                        sumi = np.sum(yi[iBeg:iFin])
    22072207                        if sumi:
    … …  
    22192219        for parm in copyNames:
    22202220            copyDict[parm] = data[parm]
    2221         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     2221        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    22222222        histList = GetHistsLikeSelected(G2frame)
    22232223        if not histList:
    … …  
    22322232                for i in result:
    22332233                    item = histList[i]
    2234                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    2235                     sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     2234                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     2235                    sampleData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    22362236                    sampleData.update(copy.deepcopy(copyDict))
    22372237        finally:
    … …  
    22392239
    22402240    def OnSampleCopySelected(event):
    2241         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
    2242         Controls = G2frame.PatternTree.GetItemPyData(
    2243             G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     2241        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
     2242        Controls = G2frame.GPXtree.GetItemPyData(
     2243            G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    22442244        histList = GetHistsLikeSelected(G2frame)
    22452245        if not histList:
    … …  
    22822282                for i in result:
    22832283                    item = histList[i]
    2284                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    2285                     sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     2284                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     2285                    sampleData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    22862286                    sampleData.update(copy.deepcopy(copyDict))
    22872287        finally:
    … …  
    22942294        for parm in copyNames:
    22952295            flagDict[parm] = data[parm][1]
    2296         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     2296        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    22972297        histList = GetHistsLikeSelected(G2frame)
    22982298        if not histList:
    … …  
    23082308                for i in result:
    23092309                    item = histList[i]
    2310                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    2311                     sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     2310                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     2311                    sampleData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    23122312                    for name in copyNames:
    23132313                        sampleData[name][1] = copy.copy(flagDict[name])
    … …  
    23582358    #reload(G2gd)
    23592359    ######################################################################
    2360     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2360    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    23612361            G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    2362     histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     2362    histName = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    23632363    G2frame.dataWindow.ClearData()
    23642364    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SampleMenu)
    … …  
    23752375    if histName[:4] in ['SASD','REFD','PWDR']:
    23762376        G2frame.dataFrame.SetScale.Enable(True)
    2377     Controls = G2frame.PatternTree.GetItemPyData(
    2378         G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     2377    Controls = G2frame.GPXtree.GetItemPyData(
     2378        G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    23792379#patch
    23802380    if 'ranId' not in data:
    … …  
    24912491        mu = 0.
    24922492        subSizer = wx.FlexGridSizer(0,4,5,5)
    2493         Substances = G2frame.PatternTree.GetItemPyData(
    2494             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
     2493        Substances = G2frame.GPXtree.GetItemPyData(
     2494            G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Substances'))
    24952495        for id,item in enumerate(data['Materials']):
    24962496            subSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Material: '),0,WACV)
    … …  
    25322532    bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
    25332533        'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
    2534     IndexId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
    2535     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    2536     limitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits')
    2537     Limits = G2frame.PatternTree.GetItemPyData(limitId)
     2534    IndexId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
     2535    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     2536    limitId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits')
     2537    Limits = G2frame.GPXtree.GetItemPyData(limitId)
    25382538    def RefreshIndexPeaksGrid(event):
    25392539        r,c =  event.GetRow(),event.GetCol()
    … …  
    25452545                peaks[r][c] = True
    25462546            G2frame.IndexPeaksTable.SetData(peaks)
    2547             G2frame.PatternTree.SetItemPyData(IndexId,[peaks,data[1]])
     2547            G2frame.GPXtree.SetItemPyData(IndexId,[peaks,data[1]])
    25482548#            G2frame.dataWindow.ForceRefresh()
    2549             if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     2549            if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    25502550                G2plt.PlotPowderLines(G2frame)
    25512551            else:
    … …  
    25552555        peaks = []
    25562556        sigs = []
    2557         Peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
     2557        Peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
    25582558        for ip,peak in enumerate(Peaks['peaks']):
    25592559            dsp = G2lat.Pos2dsp(Inst,peak[0])
    … …  
    25652565            sigs.append(sig)
    25662566        data = [peaks,sigs]
    2567         G2frame.PatternTree.SetItemPyData(IndexId,data)
     2567        G2frame.GPXtree.SetItemPyData(IndexId,data)
    25682568        UpdateIndexPeaksGrid(G2frame,data)
    25692569       
    25702570    def KeyEditPickGrid(event):
    25712571        colList = G2frame.indxPeaks.GetSelectedCols()
    2572         data = G2frame.PatternTree.GetItemPyData(IndexId)
     2572        data = G2frame.GPXtree.GetItemPyData(IndexId)
    25732573        if event.GetKeyCode() == wx.WXK_RETURN:
    25742574            event.Skip(True)
    … …  
    25912591           
    25922592    G2frame.dataWindow.ClearData()
    2593     if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     2593    if 'PWD' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    25942594        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndPeaksMenu)
    25952595        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
    … …  
    25982598    if len(data[0]):
    25992599        G2frame.dataWindow.IndexPeaks.Enable(True)
    2600         Unit = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
     2600        Unit = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
    26012601        if Unit:
    26022602            if len(Unit) == 4:  #patch
    … …  
    26402640        Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',]+2*[wg.GRID_VALUE_BOOL,]+ \
    26412641            4*[wg.GRID_VALUE_LONG,]+2*[wg.GRID_VALUE_FLOAT+':10,5',]
    2642     G2frame.PatternTree.SetItemPyData(IndexId,data)
     2642    G2frame.GPXtree.SetItemPyData(IndexId,data)
    26432643    G2frame.IndexPeaksTable = G2G.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    26442644    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Index Peak List')
    … …  
    26832683    '''respond to selection of PWDR Unit Cells data tree item.
    26842684    '''
    2685     UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
     2685    UnitCellsId = G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
    26862686    SPGlist = G2spc.spglist
    26872687    bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm','P4/mmm',
    … …  
    26892689    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',
    26902690        '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']
    2691     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    2692     Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))[1]
     2691    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     2692    Limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits'))[1]
    26932693    if 'C' in Inst['Type'][0] or 'PKS' in Inst['Type'][0]:
    26942694        wave = G2mth.getWave(Inst)
    … …  
    28772877    def OnHklShow(event):
    28782878        PatternId = G2frame.PatternId
    2879         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
    2880         controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
     2879        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'))
     2880        controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    28812881        cell = controls[6:12]
    28822882        A = G2lat.cell2A(cell)
    … …  
    29032903        if len(G2frame.HKL):
    29042904            print ' new M20,X20: %.2f %d fraction found: %.3f'%(M20,X20,float(len(peaks[0]))/len(G2frame.HKL))
    2905         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'),peaks)
    2906         if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     2905        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'),peaks)
     2906        if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    29072907            G2plt.PlotPowderLines(G2frame)
    29082908        else:
    … …  
    29102910           
    29112911    def OnSortCells(event):
    2912         controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(UnitCellsId)
     2912        controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(UnitCellsId)
    29132913        c =  event.GetCol()
    29142914        if colLabels[c] == 'M20':
    … …  
    29212921            return
    29222922        data = [controls,bravais,cells,dmin,ssopt]
    2923         G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
     2923        G2frame.GPXtree.SetItemPyData(UnitCellsId,data)
    29242924        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
    29252925       
    29262926    def CopyUnitCell(event):
    2927         controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(UnitCellsId)
     2927        controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(UnitCellsId)
    29282928        for Cell in cells:
    29292929            if Cell[-2]:
    … …  
    29352935        controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
    29362936        controls[13] = spaceGroups[bravaisSymb.index(controls[5])]
    2937         G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin,ssopt])
     2937        G2frame.GPXtree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin,ssopt])
    29382938        G2frame.dataFrame.RefineCell.Enable(True)
    29392939        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)       
    … …  
    29602960             
    29612961        PatternId = G2frame.PatternId
    2962         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
     2962        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'))
    29632963        if not len(peaks[0]):
    29642964            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
    29652965            return       
    29662966        print ' Refine cell'
    2967         controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
     2967        controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    29682968        cell = controls[6:12]
    29692969        A = G2lat.cell2A(cell)
    … …  
    29982998        controls[6:12] = G2lat.A2cell(Aref)
    29992999        controls[12] = G2lat.calc_V(Aref)
    3000         cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
     3000        cells = G2frame.GPXtree.GetItemPyData(UnitCellsId)[2]
    30013001        for cell in cells:
    30023002            cell[-2] = False
    … …  
    30083008            G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
    30093009        data = [controls,bravais,cells,dmin,ssopt]
    3010         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
     3010        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
    30113011        print " %s%10.3f" % ('refinement M20 = ',M20)
    30123012        print ' unindexed lines = ',X20
    … …  
    30193019            hkl[ip] = G2lat.Dsp2pos(Inst,hkl[ip-1])+controls[1]
    30203020        G2frame.HKL = np.array(G2frame.HKL)
    3021         if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     3021        if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    30223022            G2plt.PlotPowderLines(G2frame)
    30233023        else:
    … …  
    30303030        keepcells = []
    30313031        try:
    3032             controls,bravais,cells,dminx,ssopt = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
     3032            controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    30333033            for cell in cells:
    30343034                if cell[11]:
    … …  
    30683068            cells[0][10] = True         #select best M20
    30693069            data = [controls,bravais,cells,dmin,ssopt]
    3070             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
     3070            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
    30713071            bestCell = cells[0]
    30723072            if bestCell[0] > 10.:
    … …  
    30753075                    hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
    30763076                G2frame.HKL = np.array(G2frame.HKL)
    3077                 if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     3077                if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    30783078                    G2plt.PlotPowderLines(G2frame)
    30793079                else:
    … …  
    30863086               
    30873087    def RefreshUnitCellsGrid(event):
    3088         data = G2frame.PatternTree.GetItemPyData(UnitCellsId)
     3088        data = G2frame.GPXtree.GetItemPyData(UnitCellsId)
    30893089        cells,dminx = data[2:4]
    30903090        r,c =  event.GetRow(),event.GetCol()
    … …  
    31033103                    hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
    31043104                G2frame.HKL = np.array(G2frame.HKL)
    3105                 if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
     3105                if 'PKS' in G2frame.GPXtree.GetItemText(G2frame.PatternId):
    31063106                    G2plt.PlotPowderLines(G2frame)
    31073107                else:
    … …  
    31153115                    UnitCellsTable.SetValue(r,c,True)
    31163116                gridDisplay.ForceRefresh()
    3117             G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
     3117            G2frame.GPXtree.SetItemPyData(UnitCellsId,data)
    31183118       
    31193119    def MakeNewPhase(event):
    3120         if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
    3121             sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
     3120        if not G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases'):
     3121            sub = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Phases')
    31223122        else:
    3123             sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
     3123            sub = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
    31243124        PhaseName = ''
    31253125        dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
    … …  
    31283128            if dlg.ShowModal() == wx.ID_OK:
    31293129                PhaseName = dlg.GetValue()
    3130                 cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
     3130                cells = G2frame.GPXtree.GetItemPyData(UnitCellsId)[2]
    31313131                for Cell in cells:
    31323132                    if Cell[-2]:
    31333133                        break
    31343134                cell = Cell[2:10]       
    3135                 sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
     3135                sub = G2frame.GPXtree.AppendItem(parent=sub,text=PhaseName)
    31363136                E,SGData = G2spc.SpcGroup(controls[13])
    3137                 G2frame.PatternTree.SetItemPyData(sub, \
     3137                G2frame.GPXtree.SetItemPyData(sub, \
    31383138                    G2obj.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:],Super=ssopt))
    31393139                G2frame.GetStatusBar().SetStatusText('Change space group from '+str(controls[13])+' if needed')
    … …  
    31553155    if len(controls) < 14:              #add space group used in indexing
    31563156        controls.append(spaceGroups[bravaisSymb.index(controls[5])])
    3157     G2frame.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
     3157    G2frame.GPXtree.SetItemPyData(UnitCellsId,data)            #update with volume
    31583158    bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
    31593159        'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
    … …  
    31703170   
    31713171    G2frame.dataFrame.IndexPeaks.Enable(False)
    3172     peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
     3172    peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
    31733173    if peaks:
    31743174        G2frame.dataFrame.IndexPeaks.Enable(True)
    … …  
    33733373    a table of reflections in the data window.
    33743374    '''
    3375     Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     3375    Controls = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Controls'))
    33763376    dMin = 0.05
    33773377    if 'UsrReject' in Controls:
    … …  
    33823382        phaseName = G2frame.RefList
    33833383        if phaseName not in ['Unknown',]:
    3384             pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
    3385             phaseId =  G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
    3386             General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
     3384            pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
     3385            phaseId =  G2gd.GetGPXtreeItemId(G2frame,pId,phaseName)
     3386            General = G2frame.GPXtree.GetItemPyData(phaseId)['General']
    33873387            Super = General.get('Super',0)
    33883388            SuperVec = General.get('SuperVec',[])
    … …  
    34103410        phaseName = G2frame.RefList
    34113411        if phaseName not in ['Unknown',]:
    3412             pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
    3413             phaseId =  G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
    3414             General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
     3412            pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
     3413            phaseId =  G2gd.GetGPXtreeItemId(G2frame,pId,phaseName)
     3414            General = G2frame.GPXtree.GetItemPyData(phaseId)['General']
    34153415            Super = General.get('Super',0)
    34163416            SuperVec = General.get('SuperVec',[])
    … …  
    34423442        '''
    34433443        if phaseName not in ['Unknown',]:
    3444             pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
    3445             phaseId =  G2gd.GetPatternTreeItemId(G2frame,pId,phaseName)
     3444            pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases')
     3445            phaseId =  G2gd.GetGPXtreeItemId(G2frame,pId,phaseName)
    34463446            if not phaseId:         #phase deleted
    34473447                return None
    3448             General = G2frame.PatternTree.GetItemPyData(phaseId)['General']
     3448            General = G2frame.GPXtree.GetItemPyData(phaseId)['General']
    34493449            Super = General.get('Super',0)
    34503450        else:
    … …  
    35933593        phases = data.keys()
    35943594    G2frame.dataFrame.ClearData()
    3595     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     3595    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    35963596    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ReflMenu)
    35973597    if HKLF:
    … …  
    37083708       
    37093709    def OnCopySubstance(event):
    3710         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     3710        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    37113711        histList = GetHistsLikeSelected(G2frame)
    37123712        if not histList:
    … …  
    37253725            dlg.Destroy()       
    37263726        for item in copyList:
    3727             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    3728             Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Instrument Parameters'))[0]
     3727            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     3728            Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Instrument Parameters'))[0]
    37293729            wave = G2mth.getWave(Inst)
    37303730            ndata = copy.deepcopy(data)
    … …  
    37383738                    ndata['Substances'][name]['XAbsorption'] = absorb
    37393739                    ndata['Substances'][name]['XImag density'] = imcontrst
    3740             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Substances'),ndata)
     3740            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Substances'),ndata)
    37413741   
    37423742    def OnAddSubstance(event):
    … …  
    39583958        return substSizer
    39593959           
    3960     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     3960    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    39613961    wave = G2mth.getWave(Inst)
    39623962    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SubstanceMenu)
    … …  
    40374037       
    40384038    def OnCopyModel(event):
    4039         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     4039        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    40404040        histList = GetHistsLikeSelected(G2frame)
    40414041        if not histList:
    … …  
    40544054            dlg.Destroy()       
    40554055        for item in copyList:
    4056             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
     4056            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
    40574057            newdata = copy.deepcopy(data)
    4058             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Models'),newdata)
     4058            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Models'),newdata)
    40594059            if newdata['BackFile']:
    4060                 Profile = G2frame.PatternTree.GetItemPyData(Id)[1]
    4061                 BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,newdata['BackFile'])
    4062                 BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
    4063                 Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
     4060                Profile = G2frame.GPXtree.GetItemPyData(Id)[1]
     4061                BackId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,newdata['BackFile'])
     4062                BackSample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,BackId, 'Sample Parameters'))
     4063                Profile[5] = BackSample['Scale'][0]*G2frame.GPXtree.GetItemPyData(BackId)[1][1]
    40644064        UpdateModelsGrid(G2frame,newdata) 
    40654065        wx.CallAfter(UpdateModelsGrid,G2frame,data)
    … …  
    40684068    def OnCopyFlags(event):
    40694069        thisModel = copy.deepcopy(data)
    4070         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     4070        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    40714071        histList = GetHistsLikeSelected(G2frame)
    40724072        if not histList:
    … …  
    40864086                for i in result:
    40874087                    item = histList[i]
    4088                     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    4089                     newModel = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Models'))
     4088                    Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     4089                    newModel = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Models'))
    40904090                    newModel['Back'][1] = copy.copy(thisModel['Back'][1])
    40914091                    for ilev,level in enumerate(newModel['Particle']['Levels']):
    … …  
    41054105               
    41064106    def OnFitModelAll(event):
    4107         choices = G2gd.GetPatternTreeDataNames(G2frame,['SASD',])
     4107        choices = G2gd.GetGPXtreeDataNames(G2frame,['SASD',])
    41084108        dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential SASD refinement',
    41094109             'Select dataset to include',choices)
    … …  
    41124112            for sel in dlg.GetSelections():
    41134113                names.append(choices[sel])
    4114             Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential SASD results')
     4114            Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential SASD results')
    41154115            if Id:
    4116                 SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     4116                SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    41174117            else:
    41184118                SeqResult = {}
    4119                 Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential SASD results')
     4119                Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential SASD results')
    41204120            SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
    41214121            SeqResult['histNames'] = names
    … …  
    41474147                if not GoOn:
    41484148                    break
    4149                 sId =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
     4149                sId =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
    41504150                if i and CopyForward:
    4151                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'),JModel)
    4152                 IProfDict,IProfile = G2frame.PatternTree.GetItemPyData(sId)[:2]
    4153                 IModel = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'))
    4154                 ISample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Sample Parameters'))
    4155                 ILimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Limits'))
     4151                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'),JModel)
     4152                IProfDict,IProfile = G2frame.GPXtree.GetItemPyData(sId)[:2]
     4153                IModel = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'))
     4154                ISample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Sample Parameters'))
     4155                ILimits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Limits'))
    41564156                IfOK,result,varyList,sig,Rvals,covMatrix,parmDict,Msg = G2sasd.ModelFit(IProfile,IProfDict,ILimits,ISample,IModel)
    41574157                JModel = copy.deepcopy(IModel)
    … …  
    41644164                    break
    41654165                else:
    4166                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'),copy.deepcopy(IModel))
     4166                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'),copy.deepcopy(IModel))
    41674167               
    41684168                G2sasd.ModelFxn(IProfile,IProfDict,ILimits,ISample,IModel)
    … …  
    41744174        finally:
    41754175            wx.EndBusyCursor()   
    4176         G2frame.PatternTree.SetItemPyData(Id,SeqResult)
    4177         G2frame.PatternTree.SelectItem(Id)
     4176        G2frame.GPXtree.SetItemPyData(Id,SeqResult)
     4177        G2frame.GPXtree.SelectItem(Id)
    41784178       
    41794179    def OnFitModel(event):
    … …  
    42014201    def OnUnDo(event):
    42024202        DoUnDo()
    4203         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     4203        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    42044204            G2frame.PatternId,'Models'))
    42054205        G2frame.dataFrame.SasdUndo.Enable(False)
    … …  
    42124212        file = open(G2frame.undosasd,'rb')
    42134213        PatternId = G2frame.PatternId
    4214         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
     4214        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
    42154215        print ' Models recovered'
    42164216        file.close()
    … …  
    42214221        PatternId = G2frame.PatternId
    42224222        for item in ['Models']:
    4223             cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
     4223            cPickle.dump(G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,item)),file,1)
    42244224        file.close()
    42254225        G2frame.dataFrame.SasdUndo.Enable(True)
    … …  
    46104610        data['BackFile'] = backFile.GetValue()
    46114611        if data['BackFile']:
    4612             BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['BackFile'])
    4613             BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
    4614             Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
     4612            BackId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['BackFile'])
     4613            BackSample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,BackId, 'Sample Parameters'))
     4614            Profile[5] = BackSample['Scale'][0]*G2frame.GPXtree.GetItemPyData(BackId)[1][1]
    46154615        else:
    46164616            Profile[5] = np.zeros(len(Profile[5]))
    46174617        RefreshPlots(True)
    46184618           
    4619     Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
    4620     Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
    4621     Substances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
    4622     ProfDict,Profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[:2]
     4619    Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Sample Parameters'))
     4620    Limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits'))
     4621    Substances = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Substances'))
     4622    ProfDict,Profile = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[:2]
    46234623    if data['BackFile']:
    4624         BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['BackFile'])
    4625         BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
    4626         Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
     4624        BackId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['BackFile'])
     4625        BackSample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,BackId, 'Sample Parameters'))
     4626        Profile[5] = BackSample['Scale'][0]*G2frame.GPXtree.GetItemPyData(BackId)[1][1]
    46274627    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ModelMenu)
    46284628    G2frame.dataWindow.ClearData()
    … …  
    46724672    #multiple background files?
    46734673    backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background file: '),0,WACV)
    4674     Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['SASD',])
     4674    Choices = ['',]+G2gd.GetGPXtreeDataNames(G2frame,['SASD',])
    46754675    backFile = wx.ComboBox(parent=G2frame.dataWindow,value=data['BackFile'],choices=Choices,
    46764676        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    … …  
    46934693    '''
    46944694    def OnCopyModel(event):
    4695         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     4695        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    46964696        histList = GetHistsLikeSelected(G2frame)
    46974697        if not histList:
    … …  
    47084708            dlg.Destroy()
    47094709        for item in copyList:
    4710             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    4711             G2frame.PatternTree.SetItemPyData(
    4712                 G2gd.GetPatternTreeItemId(G2frame,Id,'Models'),copy.deepcopy(data))
     4710            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     4711            G2frame.GPXtree.SetItemPyData(
     4712                G2gd.GetGPXtreeItemId(G2frame,Id,'Models'),copy.deepcopy(data))
    47134713       
    47144714    def OnFitModel(event):
    … …  
    47224722       
    47234723    def OnModelPlot(event):
    4724         hst = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     4724        hst = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    47254725        histList = GetFileList(G2frame,'REFD')
    47264726#        histList = [hst,]
    … …  
    47454745        LinePos = []
    47464746        for item in plotList:
    4747             mId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    4748             model = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,mId,'Models'))
    4749             Substances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,mId,'Substances'))['Substances']       
     4747            mId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     4748            model = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,mId,'Models'))
     4749            Substances = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,mId,'Substances'))['Substances']       
    47504750            x,xr,y = G2pwd.makeSLDprofile(model,Substances)
    47514751            if od['value_1']:
    … …  
    47684768       
    47694769    def OnFitModelAll(event):
    4770         choices = G2gd.GetPatternTreeDataNames(G2frame,['REFD',])
     4770        choices = G2gd.GetGPXtreeDataNames(G2frame,['REFD',])
    47714771        dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Sequential REFD refinement',
    47724772             'Select dataset to include',choices)
    … …  
    47754775            for sel in dlg.GetSelections():
    47764776                names.append(choices[sel])
    4777             Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential REFD results')
     4777            Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential REFD results')
    47784778            if Id:
    4779                 SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     4779                SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    47804780            else:
    47814781                SeqResult = {}
    4782                 Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential REFD results')
     4782                Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential REFD results')
    47834783            SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
    47844784            SeqResult['histNames'] = names
    … …  
    48104810                if not GoOn:
    48114811                    break
    4812                 sId =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
     4812                sId =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
    48134813                if i and CopyForward:
    4814                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'),JModel)
    4815                 IProfDict,IProfile = G2frame.PatternTree.GetItemPyData(sId)[:2]
    4816                 IModel = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'))
    4817                 ISubstances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Substances'))['Substances']
    4818                 ILimits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Limits'))
     4814                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'),JModel)
     4815                IProfDict,IProfile = G2frame.GPXtree.GetItemPyData(sId)[:2]
     4816                IModel = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'))
     4817                ISubstances = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Substances'))['Substances']
     4818                ILimits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Limits'))
    48194819                IfOK,result,varyList,sig,Rvals,covMatrix,parmDict,Msg = G2pwd.REFDRefine(IProfile,IProfDict,Inst,ILimits,ISubstances,IModel)
    48204820                JModel = copy.deepcopy(IModel)
    … …  
    48274827                    break
    48284828                else:
    4829                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,sId, 'Models'),copy.deepcopy(IModel))
     4829                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,sId, 'Models'),copy.deepcopy(IModel))
    48304830               
    48314831                SeqResult[name] = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
    … …  
    48364836        finally:
    48374837            wx.EndBusyCursor()   
    4838         G2frame.PatternTree.SetItemPyData(Id,SeqResult)
    4839         G2frame.PatternTree.SelectItem(Id)
     4838        G2frame.GPXtree.SetItemPyData(Id,SeqResult)
     4839        G2frame.GPXtree.SelectItem(Id)
    48404840               
    48414841    def ModelPlot(data,x,xr,y):
    … …  
    48574857    def OnUnDo(event):
    48584858        DoUnDo()
    4859         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
     4859        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,
    48604860            G2frame.PatternId,'Models'))
    48614861        G2frame.dataFrame.REFDUndo.Enable(False)
    … …  
    48704870        file = open(G2frame.undorefd,'rb')
    48714871        PatternId = G2frame.PatternId
    4872         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
     4872        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Models'),cPickle.load(file))
    48734873        print ' Model recovered'
    48744874        file.close()
    … …  
    48784878        file = open(G2frame.undorefd,'wb')
    48794879        PatternId = G2frame.PatternId
    4880         cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Models')),file,1)
     4880        cPickle.dump(G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Models')),file,1)
    48814881        file.close()
    48824882        G2frame.dataFrame.REFDUndo.Enable(True)
    … …  
    52085208            G2plt.PlotPatterns(G2frame,plotType='REFD')
    52095209   
    5210     Substances = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))['Substances']
    5211     ProfDict,Profile,Name = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[:3]
     5210    Substances = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Substances'))['Substances']
     5211    ProfDict,Profile,Name = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[:3]
    52125212    if 'ifDQ' not in ProfDict:
    52135213        ProfDict['ifDQ'] = np.any(Profile[5])
    52145214        data['dQ type'] = 'None'
    5215     Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
    5216     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     5215    Limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Limits'))
     5216    Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    52175217    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.REFDModelMenu)
    52185218    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Modelling')
    … …  
    52705270        name = data[key]['Name']
    52715271        if name:
    5272             xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
    5273     powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['Sample']['Name'])
    5274     limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Limits'))[1]
    5275     inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))[0]
     5272            xydata[key] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name))
     5273    powId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['Sample']['Name'])
     5274    limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId,'Limits'))[1]
     5275    inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId,'Instrument Parameters'))[0]
    52765276    auxPlot = G2pwd.CalcPDF(data,inst,limits,xydata)
    52775277    data['I(Q)'] = xydata['IofQ']
    … …  
    53275327        name = Data[key]['Name']
    53285328        if name:
    5329             xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
     5329            xydata[key] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name))
    53305330    powName = Data['Sample']['Name']
    5331     powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
    5332     limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Limits'))[1]
    5333     inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))[0]
     5331    powId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,powName)
     5332    limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId,'Limits'))[1]
     5333    inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId,'Instrument Parameters'))[0]
    53345334    numbDen = G2pwd.GetNumDensity(Data['ElList'],Data['Form Vol'])
    53355335    BkgMax = 1.
    … …  
    54245424           
    54255425            def GetExposure(backFile):
    5426                 dataId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PWDR'+dataFile[4:])
    5427                 dataComments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,dataId,'Comments'))
     5426                dataId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'PWDR'+dataFile[4:])
     5427                dataComments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,dataId,'Comments'))
    54285428                if not backFile:
    54295429                    return -1.
    5430                 backId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,backFile)
    5431                 backComments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,backId,'Comments'))
     5430                backId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,backFile)
     5431                backComments = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,backId,'Comments'))
    54325432                expTime = 1.
    54335433                sumExp = 1.
    … …  
    54765476                           
    54775477        def ResetFlatBkg():
    5478             Smin = np.min(G2frame.PatternTree.GetItemPyData(
    5479                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PWDR'+dataFile[4:]))[1][1])
     5478            Smin = np.min(G2frame.GPXtree.GetItemPyData(
     5479                G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'PWDR'+dataFile[4:]))[1][1])
    54805480            Bmin = 0; Cmin = 0.; Cmul = 0.; CBmin = 0.
    54815481            if data['Sample Bkg.']['Name']:
    5482                 Bmin = np.min(G2frame.PatternTree.GetItemPyData(
    5483                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['Sample Bkg.']['Name']))[1][1])
     5482                Bmin = np.min(G2frame.GPXtree.GetItemPyData(
     5483                G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['Sample Bkg.']['Name']))[1][1])
    54845484                Smin += Bmin*data['Sample Bkg.']['Mult']
    54855485            if data['Container']['Name']:
    5486                 Cmin = np.min(G2frame.PatternTree.GetItemPyData(
    5487                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['Container']['Name']))[1][1])
     5486                Cmin = np.min(G2frame.GPXtree.GetItemPyData(
     5487                G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['Container']['Name']))[1][1])
    54885488                Cmul = data['Container']['Mult']
    54895489                if data['Container Bkg.']['Name']:
    5490                     CBmin = np.min(G2frame.PatternTree.GetItemPyData(
    5491                         G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['Container Bkg.']['Name']))[1][1])
     5490                    CBmin = np.min(G2frame.GPXtree.GetItemPyData(
     5491                        G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['Container Bkg.']['Name']))[1][1])
    54925492                    Cmin += CBmin*data['Container Bkg.']['Mult']
    54935493                Smin += Cmul*Cmin
    … …  
    57465746            if newName:
    57475747                data['delt-G(R)'] = copy.deepcopy(data['G(R)'])
    5748                 id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,newName)
    5749                 pId = G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls')
    5750                 subData = G2frame.PatternTree.GetItemPyData(pId)['G(R)']
     5748                id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,newName)
     5749                pId = G2gd.GetGPXtreeItemId(G2frame,id,'PDF Controls')
     5750                subData = G2frame.GPXtree.GetItemPyData(pId)['G(R)']
    57515751                if subData[1][0][-1] != data['G(R)'][1][0][-1]:
    57525752                    G2frame.ErrorDialog('delt-G(R) Error',' G(R) for '+newName+' not same R range')
    … …  
    57615761        def OnMult(invalid,value,tc):
    57625762            if invalid: return
    5763             id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,data['diffGRname'])
    5764             pId = G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls')
    5765             subData = G2frame.PatternTree.GetItemPyData(pId)['G(R)']
     5763            id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,data['diffGRname'])
     5764            pId = G2gd.GetGPXtreeItemId(G2frame,id,'PDF Controls')
     5765            subData = G2frame.GPXtree.GetItemPyData(pId)['G(R)']
    57665766            data['delt-G(R)'][1] = np.array([subData[1][0],data['G(R)'][1][1]-data['diffMult']*subData[1][1]])
    57675767            G2plt.PlotISFG(G2frame,data,newPlot=True,plotType='delt-G(R)')
    … …  
    57945794        import copy
    57955795        TextList = GetFileList(G2frame,'PDF')
    5796         Source = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     5796        Source = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    57975797        if len(TextList) == 1:
    57985798            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
    … …  
    58045804                PDFlist = [TextList[i] for i in dlg.GetSelections()]
    58055805                for item in PDFlist:
    5806                     id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    5807                     olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
     5806                    id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     5807                    olddata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id, 'PDF Controls'))
    58085808                    if od['value_1']:
    58095809                        olddata['Sample Bkg.']['Refine'] = data['Sample Bkg.']['Refine']    #only one flag
    … …  
    58125812                        olddata.update(copy.deepcopy(data))
    58135813                        olddata['Sample'] = sample
    5814                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
     5814                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id, 'PDF Controls'),olddata)
    58155815                G2frame.GetStatusBar().SetStatusText('PDF controls copied')
    58165816        finally:
    … …  
    59125912        print('Calculating PDFs...')
    59135913        choices = []
    5914         if G2frame.PatternTree.GetCount():
    5915             id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     5914        if G2frame.GPXtree.GetCount():
     5915            id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    59165916            while id:
    5917                 Name = G2frame.PatternTree.GetItemText(id)
     5917                Name = G2frame.GPXtree.GetItemText(id)
    59185918                if Name.startswith('PDF '):
    5919                     Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
     5919                    Data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id,'PDF Controls'))
    59205920                    if not Data['ElList']:
    59215921                        print('  No chemical formula for {}'.format(Name))
    59225922                    else:
    59235923                        choices.append(Name)
    5924                 id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     5924                id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    59255925        if not choices:
    59265926            print('  No PDFs to compute\n')
    … …  
    59435943            style = wx.PD_ELAPSED_TIME|wx.PD_AUTO_HIDE|wx.PD_CAN_ABORT)
    59445944        notConverged = 0
    5945         id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     5945        id, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    59465946        N = 0
    59475947        try:
    59485948            while id:
    5949                 Name = G2frame.PatternTree.GetItemText(id)
     5949                Name = G2frame.GPXtree.GetItemText(id)
    59505950                if Name in Names:
    59515951                    N += 1
    … …  
    59545954                        pgbar.Destroy()
    59555955                        break
    5956                     pId = G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls')
    5957                     Data = G2frame.PatternTree.GetItemPyData(pId)
     5956                    pId = G2gd.GetGPXtreeItemId(G2frame,id,'PDF Controls')
     5957                    Data = G2frame.GPXtree.GetItemPyData(pId)
    59585958                    print('  Computing {}'.format(Name))
    59595959                    computePDF(G2frame,Data)
    … …  
    59615961                        notConverged += not OptimizePDF(G2frame,Data,maxCycles=10)
    59625962                    computePDF(G2frame,Data)
    5963                     G2frame.PatternTree.SetItemPyData(pId,Data)
    5964                 id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     5963                    G2frame.GPXtree.SetItemPyData(pId,Data)
     5964                id, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    59655965        finally:
    59665966            pgbar.Destroy()
    … …  
    59815981    tth2q = lambda t,w:4.0*math.pi*sind(t/2.0)/w
    59825982    tof2q = lambda t,C:2.0*math.pi*C/t
    5983     dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     5983    dataFile = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    59845984    powName = 'PWDR'+dataFile[4:]
    5985     powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
     5985    powId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, powName)
    59865986    if powId: # skip if no matching PWDR entry
    5987         fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))[:2]
    5988         inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))[0]
     5987        fullLimits,limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId, 'Limits'))[:2]
     5988        inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,powId, 'Instrument Parameters'))[0]
    59895989        if 'C' in inst['Type'][0]:
    59905990            wave = G2mth.getWave(inst)
    … …  
    61436143        import copy
    61446144        TextList = GetFileList(G2frame,'PDF')
    6145         Source = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     6145        Source = G2frame.GPXtree.GetItemText(G2frame.PatternId)
    61466146        if len(TextList) == 1:
    61476147            G2frame.ErrorDialog('Nothing to copy PDF peaks to','There must be more than one "PDF" pattern')
    … …  
    61526152                PDFlist = [TextList[i] for i in dlg.GetSelections()]
    61536153                for item in PDFlist:
    6154                     id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
    6155                     olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Peaks'))
     6154                    id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,item)
     6155                    olddata = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id, 'PDF Peaks'))
    61566156                    olddata.update(copy.deepcopy(peaks))
    6157                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Peaks'),olddata)
     6157                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,id, 'PDF Peaks'),olddata)
    61586158                G2frame.GetStatusBar().SetStatusText('PDF peaks copied')
    61596159        finally:
    … …  
    61626162    def OnFitPDFpeaks(event):
    61636163        PatternId = G2frame.PatternId
    6164         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'PDF Controls'))
    6165         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'PDF Peaks'))
     6164        data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'PDF Controls'))
     6165        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'PDF Peaks'))
    61666166        if not peaks:
    61676167            G2frame.ErrorDialog('No peaks!','Nothing to fit!')
    … …  
    61696169        newpeaks = G2pwd.PDFPeakFit(peaks,data['G(R)'])[0]
    61706170        print 'PDF peak fit finished'
    6171         G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'PDF Peaks'),newpeaks)
     6171        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'PDF Peaks'),newpeaks)
    61726172        G2plt.PlotISFG(G2frame,data,peaks=newpeaks,newPlot=False)
    61736173        wx.CallAfter(UpdatePDFPeaks,G2frame,newpeaks,data)
    61746174       
    61756175    def OnFitAllPDFpeaks(event):
    6176         Names = G2gd.GetPatternTreeDataNames(G2frame,['PDF ',])
     6176        Names = G2gd.GetGPXtreeDataNames(G2frame,['PDF ',])
    61776177        dlg = G2G.G2MultiChoiceDialog(G2frame,'PDF peak fitting','Select PDFs to fit:',Names)
    61786178        try:
    61796179            if dlg.ShowModal() == wx.ID_OK:
    6180                 Id =  G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential PDF peak fit results')
     6180                Id =  G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Sequential PDF peak fit results')
    61816181                if Id:
    6182                     SeqResult = G2frame.PatternTree.GetItemPyData(Id)
     6182                    SeqResult = G2frame.GPXtree.GetItemPyData(Id)
    61836183                else:
    61846184                    SeqResult = {}
    6185                     Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential PDF peak fit results')
     6185                    Id = G2frame.GPXtree.AppendItem(parent=G2frame.root,text='Sequential PDF peak fit results')
    61866186                SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
    61876187                items = dlg.GetSelections()
    … …  
    61896189                for item in items:
    61906190                    name = Names[item]
    6191                     pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    6192                     data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,pId, 'PDF Controls'))
    6193                     peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,pId,'PDF Peaks'))
     6191                    pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     6192                    data = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,pId, 'PDF Controls'))
     6193                    peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,pId,'PDF Peaks'))
    61946194                    newpeaks,vals,varyList,sigList,parmDict,Rvals = G2pwd.PDFPeakFit(peaks,data['G(R)'])
    61956195                    if vals is None:
    … …  
    61996199                    SeqResult[name] = {'variables':vals,'varyList':varyList,'sig':sigList,'Rvals':Rvals,
    62006200                        'covMatrix':np.eye(len(varyList)),'title':name,'parmDict':parmDict}
    6201                     G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,pId, 'PDF Peaks'),newpeaks)
     6201                    G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,pId, 'PDF Peaks'),newpeaks)
    62026202                SeqResult['histNames'] = Names
    62036203                G2frame.G2plotNB.Delete('Sequential refinement')    #clear away probably invalid plot
    … …  
    62056205            dlg.Destroy()
    62066206        G2plt.PlotISFG(G2frame,data,peaks=newpeaks,newPlot=False)
    6207         G2frame.PatternTree.SetItemPyData(Id,SeqResult)
    6208         G2frame.PatternTree.SelectItem(Id)
     6207        G2frame.GPXtree.SetItemPyData(Id,SeqResult)
     6208        G2frame.GPXtree.SelectItem(Id)
    62096209        print 'All PDFs peak fitted - results in Sequential PDF peak fit results'
    62106210       
Note: See TracChangeset for help on using the changeset viewer.