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 pa- rameters 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)