globals 
   [  sample-cyclist  ;; one cyclist whose movement can be tracked
      avg-speed  ]    ;; allows for the creation of graphs 
    
turtles-own 
 [ cyclists          ;; agentset of nearby turtles, called cyclists
  nearest-neighbor   ;; closest one of cyclists
  speed ]
  ;; set random speeds within a given range 
  ;; note that "speed" is more accurately described by power-output
  ;; however, for simplicity and ease of understanding, we use the concept of speed 

to setup
  clear-all
  crt peloton-size
      
    [  setxy random-xcor min-pxcor + 40 setxy random-xcor max-pxcor  - 40
       setxy random-ycor min-pycor + 8 setxy random-ycor max-pycor - 3
       set heading 90 ]
              
    crt peloton-size
    [  setxy random-xcor min-pxcor + 40 setxy random-xcor max-pxcor  - 40
       setxy random-ycor min-pycor + 8 setxy random-ycor max-pycor - 4
       set heading 90 ]
    
    
    crt peloton-size
    [  setxy random-xcor min-pxcor + 40 setxy random-xcor max-pxcor - 40
       setxy random-ycor min-pycor + 8 setxy random-ycor max-pycor - 5
       set heading 90 ]
    
    crt peloton-size
   [  setxy random-xcor min-pxcor + 40 setxy random-xcor max-pxcor - 40
      setxy random-ycor min-pycor + 8 setxy random-ycor max-pycor - 6 
      set heading 90 ]
 
  ;; Creates the population of cyclists.
  ;; Slider adjusts the number of cyclists in random positions on each of four horizontal lines, 
  ;; facing directly to the right.
 
    
set sample-cyclist one-of turtles 
  ask sample-cyclist [ set color red ]
  ride sample-cyclist 
  reset-ticks
 end
 
 ;; This selects the cyclist whose movement can be tracked, indicated by a circle on the interface screen
 
to setup-road  
  if (pycor < 9) and (pycor > -9) [ set pcolor black ]
 end

;; Sets the width of the roadway.

to go
 
ask turtles [ peloton ] 
repeat 5 [ ask turtles [ fd speed ] 
display  ]
  ;; Connects to "to peloton rules."         
  ;; Setup for basic forward speed display/animation rules.
 
ask turtles with [count turtles-here > 1]
  [ decelerate
    separate ]       
  ;; This is a collision-avoidance rule.
  ;; It checks if there are more than one cyclist on the same patch.
  ;; If yes, then separate cyclists since they cannot share a space.
  ;; This is akin to cyclists bumping or coming within a safe zone, but separating to avoid staying in that zone
tick   
  ;; this is the Netlogo time-counter                           
     
end


to decelerate
  
let cyclist-ahead turtles-here in-cone 3 60
 
  ifelse cyclist-ahead != nobody
    [set speed (speed * deceleration) fd speed]
    [set speed (speed * speed-ratio-to-cyclist-behind) fd speed]
    
  ifelse count turtles-here > 1
    [set speed (speed * deceleration) fd speed]
    [set speed (speed * speed-ratio-to-cyclist-behind) fd speed]

;;rule is designed to slow cyclists down if there is one ahead, so as to prevent them from running over each other
;; the rule also allows speed variations to show on the graph
     
end

to peloton 
  ;; Sets the main dynamics of the peloton. 
  ;; Align and cohere allow cyclists to gravitate toward each other; 
  ;; Separate allows them to move away from each other.
  ;; The "find-cyclists" rule is connected to the 'in-radius vision' rule, 
  ;; which allows cyclists to scan in the radius set by the slider
      
 
  find-cyclists 
  
  if any? cyclists
    [ find-nearest-neighbor
      ifelse distance nearest-neighbor >= drafting-zone 
      
        [ separate ]
        [ align 
          cohere ]]
    
  ;; This rule connects to 'in radius vision' rule. It says that all the peloton rules apply if cyclists are separated by a drafting zone.
  ;; If cyclists are separated by more than this zone distance, they can no longer draft and then move at random speed and direction, 
  ;; or according to other rules that may apply.
  ;; Note the following difference between this rule and Wilenski's flocking model, from which this is adapted:  
  ;; in Wilenksi's flocking model the rule is reversed, in this way: "nearest-neighbor < mininmum-separation",
  ;; whereby the rules are engaged when birds are within the separation range
        
  ifelse speed-ratio-to-cyclist-behind <= .9
      
    [ set speed [speed] of self * (sqrt speed-ratio-to-cyclist-behind * distance-farthest-neighbor) 
      set max-align-turn (0.01 + max-align-turn) * speed-ratio-to-cyclist-behind
      set max-separate-turn (0.38 - max-separate-turn) * speed-ratio-to-cyclist-behind
      set max-cohere-turn (0.38 - max-cohere-turn) * speed-ratio-to-cyclist-behind]
       
        [ align ]
    
    ;; This is an important peloton rule. The speed ratio is the speed of the cyclist "in the wind" relative 
    ;; to cyclists behind and in drafting posisions.
    ;; Where the speed ratio is less than .9, the cyclists farthest behind can go proportionately faster than those closer
    ;; to the front. So at low speed ratios, the peloton proceeds at low density and freer movement, with constant movement from those nearest 
    ;; the back forward. 
    ;; As the speed-ratio increases, density increases and the variation in speeds decrease. 
    ;; Here I've set .9 as an arbitrary threshold (but approximately corresponding to my PCR equation - see discussion) at which the peloton undergoes 
    ;; a phase transition to "stretched phase". 
    ;; The [align] rules indicates that where cyclists are above .9 ratio, they follow basic alignment rules. It is here that cyclists
    ;; stretch in single-file lines. 
      
  ifelse speed-ratio-to-cyclist-behind > 1

   [ set speed [speed] of self * speed-ratio-to-cyclist-behind ]
      [fd speed]
  
   ;; If the speed ratio is greater than one, the density rules and do not apply, and cyclists proceed according to their own
   ;; intrinsic speed multiplied by the speed ratio.
            
        
if patch-at 8 dy = nobody [
set heading (90 - random-float .1 + .01) ]
 
if patch-at -8 dy = nobody [
set heading (90 + random-float .1 + .01) ]
      
     ;; If cyclists bump into the edge of the world, they move toward centre at random degree.
      
      
  let cyclist-ahead turtles-here in-cone 1 45 
    ifelse cyclist-ahead = nobody
      [set speed [speed] of self * speed-ratio-to-cyclist-behind] 
      [set speed [speed] of self = cyclist-ahead ]
       
     ;; This is the rule that sets the speed-ratio function. If there are no cyclists immediately ahead, cyclists are effectively "in the wind"
     ;; and inevitably slow down relative to fresher riders behind who have been saving energy by drafting. Hence the speed ratio of those 
     ;; in the wind is set at fractions of the possible speeds of those in drafting positions. 
     ;; This mimics rapidly fatiguing cyclists at front and comparatively fresh cyclists behind, but it is also represents periods when riders in the wind
     ;; simply choose to ride slowly and come to the front and decelerate, at which time riders behind are proportionately fresher or are free to pass
     ;; because their own energy stores are proportionately high and useable for passing.      
     ;; Riders behind either match the speed of those ahead or, in order to avoid collision, pass the ones ahead, 
     ;; creating a continuous passing from behind dynamic.
        
     set speed  .1 + random-float .1 
     set avg-speed sum [speed] of turtles / count turtles 
     
     ;; sets random speeds when outside drafting zone
     ;; sets the graph procedure
  
   end
 
      
to find-cyclists 
  
  set cyclists other turtles in-radius vision 
  end

     ;; Scans for cyclists within the radius set by the slider "vision"
 

to find-nearest-neighbor 
  set nearest-neighbor min-one-of cyclists [distance myself]
  end
  ;; Scans for nearest neighbors

to separate  
  turn-away ([heading] of nearest-neighbor) max-separate-turn
  end
 
  ;; "Max-separate-turn" is a slider that adjusts in proprotion to the speed ratio.

;;; ALIGN

to align  
  turn-towards average-cyclists-heading max-align-turn
  end

  ;; Allows for side-by-side or single-file alignment. "Max-align-turn" is a slider
  ;; that adjusts in proportion to the speed-ratio.
  ;; These are computed using the "average-cyclists-heading" routine, below.

to-report distance-farthest-neighbor
 
  let farthest-neighbor max-one-of turtles in-cone 10 180 [distance self]
  report distance farthest-neighbor
  end

  ;; This computes the distance from each cyclist to their farthest neighbor ahead up to 10 patches,
  ;; and connects to the density function rule above.


to-report average-cyclists-heading  
  ;; We can't just average the heading variables here.
  ;; For example, the average of 1 and 359 should be 0,
  ;; not 180.  So we have to use trigonometry.
  let x-component sum [dx] of cyclists
  let y-component sum [dy] of cyclists
  ifelse x-component <= .15 and y-component <= .25
    [ report heading]
    [ report atan x-component y-component ]
  end

;; Adapated from Wilenski's flocking model. 
;; This computes cyclists average angle of heading forward, and allows for cyclists parallet alignment, either 
;; side-by-side, or in singl-file. 
;; x and y components in Wilenski's flocking model are set at 0 (the mean of the values above and below 0)
;; I've set these at the values indicated since they allow for a finer alignment of cyclists toward the y-component centroid
;; not that if the values are not those I've set, then they are reported out "atan" values


;;; COHERE

to cohere  
  turn-towards average-heading-towards-cyclists max-cohere-turn
  end

;; This allows cyclists to move toward each other.

to-report average-heading-towards-cyclists  
  ;; "towards myself" gives us the heading from the other turtle
  ;; to me, but we want the heading from me to the other turtle,
  ;; so we add 180
  let x-component mean [sin (towards myself + 180)] of cyclists
  let y-component mean [cos (towards myself + 180)] of cyclists
  ifelse x-component >=  .25 and y-component >=  .25
    [ report heading ]
    [ report atan x-component y-component ]
   end

  ;; Adapted from Wilenski's flocking model.
  ;; This computes the mean heading of other cyclists back to me.
  ;; Note the difference between the rule above, which computes angles from x and y coordinates "0". 
  ;; Here the angles are from other cyclists to me
  ;; The x and y components in Wilenski's flocking model are set at 0 (the mean of the values above and below 0)
  ;; I've set these at the values indicated since they reduce the y-component variation (or seem to!)

  
;;; HELPER PROCEDURES (incoporated from Wilenski's flocking model)

to turn-towards [new-heading max-turn]  
  turn-at-most (subtract-headings new-heading heading ) max-turn 
  end
;; Computes difference between the existing heading and the new-heading given by the "max-turn" function, and enables
;; movement towards each other.

to turn-away [new-heading max-turn]  
  turn-at-most (subtract-headings heading new-heading ) max-turn    
  end

  ;; Computes difference between the existing heading and the new-heading given by the "max-turn" function, and enables
  ;; movement away from each other.   


to turn-at-most [turn max-turn]  
  ifelse abs turn > max-turn
  
    [ ifelse turn > 0
        [ rt max-turn  ]
        [ lt max-turn  ]]
        [ rt turn ]
       
end
        
  ;; Turn right by "turn" degrees (or left if "turn" is negative),
  ;; but never turn more than "max-turn" degrees  
 


  
  
@#$#@#$#@
GRAPHICS-WINDOW
269
70
1087
269
50
10
8.0
1
10
1
1
1
0
1
0
1
-50
50
-10
10
1
1
1
ticks
30.0

BUTTON
39
93
116
126
NIL
setup
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
122
93
203
126
NIL
go
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
9
51
232
84
peloton-size
peloton-size
1.0
1000.0
20
1.0
1
NIL
HORIZONTAL

SLIDER
4
217
237
250
max-align-turn
max-align-turn
0.0
2
0.08999999999999991
.001
1
degrees
HORIZONTAL

SLIDER
4
251
237
284
max-cohere-turn
max-cohere-turn
0.0
5
0.17999999999999994
0.01
1
degrees
HORIZONTAL

SLIDER
4
285
237
318
max-separate-turn
max-separate-turn
0.0
5
0.17999999999999994
0.01
1
degrees
HORIZONTAL

SLIDER
9
135
232
168
vision
vision
0.0
10.0
10
0.5
1
radius bike-lengths
HORIZONTAL

SLIDER
9
169
232
202
drafting-zone
drafting-zone
1
5
4.6
.1
1
bike-lengths
HORIZONTAL

PLOT
6
354
207
504
density
x position
y position
-1.0
300.0
-1.0
25.0
true
true
"set-plot-x-range -1 (max-pycor * 2)\nset-plot-y-range -1 (max-pxcor * 2)\nset-histogram-num-bars round (max-pxcor / 2)" ""
PENS
"mean position" 1.0 1 -5298144 true "" "histogram [ycor + max-pycor] of turtles"

PLOT
442
356
642
506
avg-speed
time
speed
0.0
100.0
0.1
0.15
true
true
"" ""
PENS
"cyclists" 0.1 0 -2139308 true "" "plot sum [speed] of turtles / count turtles"

MONITOR
662
405
734
450
NIL
avg-speed
3
1
11

PLOT
225
355
425
505
speed of sample-cyclist
NIL
NIL
0.0
100.0
0.0
0.2
true
true
"" ""
PENS
"speed" 0.1 0 -16777216 true "" "plot [speed] of one-of turtles"

SLIDER
660
356
991
389
speed-ratio-to-cyclist-behind
speed-ratio-to-cyclist-behind
.2
1.5
0.91
.01
1
NIL
HORIZONTAL

SLIDER
270
289
458
322
deceleration
deceleration
0
2
0.99
.01
1
NIL
HORIZONTAL

@#$#@#$#@


The applet requires Java 5 or higher. Java must be enabled in your browser settings. Mac users must have Mac OS X 10.4 or higher. Windows and Linux users may obtain the latest Java from Oracle's Java site.


Peloton 1.01

By Hugh Trenchard 
November 2012

________________________________________

WHAT IS IT?

This model attempts to show certain peloton dynamics. The peloton motion that appears in this model is not created or led in any way by special leader cyclists. There is one arbitrary threshold rule, but it follows from actual peloton principles, which I have referred to in previous work as the "peloton convergence ratio" (1). Otherwise, each cyclist follows the same set of rules, from which collective peloton motion emerges. 

This model shows three main phases of peloton dynamics: 

	~ a low speed, disintegrated phase
	~ an increasing density phase
	~ a stretched (single-file line) or synchronized phase

There is also a mixed phase in which the peloton oscillates between stretching and disintegration at high speeds.


HOW IT WORKS

The model incorporates rules from Uri Wilenski’s Flocking model with several important adaptations I have introduced.
 
The following modifications represent principles specific to pelotons:

~ a random speed rule for cyclists; 

~ a rule which then limits cyclists’speeds to match the speeds of those 		    immediately ahead;

~ a rule that causes cyclists in front or "in the wind" to slow down relative to 		  those behind according to an adjustable ratio (“speed ratio”) such that when 			  the speed ratio equals a value of less than 1, cyclists in front slow down relative 
  to those behind, and if the speed ratio is 1 or more, cyclists in front move as 	    fast or faster than those behind;

~ when the speed ratio is less than one, cyclists behind can accelerate toward the 	
  front at speeds proportionate to the distance between themselves to the cyclist   
  farthest ahead, and proportionate to the speed-ratio; i.e. the lower the group density   (i.e. the more spread out it is) and the more slowly it moves, the faster riders from    behind can move toward the front

~ associated with the rule above, a rule that adjusts the density and free
  movement of cyclists in the peloton proportionately to the speed ratio; i.e. as speeds
  increase, density increases and free movement decreases;

~ a rule that says when the cyclists reach a speed ratio of > .9, 
  cyclists align into a single-file line (stretched, or synchronized phase). 

Speed ratios are adjustable by a "slider" on the interface screen. Starting at the lowest speed ratio setting and sliding it forward, we can see how the group speeds up and gradually density increases.

As the speed ratio is increased to the arbitrary, but realistic, threshold setting of .9, the peloton shifts from high density to a stretched phase, or single-file line. This demonstrates an important effect in pelotons when riders synchronize speeds at near sustainable maximums. Weaker riders can sustain the same speeds of stronger riders by taking advantage of the energy-savings benefits of drafting (2). As the speed-ratio is further increased, the synchronized (single-file) phase breaks down and the peloton then exhibits mixed phase dynamics as it oscillates between single-file lines and high separation.

The model is set to mimic a roadway on which all cyclists move to the right and, if  isolated on their own, will drift randomly at shallow angles. As a roadway, the “world” has barriers at the top and bottom of the world view, and cyclists cannot “wrap” above or below these barriers. This is unlike Wilenski's flocking model, in which the “world” is open ended, and birds can turn and wrap to the other sides of the world in all directions.

There are three rules incorporated from Wilenski’s Netlogo flocking model: “alignment”, “separation”, and “cohesion”.

“Alignment” means that a cyclists tend to turn so they move in the same orientation of nearby cyclists.

“Separation” means that cyclists turn away from others.

“Cohesion” means that cyclists move towards others.

I refer to these as the “ASC” rules.

[The following two paragraphs are technical points which can safely be ignored 
without missing the main points about the basic dynamics I have simulated.]

Under Wilenski's model, when two birds are too close, the “separation” rule overrides the cohesion and alignment rules, which are deactivated until the minimum separation is achieved. I have modified this rule so that the reverse happens here: when cyclists reach a minimum separation, all ASC rules are engaged; below the minimum separation, the rules disengage and all cyclists spread out without interacting. Put more simply: the greater the minimin separation setting for cyclists, the more likely the ASC rules are to engage, while in Wilenski’s flocking model, the greater the minimum separation setting, the less likely the rules ASC rules are to engage. This modification for the peloton model is important since it allows for the creation of an adjustable "drafting-zone" between cyclists, where the greater the drafting zone, the more the cyclists are able to interact. In my model, I have set the ASC rules so they correlate with variations in the speed-ratio.

Note that for realistic peloton behavior, the ASC sliders must be set very low so that the degree of random lateral movement is low. This simulates cyclists’ forward movement along a roadway, rather than birds in the air which can move in any direction. 
Also note that the ASC rules affect only the cyclist’s heading, and not their speeds. In Wilenski’s model, each bird always moves forward at the same constant speed, whereas in my model, the cyclists move at random speeds within a given range. These random speeds are then constrained according to the speed of cyclists immediately ahead and the speed-ratio rule. 

More work is required. Most importantly, a modified routine is needed that allows for a more natural transition from the high density condition to the stretched condition. There are several other modifications one may consider as well, including the effects of wind or obstacles. Also, while the convection effect I have observed in pelotons (3) appears to be present in my model, it is difficult to see, and work is required to establish its actual presence or absence here. Nonetheless, at present, the model fairly demonstrates the main phases of peloton dynamics.  

HOW TO USE IT

First, determine the number of cyclists you want in the simulation and divide that number by 4. Note there are four lines that cyclists start on in a random positions, and the count for the POPULATION slider reflects the number on each line. 

Press SETUP to create the cyclists, and press GO to get them moving.

The current settings for the sliders will produce reasonably good peloton behavior.  

The main slider to adjust is the SPEED-RATIO-TO-CYCLIST-BEHIND slider, which mimics the dynamics that correspond to a changing Peloton Convergence Ratio (PCR) (1). You will see that ajdusting this slider alters the density of the group and whether they travel in lines or in clusters. Without adjusting any of the other sliders, try random adjustments to the SPEED-RATIO-TO-CYCLIST-BEHIND slider between about .8 and 1.3 to see how the group oscillates between high density clusters and single-file lines. Also notice the effects of changing the DRAFTING-ZONE slider.

Note that the DECELERATION SLIDER is primarily connected to the graphs and allows the graph to operate properly, and adjusting it will not alter the peloton behavior in any
significant way.

In the html version, at the top of graphic interface there is also a slider that
adjusts the running speed of the simulation.

THINGS TO NOTICE

Notice the increasing density as you slide the speed-ration slider from the low end to the high end, the pronounced transition at speed-ratio .9, and the the mixed-phase oscillations at speed-ratios over ratio 1. 

Also, if you have adjusted the slider over 1 and you have allowed the group to break-up into smaller groups, adjust the slider back below .9, and see how larger groups will move faster than smaller groups, and when they are within a threshold distance, cyclists will "jump" across to the group ahead, allowing for a rapid reintegration of the groups.
This is realistic peloton behavior.

At the .9 speed ratio, if you check the average speed graph, you will see that there appears to be a very slight drop in speed compared to the .8 ratio. This is counter-intuitive, and it represents the basis for a testable hypothesis in actual pelotons: is there a short term speed drop at a critical speed/density that precedes the transition to the stretched phase?

Central to the model is the observation that peloton behaviors form without a leader.
Random numbers are used in this model only to position the cyclists initially and for their speeds within a given range. The fluid, lifelike behavior of the cyclists is produced entirely by deterministic rules.

RELATED MODELS
•	Flocking; Flocking vee formation
•	Basic Traffic
by Uri Wilenski

CREDITS AND REFERENCES

This model relies in significant part on the work of Uri Wilenski, with important modifications that distinguish my peloton model from Wilenski’s model. 

Wilenski notes that his flocking model is inspired by the Boids simulation invented by Craig Reynolds. Information on Boids is available at http://www.red3d.com/cwr/boids/.
	•	Wilensky, U. (1998). NetLogo Flocking model. 		
	http://ccl.northwestern.edu/netlogo/models/Flocking. Center for Connected 	
	Learning and Computer-Based Modeling, Northwestern University, Evanston, IL. 
	•	Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/.
	Center for Connected Learning and Computer-Based Modeling, Northwestern 	
	University, Evanston, IL. 

(1) First reported in: Trenchard, H. and Mayer-Kress, G. 2005. 
Self-organized coupling and synchronization in bicycle pelotons
during mass-start bicycle racing. In Book of Abstracts of International Conference on Control and Synchronization in Dynamical Systems. Leon, Gto. Mx.

	PCR = ((Wa - Wb) / Wa) / (D/100)

Where Wa is the maximum sustainable power output (watts) of cyclist A at any given moment; 

Wb is the maximum sustainable power of cyclist B at any given moment (assuming Wa>Wb); D/100 is the percent energy savings (correlating to reduced power output) due to drafting at the velocity travelled. 

I have referred to this alternately as a "divergence" ratio and a "convergence" ratio. Regardless, the idea is that when PCR < 1, the peloton is cohesive, and at PCR > 1,the peloton disintegrates (or disintegrates in those regions of the peloton where the condition exists). For other work I have done on peloton dynamics, see http://athabascau.academia.edu/HughTrenchard.


(2) Hagberg, T. and McCole, S. 1990. The effect of drafting and aerodynamics equipment
on energy expenditure during cycling. Cycling Science 2:20.

(3) Trenchard, H. 2012. The Complex Dynamics of Bicycle Pelotons 
arXiv:1206.0816 [nlin.AO.

It should be noted that there is presently (as of 2012) a cycling race simulation developed by Samuel Manier in his work on the video game, "Pro-Cycling Manager". There is one published paper by Manier, S., and Sigaud, O. [year not given] "Compacting a Rule Base into an and/or Diagram for a Game ai". www.isir.upmc.fr/files/gameon_final.pdf, in
which the authors refer to their Pro-Cycling Manager simulation. They indicate 
having incorporated physics equations into their simulation, but do not specify which ones, and they do not address complex dynamics or peloton phases, however. I am not aware of any other computer simulations of bicycle pelotons.

@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7500403 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7500403 true true 150 285 285 225 285 75 150 135
Polygon -7500403 true true 150 135 15 75 150 15 285 75
Polygon -7500403 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7500403 true true 96 182 108
Circle -7500403 true true 110 127 80
Circle -7500403 true true 110 75 80
Line -7500403 true 150 100 80 30
Line -7500403 true 150 100 220 30

butterfly
true
0
Polygon -7500403 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7500403 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7500403 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7500403 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7500403 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7500403 true true 47 195 58
Circle -7500403 true true 195 195 58

circle
false
0
Circle -7500403 true true 0 0 300

circle 2
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240

cow
false
0
Polygon -7500403 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7500403 true true 73 210 86 251 62 249 48 208
Polygon -7500403 true true 25 114 16 195 9 204 23 213 25 200 39 123

cylinder
false
0
Circle -7500403 true true 0 0 300

dot
false
0
Circle -7500403 true true 90 90 120

face happy
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7500403 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7500403 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7500403 true true 60 15 75 300
Polygon -7500403 true true 90 150 270 90 90 30
Line -7500403 true 75 135 90 135
Line -7500403 true 75 45 90 45

flower
false
0
Polygon -10899396 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7500403 true true 85 132 38
Circle -7500403 true true 130 147 38
Circle -7500403 true true 192 85 38
Circle -7500403 true true 85 40 38
Circle -7500403 true true 177 40 38
Circle -7500403 true true 177 132 38
Circle -7500403 true true 70 85 38
Circle -7500403 true true 130 25 38
Circle -7500403 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -10899396 true false 189 233 219 188 249 173 279 188 234 218
Polygon -10899396 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7500403 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7500403 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7500403 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7500403 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7500403 true 150 0 150 300

line half
true
0
Line -7500403 true 150 0 150 150

pentagon
false
0
Polygon -7500403 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7500403 true true 110 5 80
Polygon -7500403 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7500403 true true 127 79 172 94
Polygon -7500403 true true 195 90 240 150 225 180 165 105
Polygon -7500403 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7500403 true true 135 90 165 300
Polygon -7500403 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7500403 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7500403 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7500403 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7500403 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7500403 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7500403 true true 135 90 120 45 150 15 180 45 165 90

square
false
0
Rectangle -7500403 true true 30 30 270 270

square 2
false
0
Rectangle -7500403 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7500403 true true 151 1 185 108 298 108 207 175 242 282 151 216 59 282 94 175 3 108 116 108

target
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7500403 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7500403 true true 120 120 60

tree
false
0
Circle -7500403 true true 118 3 94
Rectangle -6459832 true false 120 195 180 300
Circle -7500403 true true 65 21 108
Circle -7500403 true true 116 41 127
Circle -7500403 true true 45 90 120
Circle -7500403 true true 104 74 152

triangle
false
0
Polygon -7500403 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7500403 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7500403 true true 4 45 195 187
Polygon -7500403 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7500403 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7500403 false true 24 174 42
Circle -7500403 false true 144 174 42
Circle -7500403 false true 234 174 42

turtle
true
0
Polygon -10899396 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -10899396 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -10899396 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -10899396 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -10899396 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7500403 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7500403 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7500403 true 150 285 150 15
Line -7500403 true 15 150 285 150
Circle -7500403 true true 120 120 60
Line -7500403 true 216 40 79 269
Line -7500403 true 40 84 269 221
Line -7500403 true 40 216 269 79
Line -7500403 true 84 40 221 269

x
false
0
Polygon -7500403 true true 270 75 225 30 30 225 75 270
Polygon -7500403 true true 30 75 75 30 270 225 225 270

@#$#@#$#@
NetLogo 5.0.3
@#$#@#$#@
set population 200
setup
repeat 200 [ go ]
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
default
0.0
-0.2 0 1.0 0.0
0.0 1 1.0 0.0
0.2 0 1.0 0.0
link direction
true
0
Line -7500403 true 150 150 90 180
Line -7500403 true 150 150 210 180

@#$#@#$#@
0
@#$#@#$#@