# DLA Alternate

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 which 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 is called DLA Alternate because 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

A single green particle is created in the center (patch 0 0). Red particles move in from the periphery in straight trajectories. When a moving red particle touches a stationary green particle, the red particle turns green and stops moving. Periodically, a new red particle is created to keep the process going.

## HOW TO USE IT

Press SETUP, then press GO.

SETUP: eliminates all existing particles, initializes variables, and creates one new green particle in the center.

GO: creates a particle on the periphery that moves in towards the center. Because GO is a forever button, you will see many particles moving in.

## THINGS TO NOTICE

Green particles block the passage of red particles. We get black areas that do not have any green turtles, because the red particle are moving in straight lines, so they cannot work their way in to fill the black areas.

The red particles first appear on the perimeter of a large circle around the center of the display window.

What does the green shape remind you of? Can you think of any process in nature that could possibly generate an object of this shape?

Particles move in order, according to their distances from the center -- closer particles move before farther particles, and each particle moves just one step at a time.

## THINGS TO TRY

Run the program slowly (using the speed slider in the top-left corner of the display window). Watch how the red particles take turns in moving forward. See that only after each one of the red particles has moved, a new particle is created, which enters from the periphery.

Run the simulation until it stops. Now, beginning from the center, choose one of the "branches" and follow along outwards. At every node (a "fork in the road"), add 1, and then choose randomly between the two branches. How many nodes did you find along the way? Is it this number the same for any route you choose?

## EXTENDING THE MODEL

What happens if you start with more than one "seed" patch? What happens if the seed is a line instead of a point?

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

Let's use the term "envelope" to describe the large "circle" created by all the green particles, with the green particle that is farthest from the center defining the radius of this envelope. Within this envelope, what is the ratio between patches with green particles and patches that have no particles? Or, what is the ratio between particles and patches? Create a graph to track this ratio. Create a histogram that accumulates the end value of this process over multiple runs.

How circular is the envelope at the end of a simulation? Is it "smooth" or "bumpy"? How would you define the goodness of this circle?

Introduce a "wiggle" into the path of red particles. That means that just before the particle moves forward, it turns a bit, randomly. Should this affect the aggregation of green particles? One way to think of this extension is that you are modeling the DLA in different media, for instance in water or some chemical of different viscosity, or that there are currents in the liquid that jostle the particles about.

Let's use the term "end particles" to describe the green particles at the end of an outward reaching branch (so they are connected only to one other particle). Create a procedure to calculate and report the average number of nodes along all the possible paths from the center to the end particles). You can also create a histogram of these values.

How many "end particles" are there over time? It seem likely that this number should grow, but how would you expect this number to grow? Create a graph to track the growth in the number of these "end particles."

What is the ratio between "end particles" and nodes? Does this ratio change over time? Create a graph to track this ratio as the simulation runs.

Create a procedure that allows you to click on any two green particles and have another moving particle sprout at the first green particle you clicked and then track and color the path between these two green particles. What is the longest path between any two green particles? Is this number bound above?

## NETLOGO FEATURES

Note the use of `sort`

to make turtles execute in order by who number (meaning, oldest turtles first). Because `sort`

reports a list, we must use `foreach`

to iterate over the list in order to `ask`

each agent in it.

## RELATED MODELS

The main DLA model is a simpler implementation of the same idea; it uses grid cells instead of touching circles to form the aggregate.

DLA Alternate Linear has particles that fall straight down from the top of the world, instead of falling towards a central point.

## 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 model. http://ccl.northwestern.edu/netlogo/models/DLAAlternate. 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

breed [ movers mover ] ;; red particles zooming in from the edges breed [ stayers stayer ] ;; green 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" ;; note that the single stayer is created in the center (patch 0 0) create-stayers 1 [ set color green ] reset-ticks end to go ;; if any part of the aggregate gets close to the edge ;; of the view, then we're done if any? stayers with [distancexy 0 0 > max-pxcor - 1] [ ask movers [ die ] stop ] ;; make one new red 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 [ ;; move to the perimeter of a circle the same ;; size as the world set color red jump max-pxcor ;; and point inward rt 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 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 set color green 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. ;; note that there cannot be tangency (discriminant = 0) because the ;; turtles' trajectories are all along radii of the same circle 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.png | preview | Preview for 'DLA Alternate' | almost 10 years ago, by Uri Wilensky | Download |

This model does not have any ancestors.

This model does not have any descendants.