Changeset 45 for trunk/GSASII.py


Ignore:
Timestamp:
Mar 24, 2010 3:14:32 PM (13 years ago)
Author:
vondreel
Message:

remove plotting routines

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASII.py

    r38 r45  
    66import cPickle
    77import time
     8import copy
    89import numpy as np
    910import wx
    1011import matplotlib as mpl
    11 # use the newer wxmpl when needed
    12 (main,sub) = mpl.__version__.split('.')[0:2]
    13 if int(main) > 0 or int(sub) > 91:
    14     import wxmpl131 as wxmpl
    15 else:
    16     import wxmpl as wxmpl
    17 import pylab
    1812
    1913# load the GSAS routines
     
    2115import GSASIIcomp as G2cmp
    2216import GSASIIgrid as G2gd
     17import GSASIIplot as G2plt
    2318
    2419# print versions
     
    2823print "matplotlib: ",mpl.__version__
    2924print "numpy:      ",np.__version__
    30 print "wxmpl:      ",wxmpl.__version__
    31 
    32 __version__ = '0.1.2'
     25
     26__version__ = '0.1.3'
    3327
    3428# useful degree trig functions
     
    214208        self.root = self.PatternTree.AddRoot("Loaded Data")
    215209       
     210        plotFrame = wx.Frame(None,-1,'GSASII Plots',size=wx.Size(700,600), \
     211            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX)
     212        self.G2plotNB = G2plt.G2PlotNoteBook(plotFrame)
     213        plotFrame.Show()
     214       
    216215        self.dataDisplay = None
    217216       
     
    224223        self.Weight = False
    225224        self.IparmName = ''
    226         self.NewPlot = True
    227225        self.IfPlot = False
    228226        self.PatternId = 0
     
    238236        self.Image = 0
    239237        self.Img = 0
     238        self.Pwdr = False
    240239        self.imageDefault = {}
    241         self.PDevent = []
    242         self.IMevent = []
    243         self.SCevent = []
    244240        self.Sngl = 0
    245241        self.ifGetRing = False
     
    251247                       
    252248    def OnPatternTreeSelChanged(self, event):
    253         if self.PickId:
    254             if self.PatternTree.GetItemText(self.PickId) in ['Peak List','Limits','Peak Index List','Unit Cell List','Background']:
    255                 self.plotView = self.getPlotLimits()
     249        pltNum = self.G2plotNB.nb.GetSelection()
     250        if pltNum >= 0:                         #to avoid the startup with no plot!
     251            pltPage = self.G2plotNB.nb.GetPage(pltNum)
     252            pltPlot = pltPage.figure.gca()
     253            pltPage.xylim = [pltPlot.get_xlim(),pltPlot.get_ylim()]
     254            pltPage.views = copy.deepcopy(pltPage.toolbar._views)
    256255        item = event.GetItem()
    257256        G2gd.MovePatternTreeToGrid(self,item)
     
    296295                            Each tree item data is a list with:
    297296                            Item: the (filename,Pos,Bank) tuple
    298                             data: (x,y,w,yc,yb,yd) list from GetPowderData
     297                            data: (x,y,w,yc,yb,yd) list  of np.arrays from GetPowderData
    299298                            '''
    300299                           
     
    335334                self.PatternTree.Expand(Id)
    336335                self.PatternTree.SelectItem(Id)
    337                 self.NewPlot = True
    338                 self.PlotPatterns()
    339336   
    340337        finally:
     
    362359                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),peaks)
    363360                self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    364                 self.NewPlot = True
    365361                self.PatternTree.Expand(Id)
     362                self.PatternTree.SelectItem(Id)
    366363        finally:
    367364            dlg.Destroy()
    368365           
    369366    def OnImageRead(self,event):
    370         import copy
    371367        self.CheckNotebook()
    372368        dlg = wx.FileDialog(self, 'Choose image file', '.', '',\
     
    412408                        Data['masks'] = []
    413409                        Data['calibrant'] = ''
    414                         Data['IOradii'] = [10.,100.]
     410                        Data['IOtth'] = [2.0,5.0]
    415411                        Data['LRazimuth'] = [-45,45]
    416412                        Data['outChannels'] = 2500
     
    423419                    self.PickId = Id
    424420                    self.Image = Id
    425                     self.PlotImage()
    426421                    self.PatternTree.SelectItem(Id)
    427422                    self.PatternTree.Expand(Id)
     
    631626                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])             
    632627                        self.PatternTree.SelectItem(Id)
     628                        self.PatternTree.Expand(Id)
    633629                   
    634                     self.PlotPatterns()
    635                     self.NewPlot = True
    636630            finally:
    637631                dlg.Destroy()
     
    697691                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Image Controls'),Data)                                           
    698692                        self.PatternTree.SelectItem(Id)
     693                        self.PatternTree.Expand(Id)
    699694                    self.PickId = Id
    700695                    self.Image = Id
    701                     self.PlotImage()
    702                     self.NewPlot = True
    703696            finally:
    704697                dlg.Destroy()
     
    774767                    for item in DelItemList:
    775768                        self.PatternTree.Delete(item)
    776                     self.PlotPatterns()
    777                     self.NewPlot = True
     769                    G2plt.PlotPatterns(self)                        #so plot gets updated
    778770            finally:
    779771                dlg.Destroy()
     
    789781                if result == wx.ID_OK:
    790782                    self.PatternTree.DeleteChildren(self.root)
     783                    print 'children deleted'
    791784            finally:
    792785                dlg.Destroy()
     
    801794                    self.dirname = dlg.GetDirectory()
    802795                    G2IO.ProjFileOpen(self)
     796                    self.PatternTree.Expand(self.root)
    803797                    self.HKL = []
    804                     self.NewPlot = True
    805 #                    self.PlotPatterns()
    806798            finally:
    807799                dlg.Destroy()
     
    820812                self.PatternTree.DeleteChildren(self.root)
    821813                if self.HKL: self.HKL = []
    822                 self.NewPlot = True
    823                 self.PlotPatterns()
    824814        finally:
    825815            dlg.Destroy()
     
    851841            self.dataFrame.Clear()
    852842            self.dataFrame.Destroy()
    853         pylab.close('all')
    854843        self.Close()
    855844       
     
    10111000        file.close()
    10121001        self.UnDo.Enable(True)
    1013        
    1014     def getPlotLimits(self):
    1015         ax = self.pdplot.gca()
    1016         return [ax.get_xlim(),ax.get_ylim()]
    1017 
    1018          
    1019     def ClearEventList(self,eventList):
    1020         if eventList:
    1021             for i in range(len(eventList)):
    1022                 self.pdplot.canvas.mpl_disconnect(eventList[i])
    1023         return []
    1024 
    1025     def PlotPeakWidths(self):
    1026         newPlot = False
    1027         PatternId = self.PatternId
    1028         limitID = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
    1029         if limitID:
    1030             limits = self.PatternTree.GetItemPyData(limitID)
    1031         else:
    1032             return
    1033         instParms = self.PatternTree.GetItemPyData( \
    1034             G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))
    1035         if instParms[0][0] == 'PXC':
    1036             lam = instParms[1][1]
    1037             if len(instParms[1]) == 12:
    1038                 GU,GV,GW,LX,LY = instParms[0][6:11]
    1039             else:
    1040                 GU,GV,GW,LX,LY = instParms[0][4:9]
    1041         peakID = G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List')
    1042         if peakID:
    1043             peaks = self.PatternTree.GetItemPyData(peakID)
    1044         else:
    1045             peaks = []
    1046         try:
    1047             self.pdplot.clear()
    1048             self.IMevent = self.ClearEventList(self.IMevent)
    1049             self.PDevent = self.ClearEventList(self.PDevent)
    1050             self.SCevent = self.ClearEventList(self.SCevent)
    1051             self.pdplot.canvas.set_window_title('Peak Widths')
    1052         except:
    1053             self.pdplot.clear()
    1054             self.pdplot = pylab.figure(facecolor='white')
    1055             self.pdplot.canvas.set_window_title('Peak Widths')
    1056             self.NewPlot = True
    1057             newPlot = True
    1058         self.pdplot.canvas.SetToolTipString('')
    1059         colors=['b','g','r','c','m','k']
    1060         Xmin,Xmax = limits[1]
    1061         Xmin = min(0.5,max(Xmin,1))
    1062         Xmin /= 2
    1063         Xmax /= 2
    1064         nPts = 100
    1065         delt = (Xmax-Xmin)/nPts
    1066         thetas = []
    1067         for i in range(nPts):
    1068             thetas.append(Xmin+i*delt)
    1069         X = []
    1070         Y = []
    1071         Z = []
    1072         W = []
    1073         sig = lambda Th,U,V,W: 1.17741*math.sqrt(U*tand(Th)**2+V*tand(Th)+W)*math.pi/18000.
    1074         gam = lambda Th,X,Y: (X/cosd(Th)+Y*tand(Th))*math.pi/18000.
    1075         gamFW = lambda s,g: math.exp(math.log(g**5+2.69269*g**4*s+2.42843*g**3*s**2+4.47163*g**2*s**3+0.07842*g*s**4+s**5)/5.)
    1076         for theta in thetas:
    1077             X.append(4.0*math.pi*sind(theta)/lam)              #q
    1078             s = sig(theta,GU,GV,GW)
    1079             g = gam(theta,LX,LY)
    1080             G = gamFW(g,s)
    1081             Y.append(s/tand(theta))
    1082             Z.append(g/tand(theta))
    1083             W.append(G/tand(theta))
    1084         ax = self.pdplot.add_subplot(111)
    1085         ax.clear()
    1086         ax.set_title('Instrument and sample peak widths')
    1087         ax.set_ylabel(r'$\Delta q/q, \Delta d/d$',fontsize=14)
    1088         ax.set_xlabel(r'$q, \AA^{-1}$',fontsize=14)
    1089         ax.plot(X,Y,color='r',label='Gaussian')
    1090         ax.plot(X,Z,color='g',label='Lorentzian')
    1091         ax.plot(X,W,color='b',label='G+L')
    1092         X = []
    1093         Y = []
    1094         Z = []
    1095         W = []
    1096         for peak in peaks:
    1097             X.append(4.0*math.pi*sind(peak[0]/2.0)/lam)
    1098             s = 1.17741*math.sqrt(peak[4])*math.pi/18000.
    1099             g = peak[6]*math.pi/18000.
    1100             G = gamFW(g,s)
    1101             Y.append(s/tand(peak[0]/2.))
    1102             Z.append(g/tand(peak[0]/2.))
    1103             W.append(G/tand(peak[0]/2.))
    1104         ax.plot(X,Y,'+',color='r',label='G peak')
    1105         ax.plot(X,Z,'+',color='g',label='L peak')
    1106         ax.plot(X,W,'+',color='b',label='G+L peak')
    1107         ax.legend(loc='best')
    1108         self.NewPlot = True
    1109            
    1110         if newPlot:
    1111             pylab.show()
    1112         else:                       #1st plot
    1113             pylab.draw()
    1114            
    1115     def PlotImage(self):
    1116         from matplotlib.patches import Ellipse
    1117 
    1118         def OnImMotion(event):
    1119             self.pdplot.canvas.SetToolTipString('')
    1120             size = len(self.ImageZ)
    1121             if (xlim[0] < event.xdata < xlim[1]) & (ylim[0] > event.ydata > ylim[1]):
    1122                 item = self.itemPicked
    1123                 if item and self.PatternTree.GetItemText(self.PickId) == 'Image Controls':
    1124                     if 'Text' in str(item):
    1125                         self.pdplot.canvas.SetToolTipString('%8.3f %8.3fmm'%(event.xdata,event.ydata))
    1126                     else:
    1127                         xcent,ycent = Data['center']
    1128                         xpos = event.xdata-xcent
    1129                         ypos = event.ydata-ycent
    1130                         if 'line2' in  str(item) or 'line3' in str(item) and not Data['fullIntegrate']:
    1131                             ang = int(atan2d(-ypos,xpos))
    1132                             self.pdplot.canvas.SetToolTipString('%6d deg'%(ang))
    1133                         elif 'line0' in  str(item) or 'line1' in str(item):
    1134                             radius = math.sqrt(xpos**2+ypos**2)
    1135                             self.pdplot.canvas.SetToolTipString('%8.3fmm'%(radius))                           
    1136                 else:
    1137                     xpix = event.xdata*scalex
    1138                     ypix = event.ydata*scaley
    1139                     if (0 <= xpix <= size) and (0 <= ypix <= size):
    1140                         self.pdplot.canvas.SetToolTipString('%6d'%(self.ImageZ[ypix][xpix]))
    1141 
    1142         def OnImPlotKeyPress(event):
    1143             if self.PatternTree.GetItemText(self.PickId) == 'Image Controls':
    1144                 Data = self.PatternTree.GetItemPyData(self.PickId)
    1145                 pixelSize = Data['pixelSize']
    1146                 size = len(self.ImageZ)
    1147                 Xpos = event.xdata
    1148                 if not Xpos:            #got point out of frame
    1149                     return
    1150                 Ypos = event.ydata
    1151                 if event.key == 'm':
    1152                     print 'mask = ',Xpos,Ypos
    1153                 self.PlotImage()
    11541002               
    1155         def OnImPick(event):
    1156             if self.PatternTree.GetItemText(self.PickId) != 'Image Controls':
    1157                 return
    1158             if self.itemPicked is not None: return
    1159             pick = event.artist
    1160             self.itemPicked = pick
    1161            
    1162         def OnImRelease(event):
    1163             if self.PatternTree.GetItemText(self.PickId) != 'Image Controls':
    1164                 return
    1165             Data = self.PatternTree.GetItemPyData(self.PickId)
    1166             pixelSize = Data['pixelSize']
    1167             scalex = 1000./pixelSize[0]
    1168             scaley = 1000./pixelSize[1]
    1169             if self.itemPicked is None:
    1170                 size = len(self.ImageZ)
    1171                 Xpos = event.xdata
    1172                 if not (Xpos and self.ifGetRing):                   #got point out of frame
    1173                     return
    1174                 Ypos = event.ydata
    1175                 if Ypos and not self.pdplot.canvas.toolbar._active:         #make sure zoom/pan not selected
    1176                     if event.button == 1:
    1177                         Xpix = Xpos*scalex
    1178                         Ypix = Ypos*scaley
    1179                         xpos,ypos,I,J = G2cmp.ImageLocalMax(self.ImageZ,20,Xpix,Ypix)
    1180                         if I and J:
    1181                             xpos /= scalex
    1182                             ypos /= scaley
    1183                             Data['ring'].append([xpos,ypos])
    1184                     self.PlotImage()
    1185                 return
    1186             else:
    1187                 xpos = event.xdata
    1188                 if xpos:                                        #avoid out of frame mouse position
    1189                     ypos = event.ydata
    1190                     if self.ifGetRing:
    1191                         xypos = [xpos,ypos]
    1192                         rings = Data['ring']
    1193                         for ring in rings:
    1194                             if np.allclose(ring,xypos,.01,0):
    1195                                 rings.remove(ring)                                                                       
    1196                     else:
    1197                         xcent,ycent = Data['center']
    1198                         xpos -= xcent
    1199                         ypos -= ycent
    1200                         radius = math.sqrt(xpos**2+ypos**2)
    1201                         xpos /= radius
    1202                         ypos /= radius
    1203                         ang = int(atan2d(-ypos,xpos))
    1204                         if 'Line2D' in str(self.itemPicked):
    1205                             if 'line2' in str(self.itemPicked) and not Data['fullIntegrate']:
    1206                                 Data['LRazimuth'][0] = ang
    1207                             elif 'line3' in str(self.itemPicked) and not Data['fullIntegrate']:
    1208                                 Data['LRazimuth'][1] = ang
    1209                             elif 'line0' in str(self.itemPicked):
    1210                                 Data['IOradii'][0] = radius
    1211                             elif 'line1' in str(self.itemPicked):
    1212                                 Data['IOradii'][1] = radius
    1213                             if Data['LRazimuth'][1] < Data['LRazimuth'][0]:
    1214                                 Data['LRazimuth'][1] += 360
    1215                             if  Data['IOradii'][0] > Data['IOradii'][1]:
    1216                                 Data['IOradii'] = G2cmp.SwapXY(Data['IOradii'][0],Data['IOradii'][1])
    1217                             self.IOradText.SetValue("%8.3f,%8.3f" % (Data['IOradii'][0],Data['IOradii'][1]))
    1218                             self.LRazim.SetValue("%6d,%6d" % (Data['LRazimuth'][0],Data['LRazimuth'][1]))
    1219                         else:
    1220                             print event.xdata,event.ydata,event.button
    1221                     self.PlotImage()
    1222                 self.itemPicked = None
    1223            
    1224         newPlot = False
    1225         self.NewPlot = True
    1226         self.itemPicked = None
    1227         try:
    1228             self.pdplot.clear()
    1229             self.pdplot.canvas.toolbar.set_history_buttons()
    1230             self.pdplot.canvas.set_window_title('2D Powder Image')
    1231             self.PDevent = self.ClearEventList(self.PDevent)
    1232             self.SCevent = self.ClearEventList(self.SCevent)
    1233         except:
    1234             self.pdplot = pylab.figure(facecolor='white')
    1235             self.pdplot.clear()
    1236             self.pdplot.canvas.set_window_title('2D Powder Image')
    1237             self.NewPlot = True                     #to make sure subsequent 1-D plot will be OK
    1238             newPlot = True
    1239         if not self.IMevent:
    1240             self.IMevent.append(self.pdplot.canvas.mpl_connect('key_press_event', OnImPlotKeyPress))
    1241             self.IMevent.append(self.pdplot.canvas.mpl_connect('motion_notify_event', OnImMotion))
    1242             self.IMevent.append(self.pdplot.canvas.mpl_connect('pick_event', OnImPick))
    1243             self.IMevent.append(self.pdplot.canvas.mpl_connect('button_release_event', OnImRelease))           
    1244         PickId = self.PickId
    1245         ax = self.pdplot.add_subplot(111)
    1246         self.PlotAX = ax
    1247         ax.set_title(self.PatternTree.GetItemText(self.Image)[4:])
    1248         size,self.ImageZ = self.PatternTree.GetItemPyData(self.Image)
    1249         Data = self.PatternTree.GetItemPyData( \
    1250             G2gd.GetPatternTreeItemId(self,self.Image, 'Image Controls'))
    1251         imScale = 1
    1252         if len(self.ImageZ) > 1024:
    1253             imScale = len(self.ImageZ)/1024
    1254         pixelSize = Data['pixelSize']
    1255         scalex = 1000./pixelSize[0]
    1256         scaley = 1000./pixelSize[1]
    1257         xmax = len(self.ImageZ)
    1258         Xmax = len(self.ImageZ)*pixelSize[0]/1000.
    1259         xlim = (-0.5,Xmax-.5)
    1260         ylim = (Xmax-.5,-0.5,)
    1261         if self.Img:
    1262             xlim = self.Img.axes.get_xlim()
    1263             ylim = self.Img.axes.get_ylim()
    1264         Imin,Imax = Data['range'][1]
    1265         acolor = mpl.cm.get_cmap(Data['color'])
    1266         xcent,ycent = Data['center']
    1267         ax.set_xlabel('Image x-axis, mm',fontsize=12)
    1268         ax.set_ylabel('Image y-axis, mm',fontsize=12)
    1269         A = G2cmp.ImageCompress(self.ImageZ,imScale)
    1270         self.Img = ax.imshow(self.ImageZ[::imScale,::imScale], \
    1271             aspect='equal',cmap=acolor, \
    1272             interpolation='nearest',vmin=Imin,vmax=Imax, \
    1273             extent=[0,Xmax,Xmax,0])
    1274         ax.text(xcent,ycent,'+',ha='center',va='center',picker=3)
    1275         if Data['showLines']:
    1276             LRAzim = Data['LRazimuth']
    1277             IOradii = Data['IOradii']
    1278             arcxI = arcyI = np.array(range(LRAzim[0],LRAzim[1]+1))
    1279             arcxI = np.sin(arcxI*math.pi/180.)*Data['IOradii'][0]+xcent
    1280             arcyI = -np.cos(arcyI*math.pi/180.)*Data['IOradii'][0]+ycent
    1281             ax.plot(arcxI,arcyI,picker=3)
    1282             arcxO = arcyO = np.array(range(LRAzim[0],LRAzim[1]+1))
    1283             arcxO = np.sin(arcxO*math.pi/180.)*Data['IOradii'][1]+xcent
    1284             arcyO = -np.cos(arcyO*math.pi/180.)*Data['IOradii'][1]+ycent
    1285             ax.plot(arcxO,arcyO,picker=3)
    1286             if not Data['fullIntegrate']:
    1287                 xbeg = arcxI[0]
    1288                 ybeg = arcyI[0]
    1289                 ax.plot([xbeg,sind(LRAzim[0])*IOradii[1]+xcent],
    1290                     [ybeg,-cosd(LRAzim[0])*IOradii[1]+ycent],picker=3)
    1291                 xbeg = arcxI[-1]
    1292                 ybeg = arcyI[-1]
    1293                 ax.plot([xbeg,sind(LRAzim[1])*IOradii[1]+xcent],
    1294                     [ybeg,-cosd(LRAzim[1])*IOradii[1]+ycent],picker=3)
    1295         for xring,yring in Data['ring']:
    1296             ax.text(xring,yring,'+',color='b',ha='center',va='center',picker=3)
    1297         if Data['setRings']:
    1298             for ring in Data['rings']:
    1299                 for xring,yring in ring:
    1300                     ax.text(xring,yring,'+',ha='center',va='center')           
    1301         for ellipse in Data['ellipses']:
    1302             cent,phi,[width,height] = ellipse
    1303             ax.add_artist(Ellipse([cent[0],cent[1]],2*width,2*height,phi,ec='r',fc='none'))
    1304             ax.text(cent[0],cent[1],'+',color='b',ha='center',va='center')
    1305         self.Img.axes.set_xlim(xlim)
    1306         self.Img.axes.set_ylim(ylim)
    1307         self.pdplot.colorbar(self.Img)
    1308         if newPlot:
    1309             pylab.show()
    1310         else:                       #1st plot
    1311             pylab.draw()       
    1312                
    1313     def PlotPatterns(self):
    1314        
    1315         def OnPick(event):
    1316             if self.itemPicked is not None: return
    1317             PatternId = self.PatternId
    1318             PickId = self.PickId
    1319             pick = event.artist
    1320             mouse = event.mouseevent
    1321             xpos = pick.get_xdata()
    1322             ypos = pick.get_ydata()
    1323             ind = event.ind
    1324             xy = zip(xpos[ind],ypos[ind])
    1325             if self.PatternTree.GetItemText(PickId) == 'Peak List':
    1326                 if ind.all() != [0]:                                    #picked a data point
    1327                     inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))
    1328                     if len(inst[1]) == 10:
    1329                         ins = inst[1][4:10]
    1330                     else:
    1331                         ins = inst[1][6:12]   
    1332                     sig = ins[0]*tand(xy[0][0]/2.0)**2+ins[1]*tand(xy[0][0]/2.0)+ins[2]
    1333                     gam = ins[3]/cosd(xy[0][0]/2.0)+ins[4]*tand(xy[0][0]/2.0)           
    1334                     data = self.PatternTree.GetItemPyData(self.PickId)
    1335                     XY = [xy[0][0],0, xy[0][1],1, sig,0, gam,0, ins[5],0]       #default refine intensity 1st   
    1336                     data.append(XY)
    1337                     G2gd.UpdatePeakGrid(self,data)
    1338                 else:                                                   #picked a peak list line
    1339                     self.itemPicked = pick
    1340             elif self.PatternTree.GetItemText(PickId) == 'Limits':
    1341                 if ind.all() != [0]:                                    #picked a data point
    1342                     LimitId = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
    1343                     data = self.PatternTree.GetItemPyData(LimitId)
    1344                     if mouse.button==1:
    1345                         data[1][0] = min(xy[0][0],data[1][1])
    1346                     if mouse.button==3:
    1347                         data[1][1] = max(xy[0][0],data[1][0])
    1348                     self.PatternTree.SetItemPyData(LimitId,data)
    1349                     G2gd.UpdateLimitsGrid(self,data)
    1350                 else:                                                   #picked a limit line
    1351                     self.itemPicked = pick               
    1352             self.PlotPatterns()
    1353            
    1354         def OnPlotKeyPress(event):
    1355             if event.key == 'w':
    1356                 if self.Weight:
    1357                     self.Weight = False
    1358                 else:
    1359                     self.Weight = True
    1360                 self.PlotPatterns()
    1361                 print 'plot weighting:',self.Weight
    1362             if self.PatternTree.GetChildrenCount(self.root,False) > 1:
    1363                 if event.key == 'u' and self.Offset < 100.:
    1364                     self.Offset += 1.
    1365                     self.PlotPatterns()
    1366                 elif event.key == 'd' and self.Offset > 0.:
    1367                     self.Offset -= 1.
    1368                     self.PlotPatterns()
    1369                 elif event.key == 'c':
    1370                     print 'contouring'
    1371                     if self.Contour:
    1372                         self.Contour = False
    1373                     else:
    1374                         self.Contour = True
    1375                     self.PlotPatterns()
    1376     #            elif self.Contour and event.key == 'l':
    1377     #                event.StopPropagation()
    1378             else:
    1379                 event.Skip()
    1380                            
    1381         def OnMotion(event):
    1382             if self.itemPicked:
    1383                 xpos = event.xdata
    1384                 if xpos:                                        #avoid out of frame mouse position
    1385                     self.pdplot.canvas.SetToolTipString('%9.3f'%(xpos))
    1386                        
    1387         def OnRelease(event):
    1388             if self.itemPicked is None: return
    1389             xpos = event.xdata
    1390             if xpos:                                        #avoid out of frame mouse position
    1391                 lines = []
    1392                 for line in self.Lines: lines.append(line.get_xdata()[0])
    1393                 lineNo = lines.index(self.itemPicked.get_xdata()[0])
    1394                 if  lineNo in [0,1]:
    1395                     LimitId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Limits')
    1396                     data = self.PatternTree.GetItemPyData(LimitId)
    1397                     data[1][lineNo] = xpos
    1398                     self.PatternTree.SetItemPyData(LimitId,data)
    1399                     if self.PatternTree.GetItemText(self.PickId) == 'Limits':
    1400                         G2gd.UpdateLimitsGrid(self,data)
    1401                 else:
    1402                     PeakId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Peak List')
    1403                     data = self.PatternTree.GetItemPyData(PeakId)
    1404                     data[lineNo-2][0] = xpos
    1405                     self.PatternTree.SetItemPyData(PeakId,data)
    1406                     G2gd.UpdatePeakGrid(self,data)
    1407             self.PlotPatterns()
    1408             self.itemPicked = None   
    1409            
    1410         try:
    1411             if self.NewPlot:
    1412                 self.pdplot.clear()
    1413             self.pdplot.canvas.toolbar.set_history_buttons()
    1414             self.pdplot.canvas.set_window_title('Powder Patterns')
    1415             self.IMevent = self.ClearEventList(self.IMevent)
    1416             self.SCevent = self.ClearEventList(self.SCevent)
    1417         except:
    1418             self.pdplot = pylab.figure(facecolor='white')
    1419             self.pdplot.clear()
    1420             self.pdplot.canvas.set_window_title('Powder Patterns')
    1421             self.NewPlot = True
    1422         if not self.PDevent:
    1423             self.PDevent.append(self.pdplot.canvas.mpl_connect('key_press_event', OnPlotKeyPress))
    1424             self.PDevent.append(self.pdplot.canvas.mpl_connect('pick_event', OnPick))
    1425             self.PDevent.append(self.pdplot.canvas.mpl_connect('button_release_event', OnRelease))
    1426             self.PDevent.append(self.pdplot.canvas.mpl_connect('motion_notify_event', OnMotion))
    1427         PickId = self.PickId
    1428         PatternId = self.PatternId
    1429         colors=['b','g','r','c','m','k']
    1430         Ymax = 1.0
    1431         PlotList = []
    1432         Lines = []
    1433         item, cookie = self.PatternTree.GetFirstChild(self.root)
    1434         while item:
    1435             if 'PWDR' in self.PatternTree.GetItemText(item):
    1436                 Pattern = self.PatternTree.GetItemPyData(item)
    1437                 Pattern.append(self.PatternTree.GetItemText(item))
    1438                 PlotList.append(Pattern)
    1439             item, cookie = self.PatternTree.GetNextChild(self.root, cookie)               
    1440         for Pattern in PlotList:
    1441             xye = Pattern[1]
    1442             Ymax = max(Ymax,max(xye[1]))
    1443         offset = self.Offset*Ymax/100.0
    1444         ax = self.pdplot.add_subplot(111)
    1445         ax.cla()
    1446         if not self.NewPlot:
    1447             xlim = ax.get_xlim()
    1448             ylim = ax.get_ylim()
    1449         ax.clear()
    1450         ax.set_title('Powder Patterns')
    1451         ax.set_xlabel(r'$\mathsf{2\theta}$',fontsize=14)
    1452         ax.set_ylabel('Intensity',fontsize=12)
    1453         if self.Contour:
    1454             ContourZ = []
    1455             ContourY = []
    1456             Nseq = 0
    1457         for Pattern in PlotList:
    1458             ifpicked = False
    1459             LimitId = 0
    1460             if PickId:
    1461                 ifpicked = Pattern[2] == self.PatternTree.GetItemText(PatternId)
    1462                 LimitId = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
    1463             xye = Pattern[1]
    1464             N = PlotList.index(Pattern)
    1465             X = np.array(xye[0])
    1466             Y = np.array(xye[1])
    1467             Y += offset*N
    1468             if LimitId:
    1469                 limits = self.PatternTree.GetItemPyData(LimitId)
    1470                 Lines.append(ax.axvline(limits[1][0],color='g',dashes=(5,5),picker=3))   
    1471                 Lines.append(ax.axvline(limits[1][1],color='r',dashes=(5,5),picker=3))                   
    1472             if self.Contour:
    1473                 ContourY.append(N)
    1474                 ContourZ.append(Y)
    1475                 ContourX = X
    1476                 Nseq += 1
    1477                 ax.set_ylabel('Data sequence',fontsize=12)
    1478             else:
    1479                 if ifpicked:
    1480                     Z = np.array(xye[3])+offset*N
    1481                     W = np.array(xye[4])+offset*N
    1482                     D = np.array(xye[5])+offset*N
    1483                     if self.Weight:
    1484                         W2 = np.sqrt(np.array(xye[2]))
    1485                         D *= W2
    1486                     ax.plot(X,Y,colors[N%6]+'+',picker=3)
    1487                     ax.plot(X,Z,colors[(N+1)%6],picker=False)
    1488                     ax.plot(X,W,colors[(N+2)%6],picker=False)
    1489                     ax.plot(X,D,colors[(N+3)%6],picker=False)
    1490                     ax.axhline(0.,color=wx.BLACK)
    1491                     self.pdplot.canvas.SetToolTipString('')
    1492                     if self.PatternTree.GetItemText(PickId) == 'Peak List':
    1493                         tip = 'On data point: Pick peak - L or R MB.On line: MB down to move'
    1494                         self.pdplot.canvas.SetToolTipString(tip)
    1495                         data = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List'))
    1496                         for item in data:
    1497                             Lines.append(ax.axvline(item[0],color=colors[N%6],picker=2))
    1498                     if self.PatternTree.GetItemText(PickId) == 'Limits':
    1499                         tip = 'On data point: Lower limit - L MB; Upper limit - R MB. On limit: MB down to move'
    1500                         self.pdplot.canvas.SetToolTipString(tip)
    1501                         data = self.LimitsTable.GetData()
    1502                 else:
    1503                     ax.plot(xye[0],Y,colors[N%6],picker=False)
    1504         if PickId and self.PatternTree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
    1505             peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Index Peak List'))
    1506             for peak in peaks:
    1507                 ax.axvline(peak[0],color='b')
    1508             for hkl in self.HKL:
    1509                 ax.axvline(hkl[5],color='r',dashes=(5,5))
    1510             if self.NewPlot and peaks:
    1511                 xmin = peaks[0][0]
    1512                 xmax = peaks[-1][0]
    1513                 delt = xmax-xmin
    1514                 xlim = [max(0,xmin-delt/20.),min(180.,xmax+delt/20.)]
    1515                 ax.set_xlim(xlim)               
    1516         if self.Contour:
    1517             ax.contourf(ContourX,ContourY,ContourZ)
    1518         self.Lines = Lines
    1519         if self.NewPlot:
    1520             if self.plotView:
    1521                 ax.set_xlim(self.plotView[0])
    1522                 ax.set_ylim(self.plotView[1])
    1523         else:
    1524             ax.set_xlim(xlim)
    1525             ax.set_ylim(ylim)
    1526             if self.Contour:
    1527                 ax.set_ylim(0,Nseq-1)
    1528         if self.NewPlot:
    1529             pylab.show()
    1530             self.NewPlot = False
    1531         else:                       #1st plot
    1532             pylab.draw()
    1533        
    1534     def PlotSngl(self):
    1535         from matplotlib.patches import Circle
    1536 
    1537         def OnSCMotion(event):
    1538             xpos = event.xdata
    1539             if xpos:
    1540                 xpos = round(xpos)                                        #avoid out of frame mouse position
    1541                 ypos = round(event.ydata)
    1542                 zpos = Data['Layer']
    1543                 if '100' in Data['Zone']:
    1544                     self.pdplot.canvas.SetToolTipString('(%3d,%3d,%3d)'%(zpos,xpos,ypos))
    1545                 elif '010' in Data['Zone']:
    1546                     self.pdplot.canvas.SetToolTipString('(%3d,%3d,%3d)'%(xpos,zpos,ypos))
    1547                 elif '001' in Data['Zone']:
    1548                     self.pdplot.canvas.SetToolTipString('(%3d,%3d,%3d)'%(xpos,ypos,zpos))
    1549                    
    1550         def OnSCPick(event):
    1551             zpos = Data['Layer']
    1552             pos = event.artist.center
    1553             if '100' in Data['Zone']:
    1554                 self.pdplot.canvas.SetToolTipString('(picked:(%3d,%3d,%3d))'%(zpos,pos[0],pos[1]))
    1555             elif '010' in Data['Zone']:
    1556                 self.pdplot.canvas.SetToolTipString('(picked:(%3d,%3d,%3d))'%(pos[0],zpos,pos[1]))
    1557             elif '001' in Data['Zone']:
    1558                 self.pdplot.canvas.SetToolTipString('(picked:(%3d,%3d,%3d))'%(pos[0],pos[1],zpos))                 
    1559            
    1560         def OnSCKeyPress(event):
    1561             print event.key
    1562                    
    1563         try:
    1564             if self.NewPlot:
    1565                 self.pdplot.clear()
    1566             self.pdplot.canvas.toolbar.set_history_buttons()
    1567             self.pdplot.canvas.set_window_title('Structure Factors')
    1568             self.IMevent = self.ClearEventList(self.IMevent)
    1569             self.PDevent = self.ClearEventList(self.PDevent)
    1570         except:
    1571             self.pdplot = pylab.figure(facecolor='white')
    1572             self.pdplot.clear()
    1573             self.pdplot.canvas.set_window_title('Structure Factors')
    1574             self.NewPlot = True
    1575         if not self.SCevent:
    1576             self.SCevent.append(self.pdplot.canvas.mpl_connect('key_press_event', OnSCKeyPress))
    1577             self.SCevent.append(self.pdplot.canvas.mpl_connect('pick_event', OnSCPick))
    1578             self.SCevent.append(self.pdplot.canvas.mpl_connect('motion_notify_event', OnSCMotion))
    1579         PickId = self.PickId
    1580         ax = self.pdplot.add_subplot(111)
    1581         ax.set_aspect(aspect='equal')
    1582         HKLref = self.PatternTree.GetItemPyData(self.Sngl)
    1583         Data = self.PatternTree.GetItemPyData( \
    1584             G2gd.GetPatternTreeItemId(self,self.Sngl, 'HKL Plot Controls'))
    1585 
    1586         Type = Data['Type']           
    1587         scale = Data['Scale']
    1588         HKLmax = Data['HKLmax']
    1589         HKLmin = Data['HKLmin']
    1590         FosqMax = Data['FoMax']
    1591         FoMax = math.sqrt(FosqMax)
    1592         ifFc = Data['ifFc']
    1593         xlabel = ['k, h=','h, k=','h, l=']
    1594         ylabel = ['l','l','k']
    1595         zones = ['100','010','001']
    1596         pzone = [[1,2],[0,2],[0,1]]
    1597         izone = zones.index(Data['Zone'])
    1598         ax.set_title(self.PatternTree.GetItemText(self.Sngl)[5:])
    1599         for h,k,l,Fosq,sig,Fcsq,x,x,x in HKLref:
    1600             H = [h,k,l]
    1601             if H[izone] == Data['Layer']:
    1602                 B = 0
    1603                 if Type == 'Fosq':
    1604                     A = scale*Fosq/FosqMax
    1605                     B = scale*Fcsq/FosqMax
    1606                     C = abs(A-B)
    1607                 elif Type == 'Fo':
    1608                     A = scale*math.sqrt(max(0,Fosq))/FoMax
    1609                     B = scale*math.sqrt(max(0,Fcsq))/FoMax
    1610                     C = abs(A-B)
    1611                 elif Type == '|DFsq|/sig':
    1612                     A = abs(Fosq-Fcsq)/(scale*sig)
    1613                 elif Type == '|DFsq|>sig':
    1614                     A = abs(Fosq-Fcsq)/(scale*sig)
    1615                     if A < 1.0: A = 0                   
    1616                 elif Type == '|DFsq|>3sig':
    1617                     A = abs(Fosq-Fcsq)/(scale*sig)
    1618                     if A < 3.0: A = 0                   
    1619                 xy = (H[pzone[izone][0]],H[pzone[izone][1]])
    1620                 if A > 0.0:
    1621                     ax.add_artist(Circle(xy,radius=A,ec='g',fc='w',picker=3))
    1622                 if B:
    1623                     ax.add_artist(Circle(xy,radius=B,ec='b',fc='w'))
    1624                     radius = C
    1625                     if radius > 0:
    1626                         if A > B:
    1627                             ax.add_artist(Circle(xy,radius=radius,ec='r',fc='r'))
    1628                         else:                   
    1629                             ax.add_artist(Circle(xy,radius=radius,ec='g',fc='g'))
    1630                    
    1631         ax.set_xlabel(xlabel[izone]+str(Data['Layer']),fontsize=12)
    1632         ax.set_ylabel(ylabel[izone],fontsize=12)
    1633         ax.set_xlim((HKLmin[pzone[izone][0]],HKLmax[pzone[izone][0]]))
    1634         ax.set_ylim((HKLmin[pzone[izone][1]],HKLmax[pzone[izone][1]]))
    1635 
    1636         if self.NewPlot:
    1637             pylab.show()
    1638             self.NewPlot = False
    1639         else:                       #1st plot
    1640             pylab.draw()
    1641        
    16421003    def ErrorDialog(self,title,message):
    16431004        dlg = wx.MessageDialog(self, message, title,  wx.OK)
Note: See TracChangeset for help on using the changeset viewer.