Distinct/Discrete Element Method

Clay Wood, Daulet Sagzhanov, Xuanchi Li

Outline
• Introduction
• What is DEM?
• Brief Historical Background
• Advantages/Disadvantages
• Applications Overview
• Governing Equations
• Newtonian Mechanics
• Surface/Material Interactions
• General DEM Workflow
• DEM Simulations
• 1D Hand Calculation
• 2D Example
• Applications
• Simple Shear
• Granular Avalanche
• Mixing Concrete
• Grains Falling in Hopper
Introduction
Introduction: What is DEM?
Distinct / Discrete Element Method (DEM)
• a way of simulating discrete matter
• a numerical model capable of describing the mechanical behaviour of assemblies of discs
and spheres
• a particle-scale numerical method for modeling the bulk behavior of
• granular materials and many geomaterials (coal, ores, soil, rocks, aggregates)
• capture dual nature of materials
Characteristic example
Historical Background
 Advantages and Disadvantages of DEM

Advantages: Disadvantages:
• Modeling Movement of Individual Particles • Complex Particle Geometries and Arrangements
• Full stress and strain tensors can be measured • Roughness, Texture
• Time Steps • Grain Crushing, Particle Breakage
• Progressive Failure • Non-Idealized Contacts
DEM Applications
Civil Engineering (Geotechnical Engineering)
Chemical Engineering
Oil and gas production
Geomechanics
Mineral processing
Biochemical Engineering
Powder metallurgy
Agricultural Industry
Governing Equations: Newtonian Mechanics
𝑭
  𝑡𝑟𝑎𝑛𝑠 , 1 𝑭
  𝑡𝑟𝑎𝑛𝑠 , 2
 𝑭𝑡𝑟𝑎𝑛𝑠 =𝑚 𝒖
¨

𝑚1
  𝑚
  2

𝝎
  ¨𝟏 𝝎𝟐
 ¨

𝑭
  𝑟𝑜𝑡 =𝑻 = 𝐼 𝝎
¨
𝑛 𝑝𝑎𝑟𝑡
𝐼  1  2  
𝑭𝑡𝑜𝑡 =∑ 𝑭 𝑡𝑟𝑎𝑛𝑠 ,𝑖 + 𝑭 𝑟𝑜𝑡 , 𝑖
𝑖
Governing Equations: Other Interactions

𝑭
  𝑠𝑝𝑟𝑖𝑛𝑔 =𝑘 Δ 𝑥
Governing Equations: Conservation of Momentum

𝑭=𝑚
  𝒖¨ 𝑘𝒖𝑡
 

𝑭=𝑘
  𝒖 ∑ 𝑭=𝟎
  𝑚 ¨ 𝑡 +𝑘 𝒖𝑡 =0 ⟹ 𝒖
𝒖 ¨ 𝑡 =−
𝑚
Governing Equations (cont-d):
- Numerical Integration:
Model Workflow
- Newton’s Second Law of Motion
- Force Displacement Law

Force Displacement Laws

(e.g. stiffness, friction)

Force Boundary Displacement/Velocity

Condition Boundary Conditions

Newton’s Second Law

of Motion
1D DEM
Hand Calculation Example (1-D DEM Example)
● 1-D Bouncing Ball Matlab Simulation
● Bouncing ball released from a height of 8m
● With air resistance particles are not assumed to be elastic
● Governing Equation
Hand Calculation Example Continued, Matlab Code
clear, format compact close all
height=8; % Height in meters plot([0 length(h)],zeros(1,2),'k','LineWidth',2) % plot the
v_t=10; % Terminal velocity in meters per second floor
g=9.8; % Gravitational Acceleration hold on
C_R=0.9; % Coefficient of restitution ylim([-0.05*height 1.2*height]); % set the vertical limits
h(1)=height; % Vertical height to release the ball from % Plot the first drop as a half parabola
b=1; % Initialize bounce number traj=@(x) h(1).*(x+0.5).*(x-0.5)./((0+0.5).*(0-0.5));
for b=1:8 % Loop through three bounces plot(0:0.05:0.5,traj(0:0.05:0.5),'ro','MarkerSize',15)
v_impact(b)=v_t*sqrt(1-exp(-2*g*h(b)/(v_t^2))); % Plot each bounce as a full parabola
v_r(b)=C_R*v_impact(b)*(1-0.01*rand()); for b=1:length(h)-1
h(b+1)=-((v_t^2)/g)*log(cos(atan(v_r(b)/v_t))); traj=@(x) h(b+1).*(x-(b-0.5)).*(x-(b+0.5))./((b-(b-
end 0.5)).*(b-(b+0.5)));
sprintf('The height of the third bounce is %0.3f meters.', h(4)) plot((b-0.5):0.05:(b+0.5),traj((b-0.5):0.05:
(b+0.5)),'ro','MarkerSize',15)
end
title('Solution of a Bouncing Ball');
xlabel('Time t');
ylabel('Vertical Position');
legend('Hand Calculation');
v_impact =[9.2690                     
vr =[8.7666
                 6.5921       6.2194
                 5.2813       4.9992
                 4.4716       4.2167
                 3.8854       3.6766
                 3.4507       3.2558
                 3.0959       2.9204
                 2.8033       2.6513
                 2.5628       2.4342
                 2.3651]       2.2394]
2D DEM
 2D DEM Example

Evolution of system of 25 particles

1. Particles have initial velocity tensor.
2. Particles fall, vinitial dominated by g.
3. Bouncing dictated by E (Young’s
modulus) between particles and
sides of box.
 2D DEM Example

Evolution of system of 25 particles

1. Particles have initial velocity tensor.
2. Particles fall, vinitial dominated by g.
3. Bouncing dictated by E (Young’s
modulus) between particles and
sides of box.
 2D DEM: “Spatial Setup and Solver”
% physical parameters → global definitions
%number of particles
n_part=25;
% initialize radius, mass, & gravity
global rad, rad(1:n_part)=0.5;
global m, m(1:n_part)=1;
global g, g=-9.81;
% Young’s modulus
global E, E=10000;
% size of “bounding box”→ global definition
global lmaxx, lmaxx=n_part/2+1;
global lminx, lminx=0;
global lmaxy, lmaxy=n_part/2+1;
global lminy, lminy=0;
...
... % initialize positions and velocities
% initialize positions and velocities % set timescale for simulation (arb units)
% random number generator t_end=5;
rng('shuffle','combRecursive'); % create vector of time and particle position.
% create/sort particle centers: x,y Use ode113 to solve function ‘dem2D’.
r0_x=2*mod([1:n_part],5)+1; See ‘dem2D’ for details of particle physics
r0_y=sort(r0_x); [t,y]=ode113('dem2D',[0:0.05:t_end],y0);
% give each particle initial random velocity
v0_x=rand(size(r0_x))-0.5;
v0_y=rand(size(r0_y))-0.5;
% array of spatial vector components
y0(1:4:4*n_part-3)=r0_x;
y0(2:4:4*n_part-2)=v0_x;
y0(3:4:4*n_part-1)=r0_y;
y0(4:4:4*n_part)=v0_y;
 2D DEM: “Spatial Setup and Solver”
% physical parameters → global definitions ... % initialize positions and velocities
DefineofPhysical
%number particles Parameters: % initialize positions and velocities % set timescale for simulation (arb units)
n_part=25; % random number generator t_end=5;
● # particles
% initialize radius, mass, & gravity rng('shuffle','combRecursive'); % create vector of time and particle position.
● Mass
global rad, rad(1:n_part)=0.5; % create/sort particle centers: x,y Use ode113 to solve function ‘dem2D’.
● Radius
global m, m(1:n_part)=1; r0_x=2*mod([1:n_part],5)+1; See ‘dem2D’ for details of particle physics
● Gravity
global g, g=-9.81; r0_y=sort(r0_x); [t,y]=ode113('dem2D',[0:0.05:t_end],y0);
● Elasticity
% Young’s modulus % give each particle initial random velocity
global E, E=10000; v0_x=rand(size(r0_x))-0.5;
v0_y=rand(size(r0_y))-0.5;
% size of “bounding box”→ global definition % array of spatial vector components
y0(1:4:4*n_part-3)=r0_x;
global lmaxx, lmaxx=n_part/2+1;
y0(2:4:4*n_part-2)=v0_x;
global lminx, lminx=0; y0(3:4:4*n_part-1)=r0_y;
global lmaxy, lmaxy=n_part/2+1; y0(4:4:4*n_part)=v0_y;
global lminy, lminy=0;
...
 2D DEM: “Spatial Setup and Solver”
% physical parameters → global definitions ... % initialize positions and velocities
DefineofPhysical
%number particles Parameters: % initialize positions and velocities % set timescale for simulation (arb units)
n_part=25; % random number generator t_end=5;
● # particles
% initialize radius, mass, & gravity rng('shuffle','combRecursive'); % create vector of time and particle position.
● Mass
global rad, rad(1:n_part)=0.5; % create/sort particle centers: x,y Use ode113 to solve function ‘dem2D’.
● Radius
global m, m(1:n_part)=1; r0_x=2*mod([1:n_part],5)+1; See ‘dem2D’ for details of particle physics
● Gravity
global g, g=-9.81; r0_y=sort(r0_x); [t,y]=ode113('dem2D',[0:0.05:t_end],y0);
● Elasticity
% Young’s modulus % give each particle initial random velocity
global E, E=10000; v0_x=rand(size(r0_x))-0.5;
v0_y=rand(size(r0_y))-0.5;
% size of “bounding box”→ global definition % array of spatial vector components
y0(1:4:4*n_part-3)=r0_x;
global lmaxx, lmaxx=n_part/2+1;
Define System Size: y0(2:4:4*n_part-2)=v0_x;
global lminx, lminx=0; y0(3:4:4*n_part-1)=r0_y;
global lmaxy, lmaxy=n_part/2+1; y0(4:4:4*n_part)=v0_y;
(X,Y):
global 0→
lminy, #part/2
lminy=0; +1
...
 2D DEM: “Spatial Setup and Solver”
% physical parameters → global definitions ... % initialize positions and velocities
DefineofPhysical
%number particles Parameters: % initialize positions and velocities % set timescale for simulation (arb units)
n_part=25; % random number generator t_end=5;
● # particles
% initialize radius, mass, & gravity rng('shuffle','combRecursive'); % create vector of time and particle position.
● Mass
global rad, rad(1:n_part)=0.5; % create/sort particle centers: x,y Use ode113 to solve function ‘dem2D’.
● Radius
global m, m(1:n_part)=1; Set Particle Position/Velocity:
r0_x=2*mod([1:n_part],5)+1; See ‘dem2D’ for details of particle physics
● Gravity
global g, g=-9.81; r0_y=sort(r0_x); [t,y]=ode113('dem2D',[0:0.05:t_end],y0);
● Elasticity
% Young’s modulus % give each particle initial random velocity
create grid of particle centers, r0
global E, E=10000; v0_x=rand(size(r0_x))-0.5;
v0_y=rand(size(r0_y))-0.5;
% size of “bounding box”→ global definition randomize velocities,
% array of spatial v0
vector components
y0(1:4:4*n_part-3)=r0_x;
global lmaxx, lmaxx=n_part/2+1;
Define System Size: y0(2:4:4*n_part-2)=v0_x;
y0 = [r0xi v0xi r0yi v0yi …]
global lminx, lminx=0; y0(3:4:4*n_part-1)=r0_y;
global lmaxy, lmaxy=n_part/2+1; y0(4:4:4*n_part)=v0_y;
(X,Y):
global 0→
lminy, #part/2
lminy=0; +1
...
 2D DEM: “Spatial Setup and Solver”
% physical parameters → global definitions ...
DefineofPhysical  % initialize positions and velocities
%number particles Parameters: % initialize positions and velocities % set timescale for simulation (arb units)
n_part=25; % random number generator t_end=5;
● # particles
% initialize radius, mass, & gravity
● Mass
rng('shuffle','combRecursive'); Solve
% createfor u, ofdu/dt,
vector du^2/dt^2
time and for each
particle position. Δt:
global rad, rad(1:n_part)=0.5; % create/sort particle centers: x,y Use ode113 to solve function ‘dem2D’.
● Radius
global m, m(1:n_part)=1; Set Particle Position/Velocity:
r0_x=2*mod([1:n_part],5)+1; See ‘dem2D’ for details of particle physics
● Gravity
global g, g=-9.81; r0_y=sort(r0_x); Define physical interactions as
[t,y]=ode113('dem2D',[0:0.05:t_end],y0);
● Elasticity
% Young’s modulus % give each particle initial random velocity physics_func
create grid of particle centers, r0
global E, E=10000; v0_x=rand(size(r0_x))-0.5;
v0_y=rand(size(r0_y))-0.5; solveODE(physics_func, (t0:Δt:tend), y0)
% size of “bounding box”→ global definition randomize velocities,
% array of spatial v0
vector components
y0(1:4:4*n_part-3)=r0_x; → [t y]
global lmaxx, lmaxx=n_part/2+1;
Define System Size: y0(2:4:4*n_part-2)=v0_x;
y0 = [r0xi v0xi r0yi v0yi …]
global lminx, lminx=0; y0(3:4:4*n_part-1)=r0_y; y=[ ]
global lmaxy, lmaxy=n_part/2+1; y0(4:4:4*n_part)=v0_y;
(X,Y):
global 0→
lminy, #part/2
lminy=0; +1
...
2D DEM: “Particle Physics Engine”
function [dydt]=dem2D(t,y); % Particle-wall Interaction
global m rad E lmax lmin lmaxx lminx lmaxy lminy g n_part if (r1(1)-rad1)<lminx
a=zeros(2,n_part); a(1,i_part)=a(1,i_part)-E*((r1(1)-rad1)-lminx);
for i_part=1:n_part end
r1=[y(4*i_part-3) if (r1(1)+rad1)>lmaxx
y(4*i_part-1)]; % position of first particle a(1,i_part)=a(1,i_part)-E*((r1(1)+rad1)-lmaxx);
rad1=rad(i_part); end
% Particle-Particle Interaction if (r1(2)-rad1)<lminy
for j_part=i_part+1:n_part a(2,i_part)=a(2,i_part)-E*((r1(2)-rad1)-lminy);
r2=[y(4*j_part-3) end
y(4*j_part-1)]; % position of second particle if (r1(2)+rad1)>lmaxy
rad2=rad(j_part); a(2,i_part)=a(2,i_part)-E*((r1(2)+rad1)-lmaxy);
if (norm(r1-r2)<(rad(i_part)+rad(j_part))) end
forcemagnitude=E*abs(norm(r1-r2)-(rad1+rad2)); end
forcedirection=(r1-r2)/norm(r1-r2); a(2,:)=a(2,:)+g;
f=forcemagnitude*forcedirection; dydt=zeros(4*n_part,1);
a(:,i_part)=a(:,i_part)+f; dydt(1:4:4*n_part-3)=y(2:4:4*n_part-2);
a(:,j_part)=a(:,j_part)-f; dydt(2:4:4*n_part-2)=a(1,:)./m;
end dydt(3:4:4*n_part-1)=y(4:4:4*n_part);
end dydt(4:4:4*n_part)=a(2,:)./m;
return
2D DEM: “Particle Physics Engine”
function [dydt]=dem2D(t,y); % Particle-wall Interaction
global m rad E lmax lmin lmaxx lminx lmaxy lminy g n_part if (r1(1)-rad1)<lminx
a=zeros(2,n_part); a(1,i_part)=a(1,i_part)-E*((r1(1)-rad1)-lminx);
for i_part=1:n_part end
Pull in global variables.
r1=[y(4*i_part-3) if (r1(1)+rad1)>lmaxx
Create accel vector: [x-comp y-comp; 1 : #part]
y(4*i_part-1)]; % position of first particle a(1,i_part)=a(1,i_part)-E*((r1(1)+rad1)-lmaxx);
rad1=rad(i_part); end
populate list of particle
% Particle-Particle radii = r1
Interaction if (r1(2)-rad1)<lminy
for j_part=i_part+1:n_part a(2,i_part)=a(2,i_part)-E*((r1(2)-rad1)-lminy);
populate list of adjacent particles radii = r2
r2=[y(4*j_part-3) end
y(4*j_part-1)]; % position of second particle if (r1(2)+rad1)>lmaxy
If r1 - r2 < particle radius
rad2=rad(j_part); a(2,i_part)=a(2,i_part)-E*((r1(2)+rad1)-lmaxy);
• Fmag if=(norm(r1-r2)<(rad(i_part)+rad(j_part)))
Young’s Mod * amount of particle overlap end
• Fdir = particle overlap / norm(particle overlap)
forcemagnitude=E*abs(norm(r1-r2)-(rad1+rad2)); end
forcedirection=(r1-r2)/norm(r1-r2);
• F = Fmag * Fdir a(2,:)=a(2,:)+g;
f=forcemagnitude*forcedirection; dydt=zeros(4*n_part,1);
• Populate accel vector
a(:,i_part)=a(:,i_part)+f; dydt(1:4:4*n_part-3)=y(2:4:4*n_part-2);
a(:,j_part)=a(:,j_part)-f; dydt(2:4:4*n_part-2)=a(1,:)./m;
end dydt(3:4:4*n_part-1)=y(4:4:4*n_part);
end dydt(4:4:4*n_part)=a(2,:)./m;
return
2D DEM: “Particle Physics Engine”
function [dydt]=dem2D(t,y);   % Particle-wall Interaction
global m rad E lmax lmin lmaxx lminx lmaxy lminy g n_part if (r1(1)-rad1)<lminx
a=zeros(2,n_part); a(1,i_part)=a(1,i_part)-E*((r1(1)-rad1)-lminx);
for i_part=1:n_part end
Pull in global variables.
r1=[y(4*i_part-3) if (r1(1)+rad1)>lmaxx
Create accel vector: [x-comp y-comp; 1 : #part] Particle-wall interaction:
y(4*i_part-1)]; % position of first particle a(1,i_part)=a(1,i_part)-E*((r1(1)+rad1)-lmaxx);
rad1=rad(i_part); end
populate list of particle
% Particle-Particle radii = r1
Interaction
If particle center – particle radius < wall coordinate
if (r1(2)-rad1)<lminy
for j_part=i_part+1:n_part • Fmaga(2,i_part)=a(2,i_part)-E*((r1(2)-rad1)-lminy);
= Young’s Mod * amount of particle overlap
populate list of adjacent particles radii = r2
r2=[y(4*j_part-3) • Fdirend = particle overlap / norm(particle overlap)
y(4*j_part-1)]; % position of second particle • F =if (r1(2)+rad1)>lmaxy
Fmag * Fdir
If r1 - r2 < particle radius
rad2=rad(j_part); a(2,i_part)=a(2,i_part)-E*((r1(2)+rad1)-lmaxy);
• Repopulate accel vector
• Fmag if=(norm(r1-r2)<(rad(i_part)+rad(j_part)))
Young’s Mod * amount of particle overlap end
• Fdir = particle overlap / norm(particle overlap)
forcemagnitude=E*abs(norm(r1-r2)-(rad1+rad2)); Add end
g to all accely & / particle mass
forcedirection=(r1-r2)/norm(r1-r2);
• F = Fmag * Fdir a(2,:)=a(2,:)+g;
f=forcemagnitude*forcedirection; dydt=zeros(4*n_part,1);
• Populate accel vector Populate dydt vector = [ ]
a(:,i_part)=a(:,i_part)+f; dydt(1:4:4*n_part-3)=y(2:4:4*n_part-2);
a(:,j_part)=a(:,j_part)-f; dydt(2:4:4*n_part-2)=a(1,:)./m;
end dydt(3:4:4*n_part-1)=y(4:4:4*n_part);
end dydt(4:4:4*n_part)=a(2,:)./m;
return
2D DEM: High E
2D DEM: Low E
 2D DEM Example: Limitations

Made the following assumptions/simplifications:

● No dissipative forces
○ Friction: (Amantons’ Law or Hertzian Contact Theory)
○ Ambient fluid resistance (air/liquid)
● No particle rotation
○ Would need to calculate torque, moment of intertia...
Applications: Real Systems
Applications: Shearing Jammed Granular System
Applications: Granular Avalanche
Applications: Granular Force Networks
Applications: Concrete Mixing
Applications: Grains Falling into Hopper
Applications: Real Systems
Thank you
Citations
Slides 5-7&13: Diagrams from EDMTM Webinar

1D DEM: adapted from MATLAB “Bouncing Ball” Example

2D DEM: adapted from “Understanding the Discrete Element Method”, Matuttis, H., Chen, J.

Slide 34: https://www.youtube.com/watch?v=ruFsRGAw2Rw

Slide 35: Cambridge-Berkley Geomechanics Research Group, https://www.youtube.com/watch?v=Rlb50Ed6H6Y

Slide 36: Bob Behringer, Center for Nonlinear and Complex Systems, https://www.youtube.com/watch?v=kxmqRQjeyDA&feature=youtu.be

Slide 37: SimulationIABWeimar, https://www.youtube.com/watch?v=2szJ38qcZro

Slide 38: https://www.youtube.com/watch?v=3EbE45qGG6s

Slide 39: Helix Technologies, https://www.youtube.com/watch?v=9_-2tsoImJM&feature=youtu.be

Extras…
Governing Equations:

DEM uses two types of governing

laws:
- Newton’s Second Law of Motion
F = MA
- Force-Displacement Law
Hooke’s law, friction etc…
- Time Step