Changeset 1445


Ignore:
Timestamp:
Jul 30, 2014 10:29:52 AM (7 years ago)
Author:
vondreele
Message:

add error bars to calibration plot
disable Autosearch if peaks already picked
implement cell refine for TOF data - isn't quite right yet
implement tool tip on calibration plot to show position for each peak

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASII.py

    r1439 r1445  
    12811281            self.PatternTree.SetItemPyData(
    12821282                self.PatternTree.AppendItem(Id,text='Peak List')
    1283                 ,[])
     1283                ,{'peaks':[],'sigDict':{}})
    12841284            self.PatternTree.SetItemPyData(
    12851285                self.PatternTree.AppendItem(Id,text='Index Peak List'),
    1286                 [])
     1286                [[],[]])
    12871287            self.PatternTree.SetItemPyData(
    12881288                self.PatternTree.AppendItem(Id,text='Unit Cells List'),
     
    14571457        self.PatternTree.SetItemPyData(
    14581458            self.PatternTree.AppendItem(Id,text='Peak List')
    1459             ,[])
     1459            ,{'peaks':[],'sigDict':{}})
    14601460        self.PatternTree.SetItemPyData(
    14611461            self.PatternTree.AppendItem(Id,text='Index Peak List'),
    1462             [])
     1462            [[],[]])
    14631463        self.PatternTree.SetItemPyData(
    14641464            self.PatternTree.AppendItem(Id,text='Unit Cells List'),
     
    20302030                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Instrument Parameters'),inst)
    20312031                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),comments)
    2032                 self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),peaks)
     2032                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[peaks,[]])
    20332033                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    20342034                self.PatternTree.Expand(Id)
     
    23712371                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Instrument Parameters'),Inst)
    23722372                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
    2373                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Peak List'),[])
    2374                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[])
     2373                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Peak List'),{'peaks':[],'sigDict':{}})
     2374                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[[],[]])
    23752375                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    23762376                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Reflection Lists'),{})             
     
    28112811                            name2 = self.PatternTree.GetItemText(item2)
    28122812                            if name2 == 'Peak List':
    2813                                 peaks = self.PatternTree.GetItemPyData(item2)
     2813                                peaks = self.PatternTree.GetItemPyData(item2)['peaks']
    28142814                                file.write("%s \n" % (name+' Peak List'))               
    28152815                                for peak in peaks:
  • trunk/GSASIIgrid.py

    r1443 r1445  
    29342934        self.PeakFit.Enable(False)
    29352935        self.PFOneCycle.Enable(False)
     2936        self.AutoSearch.Enable(True)
    29362937       
    29372938        # PDR / Index Peak List
     
    52775278        G2frame.PickId = item
    52785279        data = G2frame.PatternTree.GetItemPyData(item)
     5280#patch
     5281        if isinstance(data,list):
     5282            data = {'peaks':data,'sigDict':{}}
     5283            G2frame.PatternTree.SetItemPyData(item,data)
     5284#end patch
    52795285        G2pdG.UpdatePeakGrid(G2frame,data)
    52805286        G2plt.PlotPatterns(G2frame)
     
    53325338        G2frame.PickId = item
    53335339        data = G2frame.PatternTree.GetItemPyData(item)
     5340#patch
     5341        if len(data) != 2:
     5342            data = [data,[]]
     5343            G2frame.PatternTree.SetItemPyData(item,data)
     5344#end patch
    53345345        G2pdG.UpdateIndexPeaksGrid(G2frame,data)
    53355346        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
  • trunk/GSASIIindex.py

    r1367 r1445  
    336336    if Zref:
    337337        Z = result[0][-1]
    338    
     338       
    339339    return True,np.sum(errFit(result[0],ibrav,Peaks[7],Peaks[4:7],Peaks[0],wave,Zref,Pwr)**2),A,Z,result
     340   
     341def FitHKLT(difC,ibrav,peaks,A,Z,Zref,Pwr):
     342    'needs a doc string'
     343   
     344    def errFit(values,ibrav,d,H,tof,difC,Zref,Pwr):
     345        Zero = Z
     346        if Zref:   
     347            Zero = values[-1]
     348        A = Values2A(ibrav,values[:6])
     349        Qo = 1./d**2
     350        Qc = G2lat.calc_rDsqT(H,A,Zero,tof,difC)
     351        return (Qo-Qc)*d**Pwr
     352   
     353    Peaks = np.array(peaks).T
     354   
     355    values = A2values(ibrav,A)
     356    if Zref:
     357        values.append(Z)
     358    result = so.leastsq(errFit,values,full_output=True,ftol=0.0001,factor=0.001,
     359        args=(ibrav,Peaks[7],Peaks[4:7],Peaks[0],difC,Zref,Pwr))
     360    A = Values2A(ibrav,result[0][:6])
     361    if Zref:
     362        Z = result[0][-1]
     363   
     364    return True,np.sum(errFit(result[0],ibrav,Peaks[7],Peaks[4:7],Peaks[0],difC,Zref,Pwr)**2),A,Z,result
    340365               
    341366def rotOrthoA(A):
     
    392417    H = Peaks[4:7]
    393418    Peaks[8] = 1./np.sqrt(G2lat.calc_rDsqZ(H,Aref,Z,Peaks[0],wave))
     419    peaks = Peaks.T   
     420    HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
     421    M20,X20 = calc_M20(peaks,HKL)
     422    return len(HKL),M20,X20,Aref,Z
     423   
     424def refinePeaksT(peaks,difC,ibrav,A,Zero,ZeroRef):
     425    'needs a doc string'
     426    dmin = getDmin(peaks)
     427    OK,smin,Aref,Z,result = FitHKLT(difC,ibrav,peaks,A,Zero,ZeroRef,0)
     428    Peaks = np.array(peaks).T
     429    H = Peaks[4:7]
     430    Peaks[8] = 1./np.sqrt(G2lat.calc_rDsqT(H,Aref,Z,Peaks[0],difC))
    394431    peaks = Peaks.T   
    395432    HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
  • trunk/GSASIIlattice.py

    r1443 r1445  
    459459    rpd = np.pi/180.
    460460    rdsq = calc_rDsq(H,A)+Z*sind(tth)*2.0*rpd/lam**2
     461    return rdsq
     462       
     463def calc_rDsqT(H,A,Z,tof,difC):
     464    'needs doc string'
     465    rdsq = calc_rDsq(H,A)+Z/difC
    461466    return rdsq
    462467       
  • trunk/GSASIIplot.py

    r1443 r1445  
    10281028                        xy[0] = 2.0*asind(xy[0]*wave/(4*math.pi))
    10291029                XY = G2mth.setPeakparms(Parms,Parms2,xy[0],xy[1])
    1030                 data.append(XY)
     1030                data['peaks'].append(XY)
     1031                data['sigDict'] = {}    #now invalid
    10311032                G2pdG.UpdatePeakGrid(G2frame,data)
    10321033                PlotPatterns(G2frame,plotType=plottype)
     
    11191120                data = G2frame.PatternTree.GetItemPyData(PeakId)
    11201121                if event.button == 3:
    1121                     del data[lineNo-2]
     1122                    del data['peaks'][lineNo-2]
    11221123                else:
    11231124                    if G2frame.qPlot:
    1124                         data[lineNo-2][0] = 2.0*asind(wave*xpos/(4*math.pi))
     1125                        data['peaks'][lineNo-2][0] = 2.0*asind(wave*xpos/(4*math.pi))
    11251126                    else:
    1126                         data[lineNo-2][0] = xpos
     1127                        data['peaks'][lineNo-2][0] = xpos
     1128                    data['sigDict'] = {}        #no longer valid
    11271129                G2frame.PatternTree.SetItemPyData(PeakId,data)
    11281130                G2pdG.UpdatePeakGrid(G2frame,data)
     
    14741476                    Page.canvas.SetToolTipString(tip)
    14751477                    data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
    1476                     for item in data:
     1478                    for item in data['peaks']:
    14771479                        if G2frame.qPlot:
    14781480                            if 'C' in Parms['Type'][0]:
     
    15091511            difC = Parms['difC'][1]
    15101512        if G2frame.PatternTree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
    1511             peaks = np.array((G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))))
     1513            peaks = np.array((G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))))[0]
    15121514            for peak in peaks:
    15131515                if G2frame.qPlot:
     
    18311833################################################################################
    18321834           
    1833 def PlotCalib(G2frame,Inst,XY,newPlot=False):
     1835def PlotCalib(G2frame,Inst,XY,Sigs,newPlot=False):
    18341836    '''plot of CW or TOF peak calibration
    18351837    '''
     
    18431845            except TypeError:
    18441846                G2frame.G2plotNB.status.SetStatusText('Select '+Title+' pattern first',1)
     1847            found = []
     1848            wid = 1
     1849            view = Page.toolbar._views.forward()
     1850            if view:
     1851                view = view[0][:2]
     1852                wid = view[1]-view[0]
     1853            found = XY[np.where(np.fabs(XY.T[0]-xpos) < 0.005*wid)]
     1854            if len(found):
     1855                pos = found[0][1]
     1856                if 'C' in Inst['Type'][0]:
     1857                    Page.canvas.SetToolTipString('position=%.4f'%(pos))
     1858                else:
     1859                    Page.canvas.SetToolTipString('position=%.2f'%(pos))
     1860            else:
     1861                Page.canvas.SetToolTipString('')
    18451862
    18461863    Title = 'Position calibration'
     
    18751892        if 'C' in Inst['Type'][0]:
    18761893            Y = Y-Yc
     1894            E = Sigs[ixy]
    18771895        else:
    18781896            Y = (Y-Yc)/Yc
    1879         Plot.plot(X,Y,'k+',picker=False)
     1897            E = Sigs[ixy]/Yc
     1898        if E:
     1899            Plot.errorbar(X,Y,ecolor='k',yerr=E)
     1900        Plot.plot(X,Y,'kx',picker=3)
    18801901    if not newPlot:
    18811902        Page.toolbar.push_current()
    18821903        Plot.set_xlim(xylim[0])
    18831904        Plot.set_ylim(xylim[1])
    1884         xylim = []
     1905#        xylim = []
    18851906        Page.toolbar.push_current()
    18861907        Page.toolbar.draw()
     
    21012122    PickId = G2frame.PickId
    21022123    PatternId = G2frame.PatternId
    2103     peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
     2124    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))[0]
    21042125    for peak in peaks:
    21052126        Plot.axvline(peak[0],color='b')
     
    21392160    else:
    21402161        difC = Parms['difC'][0]
    2141     peakID = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List')
    2142     if peakID:
    2143         peaks = G2frame.PatternTree.GetItemPyData(peakID)
    2144     else:
    2145         peaks = []
     2162    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))['peaks']
    21462163   
    21472164    try:
  • trunk/GSASIIpwdGUI.py

    r1443 r1445  
    325325            refs = G2mth.sortArray(refs,1,reverse=False)
    326326        for pos,mag in refs:
    327             data.append(G2mth.setPeakparms(inst,inst2,pos,mag))
     327            data['peaks'].append(G2mth.setPeakparms(inst,inst2,pos,mag))
    328328        UpdatePeakGrid(G2frame,data)
    329329        G2plt.PlotPatterns(G2frame,plotType='PWDR')       
     
    370370        try:
    371371            if dlg.ShowModal() == wx.ID_OK:
    372                 peaks = []
     372                peaks = {'peaks':[],'sigDict':{}}
    373373        finally:
    374374            dlg.Destroy()
     
    399399        dlg.SetPosition(wx.Point(screenSize[2]-Size[0]-305,screenSize[1]+5))
    400400        try:
    401             sigDict = G2pwd.DoPeakFit(FitPgm,peaks,background,limits,inst,inst2,data,oneCycle,controls,dlg)
     401            peaks['sigDict'] = G2pwd.DoPeakFit(FitPgm,peaks['peaks'],background,limits,inst,inst2,data,oneCycle,controls,dlg)
    402402        finally:
    403403            wx.EndBusyCursor()   
     404        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),peaks)
    404405        UpdatePeakGrid(G2frame,peaks)
    405406        G2plt.PlotPatterns(G2frame,plotType='PWDR')
     
    412413        Inst,Inst2 = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
    413414        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
    414         if not peaks:
     415        if not peaks['peaks']:
    415416            G2frame.ErrorDialog('No peaks!','Nothing to do!')
    416417            return
    417         newpeaks = []
    418         for peak in peaks:
    419             newpeaks.append(G2mth.setPeakparms(Inst,Inst2,peak[0],peak[2]))
     418        newpeaks = {'peaks':[],'sigDict':{}}
     419        for peak in peaks['peaks']:
     420            newpeaks['peaks'].append(G2mth.setPeakparms(Inst,Inst2,peak[0],peak[2]))
    420421        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'),newpeaks)
    421422        UpdatePeakGrid(G2frame,newpeaks)
     
    425426       
    426427        event.StopPropagation()
    427         data = G2frame.PeakTable.GetData()
     428        data['peaks'] = G2frame.PeakTable.GetData()
    428429        T = []
    429         for peak in data:T.append(peak[0])
    430         D = dict(zip(T,data))
     430        for peak in data['peaks']:T.append(peak[0])
     431        D = dict(zip(T,data['peaks']))
    431432        T.sort()
    432433        X = []
    433434        for key in T: X.append(D[key])
    434         data = X       
     435        data['peaks'] = X       
    435436       
    436437    def setBackgroundColors():
     
    472473                G2frame.dataDisplay.ForceRefresh()
    473474                setBackgroundColors()
    474                 if not len(G2frame.PatternTree.GetItemPyData(G2frame.PickId)):
    475                     G2frame.dataFrame.PeakFit.Enable(False)
    476475                       
    477476        elif colList:
     
    481480                if G2frame.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
    482481                    if key == 89: #'Y'
    483                         for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=True
     482                        for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=True
    484483                    elif key == 78:  #'N'
    485                         for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=False
     484                        for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=False
    486485        elif selectList:
    487486            G2frame.dataDisplay.ClearSelection()
     
    490489                if G2frame.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
    491490                    if key == 89: #'Y'
    492                         data[row][col]=True
     491                        data['peaks'][row][col]=True
    493492                    elif key == 78:  #'N'
    494                         data[row][col]=False
     493                        data['peaks'][row][col]=False
    495494        G2plt.PlotPatterns(G2frame,plotType='PWDR')
    496495           
     
    505504    G2frame.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
    506505    G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
    507     G2frame.dataFrame.PeakFit.Enable(False)
    508     if data:
     506    if data['peaks']:
     507        G2frame.dataFrame.AutoSearch.Enable(False)
    509508        G2frame.dataFrame.PeakFit.Enable(True)
    510509        G2frame.dataFrame.PFOneCycle.Enable(True)
     510    else:
     511        G2frame.dataFrame.PeakFit.Enable(False)
     512        G2frame.dataFrame.PFOneCycle.Enable(False)
     513        G2frame.dataFrame.AutoSearch.Enable(True)
    511514    G2frame.PickTable = []
    512515    rowLabels = []
    513516    PatternId = G2frame.PatternId
    514517    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))[0]
    515     for i in range(len(data)): rowLabels.append(str(i+1))
     518    for i in range(len(data['peaks'])): rowLabels.append(str(i+1))
    516519    if 'C' in Inst['Type'][0]:
    517520        colLabels = ['position','refine','intensity','refine','sigma','refine','gamma','refine']
     
    530533            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
    531534    T = []
    532     for peak in data:
     535    for peak in data['peaks']:
    533536        T.append(peak[0])
    534     D = dict(zip(T,data))
     537    D = dict(zip(T,data['peaks']))
    535538    T.sort()
    536539    if 'T' in Inst['Type'][0]:  #want big TOF's first
     
    538541    X = []
    539542    for key in T: X.append(D[key])
    540     data = X
     543    data['peaks'] = X
    541544    G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
    542     G2frame.PeakTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
     545    G2frame.PeakTable = G2gd.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    543546    G2frame.dataFrame.SetLabel('Peak List')
    544547    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
     
    944947            peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
    945948            newpeaks = []
    946             for peak in peaks:
     949            for peak in peaks['peaks']:
    947950                newpeaks.append(G2mth.setPeakparms(data,Inst2,peak[0],peak[2]))
    948             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),newpeaks)
     951            peaks['peaks'] = newpeaks
     952            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'),peaks)
    949953           
    950954    def OnCalibrate(event):
    951955        IndexPeaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
    952         if not len(IndexPeaks):
     956        if not len(IndexPeaks[0]):
    953957            G2frame.ErrorDialog('Can not calibrate','Index Peak List empty')
    954958            return
    955 #        Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    956         G2pwd.DoCalibInst(IndexPeaks,data)
     959        Ok = False
     960        for peak in IndexPeaks[0]:
     961            if peak[2] and peak[3]:
     962                Ok = True
     963        if not Ok:
     964            G2frame.ErrorDialog('Can not calibrate','Index Peak List not indexed')
     965            return           
     966        G2pwd.DoCalibInst(IndexPeaks[0],data)
    957967        UpdateInstrumentGrid(G2frame,data)
    958968        XY = []
    959         for peak in IndexPeaks:
     969        Sigs = []
     970        for ip,peak in enumerate(IndexPeaks[0]):
    960971            if peak[2] and peak[3]:
    961972                XY.append([peak[8],peak[0]])
     973                Sigs.append(IndexPeaks[1][ip])
    962974        if len(XY):
    963             G2plt.PlotCalib(G2frame,data,XY,newPlot=True)
     975            XY = np.array(XY)
     976            G2plt.PlotCalib(G2frame,data,XY,Sigs,newPlot=True)
    964977
    965978    def OnLoad(event):
     
    18051818    def RefreshIndexPeaksGrid(event):
    18061819        r,c =  event.GetRow(),event.GetCol()
    1807         data = G2frame.IndexPeaksTable.GetData()
     1820        peaks = G2frame.IndexPeaksTable.GetData()
    18081821        if c == 2:
    1809             if data[r][c]:
    1810                 data[r][c] = False
     1822            if peaks[r][c]:
     1823                peaks[r][c] = False
    18111824            else:
    1812                 data[r][c] = True
    1813             G2frame.IndexPeaksTable.SetData(data)
    1814             G2frame.PatternTree.SetItemPyData(IndexId,data)
     1825                peaks[r][c] = True
     1826            G2frame.IndexPeaksTable.SetData(peaks)
     1827            G2frame.PatternTree.SetItemPyData(IndexId,[peaks,data[1]])
    18151828            G2frame.dataDisplay.ForceRefresh()
    18161829           
    18171830    def OnReload(event):
    1818         data = []
    1819         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
    1820         for peak in peaks:
     1831        peaks = []
     1832        sigs = []
     1833        Peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
     1834        for ip,peak in enumerate(Peaks['peaks']):
    18211835            dsp = G2lat.Pos2dsp(Inst,peak[0])
    1822             data.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
     1836            peaks.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
     1837            try:
     1838                sig = Peaks['sigDict']['pos'+str(ip)]
     1839            except KeyError:
     1840                sig = 0.
     1841            sigs.append(sig)
     1842        data = [peaks,sigs]
    18231843        G2frame.PatternTree.SetItemPyData(IndexId,data)
    18241844        UpdateIndexPeaksGrid(G2frame,data)
     
    18401860                if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
    18411861                    if key == 89: #'Y'
    1842                         for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=True
     1862                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[0][row][col]=True
    18431863                    elif key == 78:  #'N'
    1844                         for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=False
     1864                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[0][row][col]=False
    18451865           
    18461866    if G2frame.dataDisplay:
     
    18531873    G2frame.dataFrame.IndexPeaks.Enable(False)
    18541874    G2frame.IndexPeaksTable = []
    1855     if data:
     1875    if len(data[0]):
    18561876        G2frame.dataFrame.IndexPeaks.Enable(True)
    18571877        cells = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
     
    18651885                    A = G2lat.cell2A(cell[3:9])
    18661886                    G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
    1867                     G2indx.IndexPeaks(data,G2frame.HKL)
     1887                    G2indx.IndexPeaks(data[0],G2frame.HKL)
    18681888                    for hkl in G2frame.HKL:
    18691889                        hkl.append(G2lat.Dsp2pos(Inst,hkl[3]))
    18701890    rowLabels = []
    1871     for i in range(len(data)): rowLabels.append(str(i+1))
     1891    for i in range(len(data[0])): rowLabels.append(str(i+1))
    18721892    colLabels = ['position','intensity','use','indexed','h','k','l','d-obs','d-calc']
    18731893    Types = [wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_FLOAT+':10,1',wg.GRID_VALUE_BOOL,
     
    18751895        wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5']
    18761896    G2frame.PatternTree.SetItemPyData(IndexId,data)
    1877     G2frame.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
     1897    G2frame.IndexPeaksTable = G2gd.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    18781898    G2frame.dataFrame.SetLabel('Index Peak List')
    18791899    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)               
    18801900    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
    18811901    XY = []
     1902    Sigs = []
    18821903    for r in range(G2frame.dataDisplay.GetNumberRows()):
    18831904        for c in range(G2frame.dataDisplay.GetNumberCols()):
     
    18861907            else:
    18871908                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
    1888         if data[r][2] and data[r][3]:
    1889             XY.append([data[r][8],data[r][0]])
     1909        if data[0][r][2] and data[0][r][3]:
     1910            XY.append([data[0][r][8],data[0][r][0]])
     1911            try:
     1912                sig = data[1][r]
     1913            except IndexError:
     1914                sig = 0.
     1915            Sigs.append(sig)
    18901916    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
    18911917    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
     
    18941920    G2frame.dataFrame.setSizePosLeft([490,300])
    18951921    if len(XY):
    1896         G2plt.PlotCalib(G2frame,Inst,XY,newPlot=True)
     1922        XY = np.array(XY)
     1923        G2plt.PlotCalib(G2frame,Inst,XY,Sigs,newPlot=True)
    18971924     
    18981925################################################################################
     
    20192046        PatternId = G2frame.PatternId
    20202047        PickId = G2frame.PickId   
    2021         peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
     2048        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))[0]
    20222049        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    20232050        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
     
    20872114        PickId = G2frame.PickId   
    20882115        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
    2089         if not peaks:
     2116        if not peaks[0]:
    20902117            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
    20912118            return       
     
    20982125        dmin = G2indx.getDmin(peaks)-0.005
    20992126        G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A)
    2100         G2indx.IndexPeaks(peaks,G2frame.HKL)
    2101         Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks,wave,ibrav,A,controls[1],controls[0])  #TOF?         
     2127        G2indx.IndexPeaks(peaks[0],G2frame.HKL)
     2128        if 'C' in Inst['Type'][0]:
     2129            Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks[0],wave,ibrav,A,controls[1],controls[0])
     2130        else:   #'T'OF
     2131            Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksT(peaks[0],difC,ibrav,A,controls[1],controls[0])           
    21022132        controls[1] = Zero
    21032133        controls[6:12] = G2lat.A2cell(Aref)
     
    21412171        G2frame.dataFrame.CopyCell.Enable(False)
    21422172        G2frame.dataFrame.RefineCell.Enable(False)
    2143         OK,dmin,newcells = G2indx.DoIndexPeaks(peaks,controls,bravais)
     2173        OK,dmin,newcells = G2indx.DoIndexPeaks(peaks[0],controls,bravais)
    21442174        cells = keepcells+newcells
    21452175        cells = G2indx.sortM20(cells)
Note: See TracChangeset for help on using the changeset viewer.