From 32464a63133a34fa46d38e876c1b2414f4b77198 Mon Sep 17 00:00:00 2001 From: Anthony Walker Date: Mon, 4 May 2020 14:41:48 -0700 Subject: [PATCH] Added illustration plot script and updated symbols which breaks the multi node function but this can be easily fixed by extending fsyms list at the start --- results/Revision/methodIllustration.py | 266 +++++++++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100644 results/Revision/methodIllustration.py diff --git a/results/Revision/methodIllustration.py b/results/Revision/methodIllustration.py new file mode 100644 index 0000000..f68e70c --- /dev/null +++ b/results/Revision/methodIllustration.py @@ -0,0 +1,266 @@ +# @Author: Anthony Walker +# @Date: 2020-02-21T11:28:13-08:00 +# @Email: dev.sokato@gmail.com +# @Last modified by: walkanth +# @Last modified time: 2020-03-06T15:19:40-08:00 + + + +#Programmer: Anthony Walker +#Use this file to generate figures for the 2D swept paper +import sys, os +import matplotlib as mpl +mpl.use("tkAgg") +import matplotlib.pyplot as plt +import matplotlib.gridspec as gsc +from matplotlib import cm +# from collections.abc import Iterable +# import matplotlib.animation as animation +# from mpl_toolkits import mplot3d +# from matplotlib.patches import FancyArrowPatch +import numpy as np +from matplotlib import transforms +from itertools import cycle +dir = os.path.join(os.path.dirname(__file__),'figs') +transparency = 0.25 +fsyms = ['o','s','p'] +def generateSets(*args): + """Use this function to generate sets based on block size.""" + colors,symbols,blocksize,boundaryPoints,numberOfBlocks = args + totalPoints = blocksize+2*boundaryPoints + nsteps = int(blocksize/(2*boundaryPoints)) + halfBlockSize = int(blocksize/2) + domMax = blocksize*numberOfBlocks-1 + #Upsets + upsets = list() + for j in range(0,nsteps): + upsets.append([(i,j) for i in range(j*boundaryPoints,blocksize-j*boundaryPoints)]) + + upsetsBlocks = (upsets,) + for k in range(1,numberOfBlocks,1): + tlist = list() + for uset in upsets: + tlist.append([(i+int(k*blocksize),j) for i, j in uset]) + upsetsBlocks += tlist, + #Diamond Sets + diamondsets = list() + for i in range(1,nsteps): + diamondsets.append([(j+halfBlockSize,i) for j in range(halfBlockSize-(i)*boundaryPoints,halfBlockSize+(i)*boundaryPoints,1)]) + for set in upsets[1:]: + diamondsets.append([(dx+halfBlockSize,dy+nsteps-1) for dx,dy in set]) + diamondBlocks = (diamondsets,) + for k in range(1,numberOfBlocks,1): + tlist = list() + for diaset in diamondsets: + tlist.append([(i+int(k*blocksize),j) if i+int(k*blocksize)<=domMax else (i-blocksize,j) for i, j in diaset]) + diamondBlocks += tlist, + #Downsets + downsets = list() + for i in range(nsteps,2*nsteps-1): + downsets.append([(j,i) for j in range(halfBlockSize-(i-nsteps+1)*boundaryPoints,halfBlockSize+(i-nsteps+1)*boundaryPoints,1)]) + downsetsBlocks = (downsets,) + for k in range(1,numberOfBlocks,1): + tlist = list() + for dset in downsets: + tlist.append([(i+int(k*blocksize),j) if i+int(k*blocksize)<=domMax else (i-blocksize,j) for i, j in dset]) + downsetsBlocks += tlist, + return upsetsBlocks,diamondBlocks,downsetsBlocks + +def getEdgeBlocks(blocks,boundaryPoints,blocksize): + """Use this function to highlight edge points.""" + edgeBlocks = tuple() + for block in blocks: + edgeSet = list() + for set in block: + edgeSet.append(set[:boundaryPoints*2]+set[-2*boundaryPoints:]) + edgeBlocks += edgeSet, + return edgeBlocks + +def consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps,offset=False): + """Use this function for consistency amongst axes.""" + #Setting axes + yax = -0.4 + xax = -1.5 + axisColor = "black" + axisWidth = 2 + xlabCoords = (0.4,0.1) + ylabCoords = (-0.02,0.4) + ax.text(xlabCoords[0],xlabCoords[1],"Spatial Points",transform=ax.transAxes) + ax.text(ylabCoords[0],ylabCoords[1],"Timestep",rotation=90,transform=ax.transAxes) + ax.plot((xax,blocksize*numberOfBlocks),(yax,yax),color=axisColor,linewidth=axisWidth) + ax.plot((xax,xax),(yax,4*nsteps),color=axisColor,linewidth=axisWidth) + ax.set_ylabel("Time Step") + ax.get_xaxis().set_ticks([]) + ax.get_yaxis().set_ticks([]) + ax.set_xlim(-2,numberOfBlocks*blocksize+2) + ax.set_ylim(-2,2*nsteps) + #Setting node barriers + axCoords = (0.25,0.9) + base = blocksize/2-0.5 if offset else blocksize-0.5 + # for i in range(0,numberOfBlocks): + # ax.plot((base+i*blocksize,base+i*blocksize),(yax,4*nsteps),linestyle="--",linewidth=axisWidth,color=axisColor) + +def UpTriangle(*args): + """Call this function to generate the first step of the process.""" + points,edges,colors,blocksize,numberOfBlocks,nsteps = args + fig = plt.figure() + ax = fig.add_subplot(1,1,1) + consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps) + ax.set_title("Up Triangle") + ax.axis('off') + #Setting points + lines = [] + for i,block in enumerate(points): + for set in block: + X,Y = zip(*(set)) + currLine = ax.scatter(X,Y,marker=fsyms[i],edgecolor="black",color=colors[i]) + lines.append(currLine) + nstrs = ["Node "+str(i) for i in range(len(points))] + ax.legend(lines,nstrs,loc="upper center",ncol=numberOfBlocks) + plt.savefig(os.path.join(dir,"a_UpTriangle.pdf")) + +def Comm1(*args): + """Call this function to represent the communcation steps.""" + points,edges,colors,blocksize,numberOfBlocks,nsteps = args + fig = plt.figure() + ax = fig.add_subplot(1,1,1) + consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps) + ax.set_title("Communication 1") + ax.axis('off') + #Setting points + for i,block in enumerate(points): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color='k',zorder=1,alpha=transparency) + lines = [] + for i,block in enumerate(edges): + for set in block: + X,Y = zip(*(set)) + currLine = ax.scatter(X,Y,marker=fsyms[i],edgecolor="black",facecolor=colors[i],zorder=2) + lines.append(currLine) + nstrs = ["Node "+str(i) for i in range(len(points))] + ax.legend(lines,nstrs,loc="upper center",ncol=numberOfBlocks) + plt.savefig(os.path.join(dir,"b_Comm1.pdf")) + + +def Diamond(*args): + """Call this function to generate the intermediate steps of the process.""" + points,uppoints,edges,colors,blocksize,numberOfBlocks,nsteps = args + fig = plt.figure() + ax = fig.add_subplot(1,1,1) + consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps,offset=True) + ax.set_title("Diamond") + ax.axis('off') + for i,block in enumerate(uppoints): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color="k",zorder=0,alpha=transparency) + #Setting points + lines = [] + for i,block in enumerate(points): + for set in block: + X,Y = zip(*(set)) + currLine = ax.scatter(X,Y,marker=fsyms[i],edgecolor="black",facecolor=colors[i],zorder=2) + lines.append(currLine) + nstrs = ["Node "+str(i) for i in range(len(points))] + ax.legend(lines,nstrs,loc="upper center",ncol=numberOfBlocks) + + plt.savefig(os.path.join(dir,"c_Diamond.pdf")) + +def Comm2(*args): + """Call this function to represent the communcation steps.""" + points,uppoints,edges,colors,blocksize,numberOfBlocks,nsteps = args + fig = plt.figure() + ax = fig.add_subplot(1,1,1) + consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps,offset=True) + ax.set_title("Communication 2") + ax.axis('off') + #Setting points + for i,block in enumerate(uppoints): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color='k',zorder=0,alpha=transparency) + #Setting points + for i,block in enumerate(points): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color='k',zorder=1,alpha=transparency) + lines = [] + for i,block in enumerate(edges): + for set in block: + X,Y = zip(*(set)) + currLine = ax.scatter(X,Y,marker=fsyms[i],edgecolor="black",facecolor=colors[i],zorder=2) + lines.append(currLine) + nstrs = ["Node "+str(i) for i in range(len(points))] + ax.legend(lines,nstrs,loc="upper center",ncol=numberOfBlocks) + plt.savefig(os.path.join(dir,"d_Comm2.pdf")) + + +def DownTriangle(*args): + """Call this function to generate the last step of the process.""" + points,uppoints,diapoints,edges,colors,blocksize,numberOfBlocks,nsteps = args + fig = plt.figure() + ax = fig.add_subplot(1,1,1) + consistentAxesOne(ax,blocksize,numberOfBlocks,nsteps,offset=False) + ax.set_title("Down Triangle") + ax.axis('off') + #Setting points + for i,block in enumerate(uppoints): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color='k',zorder=0,alpha=transparency) + + for i,block in enumerate(diapoints): + for set in block: + X,Y = zip(*(set)) + ax.plot(X,Y,linestyle=" ",marker=fsyms[i],color='k',zorder=1,alpha=transparency) + lines = [] + for i,block in enumerate(points): + for set in block: + X,Y = zip(*(set)) + currLine = ax.scatter(X,Y,marker=fsyms[i],edgecolor="black",facecolor=colors[i],zorder=2) + lines.append(currLine) + nstrs = ["Node "+str(i) for i in range(len(points))] + ax.legend(lines,nstrs,loc="upper center",ncol=numberOfBlocks) + plt.savefig(os.path.join(dir,"e_DownTriangle.pdf")) + +def sweepPlotGen(*args): + """Call this function to generate the swept process description plots.""" + #Generating points + nsteps = int(blocksize/(2*boundaryPoints)) + usb,diasb,dsb = generateSets(*args) + usbEdges = getEdgeBlocks(usb,args[3],args[2]) + dialen = int(np.shape(diasb)[1]/2-1) + tempDias = tuple() + for block in diasb: + templist = list() + for set in block[dialen:]: + templist.append(set) + tempDias += templist, + diasbEdges = getEdgeBlocks(tempDias,args[3],args[2]) + dshape = np.shape(diasbEdges) + for i in range(dshape[0]): + for j in range(1): + lth = len(diasbEdges[i][j]) + for k in range(dshape[2]): + x,y = diasbEdges[i][j][k] + if int(lth/2) > k: + diasbEdges[i][j][k] = x-boundaryPoints,y + else: + diasbEdges[i][j][k] = x+boundaryPoints,y + + dsbEdges = getEdgeBlocks(dsb,args[3],args[2]) + #Generating figures + UpTriangle(usb,usbEdges,args[0],args[2],args[4],nsteps) + Comm1(usb,usbEdges,args[0],args[2],args[4],nsteps) + Diamond(diasb,usb,usbEdges,args[0],args[2],args[4],nsteps) + Comm2(diasb,usb,diasbEdges,args[0],args[2],args[4],nsteps) + DownTriangle(dsb,usb,diasb,diasbEdges,args[0],args[2],args[4],nsteps) + +if __name__ == "__main__": + colors = ['#1b9e77','#d95f02','#7570b3','orange','dodgerblue','orange'] + symbols = cycle(['o','o','o','o']) + blocksize = 16#limit to appropriately divisible cases + boundaryPoints = 2 + numberOfBlocks = 3 + sweepPlotGen(colors,symbols,blocksize,boundaryPoints,numberOfBlocks)