Exploring NetLogo Models¶

NetLogo is an application that uses simulation to explore phenomenon in a wide variety of subjects. The figure below shows the initial display that is presented when NetLogo is run. As we explore NetLogo further, we will learn more about some of the NetLogo interface.

First, note the “Search the Models Library:” menu in the upper left corner. We will see next how to find pre-developed NetLogo simulation models under the “Search the Models Library:” menu. Also, note the large black area. This is the main simulation display. When a simulation model is run, the visualization of the model will be shown in this display area.

NetLogo contains a large number of models that have already been developed in different subject matter areas. To explore the model library, select the “Search the Models Library:” menu as shown in the next figure.

Opening the NetLogo Model Library

When the “Models Library” option is selected, a list will show the index of the sample models. By scrolling down you can see, there are sample models in art, biology, mathematics, social science, and other fields. There are over 100 sample models in total. The models library also contains a collection of Curricular Models, models that have been developed for use in specific courses.

You can search or filter the models using keywords by typing them at the top of the list. By typing the keyword "Biology", the list becomes constrained to show only Biology models (some models are greyed out and cannot be run). The first two NetLogo models in the Biology categories are named “AIDS” and “Ant Lines”.

Models Related to "Biology" in NetLogo

By clicking on the name of NetLogo model, you can see a description of the model. For example, clicking on the “AIDS” loads the model on the system. You will see here a collection of user interface controls (button, sliders, graphs). We will learn more in the next section about what controls like this do in NetLogo.

Opening a NetLogo Model

However, we can learn more about the model by reading the author’s description of the model. You can see this description by selecting the “Model Info” tab near at the bottom of the NetLogo window. The description for the “AIDS” model is shown in the following figure.

Looking at the Description in the “Model Info” Tab

In this figure, you can see the first section of the “AIDS” model description. A typical model description has these sections:

• WHAT IS IT? - a general understanding of what the model is trying to show or explain.
• HOW IT WORKS - the rules the agents use to create the overall behavior of the model.
• HOW TO USE IT - a description of each of the items in the interface tab.
• THINGS TO NOTICE - suggestions for things to observe while running the model.
• THINGS TO TRY - suggestions for things the user can do to control the model (move sliders, set switches, etc.) especially if these illustrate interesting conditions or patterns of behavior.
• EXTENDING THE MODEL - things to add or change in the model’s implementation to make the model more complicated, realistic,, meaningful, etc.
• NETLOGO FEATURES - any interesting or unusual features of NetLogo that the model uses in its implementation.
• RELATED MODELS - other models in the NetLogo Models Library or elsewhere that deal with related concerns.
• CREDITS AND REFERENCES - where to find the model on the web as well as other credits, citations, and links related to the model.

You should now be able to explore the NetLogo model library. In a similar way, you can explore the User Community Models using your web browser.

Running a NetLogo Model¶

The example model can be downloaded from CT-Class-Model.nlogo Download CT-Class-Model.nlogo. You can upload your own NetLogo model by clicking on the "Choose File" button next to the "Search the Models Library" menu.

Our next goal is to learn how to run a NetLogo model. The model we will study is a simple ecological model, named the “CT-Class-Model”. It explores a population of turtles who feed on a renewable resource (grass) to survive and multiply. This model can be used to answer such questions as whether a given population size is sustainable, what happens to the population under different assumptions about the quality of the grass on which the turtles feed, and how the renewable resource is affected by the changes in the size of the turtle population. This is a simple model, of course, and you could likely think of other factors that a more comprehensive model might include.

When run, the “CT-Class-Model” presents the initial window shown in the next figure. You should recognize the main simulation display window (the black panel in the center right of the window). On the left side of the display are some controls (two buttons, an on-off switch, and three sliders). Below these controls are three additional “monitors” that give information during a run of the simulation.

A Simple Ecological Model

Before the simulation can be run, it must be initialized by pressing the “Setup” button (upper left among the controls). Pressing the “Setup” button tells NetLogo to use the current settings of the on/off switch and the sliders for the simulation run. For this first run, we will use the initial settings. When the “Setup” button has been pressed (clicked on), the window appears as shown in the following figure. Three things have changed. First, the main simulation display area is no longer a black blank area. Instead, the background color is green, representing the grass, and a collection of turtles has appeared, represented by variously colored oval-like shapes. The turtles are placed at randomly chosen places in the environment. The number of turtles initially created is determined by the topmost slider. This slider has the label “number” and shows the current setting for the slider on the right part of the slider. As you can see, the slider is currently set at “85”. Second, notice that the two monitors on the bottom left have changed. One monitor, labeled “count turtles”, shows “85”, the current number of turtles. The other monitor is labeled “green patches” and has the number “1089”. NetLogo divides the simulation display into a grid of “patches” that is 33 by 33 (thus a total of 1089). The third monitor, labeled “Totals” at the top, is currently blank. This area will show a graph of turtles and patches as the simulation progresses. At this point, we are ready to begin the simulation.

Initializing the Model using the Setup Button

To run the simulation, simply press the “Go” button. Notice that the “Go” button changed its color to indicate that is now pressed “down”. As long as the “Go” button is pressed down, the simulation will continue to run. To stop the simulation, press the “Go” button again. Notice that the “Go” button changes back to its original color indicating that it is in the “up” position. Whenever the “Go” button is in the up position, the simulation is stopped. Pressing the “Go” button again resumes the simulation. If you want to restart a running simulation, simply press the “Go” button, putting the “Go” button in the “up” position, and press the “Setup” button.

When our simple NetLogo model simulation is running, four areas are constantly being updated. The figure below shows the NetLogo simulation of our model when the model has been stopped after a few steps in the simulation. First, the main simulation panel now shows both green and black patches. In our model, a patch is black when the grass has been eaten by a turtle and the grass has not had time to grow back. The set of black and green patches constantly changes as the turtles move around to find new grass to eat, changing a green patch to black, and as the grass grows back, changing a black patch to green. You will also see in this display that the number of turtles changes and that the location of each turtle changes. These changes represent growth in the turtle population by breeding of well-fed turtles and the turtles’ search for new grassy patches to eat. Second, the number of turtles, currently 523, is shown in the “count turtles” monitor. Third, the number of patches with grass, currently 202, is shown in the “green patches” monitor. Fourth, both the number of turtles and the number of green patches are shown in the graph in the “Totals” monitor. This graph shows the changes over time in the size of the turtle population and the number of grassy patches. The number of turtles is shown by the black line in the graph and the number of grassy patches is shown by the green line in the graph. As you can see, the turtles rapidly consumed many of the grassy patches and the number of turtles grew rapidly and then diminished slightly in number. The decline in the number of turtles is due to the death of turtles that cannot find grass to replenish their energy level.

You should now be able to run a NetLogo model and, by manipulating the controls in the model’s user interface, be able to explore the behavior of the model under different conditions.

Agents-Based Modeling¶

NetLogo uses a form of computational modeling called agent-based modeling. In agent-based modeling, the principal entities of interest are “agents” which operate in an “environment”. There are usually a few “types” (or “kinds”) of agents with many individual agents of each type. For example, in our simple ecological model, there are two types of agents: turtles and grassy patches.

The agents have, or own, a certain set of properties that describe their condition or features. All of the agents of a particular type (or kind) have the same properties but may have different values for these properties. For example, two turtle agents each have a location property but the two turtles are probably at different locations. Similarly, all grassy patch agents have an energy but some grassy patches may have more energy than others.

The agents’ actions are determined by a set of “rules”. The rules tell an agent how to change itself over time, how to interact with other agents, and how to react to changes in its environment. The agent’s rules determine the behavior of the specific agent. The rules and properties of an agent allow the agent to behave differently at different times. For example, if the agent represents a “person”, the agent may have an age property and rules that allow the agent to behave differently when it is is older than when it is younger. A “younger” person may be able to run faster than an “older” person. The general form of a rule is:

condition -> action(s)

This means that when a stated condition is true, the agent takes a particular action. For example, in our simple ecological simulation, one rule for a turtle might be:

"when on patch with grass" -> "eat grass"

This rule says that whenever the turtle agent finds itself on a grassy patch with grass, then the turtle should eat the grass. We will see later how such rules can be represented in a computer using NetLogo’s programming language.

Agents may be mobile-that is, capable of changing their location in the environment. For example, animals that are foraging for food, or vehicles moving in a city, are agents of this kind. Other agents may not be mobile; that is, they always are at the same location in the environment. For example, plants that are eaten by foraging animals, geographic features (lakes, mountains), and structures (buildings, streets) are agents of this kind. Agents that are mobile often have rules that define how they move about in the environment. These rules may allow for undirected (“random”) movement or more purposeful movement (“move to the nearest location with edible plants” or “turn right at the next intersection”). Agents that are not mobile often have rules that describe how they change over time or in reaction to other agents. For example, a stationary plant agent may have rules that describe how long it takes to regrow after being eaten or how much nutritional value it has, given the rain and soil conditions.

The environment describes what the world around the agents looks like. For simplicity, the environment is often divided into basic units. NetLogo, for example, divides the world into a rectangular grid. Each element of the grid is a basic unit. In NetLogo, these basic units are called “patches”. The basic units of the environment also have properties and rules.

An example of an agent-based system is the simple ecological model that represents a population of turtles in an environment of grassy patches. The figure below shows the NetLogo simulation display for this model. One property of a turtle in this model is the turtle’s age. The age is interesting to represent because it affects when the turtle can reproduce or how long the turtle can live. The environment consists of grassy patches. Properties of each patch is the nutritional value of the grass and the length of time needed to regrow the grass after it has been eaten by a turtle. The rules for a turtle determine how it moves around in the environment in search of grass to eat, whether it reproduces, and whether it survives or dies in a given condition. These rules are based on the turtles own properties (e.g., its age) and the environment (whether there is grass where the turtle is). The patches’ rules determine what level of nutrition it has when eaten and when it is regrown after being eaten.

The Simulated Agents in the Simple Ecological Model

More examples of agent-based systems will be described below. You can also explore other models in the NetLogo library.

A computational tool for agent-based system proceeds in a step-by-step fashion. Each “step” corresponds to the passage of some time. In NetLogo, each step corresponds to the “tick” of an imaginary clock. At each step, the rules of the agents and the environment are evaluated and the properties of the agents and the environment are updated. Because the computation is driven by the rules of the agents and the environment, the term rule-based systems is also used to describe this form of computation. In the blackjack system a step might consist of the dealer agent placing a card on the table in front of a player and the player deciding whether to stop or ask for another card. In the ecological simulation a step might consist of all the turtles moving a new location and eating grass if it is available at their current location.

Simulation plays an important role in agent-based modeling systems. Once the properties and rules for the agents and the environment have been defined a computational tool allows us to see how the system of agents changes and evolves. The figure above shows one example of the NetLogo simulation of the simple ecological system. One aspect of simulation system is the role of randomness. For example, in a simulation of the blackjack system there is a randomness inherent in the shuffling of the cards. It would easy to win if the cards were always dealt in the same order. When the cards are shuffled they are arranged in a random order. This is, after all, the purpose of shuffling. Non-random arrangement of the card deck often results in fights in Western movies. In the ecological model the turtles start out at random places in the environment and move around randomly thereafter. Because of this randomness, one simulation, often called a “run”, will be different in detail from the next simulation of the same system with the same setting. This is realistic because one round of blackjack is different from the next round.

In addition to the basic properties and rules, an agent-based model often has a number of “parameters.” These parameters define initial conditions, boundary conditions, or settings against which rules are evaluated. For example, in a blackjack simulation the parameters might define the number of players or the number of chips a player has (initial conditions), how many hands will be played (a boundary condition), or the card count at which the dealer “stands” (a setting). In the ecological model the parameters might define how many turtles are present at the beginning (an initial condition), the number of time steps in the simulation (a boundary condition), or the energy that the turtles gets from eating grass (a setting). By exploring the effects of different parameter settings, insight can be gained into the model. These insights can be the basis for human actions or policies in the real world.

Modeling and Computational Thinking¶

Agent-based modeling illustrates the two key components of computational thinking: abstraction and algorithms. Recall that abstraction represents real-world entities by their relevant information properties. An algorithm is a precise, step-by-step set of directions on how to manipulate the information properties.

The developer of an agent-based model uses abstraction in defining the relevant set of agents and the specific information properties of the agents.In the simple ecological model the model developer chose two types of agents - turtles and grass patches. For each turtle only several properties were considered relevant: the location, the current energy level, and the age. For each patch of grass the relevant properties were the energy content and its state of growth (grown or growing back after having been eaten). There are, of course, many more properties that could be included. To name a few:

• the sex of the turtles could be recorded so that genetic traits in the turtle population could be tracked; these traits may affect the efficiency of converting grass to energy
• water may be a factor in the environment and the turtles need for water could be included as a property
• predators or diseases in the environment could be included as additional agents with their own properties
• environmental factors like rainfall or sunshine that affect plant (re)growth and energy content could be added

The point is that the model developer decides, based on the questions to be answered, what entities are to be modelled and what information properties of these entities are included in the model. Abstraction does not tell the developer what to include but it does focus the developer on properties that can be represented in information terms.

The developer of an agent-based model uses algorithms to describe how the information properties of the agents are manipulated computationally. For example, the developer may describe that a turtle:

• looks around for the nearest grown grassy patch that is not occupied and starts moving in that direction,
• propogates if the turtle is within a certain age range and is at a high energy level
• dies it has no energy or is beyond a certain age
• gains energy as it eats grass and losses energy as it moves.

You could likely imagine other rules that might be part of the turtle’s behavior.

In considering the action taken by the turtle agent we can begin to see the outlines of the basic elements of the algorithmic process. Specifically, we can see:

• decision: the actions that the turtle agent takes depends on the conditions that exist at the time. For example, one of the rules above is that the ability for a turtle to propogate depends on the turtle’s age and its current energy level. To implement such a rule, the algorithmic process must have some way of making decisions and, based on the decision, either taking or not taking certain actions. Decisions are a way to make algorithms “smart”, adapting its actions to different circumstances.
• iteration: a turtle does not perform its steps a single time. Rather, the algorithm, once performed, may put the turtle in a new location (if it moves), may change its energy level (if it moves or eats grass), or have other effects. But we are not done. Just as real turtles take step after step - eating, moving, and propogating over time - so we also want our computational model of the turtle to behave in the same way. We want to have the turtle repeatedly perform its basic rules. This repeating of rules or steps is called iteration. Iteration makes algorithms powerful because it allows the entire lifetime of an entity to be modeled by repeating its basic steps over and over. We will see later that the power of iteration is also critical to processing “big data” because we need to perforrm the same steps to each each part of the data.
• sequence: the order in which the turtle’s rules are evaluated can make a different in how the turtle behaves. For example, consider a turtle who uses its last bit of energy to reach a grassy patch. There are two rules in the turtle’s algorithm:

1. if you have no energy then die
2. if you are on a grassy patch then eat and gain energy

For the turtle in question if the rules are considered in the order (1) followed by (2) then the turtle will die. However, if the rules are considered in the order (2) followed by (1) then the turtle will survive. Other similar cases can be found even in the simple case of our turtle. This example illustrates that the order of the steps in an algorithm is significant.

• action: an “action” is anything that an automated device has been built to perform. For example, robots might have action about moving their limbs. Automated cars (autonomous vehicles) can turn right or left. A typical “computer” can perform basic arithmetic (+, -, x, /) and logical (and, or, not) operations. Often, an “action” has the effect of changing some property of the computational model. Later in this course we will work with “big data” to take advantage of the ability of computers to perform arithmetic and logical calculations. For example, a typical computer can add to numbers in a small number of nano-seconds. A nano-second is a billionth of a second. In one nano-second light travels just one meter. In our simple turtle model simple calculations are needed to add and subtract from the turtles energy, to determine the numbers that represent the turtles new location, and to add to the turtles age. In some cases much more complex calculations are needed. For example, machine learning algorithms attempt to discern patterns in billions of pieces of data by using sophisticated mathematical and statistical calculations. In this class, the calculations will remain relatively simple.
• state: the world around is never exactly the same from moment to moment: the earth turns, people move, birds fly, the rain begins or stops. Similarly, our computational models of the real-world must reflect such change over time. For example, the age of our turtle increases over time, the energy of a single turtle changes (decreasing as it moves and increasing when it eats grass), the number of turtles in the model increases as turtles propogate and decreases when they die. The “state” of a computational model is the current values of all the properties in the model. In our simple model, the state is the age, energy, and location or all turtles and the condition of all of the grassy patches. The state is related to the other elements of algorithms. For example, a decision is made is on the basis of the “current” state (e.g., testing the current energy level of a turtle). Similarly, an action typically changes one or more properties leading to a “new” state. For example, if an autonomous vehicle turns right it changes the state of the vehicle and the property of the vehicle’s heading (or direction) is changed in the “new” state. Similarly, in the simple turtle model the action of a turtle movin changes both the turtle’s location (its coordinates on same map) and the turtle’s energy (decreasing its energy level). The “new” state then becomes the “current” state for the next step in the algorithm. In this way, a computation proceeds in a discrete manner from one state to another state one algorithmic step at a time.

These five elements - decision, iteration, sequence, action, and state - are at the heart of the algorithmic process. We will gradually expand our understanding of these elements and how to use them. Although there are only four elements, they can be composed to form algorithms that are as complex as needed to answer the questions for which the computational model is defined. By analogy, the genetic DNA code has only four basic elements, the nucleobases referred to as A, C, G, and T, from which DNA is constructed. Working with only these four nucleobases creatures of enormous complexity, versatility, and capability - from simple algae to human beings - are created. Similarly, working with only the five basic elements of algorithms we can create an algorithmic process for a computer to perform that is similarly complex, versatile, and capable.

Emergent Behavior¶

Agent-based system are often used to explore what is called “emergent behavior” of complex systems. The behavior of an individual agent is well understood - its behavior is encoded in its set of rules. For example, the rules for the turtles in the simple ecological model can be defined. However, the “system” formed by many (hundreds, thousands, millions) of agents interacting with each other and their environment also has a behavior. The system’s behavior is characterized by global properties of the agents and the environment. For example, in the simple ecological model, global properties might be how many turtles there are, how much energy is in the grassy patches, etc. We are often interested in knowing what happens over a long period of time. For example, does the turtle population stabilize at some level? does it wildly oscillate? or do the turtles die out. This long term behavior “emerges” over time. For many interesting systems it is not always easy, and may not currently be possible, to predict mathematically the “emergent” behavior given the knowledge of the rules for the agents and the environment. Thus, simulations of agent-based models are used to explore a system’s emergent behavior.

Unfortunately, no single simulation run of an agent-based model completely reveals the emergent behavior for two reasons. First, each simulation has some amount of random decision-making that makes each simulation run different from other simulation runs of the same model. Even though each simulation run is driven by some measure of randomness, systems often exhibit long-term behavior that is strikingly similar across different simulation runs. For example, we might see that a given blackjack “system” (i.e., the rules for a player agent) tends to lead to the loss of all chips very rapidly whereas another system tends toward oscillations in the number of chips over time but does not cause the player to go “bust.” In the ecological system we might observe that certain parameter settings almost always leads to extinction of the turtle population (too many turtles and not enough nutrition in the grass) while other parameter settings lead to a sustainable population of turtles and grassy patches. Second, agent-based models often have parameters that describe the initial condition of the simulation. For example, in the simple ecological model one parameter is the number of turtles that the simulation starts with. Another parameter determines how much energy the grass contains. Intuitively, a simulation run with a few turtles in a very lush environment (one where the grass has a high energy level) is likely to show a different long-term behavior than a simulation run with many turtles in a very barren environment (one where the grass has little energy). Discovering the emergent behavior involves studying many simulation scenarios for each of a variety of parameter settings.

There are many examples where agent-based modeling is used to explore the emergent behavior of complex systems. Among these examples are the following.

• economics: The national economy consists of numerous kinds of economic “agents” each making decisions to improve their material well being. Agents include individual persons making decisions on purchasing goods and services, institutions (banks, investment firms) that seek return on their investments, business providing goods and services, and governments whose policies regulate the fairness of the marketplace. While it is possible to model potential behaviors of these individual types of agents, the number of agents and the complexity of their possible interactions makes it impossible to mathematically determine overall measures of the economy (gross national product, income levels, bank stability). However, agent-based modeling can be used to study the emergent behavior of an economic model. Such a model could be used by regulatory agencies to study the potential impacts of various policies on economic growth or by businesses to determine the best strategies for managing its resources in the market place. Here are some other places that describe how agent-based modeling is applied to economics:
  • Agent-Based Computational Economics .
  • The economy needs agent-based modelling .
  • New model army .

Many other examples can be found.

• natural resource management: As the world’s population grows there is increasing attention given to how renewable natural resources are used. Natural resources include forests, fisheries, grass lands and the wildlife in these habitats. Computational agent-based models can be used to study the impact of different usage patterns and their impacts on the sustainability of the resources. The agents model the behavior of resources users (timber companies, fishing fleets, cattle producers) and the elements of the resource itself (acres of a forest, characteristics of fish habitats, square miles of grasslands). The emergent behavior can be studied to find patterns of use that avoid extinction of the resource and identify “tipping points” where the sustainability is lost. Some example of this use of agent-based model are:

  • Agents, individuals, and networks: modeling methods to inform natural resource management in regional landscapes.
  • Agent Based Modelling in Natural Resource Management.
  • An agent-based simulation model of a nutrient trading market for natural resources management .

• epidemiology: In an increasing connected world with travel to virtual anywhere in the world possible in a day the ability to detect and control the spread of infectious diseases is an important national and international issue. The current (in 2014) outbreak of the Ebola virus in West Africa is but one example of this need. Even within develop countries the spread of flu viruses is a significant concern. Agent-based models can be used to assess various tracking and containment protocols. What is the best way to use a limited supply of vaccine? Should everyone in the immediately affected area be vaccinated leaving the rest of the population exposed? Should only those in immediate contact with an infected person be vaccinated reserving the majority of the supply to treat other outbreaks? In an agent-based model the agents represent people who, when in proximity, can receive from or transmit to the infection others. Here are some example of this use of agent-based models and emergent behavior:

  • A New Tool for Epidemiology: The Usefulness of Dynamic-Agent Models in Understanding Place Effects on Health .
  • An agent-based approach for modeling dynamics of contagious disease spread .
  • An Agent-Based Spatially Explicit Epidemiological Model in MASON .

• molecular modeling: Understanding the properties of organic and inorganic materials at the molecular level is important to answering basic questions in many fields of science. In an agent-based system each atom or molecule is modelled by an agent. The physical interactions is defined by the rules that the agents follow in interacting with other agents. In chemistry notions of self-assembly of molecules can be studied. In biology various kinds of diseases can be studied using this technique. Here are others:

  • An agent-based approach for modeling molecular self-organization .
  • An Agent-based Modeling Apprach for Stochastic Molecular Events of Biochemical Networks .
  • An Artificial Intelligence Approach for Modeling Self-assembly: Agent-based Simulations of Rigid Molecules .
  • Multi-scale agent-based brain cancer modeling and prediction... .

• artistic performance: The performing and visual arts intersect with agent-based modeling ideas in interesting ways. In one case, the notion of dancers behaving according to a set of rules that defined one dancers movements in response to other dancers and the environment. This form of dance is termed “flock logic” because it derives from agent-based models of flocking behavior in animals. In the visual arts, the term “generative art” refers to creations that involve a computational element. One form of generative art uses agent-based techniques in creative ways. The Processing system for generative art is based on agent-based ideas.

  • Flock Logic .
  • OpenProcessing .
  • Generative Art: a practical guide to using processing .

Many other kinds of systems have been studies through agent-based modeling in economics, social sciences, the arts, chemistry, physics, and others. The NetLogo library contains over 100 such models. A quick search on the web will yield a wide variety of other uses of this computational technique (see for example OpenABM and RunTheModel.