# DLA Alternate Linear

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

## WHAT IS IT?

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.

## HOW IT WORKS

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.

## HOW TO USE IT

Press SETUP, then press GO.

SETUP: eliminates all existing particles and starts over

GO: runs the simulation

## THINGS TO NOTICE

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.

## THINGS TO TRY

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?

## EXTENDING THE MODEL

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.

## NETLOGO FEATURES

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.

## RELATED MODELS

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

## CREDITS AND REFERENCES

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

## HOW TO CITE

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

- Wilensky, U. (2005). NetLogo DLA Alternate Linear model. http://ccl.northwestern.edu/netlogo/models/DLAAlternateLinear. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.
- Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.

## COPYRIGHT AND LICENSE

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

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 clear-all set-default-shape turtles "circle" ;; applies to both breeds set next-color gray ;; first aggregate will be gray reset-ticks end to go ;; if any aggregates reach the top of the world, we're done if any? stayers with [pycor = max-pycor] [ ask movers [ die ] stop ] ;; make one new falling particle per tick make-mover ;; 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 ] ] tick end 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 ] end 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 end to fall ;; mover procedure fd min list 1 (ycor + max-pycor) end ;; 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 ] end to-report sign-star [ x ] report ifelse-value (x < 0) [-1] [1] end ; Copyright 2005 Uri Wilensky. ; See Info tab for full copyright and license.

There are 10 versions of this model.

## Attached files

File | Type | Description | Last updated | |
---|---|---|---|---|

DLA Alternate Linear.png | preview | Preview for 'DLA Alternate Linear' | almost 10 years ago, by Uri Wilensky | Download |

This model does not have any ancestors.

This model does not have any descendants.