yade-users team mailing list archive

[Jan Stránský <question293295@xxxxxxxxxxxxxxxxxxxxx>]

Question #293295 on Yade changed:
https://answers.launchpad.net/yade/+question/293295

    Status: Open => Answered

Jan Stránský proposed the following answer:
Hi Varun,
I see the main problem in how to correctly create cohesive interactions
between particles with CohFrictMat. Unfortunately, I am not familiar with
this model. You have to wait for somebody experienced with the model :-) or
you can search CohFrictMat in previous questions [1]..
cheers
Jan

[1] https://answers.launchpad.net/yade


2016-05-04 23:42 GMT+02:00 VG <question293295@xxxxxxxxxxxxxxxxxxxxx>:

> New question #293295 on Yade:
> https://answers.launchpad.net/yade/+question/293295
>
> Hello everyone,
>
> Here is a description of the problem I am trying to solve:
>
> -- I have a granular sample with spherical particles of diameters D1, D2,
> D3 etc. All of such big particles (lets call them agglomerates) are
> composed of smaller particles of diameter 'd', since d is the smallest
> particle size of interest.
>
> -- Initially, within each big spherical particle, all the smaller
> particles should be densely packed and connected with cohesive bonds
> (CohFrictMat). As the loading is applied, the initially defined cohesive
> bonds within each big sphere will break progressively leading to smaller
> fragments.
>
> Now, the problem I am facing: Initially, within a single big sphere
> itself, sometimes there are particles which are shown not to have any
> cohesive interaction, leaving the small individual particle free to fly.
> How can I alleviate this problem ?
>
> This is a follow-up question to
> https://answers.launchpad.net/yade/+question/292846
>
> Here is the script:
>
>
> from yade import pack
>
>
> #############################################################################
> # Set up run
>
> #############################################################################
> run_name="PeriodicCohesive_MWE"
> data_root_dir="."
>
>
>
>
> #############################################################################
> # Materials
>
> #############################################################################
> plate_material=FrictMat(
>         young=200e9
>         ,poisson=0.3
>         ,density=8000.
>         ,frictionAngle=radians(30)
>         ,label='plate_mat')
>
> O.materials.append(plate_material)
>
>
> sample_material=CohFrictMat(
>         young=4e9
>         ,poisson=0.25
>         ,density=1400
>         ,frictionAngle=radians(30)
>         ,normalCohesion=1e8*1.2
>         ,shearCohesion=.4e8*1.2
>         ,momentRotationLaw=True
>         ,label='sample_mat')
> O.materials.append(sample_material)
>
>
>
>
> #############################################################################
> # Component dimensions and operating condition
>
> #############################################################################
> # Granular material dimension
> sample_diameter=2e-4
> #sample_diameter=126e-6
> sample_radius=sample_diameter/2.0
> # Sub-particle dimension
> particle_diameter=74e-6
> particle_radius=particle_diameter/2.
>
>
> #############################################################################
> # grinding plate dimension
>
> #############################################################################
>
> rotvel=2./3.*pi*(1.5+0.5)*.254
>
>
> #############################################################################
> # Periodic Geometry
>
> #############################################################################
>
>
> # Set up periodic boundary conditions
> O.periodic=True
> xExt=4*sample_diameter
> yExt=3.*sample_diameter*2 #to block the periodicity in y direction
> zExt=xExt
> xLim=xExt
> yLim=yExt/4
> zLim=zExt
> O.cell.hSize=Matrix3(
>         xExt, 0, 0,
>         0, yExt, 0,
>         0, 0, zExt)
>
>
> length=xExt
> height=yExt
> width=zExt
>
> # Top and bottom plate thickness
> thickness=0.1*height
>
>
>
>
>
> bottomBoxes = []
> for ix in (0,1,2):
>         for iz in (0,1,2):
>                 bottomBoxes.append(box( # create 3x3 boxes with 1/3 cell
> size
>                         center=(xExt/6.*(1+2*ix),yLim -
> thickness/2.0,zExt/6.*(1+2*iz))
>                         ,extents=(xExt/6.,thickness/2.0,zExt/6.)
>                         ,wire=False
>                         ,material='plate_mat'
>                 ))
>
> bottom_id,bottom_ids = O.bodies.appendClumped(bottomBoxes) # bottom_id is
> the clump id,
>
>
> O.bodies[bottom_id].state.blockedDOFs='xyzXYZ'
>
>
>
>
> #############################################################################
> # Particle Packing
>
> #############################################################################
>
> min_corner= (0,yLim,0)
> max_corner= (xLim, yExt-yLim, zLim)
>
> sp=pack.SpherePack()
> sp.makeCloud( min_corner,max_corner, rMean=sample_radius, periodic=False,
> seed=1)
>
> print "Generated ",len(sp)," aggregates"
>
> ###########################################
> # Sample
> ###########################################
> for s in sp:
>         sphere=pack.inSphere((s[0][0],s[0][1],s[0][2]),s[1])
>         sp1=pack.randomDensePack(
>                 sphere
>                 ,spheresInCell=2000
>                 ,radius=particle_radius
>                 ,memoizeDb='/tmp/triaxPackCache.sqlite'
>                 ,returnSpherePack=True
>         )
>
>         sp1.toSimulation(material='sample_mat',color=(0.9,0.8,0.6))
>         print 'Generated ',len(sp1),' particles'
>
> Gl1_Sphere(stripes=True)
>
> #########
>  # Top
> #########
> topBoxes = []
> for ix in (0,1,2):
>         for iz in (0,1,2):
>                 topBoxes.append(box( # create 3x3 boxes with 1/3 cell size
>                         center=(xExt/6.*(1+2*ix),yExt - yLim +
> thickness/2.0,zExt/6.*(1+2*iz))
>                         ,extents=(xExt/6.,thickness/2.0,zExt/6.)
>                         ,wire=False
>                         ,material='plate_mat'
>                 ))
>
> top_id,top_ids = O.bodies.appendClumped(topBoxes) # top_id is the clump id,
>
>
> O.bodies[top_id].state.blockedDOFs='xzXYZ'
>
>
>
> plate_downforce=-0.036
>
> O.forces.addF(top_id,(0,plate_downforce,0),permanent=True)
>
> O.bodies[top_id].state.vel[0]= rotvel
>
>
>
> #############################################################################
> # Run the simulation
>
> #############################################################################
> r_int = 1.0 # interaction radius
>
> O.dt=0.5*PWaveTimeStep()
>
> O.engines=[
>         ForceResetter(),
>         InsertionSortCollider([
>                 Bo1_Sphere_Aabb(aabbEnlargeFactor=r_int, label='bo1s')
>                 ,Bo1_Box_Aabb()
>         ], allowBiggerThanPeriod=True
>         ),
>         InteractionLoop(
>         [Ig2_Sphere_Sphere_ScGeom6D(interactionDetectionFactor=r_int,
> label='ig2ss')
>         ,Ig2_Box_Sphere_ScGeom6D()
>         ],
>         [Ip2_FrictMat_FrictMat_FrictPhys()
>
> ,Ip2_CohFrictMat_CohFrictMat_CohFrictPhys(setCohesionNow=True,label="cohesiveIp")
>         ],
>         [Law2_ScGeom_FrictPhys_CundallStrack()
>         ,Law2_ScGeom6D_CohFrictPhys_CohesionMoment()
>         ]
>         ), # End InteractionLoop
>         NewtonIntegrator(damping=0.8,gravity=(0.,0.,0.)),
>
> ]
>
> O.step()
>
> def addBodyToAggreg(body,aggreg): # auxiliary function, add body
> [yade.Body instance] and all its neighbors into aggreg (python set instance)
>         if body.id in aggreg: # do nothing if b is already in aggreg ...
>                 return
>         aggreg.add(body.id) # ... otherwise add it to aggreg
>         intrs = body.intrs()
>         for i in intrs: # and add also all its neighbors ...
>                 if not isinstance(i.phys,CohFrictPhys): # ... but only
> that connected with CohFrictPhys interactions
>                         continue
>                 if i.phys.cohesionBroken: # ... but only not yet broken
>                         continue
> #               if not i.isReal:
> #                       continue
>                 i2 = i.id1 if i.id2==body.id else i.id2 # choose the
> other body of interaction
>                 b2 = O.bodies[i2]
>                 addBodyToAggreg(b2,aggreg) # and add it and all its
> neighbors to aggreg
>
> def aggregs(): # actual function to detect standalone aggregates
>         ids = set(b.id for b in O.bodies if isinstance(b.shape,Sphere)) #
> first make a set of all spheres ids
>         ret = []
>         while len(ids)>0: # while there are still some particles not
> assigned to any aggregate ...
>                 i = ids.pop() # ... choose one random ...
>                 b = O.bodies[i]
>                 a = set() # ... create new aggregate (set of sphere ids)
>                 addBodyToAggreg(b,a) # ... and add the sphere together
> with all its neigbors to aggregate
>                 for bid in a: # delete all used ids from ids
>                         ids.discard(bid)
>                 ret.append(a)
>         return ret
>
> aggs = aggregs()
> for a in aggs:
>         print a
>
>
> I would really appreciate your help.
>
> Thanks
> Varun
>
> You received this question notification because your team yade-users is
> an answer contact for Yade.
>
> _______________________________________________
> Mailing list: https://launchpad.net/~yade-users
> Post to     : yade-users@xxxxxxxxxxxxxxxxxxx
> Unsubscribe : https://launchpad.net/~yade-users
> More help   : https://help.launchpad.net/ListHelp
>

-- 
You received this question notification because your team yade-users is
an answer contact for Yade.