def getRadialOrthoradialDict(cell,targetid, large = False):
primordiafacelist= sf.getSeparatePrimordiaBoundaryFaceList(cell, targetid, large=large)
orthoradialDict = {}
radialDict = {}
targetface = sf.getFace(cell,targetid)
targetcentroid = np.array([targetface.getXCentralised(), targetface.getYCentralised(),targetface.getZCentralised()])
############################################################
for listiter in range(len(primordiafacelist)):
facelist = primordiafacelist[listiter]
########################################################
for count in range(len(facelist)):
face = facelist[count]
#nextface = facelist[(count+1)%len(facelist)]
normal = face.getNormal()
normalvec = np.array([qd.doublearray_getitem(normal,0),
qd.doublearray_getitem(normal,1),
qd.doublearray_getitem(normal,2)])
########################################################
facecentroid = np.array([face.getXCentralised(), face.getYCentralised(),face.getZCentralised()])
#Calculating direction Vector to primordia centroid
direcvec = np.subtract(targetcentroid,facecentroid)
direcvec = direcvec/np.linalg.norm(direcvec)
#Radial Vec to on-plane unitvector
radialvec = direcvec - normalvec*(np.dot(direcvec,normalvec))
radialvec = radialvec/np.linalg.norm(radialvec)
########################################################
crossvec = np.cross(radialvec,normalvec)
crossvec = crossvec/np.linalg.norm(crossvec)
orthoradialDict[face.getID()] = crossvec
radialDict[face.getID()]= radialvec
return radialDict,orthoradialDict
def getMatrixDifferenceEllipsePoints(cell,targetface, diffmatrix,primordialfaceid = 135,zoomfactor=1.): #getting the Target Form Matrix faces = qd.CellFaceIterator(cell) face = faces.next() while True: if face.getID() == targetface: break face = faces.next() #print "Face Id : ", face.getID() targetformmatrix = diffmatrix unitx = face.getUnitx() unity = face.getUnity() unitz = face.getUnitz() unit_mat = np.matrix([[qd.doublearray_getitem(unitx,0),qd.doublearray_getitem(unitx,1),qd.doublearray_getitem(unitx,2)], [qd.doublearray_getitem(unity,0),qd.doublearray_getitem(unity,1),qd.doublearray_getitem(unity,2)], [qd.doublearray_getitem(unitz,0),qd.doublearray_getitem(unitz,1),qd.doublearray_getitem(unitz,2)]]) #transposing unitmatrix transpose_unitmat = np.matrix(np.transpose(unit_mat)) #Getting Centroid of face xcent = face.getXCentralised() ycent = face.getYCentralised() zcent = face.getZCentralised() ##### getting data from ellipse & getting transformed coordinate to 3d Cartesian data = ep.plot_ellipse(cov=targetformmatrix, data_out=True,norm = True) points = zoomfactor*np.matrix(np.vstack((data,np.zeros(len(data[0]))))) transformedpoints = transpose_unitmat*points transformedpoints[0]+= xcent transformedpoints[1]+= ycent transformedpoints[2]+= zcent return transformedpoints
def getRadialOrthoradialStress(face,
radialDict,
orthoradialDict,
vectors=False):
eigenvec1 = face.getStressEigenVector1()
eigenvec2 = face.getStressEigenVector2()
eigenvalue1 = face.getStressEigenValue1()
eigenvalue2 = face.getStressEigenValue2()
vec1 = eigenvalue1 * np.array([
qd.doublearray_getitem(eigenvec1, 0),
qd.doublearray_getitem(eigenvec1, 1),
qd.doublearray_getitem(eigenvec1, 2)
])
vec2 = eigenvalue2 * np.array([
qd.doublearray_getitem(eigenvec2, 0),
qd.doublearray_getitem(eigenvec2, 1),
qd.doublearray_getitem(eigenvec2, 2)
])
radialvec = np.copy(radialDict[face.getID()])
orthoradialvec = np.copy(orthoradialDict[face.getID()])
#print radialvec,orthoradialvec
############################################
radialComp = np.dot(radialvec, vec1) + np.dot(radialvec, vec2)
orthoradialComp = np.dot(orthoradialvec, vec1) + np.dot(
orthoradialvec, vec2)
############################################
if vectors:
radialvec = radialComp * radialvec
orthoradialvec = orthoradialComp * orthoradialvec
return radialvec, orthoradialvec
############################################
return radialComp, orthoradialComp #radialvec,orthoradialvec
def getTargetFormMatrixEllipsePoints(targetface=10):
#getting the Target Form Matrix
faces = qd.CellFaceIterator(cell)
face = faces.next()
while True:
if face.getID() == targetface:
break
face = faces.next()
#print "Face Id : ", face.getID()
targetformmatrix = np.array([[
qd.getTargetFormMatrix(face, 0, 0),
qd.getTargetFormMatrix(face, 0, 1)
], [
qd.getTargetFormMatrix(face, 1, 0),
qd.getTargetFormMatrix(face, 1, 1)
]])
unitx = face.getUnitx()
unity = face.getUnity()
unitz = face.getUnitz()
unit_mat = np.matrix([[
qd.doublearray_getitem(unitx, 0),
qd.doublearray_getitem(unitx, 1),
qd.doublearray_getitem(unitx, 2)
],
[
qd.doublearray_getitem(unity, 0),
qd.doublearray_getitem(unity, 1),
qd.doublearray_getitem(unity, 2)
],
[
qd.doublearray_getitem(unitz, 0),
qd.doublearray_getitem(unitz, 1),
qd.doublearray_getitem(unitz, 2)
]])
##### getting data from ellipse
data = plot_ellipse(cov=targetformmatrix, data_out=True)
################################
return data
def getRadialOrthoradialGrowth(face, radialDict,orthoradialDict, vectors = False):
eigenvec1 = face.getRotGrowthEigenVector1()
eigenvec2 = face.getRotGrowthEigenVector2()
eigenvalue1 = face.getRotGrowthEigenValue1()
eigenvalue2 = face.getRotGrowthEigenValue2()
vec1unit = np.array([qd.doublearray_getitem(eigenvec1,0),
qd.doublearray_getitem(eigenvec1,1),
qd.doublearray_getitem(eigenvec1,2)])
vec2unit = np.array([qd.doublearray_getitem(eigenvec2,0),
qd.doublearray_getitem(eigenvec2,1),
qd.doublearray_getitem(eigenvec2,2)])
vec1 =eigenvalue1*vec1unit
vec2 = eigenvalue2*vec2unit
#print vec1unit
radialvec = np.copy(radialDict[face.getID()])
orthoradialvec = np.copy(orthoradialDict[face.getID()])
#print radialvec,orthoradialvec
########################################################################################
# sign change if needed :
# if EigenVector and RadialVec are opposite facing
########################################################################################
#print "rad.vec1 :",np.dot(radialvec, vec1unit), 'rad.vec2',np.dot(radialvec, vec2unit), np.dot(vec1unit,vec2unit)
########################################################################################
radsign1 = (np.dot(radialvec, vec1unit)<0.)*(-1)+(np.dot(radialvec, vec1unit)>0.)*(1)
radsign2 = (np.dot(radialvec, vec2unit)<0.)*(-1)+(np.dot(radialvec, vec2unit)>0.)*(1)
orthosign1 = (np.dot(orthoradialvec, vec1unit)<0.)*(-1)+(np.dot(orthoradialvec, vec1unit)>0.)*(1)
orthosign2 = (np.dot(orthoradialvec, vec2unit)<0.)*(-1)+(np.dot(orthoradialvec, vec2unit)>0.)*(1)
#print radsign1, radsign2, orthosign1, orthosign2
########################################################################################
radialComp = np.dot(radialvec,vec1)*radsign1+np.dot(radialvec,vec2)*radsign2
orthoradialComp = np.dot(orthoradialvec,vec1)*orthosign1+np.dot(orthoradialvec,vec2)*orthosign2
############################################
if vectors:
radialvec = radialComp*radialvec
orthoradialvec = orthoradialComp*orthoradialvec
return radialvec, orthoradialvec
############################################
return radialComp, orthoradialComp#radialvec,orthoradialvec
def plotGrowthDirection(cell, diffmatrix, plotdiff,step,targetface, azim = -60, elev = 30, saveDirectory = None):
# Iterating over Face
# getting neighbourhood of fast groing cell
######### Color Map ####################################
import matplotlib.colors as colors
import matplotlib.cm as cmx
jet = cm = plt.get_cmap('viridis')
maxvalue = 1.#np.pi/2
minvalue = 0.#-1.*np.pi
cNorm = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
########################################################
faceidarray = getNeighbourFaces(cell,targetface)
primordialface = sf.getFace(cell,targetface)
px = primordialface.getXCentralised()
py = primordialface.getYCentralised()
pz = primordialface.getZCentralised()
plotdiff.scatter(px,py,pz,marker='*', c= 'm',s = 30)
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID()
if faceid in faceidarray:
c = 'g'
lw = 3
zoomfactor = 1
else:
c = 'k'
lw = 1.5
zoomfactor = 1
#######################################################
# Calculation of eigen vecs
#######################################################
facediffmatrix = diffmatrix[face.getID()]
#########################################
#Getting points to plot ellipse
ellipsepoints = getMatrixDifferenceEllipsePoints(cell,face.getID(),facediffmatrix,primordialfaceid = targetface,zoomfactor = zoomfactor)
###############################
eigvec, eigval, u = np.linalg.svd(facediffmatrix)
eigval = np.divide(eigval,np.max(eigval))
eigval = 10*eigval
#######################################################
# Getting the unit matrix for transformation
#######################################################
unitx = face.getUnitx()
unity = face.getUnity()
unitz = face.getUnitz()
transformMatrix = np.transpose(np.matrix(
[[qd.doublearray_getitem(unitx,0),qd.doublearray_getitem(unitx,1),qd.doublearray_getitem(unitx,2)],
[qd.doublearray_getitem(unity,0),qd.doublearray_getitem(unity,1),qd.doublearray_getitem(unity,2)],
[qd.doublearray_getitem(unitz,0),qd.doublearray_getitem(unitz,1),qd.doublearray_getitem(unitz,2)]]))
#################################
#print "#################################"
#print eigvec
eigvec = np.matrix(np.vstack((eigvec.T, [0,0])))
#print eigvec
eigvec = np.matmul(transformMatrix,eigvec).T
#print eigvec
#print transformMatrix
#################################
# Now plotting the eigenvecs
#################################
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
plotdiff.scatter(xmean,ymean,zmean,marker='*', c= 'b',s = 30)
################################################################################################
# Plotting the angle between the radial and primary direction
################################################################################################
################################################################################################
# Getting the angle for between radial and primary growth direction
################################################################################################
#print px, py, pz
############################################################
radialvec = np.array([px-xmean,py-ymean,pz-zmean])
try:
radialvec /= np.linalg.norm(radialvec)
except RuntimeWarning:
print px, py, pz
print xmean, ymean, zmean
radialvec = np.array([0.,0.,0.])
primaryvec = np.array([eigvec[0,0],eigvec[0,1],eigvec[0,2]])
primaryvec /= np.linalg.norm(primaryvec)
############################################################
# angle : here it means dot product
############################################################
angle= np.abs(np.dot(radialvec,primaryvec))
#print px, py, pz, xmean, ymean, zmean, "radialvec ", radialvec
#print "="*20
#print faceid, angle
color = scalarMap.to_rgba(angle)
#print eigvec, eigvec.shape, eigvec[0],eigval
xlist = []
ylist = []
zlist = []
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
plotdiff.text(xmean,ymean,zmean, "%.2f"%angle)
verts = [zip(xlist, ylist,zlist)]
#plotdiff.text(xmean, ymean, zmean, "%.2f"%(angle))
#verts = [zip(np.array(ellipsepoints[0])[0],np.array(ellipsepoints[1])[0], np.array(ellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = .7,linewidths=1, facecolor = color,zorder = 10)
pc.set_edgecolor(color)
plotdiff.add_collection3d(pc)
############################################################
# For now just plotting Principal direction of Growth
############################################################
"""plotdiff.quiver(xmean,ymean,zmean,
radialvec[0],radialvec[1],radialvec[2],
color='b',length = 1,pivot='tail',zorder=-1)"""
if eigval[0]> eigval[1]:
colorvec1 = 'r'
vec1 = plotdiff.quiver(xmean,ymean,zmean,
eigvec[0,0],eigvec[0,1],eigvec[0,2],
color=colorvec1,length = 1,pivot='tail',zorder=-1)
#colorvec2 = 'b'
else:
colorvec2 = 'r'
vec2 =plotdiff.quiver(xmean,ymean,zmean,
eigvec[1,0],eigvec[1,1],eigvec[1,2],
color=colorvec2,length = 1,pivot='tail',zorder=-1)
############################################################
# Plotting face
############################################################
xlist = []
ylist = []
zlist = []
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
if faceid in faceidarray:
line, = plotdiff.plot(xlist,ylist,zlist,c=c,lw = lw)
else:
plotdiff.plot(xlist,ylist,zlist,c=c,lw = lw)
face = faces.next()
plotdiff.view_init(azim = azim, elev= elev)
#plotdiff.legend((vec1,vec2,line),("major direction","minor direction","Fast Growing"),bbox_to_anchor=(0.87, 0.95))
########################################################################
plt.savefig(saveDirectory+r"/principalGrowth_step=%03d.png"%(step),transparent=True)
del plotdiff.collections[:]
plotdiff.lines = []
return plotdiff
def plotStrainSurface(cell,
numOfLayer,
step=None,
alpha=0.8,
Length=1.0,
save=False,
azim=-70,
elev=50):
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer >
1) * (np.sqrt(3.) * (numOfLayer - 1) -
Length) + Length #the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False, figsize=(10, 8))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-0.7 * radius, 0.7 * radius))
ax.set_ylim((-0.7 * radius, 0.7 * radius))
ax.set_zlim((-0., 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
#ax.xaxis.pane.fill = False
#ax.yaxis.pane.fill = False
#ax.zaxis.pane.fill = False
########################################################################
# Plotting the Strain vectors #
########################################################################
X = []
Y = []
Z = []
U = []
V = []
W = []
eigenvalue = []
eigenvalue1array = []
eigenvalue2array = []
eigenvalueratioarray = []
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
if sf.checkExternalFace(face):
face = faces.next()
continue
eigenvec1 = face.getStrainEigenVector1()
eigenvec2 = face.getStrainEigenVector2()
eigenvalue1 = face.getStrainEigenValue1()
eigenvalue2 = face.getStrainEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
ratio = abs(
max(eigenvalue1, eigenvalue2) -
min(eigenvalue1, eigenvalue2)) / max(abs(eigenvalue1),
abs(eigenvalue2))
eigenvalueratioarray.append(ratio)
#########~~~ EIGEN VEC 1 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec1, 0))
V.append(qd.doublearray_getitem(eigenvec1, 1))
W.append(qd.doublearray_getitem(eigenvec1, 2))
#########~~~ EIGEN VEC 2 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec2, 0))
V.append(qd.doublearray_getitem(eigenvec2, 1))
W.append(qd.doublearray_getitem(eigenvec2, 2))
#ax.scatter(X[-1],Y[-1],Z[-1])
face = faces.next()
###getting Maximum Eigenvalue ratio
maxEigenValueRatio = (max(eigenvalueratioarray))
minEigenValueRatio = (min(eigenvalueratioarray))
maxEigenValue = max(map(abs, eigenvalue))
#print "Max Eigen Value Ration :", maxEigenValueRatio
#print "Min Eigen Value Ratio :", minEigenValueRatio
######## ######## ######## ######## ########
# Plotting the Cell #
######## ######## ######## ######## ########
######### Color Map
jet = cm = plt.get_cmap('plasma')
maxvalue = 1 #maxEigenValueRatio
minvalue = 0 #minEigenValueRatio
normMax = 2 # value to normalize by
cNorm = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID() #grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
#print face.getZCentralised()
eigenvalue1 = face.getStrainEigenValue1()
eigenvalue2 = face.getStrainEigenValue2()
ratio = abs(
max(eigenvalue1, eigenvalue2) - min(eigenvalue1, eigenvalue2)) / (
normMax * max(abs(eigenvalue1), abs(eigenvalue2)))
if sf.checkExternalFace(face):
ratio = 0.
#print "face ID : ", face.getID(), " ratio : ", ratio
color = scalarMap.to_rgba(ratio)
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,
alpha=alpha,
facecolor=color,
linewidths=1,
zorder=0)
pc.set_edgecolor('k')
ax.add_collection3d(pc)
ax.scatter(xcenarray[-1], ycenarray[-1], zcenarray[-1], c='r')
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
for i in range(len(X)):
veclength = np.sqrt((U[i])**2 + (V[i])**2 + (W[i])**2)
#print " veclength : ", veclength, (eigenvalue[i]/maxEigenValue)
veclength *= (eigenvalue[i] / maxEigenValue)
if veclength <= 0:
colorvec = 'r'
else:
colorvec = 'k'
ax.quiver(X[i],
Y[i],
Z[i],
U[i],
V[i],
W[i],
color=colorvec,
length=veclength,
pivot='tail',
zorder=-1)
#ax.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color='k',pivot='tail',zorder=4)# for older matplotlib
scalarMap._A = []
cbar_ax = fig.add_axes([0.873, 0.2, 0.04, 0.55])
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
clrbar = plt.colorbar(
scalarMap, cax=cbar_ax) #,orientation='horizontal',cax = cbar_ax)
clrbar.set_label("Magnitude of Stress Anisotrophy", fontsize=18)
clrbar.ax.tick_params(labelsize=14)
#ax.set_title("Time %d : Anisotrophy of Strain : Max %.4f Min %.4f"%(step,maxEigenValueRatio,minEigenValueRatio), fontsize = 20)
#print xcenarray-0.5
#plt.close("all")
ax.view_init(azim=azim, elev=elev)
if save:
saveDirectory = "strainFigures_u%02d_v%02d" % (
azim, elev) + r"/stressSurface"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory + r"/strainSurface_Time=%03d.png" % (step),
transparent=True)
plt.close()
return
def plotAbsAnisotropyStress(cell, numOfLayer,step = None, alpha = 0.8, Length=1.0,save=False,azim = -60, elev=50,
colormap = 'magma'):
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer>1)*(np.sqrt(3.)*(numOfLayer-1)-Length)+Length#the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=True,figsize=(22,10))
#fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax1 = fig.add_subplot(121,projection='3d')
ax2 = fig.add_subplot(122,projection='3d')
#ax = Axes3D(fig)
xlim = 0.5
ax1.set_xlim((-xlim*radius,xlim*radius))
ax1.set_ylim((-xlim*radius,xlim*radius))
ax1.set_zlim((-0.3*radius,0.7*radius))
ax1.axis('off')
ax1.xaxis.pane.set_edgecolor('black')
ax1.yaxis.pane.set_edgecolor('black')
#################################################
ax2.set_xlim((-xlim*radius,xlim*radius))
ax2.set_ylim((-xlim*radius,xlim*radius))
ax2.set_zlim((-0.3*radius,.7*radius))
ax2.axis('off')
ax2.xaxis.pane.set_edgecolor('black')
ax2.yaxis.pane.set_edgecolor('black')
#ax.xaxis.pane.fill = False
#ax.yaxis.pane.fill = False
#ax.zaxis.pane.fill = False
########################################################################
# Plotting the Strain vectors #
########################################################################
X = []
Y = []
Z = []
U = []
V = []
W = []
eigenvalue =[]
eigenvalue1array = []
eigenvalue2array = []
eigenvalueratioarray = []
eigenvaluedifferencearray = []
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
if sf.checkExternalFace(face):
face = faces.next()
continue
eigenvec1 = face.getStressEigenVector1()
eigenvec2 = face.getStressEigenVector2()
eigenvalue1 = face.getStressEigenValue1()
eigenvalue2 = face.getStressEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
eigen1 = eigenvalue1
eigen2 = eigenvalue2
#ratio = (max(eigen1,eigen2)- min(eigen1,eigen2))/max(eigen1,eigen2)
ratio = getAbsAnistropy(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
diff = getDifference(eigen1,eigen2)
eigenvalueratioarray.append(ratio)
eigenvaluedifferencearray.append(diff)
#########~~~ EIGEN VEC 1 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec1,0))
V.append(qd.doublearray_getitem(eigenvec1,1))
W.append(qd.doublearray_getitem(eigenvec1,2))
#########~~~ EIGEN VEC 2 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec2,0))
V.append(qd.doublearray_getitem(eigenvec2,1))
W.append(qd.doublearray_getitem(eigenvec2,2))
#ax.scatter(X[-1],Y[-1],Z[-1])
face = faces.next()
###getting Maximum Eigenvalue ratio
maxEigenValueRatio = (max(eigenvalueratioarray))
minEigenValueRatio = (min(eigenvalueratioarray))
maxEigenValue = max(map(abs,eigenvalue))
maxEigendiff = max(eigenvaluedifferencearray)
minEigendiff = min(eigenvaluedifferencearray)
#print "Max Eigen Value Ration :", maxEigenValueRatio
#print "Min Eigen Value Ratio :", minEigenValueRatio
############################################
# Plotting the Cell #
############################################
######### Color Map A ######################
jet1 = cm1 = plt.get_cmap(colormap)
maxvalue = 1.0
minvalue = 0.
normMax = 1 # value to normalize by
cNorm1 = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap1 = cmx.ScalarMappable(norm=cNorm1, cmap=jet1)
######### Color Map B ######################
jet2 = cm2 = plt.get_cmap(colormap)
maxvalue = maxEigendiff
minvalue = minEigendiff
normMax = 1 # value to normalize by
cNorm2 = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap2 = cmx.ScalarMappable(norm=cNorm2, cmap=jet2)
###################
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID()#grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist,zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
eigenvec1 = face.getStressEigenVector1()
eigenvec2 = face.getStressEigenVector2()
eigenvalue1 = face.getStressEigenValue1()
eigenvalue2 = face.getStressEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
eigen1 = eigenvalue1
eigen2 = eigenvalue2
#ratio = (max(eigen1,eigen2)- min(eigen1,eigen2))/max(eigen1,eigen2)
absratio = getAbsAnistropy(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
diffratio = getDifference(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
#####################################################################
if sf.checkExternalFace(face):
absratio = 0.
diffratio = 0.
#print "face ID : ", face.getID(), " ratio : ", ratio
color1 = scalarMap1.to_rgba(absratio)
color2 = scalarMap2.to_rgba(diffratio)
#print face.getID(), ratio
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,alpha = alpha,facecolor = color1,linewidths=1,zorder=0)
pc.set_edgecolor('k')
ax1.add_collection3d(pc)
ax1.scatter(xcenarray[-1], ycenarray[-1],zcenarray[-1],c='r')
###########################################################################################
pc = Poly3DCollection(verts,alpha = alpha,facecolor = color2,linewidths=1,zorder=0)
pc.set_edgecolor('k')
ax2.add_collection3d(pc)
ax2.scatter(xcenarray[-1], ycenarray[-1],zcenarray[-1],c='r')
#ax.text(xcenarray[-1], ycenarray[-1],zcenarray[-1],face.getID(),fontsize = 18)
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
for i in range(len(X)):
veclength = np.sqrt((U[i])**2+(V[i])**2+(W[i])**2)
#print " veclength : ", veclength, (eigenvalue[i]/maxEigenValue)
veclength *= (eigenvalue[i]/maxEigenValue)
if veclength <= 0:
colorvec = 'r'
else:
colorvec = 'k'
plot1 = ax1.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color=colorvec,length = veclength,pivot='tail',zorder=-1)
plot2 = ax2.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color=colorvec,length = veclength,pivot='tail',zorder=-1)
#ax.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color='k',pivot='tail',zorder=4)# for older matplotlib
scalarMap1._A = []
scalarMap2._A = []
#cbar_ax = fig.add_axes([0.78, 0.2, 0.04, 0.55])
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
#clrbar = plt.colorbar(scalarMap,cax = cbar_ax,ticks=np.linspace(minvalue,maxvalue,5))#,orientation='horizontal',cax = cbar_ax)
clrbar1 = plt.colorbar(scalarMap1, ax=ax1,shrink = 0.5,aspect = 10,ticks=np.linspace(0,1,5))#,orientation='horizontal',cax = cbar_ax)
clrbar1.set_label(r"Stress Anisotrophy $(s_a)$")
clrbar2 = plt.colorbar(scalarMap2, ax=ax2,shrink = 0.5,aspect = 10, ticks=np.linspace(minvalue,maxvalue,5))#,orientation='horizontal',cax = cbar_ax)
clrbar2.set_label(r"Stress Difference $(s_d)$")
#ax.set_title("Time %d : Anisotrophy of Strain : Max %.4f Min %.4f"%(step,maxEigenValueRatio,minEigenValueRatio), fontsize = 20)
#print xcenarray-0.5
#plt.close("all")
ax1.view_init(azim = azim, elev= elev)
ax2.view_init(azim = azim, elev= elev)
if save:
saveDirectory = "strainFigures_u=%03d_v=%03d"%(azim,elev)+r"/stressSurface"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
#plt.tight_layout()
#plt.savefig(saveDirectory+r"/strainSurface_Time=%03d.eps"%(step),dpi = 500,format='eps', transparent=True)
plt.savefig(saveDirectory+r"/stressAnisotropy_Time=%03d.png"%(step),dpi = 500,format='png', transparent=True)
plt.close()
return# eigenvalueratioarray
