# connect meridians to make surfaces
# caps will close it at the beginning and the end
# threshold will merge points closer than 1e-4; this is important: we want it to be closed for filling
surf=pack.sweptPolylines2gtsSurface(pts,capStart=True,capEnd=True,threshold=1e-4)
# add the surface as facets to the simulation, to make it visible
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,1)))
# now fill the inGtsSurface predicate constructed form the same surface with sphere packing generated by TriaxialTest
# with given radius and standard deviation (see documentation of pack.randomDensePack)
#
# The memoizeDb will save resulting packing into given file and next time, if you run with the same
# parameters (or parameters that can be scaled to the same one),
# it will load the packing instead of running the triaxial compaction again.
# Try running for the second time to see the speed difference!
memoizeDb='/tmp/gts-triax-packings.sqlite'
sp=SpherePack()
sp=pack.randomDensePack(pack.inGtsSurface(surf),radius=5e-3,rRelFuzz=1e-4,memoizeDb=memoizeDb,returnSpherePack=True)
sp.toSimulation()
# We could also fill the horse with triaxial packing, but have nice approximation, the triaxial would run terribly long,
# since horse discard most volume of its bounding box
# Here, we would use a very crude one, however
if 1:
import gts
horse=gts.read(open('horse.coarse.gts')) #; horse.scale(.25,.25,.25)
O.bodies.append(pack.gtsSurface2Facets(horse))
sp=pack.randomDensePack(pack.inGtsSurface(horse),radius=5e-3,memoizeDb=memoizeDb,returnSpherePack=True)
sp.toSimulation()
horse.translate(.07,0,0)
O.bodies.append(pack.gtsSurface2Facets(horse))
# specifying spheresInCell makes the packing periodic, with the given number of spheres, proportions being equal to that of the predicate
sp=pack.randomDensePack(pack.inGtsSurface(horse),radius=1e-3,spheresInCell=2000,memoizeDb=memoizeDb,returnSpherePack=True)
sp.toSimulation()
pts = pack.revolutionSurfaceMeridians([poly for theta in thetas],
thetas,
origin=Vector3(-4, 0, -1),
orientation=Quaternion.Identity)
surf = pack.sweptPolylines2gtsSurface(pts,
capStart=True,
capEnd=True,
threshold=1e-4)
O.bodies.append(pack.gtsSurface2Facets(surf, color=(1, 0, 1)))
# fill this solid with triaxial packing; it will compute minimum-volume oriented bounding box
# to minimize the number of throw-away spheres.
# It does away with about 3k spheres for radius 3e-2
sp1 = SpherePack()
sp1 = pack.randomDensePack(pack.inGtsSurface(surf),
radius=3e-2,
rRelFuzz=1e-1,
memoizeDb='/tmp/gts-triax.sqlite',
returnSpherePack=True)
sp1.toSimulation()
# translate the surface away and pack it again with sphere, but without the oriented bounding box (useOBB=False)
# Here, we need 20k spheres (with more or less the same result)
surf.translate(0, 0, 1)
O.bodies.append(pack.gtsSurface2Facets(surf, color=(1, 0, 0)))
sp2 = SpherePack()
sp2 = pack.randomDensePack(pack.inGtsSurface(surf),
radius=3e-2,
rRelFuzz=1e-1,
memoizeDb='/tmp/gts-triax-packings.sqlite',
useOBB=False,
returnSpherePack=True)
sp2.toSimulation()
aabb = pred.aabb()
dim = pred.dim()
center = pred.center()
minDim = min(dim[0], dim[1], dim[2])
# define discretisation
radius = minDim / (2 * sizeRatio)
print center, dim, ' | minDim=', minDim, ' | diameter=', 2 * radius
### regular packing
#O.bodies.append(pack.regularHexa(pred,radius=radius,gap=0.,color=(0.9,0.8,0.6)))
#O.bodies.append(pack.regularOrtho(pred,radius=radius,gap=0.,color=(0.9,0.8,0.6)))
sp = SpherePack()
# random packing
sp = pack.randomDensePack(
pred,
radius=radius,
rRelFuzz=0.3,
useOBB=True,
memoizeDb='/tmp/gts-triax-packings.sqlite',
returnSpherePack=True) # cropLayers=5 (not to use)
# periodic random packing
#sp=pack.randomDensePack(pred,radius=radius,rRelFuzz=0.3,useOBB=True,spheresInCell=2000,memoizeDb='/tmp/gts-triax-packings.sqlite',returnSpherePack=True) # cropLayers=5 (not to use)
sp.toSimulation(color=(0.9, 0.8, 0.6))
#### import mesh
O.bodies.append(
pack.gtsSurface2Facets(surface, color=(0.8, 0.8, 0.8), wire=True))
#### export packing
export.text(mesh + '_' + str(int(sizeRatio)) + '.spheres')
#### VIEW
# isotropic confinement (should be negative) isoPrestress=0, ) from yade.params.table import * if 'description' in O.tags.keys(): O.tags['id']=O.tags['id']+O.tags['description'] # make geom; the dimensions are hard-coded here; could be in param table if desired # z-oriented hyperboloid, length 20cm, diameter 10cm, skirt 8cm # using spheres 7mm of diameter concreteId=O.materials.append(CpmMat(young=young,frictionAngle=frictionAngle,poisson=poisson,density=4800,sigmaT=sigmaT,relDuctility=relDuctility,epsCrackOnset=epsCrackOnset,isoPrestress=isoPrestress)) sps=SpherePack() sp=pack.randomDensePack(pack.inHyperboloid((0,0,-.5*specimenLength),(0,0,.5*specimenLength),.25*specimenLength,.17*specimenLength),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite',returnSpherePack=True) #sp=pack.randomDensePack(pack.inAlignedBox((-.25*specimenLength,-.25*specimenLength,-.5*specimenLength),(.25*specimenLength,.25*specimenLength,.5*specimenLength)),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite',returnSpherePack=True) sp.toSimulation(material=concreteId) bb=uniaxialTestFeatures() negIds,posIds,axis,crossSectionArea=bb['negIds'],bb['posIds'],bb['axis'],bb['area'] O.dt=dtSafety*PWaveTimeStep() print 'Timestep',O.dt mm,mx=[pt[axis] for pt in aabbExtrema()] coord_25,coord_50,coord_75=mm+.25*(mx-mm),mm+.5*(mx-mm),mm+.75*(mx-mm) area_25,area_50,area_75=approxSectionArea(coord_25,axis),approxSectionArea(coord_50,axis),approxSectionArea(coord_75,axis) O.engines=[ ForceResetter(), InsertionSortCollider([Bo1_Sphere_Aabb(aabbEnlargeFactor=intRadius,label='is2aabb'),],verletDist=.05*sphereRadius), InteractionLoop(
maxCorner = (10, 10, 10)
center = (5, 5, 5)
normal = (1, 1, 1)
from yade import pack, export
pred = pack.inAlignedBox(Vector3.Zero, maxCorner)
O.bodies.append(
pack.randomDensePack(pred, radius=1., rRelFuzz=.5, spheresInCell=500))
export.text('/tmp/test.txt')
# text2vtk and text2vtkSection function can be copy-pasted from yade/py/export.py into separate py file to avoid executing yade or to use pure python
export.text2vtk('/tmp/test.txt', '/tmp/test.vtk')
export.text2vtkSection('/tmp/test.txt',
'/tmp/testSection.vtk',
point=center,
normal=normal)
# now open paraview, click "Tools" menu -> "Python Shell", click "Run Script", choose "pv_section.py" from this directiory
# or just run python pv_section.py
# and enjoy :-)
O.materials.append(FrictMat(young=young,poisson=0.5,frictionAngle=radians(angfric),density=2600,label='sph')) walls=aabbWalls([mn,mx],thickness=0,material='walls') wallIds=O.bodies.append(walls) vect=[0, 1, 1.25, 2.25, 2.5, 3.5, 3.75] vect=1/3.75*numpy.array(vect) cuadr1=pack.inAlignedBox((0,0,H*vect[0]),(D,D,H*vect[1])) #grueso cuadr2=pack.inAlignedBox((0,0,H*vect[1]),(D,D,H*vect[2])) #fino cuadr3=pack.inAlignedBox((0,0,H*vect[2]),(D,D,H*vect[3])) #grueso cuadr4=pack.inAlignedBox((0,0,H*vect[3]),(D,D,H*vect[4])) #fino cuadr5=pack.inAlignedBox((0,0,H*vect[4]),(D,D,H*vect[5])) #grueso cuadr6=pack.inAlignedBox((0,0,H*vect[5]),(D,D,H*vect[6])) #fino sph1=pack.randomDensePack(cuadr1,spheresInCell=1000,radius=rmean,rRelFuzz=Sd,returnSpherePack=True) sph2=pack.randomDensePack(cuadr2,spheresInCell=2000,radius=rmean/R1,rRelFuzz=Sd,returnSpherePack=True) sph3=pack.randomDensePack(cuadr3,spheresInCell=1000,radius=rmean,rRelFuzz=Sd,returnSpherePack=True) sph4=pack.randomDensePack(cuadr4,spheresInCell=2000,radius=rmean/R1,rRelFuzz=Sd,returnSpherePack=True) sph5=pack.randomDensePack(cuadr5,spheresInCell=1000,radius=rmean,rRelFuzz=Sd,returnSpherePack=True) sph6=pack.randomDensePack(cuadr6,spheresInCell=2000,radius=rmean/R1,rRelFuzz=Sd,returnSpherePack=True) sph1.toSimulation(material='sph') sph2.toSimulation(material='sph') sph3.toSimulation(material='sph') sph4.toSimulation(material='sph') sph5.toSimulation(material='sph') sph6.toSimulation(material='sph') n1=len(sph1) n2=len(sph2)
noTableOk=True,
young=25e9,
poisson=.2,
epsCrackOnset=1e-4,
relDuctility=30,
sigmaT=3e6,
frictionAngle=atan(0.8),
density=4800.,
intRadius=1.5,
dtSafety=.8,
damping=0.3,
strainRateTension=.4,
strainRateCompression=3,
specimenSize=50e-3,
radius=1e-3,
outBase="/tmp/cpm_uniax",
)
from yade.params.table import *
if 'description' in O.tags.keys():
outBase = "{}_{}".format(outBase, O.tags['description'])
s = specimenSize
sp = pack.randomDensePack(inAlignedBox((0, 0, 0), (s, s, s)),
radius,
spheresInCell=1000,
memoizeDb="packing.db",
returnSpherePack=True)
sp.toSimulation()
sp.save("/tmp/aaa.ps")
# pts=pack.revolutionSurfaceMeridians([[(pt[0],pt[1]+2e-3*theta) for pt in poly] for theta in thetas],thetas
#
pts=pack.revolutionSurfaceMeridians([[(pt[0],pt[1]+1e-2*theta) for pt in poly] for theta in thetas],thetas,origin=Vector3(0,-.05,.1),orientation=Quaternion((1,1,0),pi/4))
# connect meridians to make surfaces
# caps will close it at the beginning and the end
# threshold will merge points closer than 1e-4; this is important: we want it to be closed for filling
surf=pack.sweptPolylines2gtsSurface(pts,capStart=True,capEnd=True,threshold=1e-4)
# add the surface as facets to the simulation, to make it visible
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,1)))
# now fill the inGtsSurface predicate constructed form the same surface with sphere packing generated by TriaxialTest
# with given radius and standard deviation (see documentation of pack.randomDensePack)
#
# The memoizeDb will save resulting packing into given file and next time, if you run with the same
# parameters (or parameters that can be scaled to the same one),
# it will load the packing instead of running the triaxial compaction again.
# Try running for the second time to see the speed difference!
memoizeDb='/tmp/gts-triax-packings.sqlite'
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(surf),radius=5e-3,rRelFuzz=1e-4,memoizeDb=memoizeDb))
# We could also fill the horse with triaxial packing, but have nice approximation, the triaxial would run terribly long,
# since horse discard most volume of its bounding box
# Here, we would use a very crude one, however
if 1:
import gts
horse=gts.read(open('horse.coarse.gts')) #; horse.scale(.25,.25,.25)
O.bodies.append(pack.gtsSurface2Facets(horse))
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(horse),radius=5e-3,memoizeDb=memoizeDb))
horse.translate(.07,0,0)
O.bodies.append(pack.gtsSurface2Facets(horse))
# specifying spheresInCell makes the packing periodic, with the given number of spheres, proportions being equal to that of the predicate
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(horse),radius=1e-3,spheresInCell=2000,memoizeDb=memoizeDb))
if not os.path.exists('VTK' + timeStr + identifier):
os.mkdir('VTK' + timeStr + identifier)
else:
shutil.rmtree('VTK' + timeStr + identifier)
os.mkdir('VTK' + timeStr + identifier)
mx = Vector3(0.9639118565206523, 0.9324110610237126, 0.8800533096533549)
mn = Vector3(-0.9518976876470108, -0.9685168132064216, -0.9451956043076566)
walls = aabbWalls([mn, mx], thickness=0)
wallIds = O.bodies.append(walls)
pred = pack.inSphere(Vector3(0, 0, 0), 1)
sp = pack.randomDensePack(pred,
radius=0.1,
rRelFuzz=0.1,
returnSpherePack=False,
seed=1)
O.bodies.append(sp)
O.engines = O.engines[0:3] + [
FlowEngine(dead=0, label="flow", multithread=False)
] + O.engines[3:5]
# visualization of the alpha boundary: filter cells by "alpha" in paraview
def pressureField():
flow.saveVtk('VTK' + timeStr + identifier + '/', withBoundaries=False)
O.engines = O.engines + [
# material
concreteId = O.materials.append(
CpmMat(
young=young,
poisson=poisson,
frictionAngle=frictionAngle,
epsCrackOnset=epsCrackOnset,
relDuctility=relDuctility,
sigmaT=sigmaT,
))
# spheres
sp = pack.randomDensePack(pack.inCylinder((0, 0, 0), (specimenLength, 0, 0),
specimenRadius),
radius=sphereRadius,
spheresInCell=500,
memoizeDb='/tmp/packing-brazilian.db',
returnSpherePack=True)
sp.toSimulation()
# walls
zMin, zMax = [pt[2] for pt in aabbExtrema()]
wallIDs = O.bodies.append([wall((0, 0, z), 2) for z in (zMin, zMax)])
walls = wallMin, wallMax = [O.bodies[i] for i in wallIDs]
v = strainRate * 2 * specimenRadius
wallMin.state.vel = (0, 0, +v)
wallMax.state.vel = (0, 0, -v)
# engines
O.engines = [
ForceResetter(),
"""
from numpy import arange
from yade import pack
import pylab
# define the section shape as polygon in 2d; repeat first point at the end to close the polygon
sq2=sqrt(2)
poly=((3+.1,0),(3+0,.1),(3+sq2,.1+sq2),(3+.1+sq2,sq2),(3+.1,0))
#pylab.plot(*zip(*poly)); pylab.xlim(xmin=0); pylab.grid(); pylab.title('Meridian of the revolution surface\n(close to continue)'); pylab.gca().set_aspect(aspect='equal',adjustable='box'); pylab.show()
thetas=arange(0,pi/8,pi/24)
pts=pack.revolutionSurfaceMeridians([poly for theta in thetas],thetas,origin=Vector3(-4,0,-1),orientation=Quaternion.Identity)
surf=pack.sweptPolylines2gtsSurface(pts,capStart=True,capEnd=True,threshold=1e-4)
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,1)))
# fill this solid with triaxial packing; it will compute minimum-volume oriented bounding box
# to minimize the number of throw-away spheres.
# It does away with about 3k spheres for radius 3e-2
sp1=SpherePack()
sp1=pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax.sqlite',returnSpherePack=True)
sp1.toSimulation()
# translate the surface away and pack it again with sphere, but without the oriented bounding box (useOBB=False)
# Here, we need 20k spheres (with more or less the same result)
surf.translate(0,0,1);
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,0)))
sp2=SpherePack()
sp2=pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax-packings.sqlite',useOBB=False,returnSpherePack=True)
sp2.toSimulation()
from yade import qt
qt.View()
# -*- coding: utf-8 -*-
from numpy import arange
from yade import pack
import pylab
# define the section shape as polygon in 2d; repeat first point at the end to close the polygon
sq2=sqrt(2)
poly=((3+.1,0),(3+0,.1),(3+sq2,.1+sq2),(3+.1+sq2,sq2),(3+.1,0))
#pylab.plot(*zip(*poly)); pylab.xlim(xmin=0); pylab.grid(); pylab.title('Meridian of the revolution surface\n(close to continue)'); pylab.gca().set_aspect(aspect='equal',adjustable='box'); pylab.show()
thetas=arange(0,pi/8,pi/24)
pts=pack.revolutionSurfaceMeridians([poly for theta in thetas],thetas,origin=Vector3(-4,0,-1),orientation=Quaternion.Identity)
surf=pack.sweptPolylines2gtsSurface(pts,capStart=True,capEnd=True,threshold=1e-4)
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,1)))
# fill this solid with triaxial packing; it will compute minimum-volume oriented bounding box
# to minimize the number of throw-away spheres.
# It does away with about 3k spheres for radius 3e-2
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax-packings.sqlite'))
# translate the surface away and pack it again with sphere, but without the oriented bounding box (useOBB=False)
# Here, we need 20k spheres (with more or less the same result)
surf.translate(0,0,1);
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,0)))
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax-packings.sqlite',useOBB=False))
if surface.is_closed(): pred=pack.inGtsSurface(surface) # get characteristic dimensions aabb=pred.aabb() dim=pred.dim() center=pred.center() minDim=min(dim[0],dim[1],dim[2]) # define discretisation radius=minDim/(2*sizeRatio) print center, dim, ' | minDim=', minDim, ' | diameter=', 2*radius ### regular packing #O.bodies.append(pack.regularHexa(pred,radius=radius,gap=0.,color=(0.9,0.8,0.6))) #O.bodies.append(pack.regularOrtho(pred,radius=radius,gap=0.,color=(0.9,0.8,0.6))) sp=SpherePack() # random packing sp=pack.randomDensePack(pred,radius=radius,rRelFuzz=0.3,useOBB=True,memoizeDb='/tmp/gts-triax-packings.sqlite',returnSpherePack=True) # cropLayers=5 (not to use) # periodic random packing #sp=pack.randomDensePack(pred,radius=radius,rRelFuzz=0.3,useOBB=True,spheresInCell=2000,memoizeDb='/tmp/gts-triax-packings.sqlite',returnSpherePack=True) # cropLayers=5 (not to use) sp.toSimulation(color=(0.9,0.8,0.6)) #### import mesh O.bodies.append(pack.gtsSurface2Facets(surface,color=(0.8,0.8,0.8),wire=True)) #### export packing export.text(mesh+'_'+str(int(sizeRatio))+'.spheres') #### VIEW from yade import qt qt.View()
JCFpmMat(young=young,
cohesion=cohesion,
density=density,
frictionAngle=radians(finalFricDegree),
tensileStrength=sigmaT,
poisson=poisson,
label='JCFmat'))
#### preprocessing to get dimensions
numSpheres = 10000
pred = pack.inAlignedBox(
mn, mx) #- pack.inCylinder((0, -.01, 0), (0, .01, 0), 0.04)
sp = pack.randomDensePack(pred,
radius=0.0015,
spheresInCell=numSpheres,
rRelFuzz=0.25,
returnSpherePack=True)
sp.toSimulation()
export.textExt('240x80mmBeam_1.5mmrad.spheres', 'x_y_z_r')
dim = utils.aabbExtrema()
xinf = dim[0][0]
xsup = dim[1][0]
X = xsup - xinf
yinf = dim[0][1]
ysup = dim[1][1]
Y = ysup - yinf
zinf = dim[0][2]
zsup = dim[1][2]
Z = zsup - zinf
from yade import pack, export
pred = pack.inAlignedBox((0,0,0),(10,10,10))
O.bodies.append(pack.randomDensePack(pred,radius=1.,rRelFuzz=.5,spheresInCell=500,memoizeDb='/tmp/pack.db'))
export.textExt('/tmp/test.txt',format='x_y_z_r_attrs',attrs=('b.state.pos.norm()','b.state.pos'),comment='dstN dstV_x dstV_y dstV_z')
# text2vtk and text2vtkSection function can be copy-pasted from yade/py/export.py into separate py file to avoid executing yade or to use pure python
export.text2vtk('/tmp/test.txt','/tmp/test.vtk')
export.text2vtkSection('/tmp/test.txt','/tmp/testSection.vtk',point=(5,5,5),normal=(1,1,1))
# now open paraview, click "Tools" menu -> "Python Shell", click "Run Script", choose "pv_section.py" from this directiory
# or just run python pv_section.py
# and enjoy :-)
capStart=True,
capEnd=True,
threshold=1e-4)
# add the surface as facets to the simulation, to make it visible
O.bodies.append(pack.gtsSurface2Facets(surf, color=(1, 0, 1)))
# now fill the inGtsSurface predicate constructed form the same surface with sphere packing generated by TriaxialTest
# with given radius and standard deviation (see documentation of pack.randomDensePack)
#
# The memoizeDb will save resulting packing into given file and next time, if you run with the same
# parameters (or parameters that can be scaled to the same one),
# it will load the packing instead of running the triaxial compaction again.
# Try running for the second time to see the speed difference!
memoizeDb = '/tmp/gts-triax-packings.sqlite'
O.bodies.append(
pack.randomDensePack(pack.inGtsSurface(surf),
radius=5e-3,
rRelFuzz=1e-4,
memoizeDb=memoizeDb))
# We could also fill the horse with triaxial packing, but have nice approximation, the triaxial would run terribly long,
# since horse discard most volume of its bounding box
# Here, we would use a very crude one, however
if 1:
import gts
horse = gts.read(open('horse.coarse.gts')) #; horse.scale(.25,.25,.25)
O.bodies.append(pack.gtsSurface2Facets(horse))
O.bodies.append(
pack.randomDensePack(pack.inGtsSurface(horse),
radius=5e-3,
memoizeDb=memoizeDb))
horse.translate(.07, 0, 0)
O.bodies.append(pack.gtsSurface2Facets(horse))
# specifying spheresInCell makes the packing periodic, with the given number of spheres, proportions being equal to that of the predicate
sigmaT=sigmaT,
epsCrackOnset=epsCrackOnset,
relDuctility=relDuctility))
frictMat = O.materials.append(
FrictMat(young=young, poisson=poisson, frictionAngle=frictionAngle))
# spheres
pred = pack.inCylinder(
(0, 0, 0),
(0, 0, height), .5 * width) if testType == 'cyl' else pack.inAlignedBox(
(-.5 * width, -.5 * width, 0),
(.5 * width, .5 * width, height)) if testType == 'cube' else None
sp = SpherePack()
sp = pack.randomDensePack(pred,
spheresInCell=2000,
radius=rParticle,
memoizeDb='/tmp/triaxTestOnCylinder.sqlite',
returnSpherePack=True)
spheres = sp.toSimulation(color=(0, 1, 1), material=concMat)
# bottom and top of specimen. Will have prescribed velocity
bot = [
O.bodies[s] for s in spheres
if O.bodies[s].state.pos[2] < rParticle * bcCoeff
]
top = [
O.bodies[s] for s in spheres
if O.bodies[s].state.pos[2] > height - rParticle * bcCoeff
]
vel = strainRate * (height - rParticle * 2 * bcCoeff)
for s in bot:
maxCorner = (10,10,10)
center = (5,5,5)
normal = (1,1,1)
from yade import pack, export
pred = pack.inAlignedBox(Vector3.Zero,maxCorner)
O.bodies.append(pack.randomDensePack(pred,radius=1.,rRelFuzz=.5,spheresInCell=500))
export.text('/tmp/test.txt')
# text2vtk and text2vtkSection function can be copy-pasted from yade/py/export.py into separate py file to avoid executing yade or to use pure python
export.text2vtk('/tmp/test.txt','/tmp/test.vtk')
export.text2vtkSection('/tmp/test.txt','/tmp/testSection.vtk',point=center,normal=normal)
# now open paraview, click "Tools" menu -> "Python Shell", click "Run Script", choose "pv_section.py" from this directiory
# or just run python pv_section.py
# and enjoy :-)
from yade.params.table import * assert testType in ['cyl','cube'] # materials concMat = O.materials.append(CpmMat( young=young,frictionAngle=frictionAngle,poisson=poisson,sigmaT=sigmaT, epsCrackOnset=epsCrackOnset,relDuctility=relDuctility )) frictMat = O.materials.append(FrictMat( young=young,poisson=poisson,frictionAngle=frictionAngle )) # spheres pred = pack.inCylinder((0,0,0),(0,0,height),.5*width) if testType=='cyl' else pack.inAlignedBox((-.5*width,-.5*width,0),(.5*width,.5*width,height)) if testType=='cube' else None sp=SpherePack() sp = pack.randomDensePack(pred,spheresInCell=2000,radius=rParticle,memoizeDb='/tmp/triaxTestOnCylinder.sqlite',returnSpherePack=True) spheres=sp.toSimulation(color=(0,1,1),material=concMat) # bottom and top of specimen. Will have prescribed velocity bot = [O.bodies[s] for s in spheres if O.bodies[s].state.pos[2]<rParticle*bcCoeff] top = [O.bodies[s] for s in spheres if O.bodies[s].state.pos[2]>height-rParticle*bcCoeff] vel = strainRate*(height-rParticle*2*bcCoeff) for s in bot: s.shape.color = (1,0,0) s.state.blockedDOFs = 'xyzXYZ' s.state.vel = (0,0,-vel) for s in top: s.shape.color = Vector3(0,1,0) s.state.blockedDOFs = 'xyzXYZ' s.state.vel = (0,0,vel)
# -*- coding: utf-8 -*-
""" CAUTION:
Running this script can take very long!
"""
from numpy import arange
from yade import pack
import pylab
# define the section shape as polygon in 2d; repeat first point at the end to close the polygon
sq2=sqrt(2)
poly=((3+.1,0),(3+0,.1),(3+sq2,.1+sq2),(3+.1+sq2,sq2),(3+.1,0))
#pylab.plot(*zip(*poly)); pylab.xlim(xmin=0); pylab.grid(); pylab.title('Meridian of the revolution surface\n(close to continue)'); pylab.gca().set_aspect(aspect='equal',adjustable='box'); pylab.show()
thetas=arange(0,pi/8,pi/24)
pts=pack.revolutionSurfaceMeridians([poly for theta in thetas],thetas,origin=Vector3(-4,0,-1),orientation=Quaternion.Identity)
surf=pack.sweptPolylines2gtsSurface(pts,capStart=True,capEnd=True,threshold=1e-4)
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,1)))
# fill this solid with triaxial packing; it will compute minimum-volume oriented bounding box
# to minimize the number of throw-away spheres.
# It does away with about 3k spheres for radius 3e-2
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax.sqlite'))
# translate the surface away and pack it again with sphere, but without the oriented bounding box (useOBB=False)
# Here, we need 20k spheres (with more or less the same result)
surf.translate(0,0,1);
O.bodies.append(pack.gtsSurface2Facets(surf,color=(1,0,0)))
O.bodies.append(pack.randomDensePack(pack.inGtsSurface(surf),radius=3e-2,rRelFuzz=1e-1,memoizeDb='/tmp/gts-triax-packings.sqlite',useOBB=False))
from yade import qt
qt.View()
# --- Creating a sample of spheres
# definition of a predicate
from yade import pack
Lx = 10
Ly = 10
Lz = 6
pred = pack.inAlignedBox((0,0,0),(Lx,Ly,Lz))
# use of randomDensePack() function
nSpheres = 1500.0
poros=0.13 # apparently the value of porosity of samples generated by pack.randomDensePack
rMeanSpheres = pow(Lx*Ly*Lz*3.0/4.0*(1-poros)/(pi*nSpheres),1.0/3.0)
print('\nGenerating sphere sample, be patient')
sp = pack.randomDensePack(pred,radius=rMeanSpheres,rRelFuzz=0.3,memoizeDb='/tmp/gts-triax-packings.sqlite',returnSpherePack=True)
sp.toSimulation(color=(0.9,0.8,0.6),wire=False,material=mat)
print('Sphere sample generated !')
# --- The joint surface : half of the height
import gts
v1 = gts.Vertex(0 , 0 , Lz/2.0)
v2 = gts.Vertex(Lx, 0 , Lz/2.0)
v3 = gts.Vertex(Lx, Ly, Lz/2.0)
v4 = gts.Vertex(0 , Ly, Lz/2.0)
e1 = gts.Edge(v1,v2)
e2 = gts.Edge(v2,v4)
e3 = gts.Edge(v4,v1)
f1 = gts.Face(e1,e2,e3)
from yade import pack, export
pred = pack.inAlignedBox((0, 0, 0), (10, 10, 10))
O.bodies.append(
pack.randomDensePack(pred,
radius=1.,
rRelFuzz=.5,
spheresInCell=500,
memoizeDb='/tmp/pack.db'))
export.textExt('/tmp/test.txt',
format='x_y_z_r_attrs',
attrs=('b.state.pos.norm()', 'b.state.pos'),
comment='dstN dstV_x dstV_y dstV_z')
# text2vtk and text2vtkSection function can be copy-pasted from yade/py/export.py into separate py file to avoid executing yade or to use pure python
export.text2vtk('/tmp/test.txt', '/tmp/test.vtk')
export.text2vtkSection('/tmp/test.txt',
'/tmp/testSection.vtk',
point=(5, 5, 5),
normal=(1, 1, 1))
# z-oriented hyperboloid, length 20cm, diameter 10cm, skirt 8cm
# using spheres 7mm of diameter
concreteId = O.materials.append(
CpmMat(young=young,
frictionAngle=frictionAngle,
poisson=poisson,
density=4800,
sigmaT=sigmaT,
relDuctility=relDuctility,
epsCrackOnset=epsCrackOnset,
isoPrestress=isoPrestress))
spheres = pack.randomDensePack(pack.inHyperboloid(
(0, 0, -.5 * specimenLength), (0, 0, .5 * specimenLength),
.25 * specimenLength, .17 * specimenLength),
spheresInCell=2000,
radius=sphereRadius,
memoizeDb='/tmp/triaxPackCache.sqlite',
material=concreteId)
#spheres=pack.randomDensePack(pack.inAlignedBox((-.25*specimenLength,-.25*specimenLength,-.5*specimenLength),(.25*specimenLength,.25*specimenLength,.5*specimenLength)),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite')
O.bodies.append(spheres)
bb = uniaxialTestFeatures()
negIds, posIds, axis, crossSectionArea = bb['negIds'], bb['posIds'], bb[
'axis'], bb['area']
O.dt = dtSafety * PWaveTimeStep()
print 'Timestep', O.dt
mm, mx = [pt[axis] for pt in aabbExtrema()]
coord_25, coord_50, coord_75 = mm + .25 * (mx - mm), mm + .5 * (
mx - mm), mm + .75 * (mx - mm)
area_25, area_50, area_75 = approxSectionArea(
) from yade.params.table import * assert testType in ['cyl','cube'] # materials concMat = O.materials.append(CpmMat( young=young,frictionAngle=frictionAngle,poisson=poisson,sigmaT=sigmaT, epsCrackOnset=epsCrackOnset,relDuctility=relDuctility )) frictMat = O.materials.append(FrictMat( young=young,poisson=poisson,frictionAngle=frictionAngle )) # spheres pred = pack.inCylinder((0,0,0),(0,0,height),.5*width) if testType=='cyl' else pack.inAlignedBox((-.5*width,-.5*width,0),(.5*width,.5*width,height)) if testType=='cube' else None sp = pack.randomDensePack(pred,spheresInCell=2000,radius=rParticle,memoizeDb='/tmp/triaxTestOnCylinder.sqlite',color=(0,1,1),material=concMat) O.bodies.append(sp) # bottom and top of specimen. Will have prescribed velocity bot = [s for s in sp if s.state.pos[2]<rParticle*bcCoeff] top = [s for s in sp if s.state.pos[2]>height-rParticle*bcCoeff] for s in sp: s.shape.color = (0,1,1) vel = strainRate*(height-rParticle*2*bcCoeff) for s in bot: s.shape.color = (1,0,0) s.state.blockedDOFs = 'xyzXYZ' s.state.vel = (0,0,-vel) for s in top: s.shape.color = Vector3(0,1,0) s.state.blockedDOFs = 'xyzXYZ' s.state.vel = (0,0,vel)
# definition of a predicate
from yade import pack
Lx = 10
Ly = 10
Lz = 6
pred = pack.inAlignedBox((0, 0, 0), (Lx, Ly, Lz))
# use of randomDensePack() function
nSpheres = 1500.0
poros = 0.13 # apparently the value of porosity of samples generated by pack.randomDensePack
rMeanSpheres = pow(Lx * Ly * Lz * 3.0 / 4.0 * (1 - poros) / (pi * nSpheres),
1.0 / 3.0)
print('\nGenerating sphere sample, be patient')
sp = pack.randomDensePack(pred,
radius=rMeanSpheres,
rRelFuzz=0.3,
memoizeDb='/tmp/gts-triax-packings.sqlite',
returnSpherePack=True)
sp.toSimulation(color=(0.9, 0.8, 0.6), wire=False, material=mat)
print('Sphere sample generated !')
# --- The joint surface : half of the height
import gts
v1 = gts.Vertex(0, 0, Lz / 2.0)
v2 = gts.Vertex(Lx, 0, Lz / 2.0)
v3 = gts.Vertex(Lx, Ly, Lz / 2.0)
v4 = gts.Vertex(0, Ly, Lz / 2.0)
e1 = gts.Edge(v1, v2)
e2 = gts.Edge(v2, v4)
e3 = gts.Edge(v4, v1)
radius=1e-02
kwBoxes={'color':[1,0,0],'wire':True,'dynamic':False,'material':1}
O.bodies.append(utils.geom.facetCylinder(center=Vector3(0,0,L/2.), radius=l, height=L, orientation=Quaternion((1, 0, 0), 0),**kwBoxes))
###erase the top and bottom facet of the cylinder
for i in range(0,40,4):
O.bodies.erase(i)
for i in range(1,38,4):
O.bodies.erase(i)
predicate=inCylinder(centerBottom=Vector3(0,0,0), centerTop=Vector3(0,0,L+L/2.), radius=l-0.005)
sp=SpherePack()
sp=pack.randomDensePack(predicate, radius=radius, material='Smat', cropLayers=10, rRelFuzz=0.0, spheresInCell=100,returnSpherePack=True)
sp.toSimulation()
########################
#### WALL GENERATION ##
########################
O.materials.append(FrictMat(young=E,poisson=poisson,density=density,frictionAngle=frictionAngleW,label='Wmat'))
topPlate=utils.wall(position=hMax(2)+radius*10,sense=0, axis=2,color=Vector3(1,0,0),material='Wmat')
O.bodies.append(topPlate)
bottomPlate=utils.wall(position=0,sense=0, axis=2,color=Vector3(1,0,0),material='Wmat')
O.bodies.append(bottomPlate)
######################
#### MOVE TOP WALL ##
######################
# use the ScGeom variant scGeom=False ) from yade.params.table import * if 'description' in O.tags.keys(): O.tags['id']=O.tags['id']+O.tags['description'] # make geom; the dimensions are hard-coded here; could be in param table if desired # z-oriented hyperboloid, length 20cm, diameter 10cm, skirt 8cm # using spheres 7mm of diameter concreteId=O.materials.append(CpmMat(young=young,frictionAngle=frictionAngle,poisson=poisson,density=4800,sigmaT=sigmaT,crackOpening=crackOpening,epsCrackOnset=epsCrackOnset,isoPrestress=isoPrestress)) spheres=pack.randomDensePack(pack.inHyperboloid((0,0,-.5*specimenLength),(0,0,.5*specimenLength),.25*specimenLength,.17*specimenLength),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite',material=concreteId) #spheres=pack.randomDensePack(pack.inAlignedBox((-.25*specimenLength,-.25*specimenLength,-.5*specimenLength),(.25*specimenLength,.25*specimenLength,.5*specimenLength)),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite') O.bodies.append(spheres) bb=uniaxialTestFeatures() negIds,posIds,axis,crossSectionArea=bb['negIds'],bb['posIds'],bb['axis'],bb['area'] O.dt=dtSafety*PWaveTimeStep() print 'Timestep',O.dt mm,mx=[pt[axis] for pt in aabbExtrema()] coord_25,coord_50,coord_75=mm+.25*(mx-mm),mm+.5*(mx-mm),mm+.75*(mx-mm) area_25,area_50,area_75=approxSectionArea(coord_25,axis),approxSectionArea(coord_50,axis),approxSectionArea(coord_75,axis) O.engines=[ ForceResetter(), InsertionSortCollider([Bo1_Sphere_Aabb(aabbEnlargeFactor=intRadius,label='is2aabb'),],verletDist=.05*sphereRadius), InteractionLoop(
# define the section shape as polygon in 2d; repeat first point at the end to close the polygon
sq2 = sqrt(2)
poly = ((3 + 0.1, 0), (3 + 0, 0.1), (3 + sq2, 0.1 + sq2), (3 + 0.1 + sq2, sq2), (3 + 0.1, 0))
# pylab.plot(*zip(*poly)); pylab.xlim(xmin=0); pylab.grid(); pylab.title('Meridian of the revolution surface\n(close to continue)'); pylab.gca().set_aspect(aspect='equal',adjustable='box'); pylab.show()
thetas = arange(0, pi / 8, pi / 24)
pts = pack.revolutionSurfaceMeridians(
[poly for theta in thetas], thetas, origin=Vector3(-4, 0, -1), orientation=Quaternion.Identity
)
surf = pack.sweptPolylines2gtsSurface(pts, capStart=True, capEnd=True, threshold=1e-4)
O.bodies.append(pack.gtsSurface2Facets(surf, color=(1, 0, 1)))
# fill this solid with triaxial packing; it will compute minimum-volume oriented bounding box
# to minimize the number of throw-away spheres.
# It does away with about 3k spheres for radius 3e-2
O.bodies.append(
pack.randomDensePack(pack.inGtsSurface(surf), radius=3e-2, rRelFuzz=1e-1, memoizeDb="/tmp/gts-triax.sqlite")
)
# translate the surface away and pack it again with sphere, but without the oriented bounding box (useOBB=False)
# Here, we need 20k spheres (with more or less the same result)
surf.translate(0, 0, 1)
O.bodies.append(pack.gtsSurface2Facets(surf, color=(1, 0, 0)))
O.bodies.append(
pack.randomDensePack(
pack.inGtsSurface(surf), radius=3e-2, rRelFuzz=1e-1, memoizeDb="/tmp/gts-triax-packings.sqlite", useOBB=False
)
)
from yade import qt
qt.View()
# using spheres 7mm of diameter
concreteId = O.materials.append(
CpmMat(young=young,
frictionAngle=frictionAngle,
poisson=poisson,
density=4800,
sigmaT=sigmaT,
relDuctility=relDuctility,
epsCrackOnset=epsCrackOnset,
isoPrestress=isoPrestress))
sps = SpherePack()
sp = pack.randomDensePack(pack.inHyperboloid(
(0, 0, -.5 * specimenLength), (0, 0, .5 * specimenLength),
.25 * specimenLength, .17 * specimenLength),
spheresInCell=2000,
radius=sphereRadius,
memoizeDb='/tmp/triaxPackCache.sqlite',
returnSpherePack=True)
#sp=pack.randomDensePack(pack.inAlignedBox((-.25*specimenLength,-.25*specimenLength,-.5*specimenLength),(.25*specimenLength,.25*specimenLength,.5*specimenLength)),spheresInCell=2000,radius=sphereRadius,memoizeDb='/tmp/triaxPackCache.sqlite',returnSpherePack=True)
sp.toSimulation(material=concreteId)
bb = uniaxialTestFeatures()
negIds, posIds, axis, crossSectionArea = bb['negIds'], bb['posIds'], bb[
'axis'], bb['area']
O.dt = dtSafety * PWaveTimeStep()
print 'Timestep', O.dt
mm, mx = [pt[axis] for pt in aabbExtrema()]
coord_25, coord_50, coord_75 = mm + .25 * (mx - mm), mm + .5 * (
mx - mm), mm + .75 * (mx - mm)
area_25, area_50, area_75 = approxSectionArea(
from yade import pack """Simple script to create tunnel with random dense packing of spheres. The tunnel is difference between an axis-aligned box and cylinder, or which axis is going through the bottom wall (-z) of the box. The tunnel hole is oriented along +y, the face is in the xz plane. The first you run this scipt, a few minutes is neede to generate the packing. It is saved in /tmp/triaxPackCache.sqlite and at next time it will be only loaded (fast). """ # set some geometry parameters: domain box size, tunnel radius, radius of particles boxSize=Vector3(5,8,5) tunnelRad=2 rSphere=.1 # construct spatial predicate as difference of box and cylinder: # (see scripts/test/pack-predicates.py for details) # # http://beta.arcig.cz/~eudoxos/yade/epydoc/yade._packPredicates.inAlignedBox-class.html # http://beta.arcig.cz/~eudoxos/yade/epydoc/yade._packPredicates.inCylinder-class.html pred=pack.inAlignedBox((-.5*boxSize[0],-.5*boxSize[1],0),(.5*boxSize[0],.5*boxSize[1],boxSize[2])) - pack.inCylinder((-.5*boxSize[0],0,0),(.5*boxSize[0],0,0),tunnelRad) # Use the predicate to generate sphere packing inside # # http://beta.arcig.cz/~eudoxos/yade/epydoc/yade.pack-module.html#randomDensePack O.bodies.append(pack.randomDensePack(pred,radius=rSphere,rRelFuzz=.3,memoizeDb='/tmp/triaxPackCache.sqlite',spheresInCell=3000)) from yade import qt qt.Controller() qt.View()
