Changeset 2905


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

use GPXtree in place of PatternTree?

Location:
branch/2frame
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • 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:
  • 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 = {}
  • 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]
  • 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        
  • 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)
  • 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
  • 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       
  • 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)
  • 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)
  • 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: