SugarScape

SugarScape is a model developed by Joshua Epstein and Robert Axtell (see references.)

In the first version hungry agents roam the countryside looking for sugar. As they roam, they burn sugar at a rate determined by their metabolism. If an agent burns up all of his sugar before he finds more, he dies. An agent's ability to spot sugar is determined by how far it can see. This is controlled by its vision attribute.

When an agent discovers a patch of sugar, he consumes it and resumes his search for more sugar. Eventually, the patch will grow more sugar at a rate determined by its growBack attribute.

By playing with these parameters-- metabolism, vision, and growBack-- users can gain insight into phenomena such as carrying capacity, distribution of wealth, seasonal migration, and resource consumption.

In version 2 agents have finite life times and the ability to mate. In this version users can also gain� insight into phenomena such as fertility, cultural dynamics, proto-history, even combat.

In version 3 a second commodity is introduced: spice. An agent rich in sugar but poor in spice can trade with an agent in the opposite situation. The number of units of spice equivalent to a unit of sugar fluctuates according to supply and demand. The model provides interesting insights into the performance of markets populated by rational agents versus markets populated by evolving agents.

In version 4, disease is added to the model. Users can study the transmission of disease, the effects on the economy, and disease control policies.

CNP SugarScape

CNP SugarScape is a version of SugarScape 1.0 described above, but with a twist. Instead of vision, turtles have a broadcast range. Following the Contract Net Protocol (CNP), turtles broadcast requests for proposals (rfp's). Patches that receive these requests may send proposals back to the turtle. The turtle selects the best proposal, and moves toward the patch to pick up the sugar.

Here is CNP SugarScape at initialization. Note that there are 100 turtles. Each has a random broadcast range (0 � 5 patches), a random metabolism (0 � 0.3), and a random initial endowment of energy (0% � 100%). The average energy is 50.29%.

After a short amount of time the population stabilizes at 39 turtles with an average energy of 26.53%. This is the environment's carrying capacity.

Design

Every turtle in SugarScape has a proposal queue, every patch has an rfp queue. Turtles place rfps in the rfp queues of nearby patches. An rfp contains a reference to the turtle that created it.

If a patch decides to respond to an rfp in its queue, it places a proposal in the proposal queue of the turtle that sent the original rfp. The proposal contains a reference back to the patch that created it.

Here it is as a class diagram:

Implementation

The Sugarscape model (ss.nlogo) is a good introduction to the NetLogo language. It is further analyzed in overview3.html.

Agent Attributes

Including the proposal queue, a turtle has six attributes:

turtles-own [
�� energy ���������� ; dead = 0% <= energy <= 100%
�� metabolism ������ ; rate sugar is burned by moving <= 0.3
�� proposal-queue �� ; patches put proposals here
�� broadcast-range � ; how far can rfps be transmitted <= 5
�� hasProposal ����� ; = true if turtle has accepted a proposal
�� target����������� ; = the patch that made the accepted proposal
]

A patch has three attributes:

patches-own [
�� sugar ����������� ; = amount of sugar here <= 100%
�� grow-back ������� ; how fast sugar is replenished <= 5
�� rfp-queue�������� ; turtles put rfp's here
]

Agent Initialization

We begin with the standard initialization procedures:

to init-agents
�� ca
�� init-turtles
�� init-patches
�� repeat 5 [diffuse sugar .1]
end

to init-turtles
�� crt 100
�� ask turtles [init-turtle]
end

to init-patches
�� ask patches [init-patch]
end

A turtle is initialized with a random energy, metabolism, position, and broadcast range. The redness of the turtle reflects its energy level.

to init-turtle
�� set energy random 100
�� set metabolism random-float 0.3
�� set broadcast-range 5
�� set hasProposal false
�� set proposal-queue []
�� setxy random-xcor random-ycor
�� set color scale-color red energy 140 0
end

A patch is initialized with a random amount of sugar and a random grow back rate. The greenness of a patch reflects how much sugar is present.

to init-patch
�� set sugar random 100
�� set grow-back random 5
�� set rfp-queue []
�� set pcolor scale-color green sugar 140 0
end

Updating Agents

We begin with the usual machinery for updating agents:

to update-agents
�� update-turtles
�� update-patches
end

to update-patches
�� ask patches [update-patch]
end

to update-turtles
�� ask turtles [update-turtle]
end

A patch goes through cycles of making proposals and growing sugar:

to update-patch
�� make-proposals
�� grow-sugar
end

A turtle goes through cycles of making rfp's and seeking sugar:

to update-turtle
�� make-rfps
�� seek-sugar
end

Requesting and selecting proposals from patches

If a turtle has no proposal, it selects a proposal from its queue. If the queue is empty, the turtle broadcasts an rfp:

to make-rfps
�� if not hasProposal
����� [
�������� ifelse empty? proposal-queue
����������� [make-rfp]
����������� [select-proposal]
����� ]
end

A turtle sorts its proposal queue by distance and awards the contract to the nearest patch:

to select-proposal
�� set proposal-queue
����� sort-by [distance ?1 < distance ?2] proposal-queue
�� set target first proposal-queue
�� set hasProposal true
�� set proposal-queue []
end

A turtle "makes" and rfp simply by putting a reference to itself into the rfp queues of all nearby patches.

to make-rfp
�� locals [near]
�� set near patches in-radius broadcast-range
�� ask near [set rfp-queue lput myself rfp-queue]
end

Note the use of myself instead of self. In NetLogo self always refers to the agent executing a command, while myself refers to the agent asking for a command to be executed.

Seeking and consuming sugar

Each cycle a turtle advances one step toward its target. When it arrives, it consumes sugar. If a turtle has no target, it moves twice the distance of its broadcast range looking for new sources of sugar:

to seek-sugar
�� ifelse hasProposal
����� [
������ ��ifelse target = patch-here
����������� [consume-sugar target]
����������� [move-toward target 1]
����� ]
����� [move-toward one-of patches broadcast-range * 2]

end

A turtle converts sugar into equal amounts of energy:

to consume-sugar [p]
�� locals [old-energy]
�� set old-energy energy
�� set energy max (list (value-from p [sugar]) 100)
�� ask p [set sugar
����������� � sugar - ((value-from myself [energy]) - old-energy)]
�� set hasProposal false
�� move-toward one-of patches 2 * broadcast-range
�� type self
�� print " has consumed sugar"
end

As a turtle moves, it consumes energy according to its metabolism rate:

to move-toward [goal steps]
�� face goal
�� fd steps
�� set energy (energy - energy * metabolism * steps)
�� set color scale-color red energy 140 0
�� if (energy <= 0)
�� [
����� type self
����� print " is dying"
����� die
�� ]
end

Making proposals and sugar

If a patch has sugar, it places a proposal, which is simply a reference to itself, into the proposal queue of every agent in its rfp queue provided that 1. the agent hasn't died and 2. the agent hasn't accepted a proposal from another patch:

to make-proposals
�� locals [candidate]
�� if (0 < sugar)
�� [
����� if (not empty? rfp-queue)
�������� [set candidate (first rfp-queue)]
����� while [not empty? rfp-queue and
����������������������� ((candidate = nobody) or
����������������������� (value-from candidate [hasProposal]))]
����� [
�������� set rfp-queue bf rfp-queue
�������� if (not empty? rfp-queue) [set candidate (first rfp-queue)]
����� ]
����� if not empty? rfp-queue
����� [
�� ������ask candidate
����������� [set proposal-queue (lput myself proposal-queue)]
�������� set rfp-queue bf rfp-queue
����� ]
��� ]
end

If sugar level is below 50, a patch incrementally adds a tiny bit of sugar on every cycle. Note the color being restored:

to grow-sugar
�� if sugar < 50
����� [ set sugar min (list 100 (sugar + grow-back)) ]
�� set pcolor scale-color green sugar 140 0
end

Gathering statistics

Here are a few simple statistics:

to-report avg-energy
�� locals [result]
�� ask turtles [set result result + energy]
�� report result / (count turtles)
end

to-report population
�� report count turtles
end