DLA Alternate Linear

DLA Alternate Linear preview image

1 collaborator

Uri_dolphin3 Uri Wilensky (Author)


chemistry and physics 

Tagged by Reuven M. Lerner almost 11 years ago

diffusion-limited aggregation 

Tagged by Reuven M. Lerner almost 11 years ago

Model group CCL | Visible to everyone | Changeable by group members (CCL)
Model was written in NetLogo 5.0.4 • Viewed 342 times • Downloaded 66 times • Run 1 time
Download the 'DLA Alternate Linear' modelDownload this modelEmbed this model

Do you have questions or comments about this model? Ask them here! (You'll first need to log in.)


Like the main DLA model, this model demonstrates diffusion-limited aggregation. In this variant, instead of particles forming a circular aggregate that grows from a central point, particles form vertical aggregates that grow along an edge.

In diffusion limited aggregation, particles moving (diffusing) in random trajectories stick together (aggregate) to form beautiful treelike branching fractal structures. There are many patterns found in nature that resemble the patterns produced by this model: crystals, coral, fungi, lightning, and so on.

This model has "Alternate" in its name because, like DLA Alternate, it is based on slightly different rules than the main DLA model. In the main model, the aggregate forms on a grid. In this version, there is no grid; the particles are circles and we do the necessary calculations to determine exactly when the circles touch each other. That makes this version more complicated, but arguably more physically accurate.


Gray particles fall from the top of the world, straight down. When a falling particle touches the floor, or a stationary particle, the falling particle stops moving. Periodically, a new particle is created to keep the process going.

When a particle touches the floor, it changes color. When a particle touches another particle, it takes that particle's color. That makes it easy to see the separate aggregates that form.


Press SETUP, then press GO.

SETUP: eliminates all existing particles and starts over

GO: runs the simulation


Stuck particles block the passage of falling particles. We get black areas that do not have any stuck particles, because the falling particles are moving in straight lines, so they cannot work their way in to fill the black areas.

The simulation runs slower as it goes on. That's because there are more and more particles in the view that have to be redrawn. If you freeze the view, the model will always run at the same speed. You can also use the speed slider to "fast forward" the model.

The number of "live" aggregates (that can still grow) decreases over time.


Try changing the size of the world (by editing the view). What happens when the world is very tall? How many live aggregates do you end up with?


Create a plot showing the number of live aggregates over time. Over several runs, does this graph have a typical shape?

Introduce a "wiggle" into the path of falling particles. That means that just before the particle moves forward, it turns a bit, randomly. How does the affect the aggregate? Experiment with different amounts of wiggle.


The code is mostly the same as in DLA Alternate.

In particular, the collision-distance procedure, the one with all the hairy math, is the same. It would actually be possible to use simpler math in this model, because we know that only the y coordinate of the moving particle is changing, while its x coordinate remains the same.


DLA and DLA Alternate are the same idea, but with particles all falling towards a central point instead of straight down.


The mathematical procedures used in calculating the collision paths comes from: Eric W. Weisstein, "Circle-Line Intersection". From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/Circle-LineIntersection.html


If you mention this model in a publication, we ask that you include these citations for the model itself and for the NetLogo software:


Copyright 2005 Uri Wilensky.


This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

Commercial licenses are also available. To inquire about commercial licenses, please contact Uri Wilensky at uri@northwestern.edu.

Comments and Questions

Click to Run Model

globals [
  next-color  ;; this is the next color we'll use when a new aggregate starts
              ;; (when a particle touches the bottom edge of the world)

breed [ movers mover ]     ;; gray particles zooming down from the top
breed [ stayers stayer ]   ;; colored particles that stay where they are

;; throughout, we assume that the turtles are all of size 1.
;; to support different-sized turtles, minor adjustments
;; would be needed.

to setup
  set-default-shape turtles "circle"  ;; applies to both breeds
  set next-color gray                 ;; first aggregate will be gray

to go
  ;; if any aggregates reach the top of the world, we're done
  if any? stayers with [pycor = max-pycor] [
    ask movers [ die ]
  ;; make one new falling particle per tick
  ;; we sort the green particles by who number, because we
  ;; need to make sure that closer particles move before farther
  ;; particles, otherwise we could get wrong results when two
  ;; greens are very close together.  SORT reports a list and
  ;; not an agentset (since agentsets are always in random
  ;; order), so we use FOREACH to iterate over the sorted list
  foreach sort movers [ ask ? [ move ] ]

to make-mover
  create-movers 1 [
    ;; start at a random location along the top edge
    setxy random-xcor max-pycor
    ;; head down
    set heading 180

to move  ;; mover procedure
  ;; any greens within a 2 step radius are potential
  ;; candidates for colliding with.  (Remember, in-radius
  ;; measures the distances between turtles' centers; but
  ;; we're checking for how far apart the edges are, hence
  ;; the 2 step radius: 1 is the sum of the two radii, and
  ;; another 1 for the distance from edge to edge.)  The
  ;; closest one we find is the one we actually collide with.
  let blocker min-one-of (stayers in-radius 2)
               [ collision-distance myself ]
  ;; if there's nothing within 2 steps, then we're free
  ;; to take a step forward
  if blocker = nobody
    [ fd 1
      if ycor = min-pycor
       [ set breed stayers
         set color next-color
         ;; the next aggregate that starts will be a new color
         set next-color next-color + 10 ]
      stop ]
  ;; see how far away the one we're about to collide with is.
  let dist [collision-distance myself] of blocker
  ;; if it's more than one step away, we're still free to
  ;; take a step forward.
  if dist > 1
    [ fd 1
      stop ]
  ;; otherwise, go forward until we're just touching the
  ;; "blocker", then cease any further motion
  fd dist
  set breed stayers
  ;; turn the same color as the particle we touched
  set color [color] of blocker

to fall  ;; mover procedure
  fd min list 1 (ycor + max-pycor)

;; essentially what all this math does is compute the intersection
;; point between a line and a circle.  the line is the straight path the
;; center point of the moving particle is following.  the circle is
;; a circle of radius 1 around the center of the stationary particle.
;; see http://mathworld.wolfram.com/Circle-LineIntersection.html
;; The details of the math are hard to follow, but the gist of it
;; is that the system of two equations, one for the circle and one
;; for the line, can be combined into a single quadratic equation,
;; and then that equation can be solved by the quadratic formula.
;; Note the strong resemblance of the formulas on the web page
;; to the quadratic formula.

to-report collision-distance [ incoming ]  ;; stayer procedure
  let x1 [xcor] of incoming - xcor
  let y1 [ycor] of incoming - ycor
  let d-x sin [heading] of incoming
  let d-y cos [heading] of incoming
  let x2 x1 + d-x
  let y2 y1 + d-y
  let big-d x1 * y2 - x2 * y1
  let discriminant 1 - big-d ^ 2
  ;; if the discriminant isn't positive, then there is no collision.
  if discriminant <= 0
    [ report false ]
  ;; the line and the circle will intersect at two points.  we find
  ;; both points, then look to see which one is closer
  let new-x-1 (   big-d *  d-y + sign-star d-y * d-x * sqrt discriminant)
  let new-y-1 ((- big-d) * d-x + abs       d-y       * sqrt discriminant)
  let new-x-2 (   big-d *  d-y - sign-star d-y * d-x * sqrt discriminant)
  let new-y-2 ((- big-d) * d-x - abs       d-y       * sqrt discriminant)
  let distance1 sqrt ((x1 - new-x-1) ^ 2 + (y1 - new-y-1) ^ 2)
  let distance2 sqrt ((x1 - new-x-2) ^ 2 + (y1 - new-y-2) ^ 2)
  ifelse distance1 < distance2
    [ report distance1 ]
    [ report distance2 ]

to-report sign-star [ x ]
  report ifelse-value (x < 0) [-1] [1]

; Copyright 2005 Uri Wilensky.
; See Info tab for full copyright and license.

There are 10 versions of this model.

Uploaded by When Description Download
Uri Wilensky about 11 years ago Updated to NetLogo 5.0.4 Download this version
Uri Wilensky over 11 years ago Updated version tag Download this version
Uri Wilensky over 11 years ago Updated to version from NetLogo 5.0.3 distribution Download this version
Uri Wilensky over 12 years ago Updated to NetLogo 5.0 Download this version
Uri Wilensky about 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky about 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky about 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky about 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky about 14 years ago Model from NetLogo distribution Download this version
Uri Wilensky about 14 years ago DLA Alternate Linear Download this version

Attached files

File Type Description Last updated
DLA Alternate Linear.png preview Preview for 'DLA Alternate Linear' about 11 years ago, by Uri Wilensky Download

This model does not have any ancestors.

This model does not have any descendants.