{ if (navigator.userAgent.match('HeadlessChrome')) return html``; return md`Forked from Tom MacWright's [Diffusion-limited aggregation](https://beta.observablehq.com/@tmcw/diffusion-limited-aggregation), with speedup to the rendering from Fabian Iwand's [fork](https://beta.observablehq.com/d/6476797a385e8d05). *Tom MacWright's original description:* Based heavily on [Michael Drzal’s bl.ock](https://bl.ocks.org/xmichaelx/39fa023f9ce1fb82d5c0). I made it because [Michael Fogleman](https://github.com/fogleman/dlaf) wrote an implementation recently that’s probably 1,000 times faster than this one. And Michael Fogleman also pointed to [dla-nd](https://github.com/markstock/dla-nd) by [Mark Stock](http://markjstock.org/dla-nd/) which is also so cool. Anyway, I made it kind of pretty and fast but otherwise didn’t invent anything. Tweak those sliders. *New stuff:* The large-scale structure of DLA clusters is known to be quite sensitive to anisotropy in the system. For instance, if the particles are constrained to a grid, there's a bias towards the grid directions in large DLA clusters (see e.g. [this paper of Meakin's](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.33.3371)). [Fogleman's very pretty images in [his twitter thread](https://twitter.com/FogleBird/status/1093352480950439936) are made with an "off-lattice" DLA which is immune to this effect.] If you're trying to use DLA to model some serious physics like dust bunny formation then this kind of thing can make your life hard, but in this notebook we **exploit** this sensitivity by varying the attachment rules to generate different flavors of DLA. To be more precise, recall that in the original notebook, each particle in the system undergoes a random walk and becomes "stuck" and joins the cluster when it sits next to a stuck particle. Visually, the particle becomes stuck if there are any stuck particles in the black boxes in this diagram: (the green square is the position of the wandering particle). To go beyond this, we can keep track of the **number** of stuck particles that are "nearest-neighbors" on the grid: (\`#NN\`) and the number of stuck particles that are "next-nearest-neighbors" on the grid: (\`#NNN\`). Using this data, we can explore different attachment rules which depend on the values of \`#NN\` and \`#NNN\` (e.g. we can have particles get stuck only if \`#NN\` is 1 or 3). To make things even more interesting, we can tune the importance of various rules by making the rules probabilistic (that is, particles satisfying the conditions only get stuck with some fixed frequency). [So the "CA" in the title stands for "[cellular automata](https://en.wikipedia.org/wiki/Cellular_automaton)", as rules depending on \`#NN\` and \`#NNN\` are common in those systems.] I've included a few preset rules below; try switching them while the cluster is growing and watching the different geometries build off each other! If you're feeling really adventurous you can also try tweaking them or creating your own (more detailed instructions [below](#rulesFormat)). I've also [implemented](#updateSingleParticleFast) an algorithm inspired by Fogleman's ["dlaf"](https://github.com/fogleman/dlaf), where particles are added **one at a time** by repeatedly jumping ${tex`d_{stuck}`} in a random direction until stuck, where ${tex`d_{stuck}`} is the distance to the closest stuck particle (for this, I use [d3-quadtree](https://github.com/d3/d3-quadtree)). For larger box sizes, the dlaf-inspired algorithm seems to finish more quickly, however the clusters that grow seem to be different from those created by the original algorithm. One visual change is that particles are colored differently depending on the (even-odd) parity of their coordinate sums *x+y*. In the original algorithm, particles make steps of ${tex`(\pm1,\pm1)`}, which preserves this parity, so there are effectively two distinct populations of particles (they move like black and white bishops on a chessboard). In the dlaf-inspired algorithm, particles make bigger jumps, so they change their parities frequently. However, with either algorithm, one can design growth rules where the two colors segregate by varying the rules carefully (see e.g. the "two-color moss").` }