def plotHeightSurface(numOfLayer, endStep,eta,startStep=0,stepsize= 1,maxarea = None, areastep = 20,
startarea = None, endarea = 850,resetids = False):
import numpy as np
import matplotlib.pyplot as plt
import os
########################################################################
# faceidarray for Primordia
if not os.path.isfile("qdObject_step=001.obj"):
return [0.,0.,0.,0.,0.,0.,0.,0.,0.]
cell = sf.loadCellFromFile(1)
initialTissueSurfaceArea = sf.getSurfaceArea(cell)
#######################################################################
# Starting the Calculation
######################################################################
#######################################################################
laststep = 1
plotargs = {"markersize": 10, "capsize": 10,"elinewidth":3,"markeredgewidth":2}
#######################################################################
heightArray = []
tissueSurfaceAreaArray = []
timeArray = []
dhdAArray = []
volumeArray = []
radiusMeanArray = []
radiusVarArray = []
###################################################
if not startarea:#no startarea given
startarea = int(initialTissueSurfaceArea)
###################################################
listsurfacearea = np.linspace(startarea,endarea,15)
for steparea in listsurfacearea:
step,tissueSurfaceArea = sf.getTimeStep(steparea, endStep, laststep, stepsize = 10)
step2,tissueSurfaceArea2 = sf.getTimeStep(steparea+areastep, endStep, step, stepsize = 10)
if step == step2:break
########################################################################
if not (os.path.isfile("qdObject_step=%03d.obj"%step) or os.path.isfile("qdObject_step=%03d.obj"%step2) ):#check if file exists
break
cell = sf.loadCellFromFile(step,resetids = resetids)
cell2 = sf.loadCellFromFile(step2,resetids = resetids)
################################################
radiusArray = getMeanRadius(cell)
################################################
radiusMeanArray.append(np.mean(radiusArray))
radiusVarArray.append(np.std(radiusArray))
volumeArray.append(cell.getNonConvexVolume())#getting the volume of the tissue
tissueSurfaceAreaArray.append(tissueSurfaceArea)
height = getTissueHeight(cell)
height2 = getTissueHeight(cell2)
heightArray.append(height)
timeArray.append(step)
########################################################################
dhdA = (height2-height)/(tissueSurfaceArea2-tissueSurfaceArea)
dhdAArray.append(dhdA)
########################################################################
print step, tissueSurfaceArea, height
########################################################################
return [tissueSurfaceAreaArray, heightArray, timeArray,dhdAArray,volumeArray,radiusMeanArray, radiusVarArray]
def plotAspectRatio(targetid,othertargetid, targetsurfacearea,
startStep=1,stepsize= 1,largerCondition =True ,maxarea = None, areastep = 10,
startarea = None,
endarea = 850):
import numpy as np
import matplotlib.pyplot as plt
import os
########################################################################
# faceidarray for Primordia
if not os.path.isfile("qdObject_step=001.obj"):
return [0.,0.,0.,0.,0.,0.,0.,0.,0.]
cell = sf.loadCellFromFile(1,resetids=True)
initialTissueSurfaceArea = sf.getSurfaceArea(cell)
#######################################################################
# Starting the Calculation
#######################################################################
#######################################################################
laststep = 1
plotargs = {"markersize": 10, "capsize": 10,"elinewidth":3,"markeredgewidth":2}
#######################################################################
primordialroundnessArray = []
primordialBoundaryroundnessArray = []
othertissueroundnessArray = []
tissueSurfaceAreaArray = []
if not startarea:#no startarea given
startarea = int(initialTissueSurfaceArea)
#######################################################################
listsurfacearea = np.linspace(startarea,endarea,10)
###################################################
for steparea in listsurfacearea:
step,tissueSurfaceArea = sf.getTimeStep(steparea, endStep, laststep, stepsize = 10)
########################################################################
if not os.path.isfile("qdObject_step=%03d.obj"%step):#check if file exists
break
cell = sf.loadCellFromFile(step,resetids=True)
################################################
primordialfaces = sf.getPrimordiaFaces(cell,targetid, large = False)
primordialfaceids = [f.getID() for f in primordialfaces]
primordialBoundaryfaces = sf.getPrimordiaBoundaryFaceList(cell,targetid,large= True)
primordialBoundaryfaceids = [f.getID() for f in primordialBoundaryfaces]
othertissuefacelist = sf.getPrimordiaFaces(cell,othertargetid, large=False)+\
sf.getPrimordiaBoundaryFaceList(cell,othertargetid,large= True)#getMeristemFaces(cell,primordialfaceids+primordialBoundaryfaceids)
################################################
########################################################################
# calculate the roundness
########################################################################
primordiaRoundness = calculateMeanAspectRatio(primordialfaces)
primordialBoundaryRoundness = calculateMeanAspectRatio(primordialBoundaryfaces)
othertissueRoundness = calculateMeanAspectRatio(othertissuefacelist)
######################################################
tissueSurfaceAreaArray.append(tissueSurfaceArea)
primordialroundnessArray.append(primordiaRoundness)
primordialBoundaryroundnessArray.append(primordialBoundaryRoundness)
othertissueroundnessArray.append(othertissueRoundness)
########################################################################
laststep = step
########################################################################
print tissueSurfaceArea, step
return [tissueSurfaceAreaArray,primordialroundnessArray,
primordialBoundaryroundnessArray,othertissueroundnessArray]
def plotFeedbackCorrection(targetid, targetsurfacearea,endStep = 2000,
startStep=1,stepsize= 20,maxarea = None, areastep = 10,resetids = False,
saveName = None):
import numpy as np
import matplotlib.pyplot as plt
import os
########################################################################
# faceidarray for Primordia
if not os.path.isfile("qdObject_step=001.obj"):
return [0.,0.,0.,0.,0.,0.,0.,0.,0.]
########################################################################
# getting the time step for computation
########################################################################
step,tissueSurfaceArea = sf.getTimeStep(targetsurfacearea, endStep, startStep, stepsize = stepsize,resetids = resetids)
#######################################################################
# Starting the Calculation
#######################################################################
cell = sf.loadCellFromFile(step,resetids = resetids)#loading cell
#######################################################################
targetface = sf.getFace(cell, targetid)#getting top priomrdial face
cell.calculateStressStrain()#calculating stress and strain
cell.setRadialOrthoradialVector(targetface)#setting the rad/orthorad vectors
#######################################################################
# calculating the rad/orthorad Component of Correction terms
#######################################################################
cell.setRadialOrthoradialFeedbackCorrection()
cell.setRadialOrthoradialStress()
cell.setPrincipalDeformationVector()
cell.setPrincipalDeformationFeedbackCorrection()
#######################################################################
# Plotting
#######################################################################
sf.plotRadialOrthoradialFeedbackCorrectionSurface(cell, numOfLayer,
azim = -60, elev = 60,
name =saveName+"_feedbackcorrection_radialOrthoradial")
sf.plotTracePrincipalDeformationFeedbackCorrectionSurface(cell,numOfLayer,
azim = -60, elev = 60,
name =saveName+"_feedbackcorrection_trace")
sf.plotPrincipalDeformationFeedbackCorrectionSurface(cell, numOfLayer,
azim = -60, elev = 60,
name =saveName+"_feedbackcorrection_principalDeformation")
sf.plotStressSurface(cell, numOfLayer,
azim = -60, elev = 60,
name =saveName+"_stressSurface_principal")
return
def plotMeanStressGrowth(numOfLayer, targetid,endStep,eta,
meanstress, meandilation,
color,startStep=0,stepsize= 1,largerCondition =True ,maxarea = None, areastep = 20,
startarea = None,
endarea = 850,resetids = True):
import numpy as np
import matplotlib.pyplot as plt
import os
########################################################################
# faceidarray for Primordia
if not os.path.isfile("qdObject_step=001.obj"):
return [0.,0.,0.,0.,0.,0.,0.,0.,0.]
cell = sf.loadCellFromFile(1,resetids=resetids)
initialTissueSurfaceArea = sf.getSurfaceArea(cell)
#######################################################################
# Starting the Calculation
#######################################################################
#######################################################################
laststep = 1
plotargs = {"markersize": 10, "capsize": 10,"elinewidth":3,"markeredgewidth":2}
#######################################################################
orthoradialStressArray = []
radialStressArray = []
radialGrowthArray = []
orthoradialGrowthArray = []
meanstressEigenvalue1Array = []
meanstressEigenvalue2Array = []
meangrowthEigenvalue1Array = []
meangrowthEigenvalue2Array = []
meangaussianCurvatureArray = []
###################################################
# save standard deviations of the stress and growth
###################################################
radialStressSDArray = []
orthoradialStressSDArray = []
radialGrowthSDArray = []
orthoradialGrowthSDArray = []
meanstressEigenvalue1SDArray = []
meanstressEigenvalue2SDArray = []
meangrowthEigenvalue1SDArray = []
meangrowthEigenvalue2SDArray = []
###################################################
tissueSurfaceAreaArray = []
primordiaAreaArray = []
boundaryAreaArray = []
heightArray = []
###################################################
if not startarea:#no startarea given
startarea = int(initialTissueSurfaceArea)
###################################################
listsurfacearea = np.linspace(startarea,endarea,10)
#print listsurfacearea
#for steparea in range(startarea, endarea, int(areastep)):
for steparea in listsurfacearea:
step,tissueSurfaceArea = sf.getTimeStep(steparea, endStep, laststep, stepsize = 10,resetids = resetids)
########################################################################
step2,tissueSurfaceArea2 = sf.getTimeStep(steparea+areastep, endStep, step, stepsize = 10,resetids = resetids)
########################################################################
if not os.path.isfile("qdObject_step=%03d.obj"%step):#check if file exists
break
cell = sf.loadCellFromFile(step,resetids=resetids)
cell2 = sf.loadCellFromFile(step2,resetids=resetids)
################################################
cell.calculateStressStrain()
################################################
primordialface = sf.getFace(cell, targetid)
################################################
cell.setRadialOrthoradialVector(primordialface)
cell.setRadialOrthoradialStress()
################################################
sf.calculateDilation(cell,cell2)
########################################################################
# Starting the Calculation of mean growth and mean stress on boundary
########################################################################
# mean stress
########################################################################
faceList = sf.getPrimordiaBoundaryFaceList(cell,targetid,large= large)
primordiafacelist = sf.getPrimordiaFaces(cell, targetid, large = False)
primordiaarea = 0.
for face in primordiafacelist:
primordiaarea += face.getAreaOfFace()
######################################################
#radialDict, orthoradialDict = getRadialOrthoradialDict(cell,targetid,large = large)
######################################################
radialStress = []
orthoradialStress = []
radialGrowth = []
orthoradialGrowth = []
stressEigenvalue1Array = []
stressEigenvalue2Array = []
growthEigenvalue1Array = []
growthEigenvalue2Array = []
gaussianCurvatureArray = []
dTissueSurfaceArea = tissueSurfaceArea2-tissueSurfaceArea
boundaryarea = 0.
for face in faceList:
boundaryarea += face.getAreaOfFace()
#######################################################
radstress, orthstress,stresseigenvalue1, stresseigenvalue2 = getRadialOrthoradialStress(face)
radGrowth, orthGrowth, growtheigenvalue1, growtheigenvalue2 = getRadialOrthoradialGrowth(face)
#######################################################
radialStress.append(radstress)
orthoradialStress.append(orthstress)
radialGrowth.append(radGrowth)
orthoradialGrowth.append(orthGrowth)
stressEigenvalue1Array.append(stresseigenvalue1)
stressEigenvalue2Array.append(stresseigenvalue2)
growthEigenvalue1Array.append(growtheigenvalue1)
growthEigenvalue2Array.append(growtheigenvalue2)
gaussianCurvatureArray.append(sf.getFaceWeightedGaussianCurvature(face))
######################################################
radialStressArray.append(np.mean(radialStress))
orthoradialStressArray.append(np.mean(orthoradialStress))
radialGrowthArray.append(np.mean(radialGrowth))
orthoradialGrowthArray.append(np.mean(orthoradialGrowth))
tissueSurfaceAreaArray.append(tissueSurfaceArea)
primordiaAreaArray.append(primordiaarea)
boundaryAreaArray.append(boundaryarea)
######################################################
height = getPrimordiaHeight(cell,targetid)
heightArray.append(height)
######################################################
meanstressEigenvalue1Array.append(np.mean(stressEigenvalue1Array))
meanstressEigenvalue2Array.append(np.mean(stressEigenvalue2Array))
meangrowthEigenvalue1Array.append(np.mean(growthEigenvalue1Array))
meangrowthEigenvalue2Array.append(np.mean(growthEigenvalue2Array))
meangaussianCurvatureArray.append(np.mean(gaussianCurvatureArray))
#######################################################
# calculating the standard deviation
#######################################################
meanstressEigenvalue1SDArray.append(np.std(stressEigenvalue1Array))
meanstressEigenvalue2SDArray.append(np.std(stressEigenvalue2Array))
meangrowthEigenvalue1SDArray.append(np.std(growthEigenvalue1Array))
meangrowthEigenvalue2SDArray.append(np.std(growthEigenvalue2Array))
radialStressSDArray.append(np.std(radialStress))
orthoradialStressSDArray.append(np.std(orthoradialStress))
radialGrowthSDArray.append(np.std(radialGrowth))
orthoradialGrowthSDArray.append(np.std(orthoradialGrowth))
#meanstress.errorbar(tissueSurfaceArea, np.mean(radialStress),
# yerr = np.std(radialStress)/float(len(radialStress)),fmt='o',label = r":$\sigma_{r}$",c=color,**plotargs)
#meanstress.errorbar(tissueSurfaceArea, np.mean(orthoradialStress),
# yerr = np.std(orthoradialStress)/float(len(orthoradialStress)),fmt='<',label = r":$\sigma_{o}$",c=color,**plotargs)
########################################################################
# mean dilation
########################################################################
#meandilation.errorbar(tissueSurfaceArea, np.mean(radialGrowth),
# yerr = np.std(radialGrowth)/float(len(radialGrowth)),fmt='o',label = r":$g_{r}$",c=color,**plotargs)
#meandilation.errorbar(tissueSurfaceArea, np.mean(orthoradialGrowth),
# yerr = np.std(orthoradialGrowth)/float(len(orthoradialGrowth)),fmt='<',label = r":$g_{o}$",c=color,**plotargs)
########################################################################
laststep = step
########################################################################
print tissueSurfaceArea, tissueSurfaceArea2,dTissueSurfaceArea, step , step2
########################################################################
return [tissueSurfaceAreaArray, radialStressArray, orthoradialStressArray,
radialGrowthArray, orthoradialGrowthArray,
primordiaAreaArray,
heightArray,
meanstressEigenvalue1Array, meanstressEigenvalue2Array,
meangrowthEigenvalue1Array, meangrowthEigenvalue2Array, boundaryAreaArray,
radialStressSDArray, orthoradialStressSDArray,
radialGrowthSDArray, orthoradialGrowthSDArray,
meanstressEigenvalue1SDArray, meanstressEigenvalue2SDArray,
meangrowthEigenvalue1SDArray, meangrowthEigenvalue2SDArray,
meangaussianCurvatureArray
]
duration = args.duration
startstep = args.starttime
endstep = args.endtime
timestep = args.timestep
surfacearea = args.surfacearea
resetids = args.resetids
#################################################
# if surface area is used, calculate timstep
#################################################
if surfacearea:
endStep = 2000
startStep = 1
endStep, endarea = sf.getTimeStep(surfacearea,
endStep,
startStep,
stepsize=10,
resetids=resetids)
endarea = int(endarea)
areastep = timestep #use area step instead of time for plotting
#####################################################################################################
#key to sort the file_names in order
numbers = re.compile(r'(\d+)')
def numericalSort(value):
parts = numbers.split(value)
parts[1::2] = map(int, parts[1::2])
return parts