LIGGGHTS vs LAMMPS for DEM: validation and scaling on cloudHPC

TL;DR
- We ran the same granular physics in LIGGGHTS-PUBLIC 3.8.0 and in LAMMPS (GRANULAR package) on cloudHPC: 3 validation cases + a scaling study up to 192 cores, 27 runs in total.
- Physics match: Hertz contact times match the analytical solution to 0.014 % in both codes; silo flow rates agree within 0.7 %; without rolling resistance, column-collapse runouts land in the same 2 mm bin.
- One trap: in the LAMMPS build we used (7 Feb 2024) the
tsujidamping returns the wrong restitution (e = 0.44 when 0.3 is requested). It is the missing โ2 factor that LAMMPS corrected in a later release; LIGGGHTS hits the target exactly. - Speed: LIGGGHTS was 1.15โ1.25ร faster at every core count; both codes scale the same way (โ 9ร from 8 to 192 cores on 818 k particles).
- Validation: both reproduce Beverloo’s C = 0.58 and are within +3.5 % of the Lube et al. (2004) experimental runout at a โ 3.

Why compare LIGGGHTS and LAMMPS now?
LIGGGHTS (“LAMMPS Improved for General Granular and Granular Heat Transfer Simulations”) was forked from a 2012 version of LAMMPS and became the open-source reference for the Discrete Element Method (DEM). Its public branch has been frozen at 3.8.0 since 30 November 2017 (version history). Meanwhile LAMMPS itself kept moving: its pair_style granular now offers Hertz, JKR and DMT normal models, Mindlin tangential contacts, rolling and twisting resistance, all in the parent code that is actively maintained.
So the practical question for anyone starting a DEM project today is simple: is the specialised fork still worth using, or has the parent caught up? Both codes are available on cloudHPC, so we set up identical cases and let the numbers answer.
Results at a glance
| Case | Metric | Reference | LIGGGHTS | LAMMPS |
|---|---|---|---|---|
| 1. Hertz impact | contact time, 0.1โ10 m/s | Hertz (analytical) | max error 0.013 % | max error 0.014 % |
| 1. Hertz impact | restitution, input e = 0.3 | 0.30 | 0.300 | 0.440 (tsuji, 7 Feb 2024 build) |
| 2. Silo discharge | flow rate W, D0 = 24 mm | Beverloo, C = 0.58 | 0.2049 kg/s | 0.2034 kg/s |
| 2. Silo discharge | fitted Beverloo C / k | 0.58 / 1.5 (textbook) | 0.583 / 0.51 | 0.580 / 0.50 |
| 3. Column collapse | runout, a โ 3 | Lube et al. 2004 | +3.5 % | +3.4 % |
| 3. Column collapse | runout, a โ 1 | Lube et al. 2004 | โ9.7 % | โ9.7 % |
| Scaling | loop time, 818 k particles, 192 cores | โ | 69.5 s | 86.9 s |
| Speed | LAMMPS / LIGGGHTS time ratio | โ | 1 | 1.15โ1.25 |
How the runs were set up
- Solvers: LIGGGHTS-PUBLIC 3.8.0 (
pair_style gran model hertz tangential history) and LAMMPS with the GRANULAR package, the 7 Feb 2024 build available on cloudHPC at the time of testing (pair_style granular hertz/material โฆ tangential mindlin โฆ damping tsuji). - Same input data: one Python generator writes a single data file per case. LIGGGHTS (
atom_style granular) and LAMMPS (atom_style sphere) read the sameid type diameter density x y zlines, so both codes start from identical particle positions and diameters. - Material: soda-lime glass beads, ฯ = 2500 kg/mยณ, E = 10 MPa (softened, as usual in DEM), ฮฝ = 0.3, e = 0.9, ฮผ = 0.5, ยฑ5 % size polydispersity.
- Walls: analytic cylinders in both codes. Floors and the silo base are frozen particles (more on why below).
- Machines: cloudHPC hypercore instances (physical cores, one MPI process per core), regular (non-preemptible) instances so that timings are not disturbed.
Case 1 โ Hertz impact: contact time and restitution

Nine pairs of 4 mm spheres collide head-on. Five pairs test the restitution (e = 0.3 โ 1.0 at 1 m/s), four more test the Hertz contact time over two decades of impact velocity (0.1 โ 10 m/s, elastic). The contact time is measured from the overlap history, the restitution from the velocities before and after contact.

| Input e | LIGGGHTS measured e | LAMMPS (tsuji) measured e | LAMMPS error |
|---|---|---|---|
| 0.3 | 0.300 | 0.440 | +47 % |
| 0.5 | 0.500 | 0.616 | +23 % |
| 0.7 | 0.700 | 0.778 | +11 % |
| 0.9 | 0.900 | 0.928 | +3 % |
| 1.0 | 1.000 | 1.000 | 0 % |
What we learned. The elastic part of the contact law is identical and exact in both codes: contact times match the Hertz solution within 0.014 % from 0.1 to 10 m/s. The damping is not. LIGGGHTS reproduces the requested restitution exactly. The LAMMPS tsuji model in the 7 Feb 2024 build returns a bouncier contact, and the error grows as e decreases.
The LAMMPS documentation explains why: a โ2 factor in the Tsuji damping (from Marshall, 2009) was missing in earlier versions and was added in a later release. We checked it with the same LAMMPS build (run locally, inputs and log in the package): feeding it an input that includes the โ2 factor brings the measured e back to 0.300 / 0.500 / 0.700 / 0.900. Newer LAMMPS versions also provide damping coeff_restitution, whose formula is the same one LIGGGHTS uses. Not available in the build we tested, so for cases 2 and 3 we used a calibrated tsuji input of 0.862, which gives the target e = 0.9 in LAMMPS.
Practical rule: whatever DEM code you use, run a two-particle impact test before trusting a restitution coefficient. It takes seconds on cloudHPC (our impact run cost โฌ0.01).
Case 2 โ Silo discharge vs Beverloo

A flat-bottom cylindrical silo (ร 120 mm) is filled with ~66 600 beads of 3 mm, settled for 0.7 s, then the orifice is opened (D0 = 18, 24, 30 mm). The mass flow rate W comes from a linear fit of discharged mass between 0.5 and 2.5 s. The reference is the Beverloo correlation, W = C ฯ_b โg (D0 โ k d)^2.5, with ฯ_b = 1505 kg/mยณ from the measured settled packing (ฯ = 0.60).

| D0 [mm] | W LIGGGHTS [kg/s] | W LAMMPS [kg/s] | Difference | Beverloo textbook [kg/s] |
|---|---|---|---|---|
| 18 | 0.0967 | 0.0971 | โ0.4 % | 0.0579 |
| 24 | 0.2049 | 0.2034 | +0.7 % | 0.1452 |
| 30 | 0.3783 | 0.3785 | โ0.1 % | 0.2839 |
What we learned. The two codes are indistinguishable: within 0.7 % at every orifice, with practically overlapping discharge curves. Both sit 33โ68 % above the textbook Beverloo curve, but the fit tells the story: C = 0.583 (LIGGGHTS) and 0.580 (LAMMPS), the textbook 0.58, and k โ 0.5 instead of 1.5. The difference is geometric: our orifice rim is made of spheres, so the opening widens by up to one bead diameter just above the base. That shifts the “empty annulus” term by about one d (1.5 โ 1 โ 0.5).
A modelling note. We first tried to build the perforated base with a LAMMPS region wall (a slab minus a cylinder). Region walls cannot represent the sharp edge of a hole: particles near the rim fell through or were ejected. LIGGGHTS can use an STL mesh plate instead. To keep the geometry identical in both codes we used the classic DEM approach: a rough base of frozen particles with the orifice cut out and a frozen plug that is deleted to open the silo.
Case 3 โ Granular column collapse vs experiments

A column of 2 mm beads (initial radius r_i = 30 mm, aspect ratio a = h_i / r_i โ 1 and โ 3) settles inside a cylinder, which is then removed instantly. The final runout rโ is compared with the experimental scaling of Lube et al. (2004): rโ = r_i (1 + 1.24 a) for a < 1.7 and rโ = r_i (1 + 1.6 a^ยฝ) for a > 1.7. Runout is measured as the edge of the continuous deposit (annulus coverage below 50 %), so isolated rolling grains do not inflate it. A third run adds rolling resistance (ฮผ_r = 0.1): rolling_friction cdt in LIGGGHTS, rolling sds in LAMMPS.

| Case | a (LIGGGHTS / LAMMPS) | rโ LIGGGHTS [mm] | rโ LAMMPS [mm] | Lube et al. [mm] (LIGGGHTS / LAMMPS a) | Error LIGGGHTS / LAMMPS |
|---|---|---|---|---|---|
| a โ 1 | 1.04 / 1.04 | 62 | 62 | 68.6 / 68.7 | โ9.7 % / โ9.7 % |
| a โ 3 | 2.92 / 2.93 | 116 | 116 | 112.0 / 112.2 | +3.5 % / +3.4 % |
| a โ 3, ฮผ_r = 0.1 | 3.02 / 3.01 | 108 | 112 | 113.4 / 113.3 | โ4.8 % / โ1.1 % |
What we learned. Without rolling resistance the two codes give the same runout and the same deposit profile. The tall column (a โ 3) is within 3.5 % of the experiment; the squat column (a โ 1) stops about 10 % short, a known sensitivity of short columns to friction and initial packing. With rolling resistance the codes diverge by two bins (4 mm), because cdt and sds are different models: same ฮผ_r, different torque law. If your application needs rolling resistance (non-spherical grains approximated by spheres), calibrate it in the code you will use.
Speed and scaling (818 k particles)
A dense lattice of 805 500 flowing beads (d = 1 mm) on a 12 684-bead base (818 339 particles including the orifice plug) discharges for 30 000 steps on hypercore instances from 8 to 192 cores. We report the solver loop time from each log (instance boot and result upload excluded).

| Cores | LIGGGHTS [s] | LAMMPS [s] | LAMMPS / LIGGGHTS | Efficiency LIGGGHTS / LAMMPS | Solver cost LIGGGHTS / LAMMPS |
|---|---|---|---|---|---|
| 8 | 640.8 | 768.2 | 1.20 | 100 % / 100 % | โฌ0.31 / โฌ0.38 |
| 16 | 526.5 | 646.8 | 1.23 | 61 % / 59 % | โฌ0.51 / โฌ0.63 |
| 32 | 339.5 | 389.3 | 1.15 | 47 % / 49 % | โฌ0.66 / โฌ0.76 |
| 48 | 242.2 | 281.0 | 1.16 | 44 % / 46 % | โฌ0.71 / โฌ0.82 |
| 96 | 119.4 | 149.8 | 1.25 | 45 % / 43 % | โฌ0.70 / โฌ0.88 |
| 192 | 69.5 | 86.9 | 1.25 | 38 % / 37 % | โฌ0.82 / โฌ1.02 |
Solver cost = loop time ร cores ร โฌ0.22 per vCPU-hour (regular hypercore).
What we learned.
- LIGGGHTS is consistently 15โ25 % faster than LAMMPS on the same physics. The same gap appears in the silo (904 s vs 1124 s at D0 = 24 mm) and collapse runs (1067 s vs 1330 s at a โ 3).
- Both codes scale the same way: 9.2ร (LIGGGHTS) and 8.8ร (LAMMPS) from 8 to 192 cores. The modest efficiency is geometry, not the codes. A cylindrical bed in a Cartesian box leaves many subdomains nearly empty (at 192 ranks, 80 of them held fewer than 1 200 of the 818 k particles), and the jump from 8 to 16 ranks puts a whole layer of subdomains below the floor. A
balancecommand or a tighter box would help both codes equally. - In euros, the fastest solution is not the cheapest: 8 cores cost โฌ0.31 of solver time, 192 cores โฌ0.82, for a 9ร shorter wait.
Run times and costs
| Series | Runs | Instance | Billed cost |
|---|---|---|---|
| Sizing + impact | 3 | 16 vCPU hypercore / 2 vCPU highcore | โฌ0.78 |
| Silo discharge (3 orifices ร 2 codes) | 6 | 16 vCPU hypercore, regular | โฌ13.03 |
| Column collapse (3 cases ร 2 codes) | 6 | 16 vCPU hypercore, regular | โฌ13.52 |
| Scaling (6 sizes ร 2 codes) | 12 | 8โ192 vCPU hypercore, regular | โฌ73.36 |
| Total | 27 | โฌ100.69 |
The billed cost includes instance boot, result upload and shutdown, not only the solver. For the 192-core scaling runs the solver ran for about 70โ90 s but each instance was billed for about 26โ27 minutes. For short benchmark runs the overhead dominates, so run short jobs on few cores and keep large instances for long simulations.
How to run LIGGGHTS and LAMMPS DEM cases on cloudHPC
- LIGGGHTS: upload a folder with one input file whose name starts with
in(e.g.in.hopper) plus meshes and data files referenced with relative paths. Other files must not start within(renameinlet.stltoplate_inlet.stl). - LAMMPS: input files named
in.*,*.in,*.lmpor*.lammps. Several main inputs run one after the other; variables must be defined inside the input (no-varon the command line). With one input the log islog.lammps, with several it islog.<input>.lammps. - Cores: both codes run one MPI process per physical core. Use hypercore or highcore; on hyperthreaded types only half the selected vCPU are used.
- Check the restitution in your LAMMPS build with a two-particle test before production (see Case 1).
- Size the box to the particles, not to the loose fill: empty subdomains made our silo runs about twice as slow as necessary.
- Download your results: cloudHPC storage is cleaned automatically after 60 days.
FAQ
Is LIGGGHTS still maintained?
The public branch, LIGGGHTS-PUBLIC, has had no release since 3.8.0 (November 2017). It still compiles and runs well, and in our tests it was the faster of the two codes.
Can LAMMPS replace LIGGGHTS for DEM?
For spherical particles with Hertz-Mindlin contacts, yes: in our tests the physics matched within 0.7 % (silo) and to the same 2 mm (collapse, without rolling resistance). Check the damping model in your LAMMPS version and expect runs to be 15โ25 % slower than LIGGGHTS.
Why does my LAMMPS granular simulation have the wrong coefficient of restitution?
In LAMMPS versions before the โ2 correction, damping tsuji under-damps the contact (e = 0.44 instead of 0.3 in our test). Use damping coeff_restitution in newer versions, or calibrate the tsuji input with a two-particle impact.
How many cores should I use for a DEM simulation?
In our test, parallel efficiency fell below 50 % once each core had fewer than about 25 000 particles (cylindrical geometry, default decomposition). If you pay per core-hour, fewer cores are cheaper; if the deadline matters, 96 cores cut the solver time by about 5ร and 192 cores by about 9ร compared with 8 cores.
Does LIGGGHTS support STL walls that LAMMPS does not?
Yes. LIGGGHTS can use triangulated STL meshes as walls (fix mesh/surface + fix wall/gran). LAMMPS granular walls are analytic primitives or regions, and region walls do not handle sharp edges such as an orifice rim. For complex equipment geometry this is still a strong reason to choose LIGGGHTS.
References
- C. Kloss, C. Goniva, A. Hager, S. Amberger, S. Pirker, Models, algorithms and validation for opensource DEM and CFDโDEM, Progress in Computational Fluid Dynamics 12 (2012) 140โ152. doi:10.1504/PCFD.2012.047457
- A. P. Thompson et al., LAMMPS โ a flexible simulation tool for particle-based materials modeling at the atomic, meso, and continuum scales, Computer Physics Communications 271 (2022) 108171. doi:10.1016/j.cpc.2021.108171
- W. A. Beverloo, H. A. Leniger, J. van de Velde, The flow of granular solids through orifices, Chemical Engineering Science 15 (1961) 260โ269. doi:10.1016/0009-2509(61)85030-6
- G. Lube, H. E. Huppert, R. S. J. Sparks, M. A. Hallworth, Axisymmetric collapses of granular columns, Journal of Fluid Mechanics 508 (2004) 175โ199. doi:10.1017/S0022112004009036
- Y. Tsuji, T. Tanaka, T. Ishida, Lagrangian numerical simulation of plug flow of cohesionless particles in a horizontal pipe, Powder Technology 71 (1992) 239โ250. doi:10.1016/0032-5910(92)88030-L
- K. L. Johnson, Contact Mechanics, Cambridge University Press, 1985. doi:10.1017/CBO9781139171731
- LAMMPS documentation, pair_style granular (damping models, โ2 correction of the Tsuji model). docs.lammps.org/pair_granular.html
- CFDEMยฎproject, LIGGGHTSยฎ version history. cfdem.com/liggghtsr-version-history
- LIGGGHTS-PUBLIC source repository. github.com/CFDEMproject/LIGGGHTS-PUBLIC
CloudHPC is a HPC provider to run engineering simulations on the cloud. CloudHPC provides from 1 to 224 vCPUs for each process in several configuration of HPC infrastructure - both multi-thread and multi-core. Current software ranges includes several CAE, CFD, FEA, FEM software among which OpenFOAM, FDS, Blender and several others.
New users benefit of a FREE trial of 300 vCPU/Hours to be used on the platform in order to test the platform, all each features and verify if it is suitable for their needs