High-performance Diffusion-Limited Aggregation (DLA) solver with Numba JIT compilation and parallel rendering.

Simulates particle aggregation through random walks on a 2D lattice:

1. Random Walk: Particles perform 4-neighbor random walks
2. Sticking Rule: Particles stick when adjacent to existing aggregate
3. Growth: Dendritic structures emerge from stochastic aggregation

Fractal Analysis: Mass-radius relationship $M(R) \propto R^D$ gives fractal dimension $D \approx 1.71$ (2D DLA)

• Numba JIT: Compiled random walk for 100x speedup
• Parallel rendering: Multi-core GIF generation
• NetCDF output: Compact compressed format
• 4 test cases: Classic, competitive, controlled, dense
• Fractal analysis: Automatic $D$ calculation

# From PyPI
pip install dla-ideal-solver

# From source
git clone https://github.com/sandyherho/dla-ideal-solver.git
cd dla-ideal-solver
pip install -e .

Command line:

# Run single case
dla-simulate case1

# Run all cases
dla-simulate --all

# Custom cores
dla-simulate case1 --cores 8

Python API:

from dla_ideal import DLASolver

solver = DLASolver(N=512, n_cores=8)

result = solver.solve(
    n_walkers=10000,
    n_seeds=1,
    max_iter=100000,
    injection_mode='random'
)

print(f"Particles: {result['n_particles']}")
print(f"Aggregates: {result['n_aggregates']}")
print(f"Fractal dimension: {result['fractal_dimension']:.3f}")

Key parameters:

lattice_size = 512          # Grid size (N×N)
n_walkers = 10000           # Number of particles
n_seeds = 1                 # Initial sticky particles
max_iterations = 100000     # Safety limit
injection_mode = random     # 'random' or 'radial'
injection_radius = 180      # For radial mode
snapshot_interval = 100     # Frames per N particles

NetCDF variables:

• grid(x,y): Final aggregate
• snapshots(time,x,y): Growth evolution
• glued_counts(time): Particle timeline
• radii, masses: Fractal analysis data

Attributes:

• fractal_dimension: $D$ from $M(R)$ fit
• n_aggregates: Number of clusters
• n_particles: Total stuck particles

Reading data:

import netCDF4 as nc

data = nc.Dataset('outputs/case1_classic_dla.nc')
grid = data['grid'][:]
snapshots = data['snapshots'][:]
D = data.fractal_dimension
print(f"Fractal dimension: {D:.3f}")

The fractal dimension $D$ is computed from the mass-radius scaling relationship:

$$M(R) = \int_0^R \rho(r) , dV \propto R^D$$

where $M(R)$ is the mass within radius $R$ from the aggregate center. For 2D DLA:

$$\log M(R) = D \log R + \text{const}$$

The slope $D$ is obtained via linear regression on $\log$-$\log$ scale. Theoretical predictions give $D \approx 1.71$ for 2D DLA structures.

@software{dla_solver_2025,
  author = {Herho, Sandy H. S. and Fajary, Faiz R. and Anwar, Iwan P. and Khadami, Faruq and 
            Trilaksono, Nurjanna J. and Suwarman, Rusmawan and
            Irawan, Dasapta E.},
  title = {DLA Solver: Diffusion-Limited Aggregation with Numba},
  year = {2026},
  version = {0.0.4},
  license = {MIT}
}

• Sandy H. S. Herho
• Faiz R. Fajary
• Iwan P. Anwar
• Faruq Khadami
• Nurjanna J. Trilaksono
• Rusmawan Suwarman
• Dasapta E. Irawan

MIT License - See LICENSE for details.