The Recursive Porous Agent Simulation Toolkit (Repast) is one of several agent modeling toolkits that are available. Repast borrows many concepts from the Swarm [and] is differentiated from Swarm since Repast has multiple pure implementations in several languages and built-in adaptive features such as genetic algorithms and regression.

There are fixed and flexible components. The fixed are the Engine, Logging, and Interactive and Batch Run Modules. The Engine contains Engine Controller, Scheduler, Action, and Agent components. The logging has a Data and an Objects Logger. Data logger store simple values, and Objects store the full state of each agent.

The batch module can be controlled by a Parameter Sweep Framework, that iterates over a range of model input parameters to complete a set of simulation runs.

The Adaptive Behaviors Module provides adaptive components for implementing agent behaviors. The components can include genetic algorithms, neural networks, other artificial intelligence tools, and regression tools. The Domains Module provides area-specific functions. Example components include tools for general networks, social systems, geographical information systems (GIS), systems dynamics, and computational game theory.

Many agent-based modeling and simulation researchers and practitioners have called for varying levels of simulation interoperability ranging from shared software architectures to common agent communications languages. These calls have been at least partially answered by several specifications and technologies. In fact, Tanenbaum [1988] has remarked that the “nice thing about standards is that there are so many to choose from.” Tanenbaum goes on to say that “if you do not like any of them, you can just wait for next year’s model.” This article does not seek to introduce next year’s model. Rather, the goal is to contribute to the larger simulation community the authors’ accumulated experiences from developing several implementations of an agent-based simulation toolkit. As such, this article focuses on the implementation of simulation architectures rather than agent communications languages. It is hoped that ongoing architecture standards efforts will benefit from this new knowledge and use it to produce architecture standards with increased robustness.

The paper describes the three implementations (Java, .Net, python), showing advantages and disadvantages of each implementation. It also shows a set of groups that work with repast and their scientific questions. How do national borders emerge and why do they take the shapes that they do? How did ancient people build their tools and why did they use the approaches that were chosen?

We implement a model of wolf-sheep predation (Wilenski 1998) in Repast S as a demonstration of the toolkit’s capabilities. This model represents a simple variation of predator prey behavior using three agents: wolves, sheep, and grass. Both the wolves and sheep move randomly on a grid, and the movement has a cost in the form of lost energy. The wolves and sheep need to eat food in order to replenish their energy, and they will die once their energy level reaches zero.

Wolves prey on sheep and may eat them if the two are located in the same spatial position, thereby increasing the wolf’s energy level. Sheep may similarly eat grass if the sheep is located on a patch which contains living grass. Once a sheep eats the grass in its location, the grass needs to regrow before the sheep can eat it again. Repast S models a re-grow rate for grass by counting down after the grass has been eaten in a specific location. Reproduction is modeled by a random process that creates a child from the parent, divides the energy of the parent agent in half, and assigns the energy equally to the parent and child.

The movement do not use the concept of neighbourhood:

  public void move() {
    Context context = ContextUtils.getContext(this);
    Grid grid = (Grid) context.getProjection(“Simple Grid”);
    GridDimensions dims = grid.getDimensions();
    GridPoint point = grid.getLocation(this);
    x = point.getX() + (int) Math.round(2*Math.random() - 1);
    y = point.getY() + (int) Math.round(2*Math.random() - 1);
    grid.move(this, x, y);
  }

It returns the agents in the same cell using a function getObjectsAt() which needs a position in the space:

  Sheep sheep = null;
  for (SimpleAgent agent : grid.getObjectsAt(x,y)){
    if (agent instanceof Sheep)
      sheep = (Sheep) agent;
  }
  if (sheep != null){
    sheep.die();
    energy = energy + gain;
  }

RePast supports the exchange of data between agents. Work is currently underway to support group-based communication

RePast supports various sorts of spatial relationships (2D, 3D, hexagonal grids, hexagonal tori, vector spaces, raster spaces, etc.). Work is underway on a GIS library that will contain additional geographic operators. There are simple positioning algorithms as well as simple influence spaces

GIS Integration: (e.g. OpenMap, Java Topology Suite, and GeoTools). Repast simulations can also be run within ArcGIS through an extension called Agent Analyst (http://www.institute.redlands.edu/agentanalyst).

graphing/statistics: (e.g. Colt statistical package, and basic Repast functionality for simple network statistics)

  Repast development appears to have been driven by

several objectives. The initial objective was to implement Swarm, or equivalent functionality, in Java. How- ever, Repast did not adopt all of Swarm’s design philosophy and does not implement swarms. Repast was also clearly intended to support one domain - social science - in particular, and includes tools specific to that domain. The additional objective of making it easier for inexperienced users to build models has been approached in several ways by the Repast project. These approaches include a built-in simple model, and interfaces through which menus and Python code can be used to begin model construction.

Abstract: Our GeoGraph 3D extensions to the RePast agent-based simulation platform support models in which mobile agents travel and interact on rugged terrain or on network landscapes such as social networks of established organizational teams or spatial networks at any scale from rooms within buildings to urban neighborhoods to large geographic networks of cities. Interactive GeoGraph 3D visualizations allow researchers to zoom and pan within the simulation landscape as the model runs. Model-specific 3D representations of agents flock together on terrain landscapes, and teleport or travel along links on network landscapes. Agents may be displayed on network nodes either as individual agents or as dynamic 3D bar charts that reflect the composition of each node's population. Batch modes support scientific control via fully separated random number series, customized parameter combinations, and automatic data collection for many thousands of simulation runs. This paper introduces the GeoGraph 3D computational laboratory and briefly describes three representative GeoGraph models along with basic GeoGraph 3D capabilities and components.

It has an example of a model of SARS, where individual agents travel between communities and bar charts for each community show the epidemiological status. Green agents are healthy, pink are infected, red are sick, gray are dead, and white are recovered and immune. Gray links are base links, such as highways or trains, yellow links are high-speed shortcuts in the landscape such as airline routes.

Multiple agents per node, and agents to interacting both directly and indirectly. The figure includes an undulating mesh network enhanced by several spatial small-world shortcuts. The ring around each agent shows how far it can see.

Series of classes that allow for the creation and observation of teams of agents that behave as social hierarchies. For each layer of responsibility in the organization, there can be a specific type of Hierarchy Agent that fills that role. These agents have additional capabilities that allow for command and message passing to follow a chain of command. To support this, the simulation can show visualizations of these communication links in a variety of contexts, ranging from lines drawn between the members of the group, to group coloration, to tree views that show the hierarchy by group member name, command, and status.

GeoGraph provides three classes of proto-agents, from which agents may inherit specific geographic capabilities that correspond to classes of GeoGraph landscapes.

• GeoAgent3D: knows how to navigate networks. It may evaluate nodes within a network-specific neighborhood, and may also compute shortest paths from one node to another along multiple links.
• FreeAgent3D: moves between nodes without following links.
• NodelessAgent3D: a free roaming agent. provides the basis for the Flocking agents.

TerraME: just having different neighbourhood types. The problem arises when we have time associated to moving in the space, according to the weight of the link.

GeoGraphs can import network landscapes and corresponding territorial outline maps from shape files. The original version of GeoGraphs was built for Swarm.