🔬 condensed matter

multisphere: a Python implementation of the Multi Sphere Shape generator (MSS) for DEM simulations

The paper introduces "multisphere," an open-source Python package that generates multi-sphere representations of complex particles for DEM simulations by reconstructing triangulated meshes and voxelized volumes into intersecting sphere sets, while providing tools for evaluation, visualization, and export.

Original authors: Felix Buchele, Patric Müller, Thorsten Pöschel

Published 2026-04-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Felix Buchele, Patric Müller, Thorsten Pöschel

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a perfect replica of a complex object—like a cow, a grain of sand, or a bunny rabbit—but you are only allowed to use perfectly round marbles.

That is essentially the challenge this paper addresses. In the world of computer simulations (specifically for things like avalanches, soil mechanics, or how coffee beans flow), scientists need to model how particles bump into each other. Computers are very good at calculating how two round marbles hit each other, but they struggle when the objects are weird shapes like jagged rocks or flat pebbles.

Here is the story of multisphere, the tool described in the paper, explained in simple terms:

1. The Problem: The "Round Marble" Limitation

Think of the Discrete Element Method (DEM) as a giant digital sandbox. To simulate how a pile of sand collapses or how a rock breaks, the computer needs to know the shape of every single grain.

The Issue: If you tell the computer, "Here is a jagged rock," it has to do incredibly complex math to figure out how it hits another jagged rock. This is slow and computationally expensive.
The Shortcut: It is much faster to tell the computer, "Here is a cluster of 500 marbles glued together." The computer can instantly calculate how these marble-clusters interact because it only needs to check if the marbles touch.

2. The Solution: The "Pixel-to-Marble" Translator

The authors created a Python tool called multisphere. Think of it as a 3D printer that only uses marbles.

Input: You give the tool a digital model of a weird shape. This could be a 3D scan of a real rock, a photo of a grain of sand, or a computer drawing (CAD).
The Magic: The tool takes that shape and figures out exactly where to place hundreds or thousands of marbles so that, when you look at the whole group, it looks exactly like the original rock.
The Result: You get a "Multi-Sphere" model. It's not a solid rock anymore; it's a cloud of overlapping marbles that looks and acts like the rock in the simulation.

3. Why This Tool is Special (The "Smart" Part)

There are other tools that try to do this, but multisphere is special for two reasons:

Efficiency (The "Fewer Marbles" Rule): Other tools might need 10,000 marbles to make a decent-looking rock. multisphere is smarter; it can often make a rock that looks just as good using only 2,000 marbles. Fewer marbles mean the computer simulation runs much faster.
Symmetry (The "Mirror" Rule): If you have a perfectly symmetrical object (like a snowflake or a dice), some tools might accidentally make the marble version slightly lopsided. multisphere is careful to keep the symmetry perfect, just like the original.

4. How It Works (The Three Steps)

The tool follows a simple three-step recipe:

Preparation (The Scan): It takes your 3D shape and turns it into a digital grid of tiny cubes (like a 3D pixelated image).
Construction (The Packing): It runs a smart algorithm to find the best spots to drop marbles into those cubes. It keeps adding marbles until the "marble cloud" matches the original shape closely enough.
Review (The Check): It gives you a score (called the "Dice Coefficient") to tell you how good the match is. If the score is high, your marble-rock is a perfect twin of the real thing. It also lets you export the data so you can use it in your simulation.

5. Why Should We Care?

Imagine you are studying how a bridge collapses under heavy traffic, or how a landslide moves down a mountain.

Before this tool: Simulating thousands of irregular rocks would take days or weeks because the computer was doing heavy math for every jagged edge.
With this tool: The computer treats those rocks as clusters of marbles. The math becomes simple, and the simulation runs in minutes.

In a nutshell:
multisphere is a translator that turns complex, jagged 3D shapes into simple clusters of spheres. It allows scientists to run faster, more accurate simulations of how the real world moves, breaks, and flows, without needing supercomputers to do the heavy lifting. It turns the "impossible math" of jagged rocks into the "easy math" of rolling marbles.

1. Problem Statement

The Discrete Element Method (DEM) is a standard numerical technique for simulating granular systems in fields like geomechanics and process engineering. However, the macroscopic behavior of these systems is heavily dependent on the shape of individual particles.

The Challenge: Simulating non-spherical particles is computationally expensive because complex contact detection and force evaluation are difficult to calculate directly.
The Existing Solution: The "multi-sphere approach" approximates complex shapes ( $S$ ) as a union of $n$ intersecting spheres ( $\tilde{S}$ ). This reduces complex interactions to simpler sphere-sphere interactions.
The Gap: Finding the optimal set of sphere positions and radii to minimize the geometric mismatch between the target shape and the approximation is a difficult optimization problem. Existing generators often require a high number of spheres to achieve high accuracy, lack symmetry preservation, or are not easily integrated into modern Python-based DEM workflows.

2. Methodology

The paper presents multisphere, an open-source Python package implementing the Multi-Sphere Shape (MSS) generator algorithm.

Core Algorithm (MSS)

The MSS algorithm solves the optimization problem of minimizing the symmetric difference (mismatch) between the target shape $S$ and the multi-sphere approximation $\tilde{S}$ :
$|S \triangle \tilde{S}| \equiv |(S \cup \tilde{S}) \setminus (S \cap \tilde{S})|$
Key features of the MSS algorithm include:

Efficiency: It requires fewer spheres than other generators to achieve a specific mismatch value.
Symmetry Preservation: It ensures the generated particle model retains the same symmetries as the target shape.
Constraints: The optimization respects constraints such as minimum sphere size and minimum distance between sphere centers.

Software Architecture

The package follows a three-stage workflow:

Preprocessing:
- Accepts input as triangulated surface meshes (STL, OBJ, PLY) or voxelized volumes (NumPy arrays).
- Meshes are internally converted to a VoxelGrid (3D voxel grid) with a defined voxel size ( $\Delta$ ) derived from the bounding box.
Processing:
- The core function multisphere_from_voxels (or multisphere_from_mesh) generates the sphere set.
- Termination Criteria: The reconstruction stops based on user-defined limits: target accuracy (Dice-Sørensen coefficient), minimum admissible sphere radius, or maximum number of spheres.
- Mesh Confinement: An optional flag (confine_mesh) prevents the approximation from extending beyond the original mesh surface by reducing sphere radii, which is critical for simulating particle fracture to avoid unphysical overlaps.
Postprocessing:
- Outputs a SpherePack object containing sphere positions and radii in physical units.
- Tools are provided to convert the sphere pack back into a surface mesh (create_multisphere_mesh) for visualization and accuracy evaluation.

Technical Dependencies

Language: Python $\ge$ 3.10.
Core Libraries: numpy, scipy, scikit-image, trimesh.
Visualization: pyvista.
Mesh Operations: manifold3D.

3. Key Contributions

Open-Source Implementation: Provides the first accessible Python implementation of the MSS algorithm, making it available via PyPI (pip install multisphere).
Unified Interface: Offers a seamless workflow to convert both CAD/tomography meshes and voxel data into DEM-ready multi-sphere representations.
Optimization: Delivers high-fidelity particle shapes with a reduced number of spheres compared to other methods, directly lowering the computational cost of DEM simulations (where sphere-sphere interaction count is a bottleneck).
Robust Evaluation Tools: Includes built-in functions to compute the Dice-Sørensen coefficient ( $D$ ) for quantitative accuracy assessment and tools for interactive 3D visualization.

4. Results and Validation

The paper validates the package using two primary case studies:

Standard Geometric Models: The "Stanford Bunny" was reconstructed with varying sphere counts ( $n=10, 50, 629$ ). Visualizations show the progressive improvement in shape fidelity as $n$ increases.
Real-World Granular Materials: The package was tested on 402 particles from the "Sand Atlas" (including Hamburg sand, couscous, and various sand types).
- Accuracy: The Dice coefficient ( $D$ ) was plotted against the number of spheres. The results show a clear trend where accuracy increases with sphere count, with a mean value and standard deviation calculated across all particle types.
- Performance: Runtime analysis indicates the algorithm is computationally efficient, suitable for applications requiring frequent particle reconstruction (e.g., fragmentation simulations).

5. Significance and Impact

The multisphere package addresses a critical bottleneck in DEM simulations: the trade-off between particle shape fidelity and computational cost.

Efficiency: By generating accurate representations with fewer spheres, it significantly reduces the number of contact calculations required, speeding up simulations involving large numbers of irregular particles.
Versatility: It supports dynamic simulations where particle shapes change (e.g., plastic deformation or fracture), as the MSS algorithm can efficiently reconstruct new shapes on the fly.
Accessibility: By wrapping a complex computational geometry algorithm in a user-friendly Python package with support for standard file formats (STL, VTK, CSV), it lowers the barrier to entry for researchers in materials science and geomechanics to perform high-fidelity, shape-resolved DEM simulations.