Autumn Extended

No preview image

1 collaborator

Default-person Michelle Carr (Author)


(This model has yet to be categorized with any tags)
Model group LS426_2013 | Visible to everyone | Changeable by everyone
Model was written in NetLogo 5.0.3 • Viewed 462 times • Downloaded 33 times • Run 0 times
Download the 'Autumn Extended' modelDownload this modelEmbed this model

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


If you live in a climate that is warm during the summer and cold in the winter, then you are probably familiar with the beautiful autumn phenomenon in which leaves turn color before dying and falling off of the tree. This model simulates the ways in which leaves change their colors and fall, making it possible to explore and understand this beautiful annual spectacle.


Why and how leaves change colors and fall is surprisingly complicated, and has to do with a combination of sunlight, heat, and rain. (Leaves can be blown off by strong winds even if they have not yet changed color, so wind has a role too.)

The colors that we see in each leaf stem from the presence of natural substances that are produced and stored in each leaf. Three substances contribute to a leaf's color:

  • Green comes from chlorophyll (or a set of related substances known as chlorophylls), which converts sunlight and water into sugar. Chlorophyll molecules are destroyed and not replenished when they are exposed to excessive sunlight and when temperatures are low. Thus, cold sunny fall days make the overall concentration of chlorophyll decrease. Overall chlorophyll concentration rises again in the sunlight (as long as there is not too much!) and when there is water.

  • Yellow comes from a substance called carotene. Carotene molecules help give color to carrots and sweet potatoes. The concentration of carotene remains constant throughout a leaf's life. However, the yellow color is often masked by the chlorophyll's green color. A leaf with lots more chlorophyll (typical in the summer) will be exclusively green, albeit with strong yellow tints masked behind the green. As the chlorophyll dies, however, the presence of carotene becomes apparent, resulting in a yellow leaf.

  • Red comes from a substance called anthocyanins. Anthocyanin molecules are created in the presence of high sugar concentrations and water concentrations in the leaf. (The higher the concentration of sugar, the more anthocyanins are produced.) Sugar concentration increases when cold weather causes the tree to shut down its water circulation to the rest of the tree; whatever water and sugar are trapped in the leaf are then converted into anthocyanins.

Each tick of the clock in the model consists of two stages: (1) Weather (rain, wind, sun) affects the leaves, adding or removing sugar, water, or chlorophyll as appropriate, and (2) the leaf reacts to its environment, adding anthocyanins as appropriate, and changing color to reflect the modified environment.

Water does not enter each leaf directly, but is absorbed by the tree's roots, from which it is pulled up the trunk and into the branches and leaves. In this model, the entire ground is assumed to contain tree roots, and thus all raindrops flow toward the trunk once they reach the ground. Similarly, all of the raindrops travel up the trunk of the tree, and then along the branches (which are not represented in the model), out to the leaves. Leaves collect water from nearby raindrops. Raindrops disappear when they have no more water left in them.

Leaves in the model have an "attachedness" attribute, which the model uses to indicate how strongly the leaf is clinging to the tree. Attachedness rises with water, and declines in wind and rain. (On a very windy day, leaves may blow off even if they're completely green.)

Because the NetLogo color space does not include all possible colors, this model uses a threshold algorithm to determine the color of the leaf, as an approximation of the real color. Whenever chlorophyll is above 50%, the leaf is green. Below that, the leaf is given a yellow, red, or orange color, depending on if there is a majority of carotene, anthocyanins, or both, respectively.

Note that the intensity of the leaf colors varies with the level of chlorophyll, carotene, and/or anthocyanins. So a chlorophyll-laden tree will have dark-green leaves, whereas one with only a little bit will have light-green leaves.


To use the model, press SETUP. This will create the tree trunk and branches, and will also create the leaves of the tree, which are the main agents in this model. Press GO to set the system in motion.

Now comes the interesting and/or tricky part, namely adjusting the sliders under the view so that the weather produces conditions you want to explore or study. If the leaves appear to be losing chlorophyll due to a lack of water (which you can monitor in the "Leaf averages" plot), you can make it rain by adjusting the RAIN-INTENSITY slider. To make the wind blow, adjust the WIND-FACTOR slider.

The sun's strength (in terms of intensity of sunlight) is set with the SUN-INTENSITY slider. As noted above, leaves need sunlight to produce chlorophyll and sugar -- but too much sunlight may begin to destroy these chemicals.

Finally, you can change the TEMPERATURE slider. If the temperature is too cold, the chlorophyll molecules will be destroyed, setting in motion the creation of anthocyanins.

Once you have mastered the basics of the model, you might want to consider setting the two sliders in the top left corner, START-SUGAR-MEAN and START-SUGAR-STDDEV, which influence the mean and spread of the initial distribution of sugar among the leaves. Maple leaves, for example, tend to have a lot of sugar in them to begin with, which means that they'll turn redder than other leaves under similar conditions.

The LEAF-DISPLAY-MODE in the lower right corner changes the way in which leaves are depicted. Normally, each leaf is painted as a solid NetLogo "default" turtle wedge. This is the case when LEAF-DISPLAY-MODE is set to "solid," the default. Selecting a different value for LEAF-DISPLAY-MODE then changes each leaf to show an empty, half-full, or full shape, according to the variable that was chosen. Thus if LEAF-DISPLAY-MODE is set to "water", each leaf will be shown as empty (if low on water), half-full (if somewhat stocked with water), or full (if relatively full of water).


Leaves absorb water when they are hit by raindrops -- which means that with light rain and many leaves, the "inside" leaves will fail to get enough rain.

The stronger the wind, the more each leaf shakes.

You can simulate a minor hurricane by turning the wind and rain up to their maximum values. Watch the leaves all fall off at once!


Can you get all of the leaves to turn red before falling? How about to turn orange before falling? How about yellow? Now try to mix things up, such that the same tree will have leaves of many different colors. (Hint: You will probably need to adjust the sun, rain, and temperature sliders several times to get the combination to look right.)

Try to get the leaves to turn yellow and then green again.

In some climates trees do not lose their leaves. Can you adjust the climate conditions so that you can make the tree keep some of its leaves?


In real life, leaves that face the sun tend to be yellower than those that don't. Change the model such that the sun can be positioned (and moved), and such that leaves facing the sun are more sensitive to sunlight than those that don't.

The model is very simplistic in its approach to water and sugar -- namely, that all water comes from rain, that raindrops can affect multiple leaves, and that raindrops disappear as they hit the ground. A more realistic model would have raindrops disappear as soon as they hit a leaf, but would also allow for water to travel from the ground to the leaves, via the trunk and branches. Also a more realistic model would model the transport of sugars between leaves and the storage of excess sugar in the roots.

Allow for the budding and growth of new leaves, in addition to the death of mature ones.

Add day-night cycles, in which the temperature drops and the sun goes down for several ticks of the clock. In the dark, the tree would then consume sugars and produce water through respiration.


Because NetLogo's color space is incomplete, we needed to fake color pigmentation blending a bit. Notice how we handle setting colors by means of thresholds. This means that there can be sudden, jarring color changes if the weather conditions are a bit extreme.

Also note that the NetLogo color scheme, and the scale-color primitive, produce colors that range from white to black. Because in this model we wants to vary hues without getting too close to either black or white, we used the scale-color primitive but on a -50 to 150 scale, rather than the usual 0 to 100.

When a leaf dies, its breed changes to dead-leaves. This keeps it in the system, but allows us to issue instructions to only those leaves that are alive.

Notice how the sun's color changes as SUN-INTENSITY changes. What happens to the label when the sun becomes dark and small?


Plant Growth is in some ways a model of the opposite process, namely how do leaves grow, as opposed to how do leaves die.


Thanks to Reuven Lerner for his work on this model.


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 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


In playing with fireflies, fireworks, and autumn models, we learned about the basic functions and abilities that NetLogo provides. Playing with the autumn model was definitely the most challenging, but also afforded probably the best learning opportunites because of the variety of variables already included in the program. We felt the interface is a very good setting for learning about leaf color changes and attachedness attributes. It was impossible to play around with the model without getting some information about what we felt people were supposed to be learning (i.e. reasoning for how to change leaf colors in the scientific, not just in a programmatic sense.)

While we thought there would be many similarities to MicroWorlds, little of the syntax translated, but we did have a "basic programming" foundation (logic and reasoning, so to speak) that was somewhat helpful. At the same time, some of the biggest obstacles were figuring out how the code and the interface were related (i.e. that you do not need to define global variables) and the functionality of patches and turtles work in different ways.

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

breed [leaves leaf]
breed [dead-leaves dead-leaf]
breed [raindrops raindrop]
breed [suns sun]

leaves-own [
  water-level       ;; amount of water in the leaf
  sugar-level       ;; amount of sugar in the leaf
  attachedness      ;; how attached the leaf is to the tree
  chlorophyll       ;; level of chemical making the leaf green
  carotene          ;; level of chemical making the leaf yellow
  anthocyanin       ;; level of chemical making the leaf red

raindrops-own [
  location          ;; either "falling", "in root", "in trunk", or "in leaves"

globals [
  bottom-line        ;; controls where the ground is
  evaporation-temp   ;; temperature at which water evaporates

;; ---------------------------------------
;; setup
;; ---------------------------------------

to setup
  set bottom-line min-pycor + 1
  set evaporation-temp 30
  set-default-shape raindrops "circle"
  set-default-shape suns "circle"

  ;; Create sky and grass
  ask patches
    [ set pcolor blue - 2 ]
  ask patches with [pycor < min-pycor + 2]
    [ set pcolor green ]

  ;; Create leaves
  create-leaves number-of-leaves [
    set chlorophyll 50 + random 50
    set water-level 75 + random 25
    ;; the sugar level is drawn from a normal distribution based on user inputs
    set sugar-level random-normal start-sugar-mean start-sugar-stddev
    set carotene random 100
    set attachedness 100 + random 50
    ;; using sqrt in the next command makes the turtles be
    ;; evenly distributed; if we just said "fd random-float 10"
    ;; there'd be more turtles near the center of the tree,
    ;; which would look funny
    fd sqrt random-float 100

  ;; Create trunk and branches
  ask patches with [pxcor = 0 and pycor <= 5 or
                    abs pxcor = (pycor + 2) and pycor < 4 or
                    abs pxcor = (pycor + 8) and pycor < 3]
    [ set pcolor brown ]

  ;; Create the sun
  create-suns 1 [
    setxy sun-placement - 2
          max-pycor - 3
    ;; change appearance based on intensity

  ;; plot the initial state

;; ---------------------------------------
;; go
;; ---------------------------------------

to go
  ;; Stop if all of the leaves are dead
  if not any? leaves [ stop ]

  ;; Have the wind blow and rain fall;
  ;; move any water in the sky, on the ground, and in the tree;
  ;; set the appearance of the sun on the basis of its intensity.
  ask suns [ show-intensity ]

  ;; Now our leaves respond accordingly
  ask attached-leaves

  ;; if the leaves are falling keep falling
  ask leaves [ fall-if-necessary ]

  ;; Leaves on the bottom should be killed off
  ask leaves with [ycor <= bottom-line]
    [ set breed dead-leaves ]

  ;; Leaves without water should also be killed off
  ask leaves with [water-level < 1]
    [ set attachedness 0 ]

  ;; Make sure that values remain between 0 - 100
  ask leaves [
    if chlorophyll < 0 [ set chlorophyll 0 ]
    if chlorophyll > 100 [ set chlorophyll 100 ]
    if water-level < 0 [ set water-level 0 ]
    if water-level > 100 [ set water-level 100 ]
    if sugar-level < 0 [ set sugar-level 0 ]
    if sugar-level > 100 [ set sugar-level 100 ]
    if carotene < 0 [ set carotene 0 ]
    if carotene > 100 [ set carotene 100 ]
    if anthocyanin < 0 [ set anthocyanin 0 ]
    if anthocyanin > 100 [ set anthocyanin 100 ]
    if attachedness < 0 [ set attachedness 0 ]
    if attachedness > 100 [ set attachedness 100 ]

ask leaves [
  if (distancexy sun-placement max-pycor - 3) < 10 [ set chlorophyll 30]
  ;; increment the tick counter

;; ---------------------------------------
;; make-wind-blow: When the wind blows,
;; the leaves move around a little bit
;; (for a nice visual effect), and
;; reduce their attachedness by the wind factor.
;; This means that leaves will fall off more
;; rapidly in stronger winds.
;; ---------------------------------------

to make-wind-blow
  ask leaves [ ifelse random 2 = 1
                 [ rt 10 * wind-factor ]
                 [ lt 10 * wind-factor ]
               set attachedness attachedness - wind-factor

;; ---------------------------------------
;; make-rain-fall: rain is a separate breed
;; of small turtles that come from the top of the world.
;; ---------------------------------------

to make-rain-fall
  ;; Create new raindrops at the top of the world
  create-raindrops rain-intensity [
    setxy random-xcor max-pycor
    set heading 180
    fd 0.5 - random-float 1.0
    set size .3
    set color gray
    set location "falling"
    set amount-of-water 10
  ;; Now move all the raindrops, including
  ;; the ones we just created.
  ask raindrops [ fd random-float 2 ]

;; --------------------------------------------------------
;; move-water: water goes from raindrops -> ground,
;; ground -> trunk/branches, and trunk/branches to leaves.
;; --------------------------------------------------------

to move-water

  ;; We assume that the roots extend under the entire grassy area; rain flows through
  ;; the roots to the trunk
  ask raindrops with [location = "falling" and pcolor = green] [
    set location "in roots"
    face patch 0 ycor

  ;; Water flows from the trunk up to the central part of the tree.
  ask raindrops with [location = "in roots" and pcolor = brown] [
    face patch 0 0
    set location "in trunk"

  ;; Water flows out from the trunk to the leaves.  We're not going to
  ;; simulate branches here in a serious way
  ask raindrops with [location = "in trunk" and patch-here = patch 0 0] [
    set location "in leaves"
    set heading random 360

  ;; if the raindrop is in the leaves and there is nothing left disappear
  ask raindrops with [location = "in leaves" and amount-of-water <= 0.5] [

  ;; if the raindrops are in the trunk or leaves and they are at a place
  ;; where they can no longer flow into a leaf then disappear
  ask raindrops with [
    (location = "in trunk" or location = "in leaves")
     and (ycor > max [ycor] of leaves or
          xcor > max [xcor] of leaves or
          xcor < min [xcor] of leaves) ] [

;; Turtle Procedures
;; --------------------------------------------------------

;; --------------------------------------------------------
;; show-intensity: Change how the sun looks to indicate
;; intensity of sunshine.
;; --------------------------------------------------------

to show-intensity  ;; sun procedure
  set color scale-color yellow sun-intensity 0 150
  set size sun-intensity / 10
  set label word sun-intensity "%"
  ifelse sun-intensity < 50
    [ set label-color yellow ]
    [ set label-color black  ]

to sun-movement ;;adaption

;; --------------------------------------------------------
;; adjust-water: Handle the ups and downs of water within the leaf
;; --------------------------------------------------------

to adjust-water
  ;; Below a certain temperature, the leaf does not absorb
  ;; water any more.  Instead, it converts sugar and and water
  ;; to anthocyanin, in a proportion
  if temperature < 10 [ stop  ]

  ;; If there is a raindrop near this leaf with some water
  ;; left in it, then absorb some of that water
  let nearby-raindrops raindrops in-radius 2 with [location = "in leaves" and amount-of-water >= 0]

  if any? nearby-raindrops [
    let my-raindrop min-one-of nearby-raindrops [distance myself]
    set water-level water-level + ([amount-of-water] of my-raindrop * 0.20)
    ask my-raindrop [
      set amount-of-water (amount-of-water * 0.80)

  ;; Reduce the water according to the temperature
  if temperature > evaporation-temp
    [ set water-level water-level - (0.5 * (temperature - evaporation-temp)) ]

  ;; If the water level goes too low, reduce the attachedness
  if water-level < 25
    [ set attachedness attachedness - 1 ]

;; ---------------------------------------
;; adjust-chlorophyll: It's not easy being green.
;; Chlorophyll gets reduces when the temperature is
;; low, or when the sun is strong.  It increases when
;; the temperature is normal and the sun is shining.
;; ---------------------------------------

to adjust-chlorophyll

  ;; If the temperature is low, then reduce the chlorophyll
  if temperature < 15
    [ set chlorophyll chlorophyll - (.5 * (15 - temperature)) ]

  ;; If the sun is strong, then reduce the chlorophyll
  if sun-intensity > 75
    [ set chlorophyll chlorophyll - (.5 * (sun-intensity - 75)) ]

  ;; New chlorophyll comes from water and sunlight
  if temperature > 15 and sun-intensity > 20
    [ set chlorophyll chlorophyll + 1 ]

;; ---------------------------------------
;; adjust-sugar: water + sunlight + chlorophyll = sugar
;; ---------------------------------------

to adjust-sugar
  ;; If there is enough water and sunlight, reduce the chlorophyll
  ;; and water, and increase the sugar
  if water-level > 1 and sun-intensity > 20 and chlorophyll > 1
    [ set water-level water-level - 0.5
      set chlorophyll chlorophyll - 0.5
      set sugar-level sugar-level + 1
      set attachedness attachedness + 5

  ;; Every tick of the clock, we reduce the sugar by 1
  set sugar-level sugar-level - 0.5

;; ---------------------------------------
;; fall-if-necessary:  If a leaf is above the bottom row, make it fall down
;; If it hits the bottom line, make it a dead-leaf
;; ---------------------------------------

to fall-if-necessary
  if attachedness > 0 [ stop ]
  if ycor > bottom-line
      let target-xcor (xcor + random-float wind-factor
                            - random-float wind-factor)
      facexy target-xcor bottom-line
      fd random-float (.7 * max (list wind-factor .5))

;; ---------------------------------------
;; change-color: Because NetLogo has a limited color scheme,
;; we need very simple rules
;; ---------------------------------------

to change-color
  ;; If the temperature is low, then we turn the
  ;; sugar into anthocyanin
  if temperature < 20 and sugar-level > 0 and water-level > 0
    [ set sugar-level sugar-level - 1
      set water-level water-level - 1
      set anthocyanin anthocyanin + 1 ]

  ;; If we have more than 50 percent chlorophyll, then
  ;; we are green, and scale the color accordingly
  ifelse chlorophyll > 50
       [ set color scale-color green chlorophyll 150 -50 ]

  ;; If we are lower than 50 percent chlorophyll, then
  ;; we have yellow (according to the carotene), red (according
  ;; to the anthocyanin), or orange (if they are about equal).

       ;; If we have roughly equal anthocyanin and carotene,
       ;; then the leaves should be in orange.
       [ if abs (anthocyanin - carotene ) < 10
           [ set color scale-color orange carotene 150 -50 ]

         if anthocyanin > carotene + 10
           [ set color scale-color red anthocyanin 170 -50 ]

         if carotene > anthocyanin + 10
           [ set color scale-color yellow carotene 150 -50 ]

to change-shape
  ifelse leaf-display-mode = "solid"
    [ set shape "default" ]
  [ if leaf-display-mode = "chlorophyll"
      [ set-shape-for-value chlorophyll ]
    if leaf-display-mode = "water"
      [ set-shape-for-value water-level ]
    if leaf-display-mode = "sugar"
      [ set-shape-for-value sugar-level ]
    if leaf-display-mode = "carotene"
      [ set-shape-for-value carotene ]
    if leaf-display-mode = "anthocyanin"
      [ set-shape-for-value anthocyanin ]
    if leaf-display-mode = "attachedness"
      [ set-shape-for-value attachedness ]

;; returns all leaves still attached

to-report attached-leaves
  report leaves with [attachedness > 0]

;; makes the leaf appear to be more or less filled depending on value

to set-shape-for-value [value]
  ifelse value > 75 [ set shape "default" ]
  [ ifelse value <= 25 [ set shape "default one-quarter" ]
    [ ifelse value <= 50 [ set shape "default half" ]
                         [ set shape "default three-quarter" ]]]

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

There are 2 versions of this model.

Uploaded by When Description Download
Michelle Carr over 11 years ago Version 2, with reflection Download this version
Michelle Carr over 11 years ago Initial upload Download this version

Attached files

No files

This model does not have any ancestors.

This model does not have any descendants.