2 more examples moved

Author: quaquel

examples/forest_fire/forest_fire/agent.py

@@ -1,32 +1,31 @@
-import mesa
+from mesa.experimental.cell_space import FixedAgent
 
 
-class TreeCell(mesa.Agent):
+class TreeCell(FixedAgent):
     """
     A tree cell.
 
     Attributes:
-        x, y: Grid coordinates
         condition: Can be "Fine", "On Fire", or "Burned Out"
-        unique_id: int
 
     """
 
-    def __init__(self, model):
+    def __init__(self, model, cell):
         """
         Create a new tree.
         Args:
             model: standard model reference for agent.
         """
         super().__init__(model)
         self.condition = "Fine"
+        self.cell = cell
 
     def step(self):
         """
         If the tree is on fire, spread it to fine trees nearby.
         """
         if self.condition == "On Fire":
-            for neighbor in self.model.grid.iter_neighbors(self.pos, True):
+            for neighbor in self.cell.neighborhood.agents:
                 if neighbor.condition == "Fine":
                     neighbor.condition = "On Fire"
             self.condition = "Burned Out"

examples/forest_fire/forest_fire/model.py

@@ -1,5 +1,7 @@
 import mesa
 
+from mesa.experimental.cell_space import OrthogonalMooreGrid
+
 from .agent import TreeCell
 
 
@@ -8,19 +10,19 @@ class ForestFire(mesa.Model):
     Simple Forest Fire model.
     """
 
-    def __init__(self, width=100, height=100, density=0.65):
+    def __init__(self, width=100, height=100, density=0.65, seed=None):
         """
         Create a new forest fire model.
 
         Args:
             width, height: The size of the grid to model
             density: What fraction of grid cells have a tree in them.
         """
-        super().__init__()
-        # Set up model objects
+        super().__init__(seed=seed)
 
-        self.grid = mesa.space.SingleGrid(width, height, torus=False)
+        # Set up model objects
 
+        self.grid = OrthogonalMooreGrid((width, height), capacity=1)
         self.datacollector = mesa.DataCollector(
             {
                 "Fine": lambda m: self.count_type(m, "Fine"),
@@ -30,14 +32,13 @@ def __init__(self, width=100, height=100, density=0.65):
         )
 
         # Place a tree in each cell with Prob = density
-        for contents, (x, y) in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < density:
                 # Create a tree
-                new_tree = TreeCell(self)
+                new_tree = TreeCell(self, cell)
                 # Set all trees in the first column on fire.
-                if x == 0:
+                if cell.coordinate[0] == 0:
                     new_tree.condition = "On Fire"
-                self.grid.place_agent(new_tree, (x, y))
 
         self.running = True
         self.datacollector.collect(self)
@@ -59,8 +60,4 @@ def count_type(model, tree_condition):
         """
         Helper method to count trees in a given condition in a given model.
         """
-        count = 0
-        for tree in model.agents:
-            if tree.condition == tree_condition:
-                count += 1
-        return count
+        return len(model.agents.select(lambda x: x.condition == tree_condition))

examples/hex_snowflake/hex_snowflake/cell.py

@@ -1,60 +1,58 @@
 import mesa
 
+from mesa.experimental.cell_space import FixedAgent
 
-class Cell(mesa.Agent):
+
+class Cell(FixedAgent):
     """Represents a single ALIVE or DEAD cell in the simulation."""
 
     DEAD = 0
     ALIVE = 1
 
-    def __init__(self, pos, model, init_state=DEAD):
+    def __init__(self, cell, model, init_state=DEAD):
         """
         Create a cell, in the given state, at the given x, y position.
         """
         super().__init__(model)
-        self.x, self.y = pos
+        self.cell = cell
         self.state = init_state
-        self._nextState = None
-        self.isConsidered = False
+        self._next_state = None
+        self.is_considered = False
 
     @property
     def is_alive(self):
         return self.state == self.ALIVE
 
-    @property
-    def neighbors(self):
-        return self.model.grid.iter_neighbors((self.x, self.y))
-
     @property
     def considered(self):
-        return self.isConsidered is True
+        return self.is_considered is True
 
     def determine_state(self):
         """
         Compute if the cell will be dead or alive at the next tick. A dead
         cell will become alive if it has only one neighbor. The state is not
-        changed here, but is just computed and stored in self._nextState,
+        changed here, but is just computed and stored in self._next_state,
         because our current state may still be necessary for our neighbors
         to calculate their next state.
         When a cell is made alive, its neighbors are able to be considered
         in the next step. Only cells that are considered check their neighbors
         for performance reasons.
         """
         # assume no state change
-        self._nextState = self.state
+        self._next_state = self.state
 
-        if not self.is_alive and self.isConsidered:
+        if not self.is_alive and self.is_considered:
             # Get the neighbors and apply the rules on whether to be alive or dead
             # at the next tick.
-            live_neighbors = sum(neighbor.is_alive for neighbor in self.neighbors)
+            live_neighbors = sum(neighbor.is_alive for neighbor in self.cell.neighborhood.agents)
 
             if live_neighbors == 1:
-                self._nextState = self.ALIVE
-                for a in self.neighbors:
-                    a.isConsidered = True
+                self._next_state = self.ALIVE
+                for a in self.cell.neighborhood.agents:
+                    a.is_considered = True
 
     def assume_state(self):
         """
         Set the state to the new computed state
         """
-        self.state = self._nextState
+        self.state = self._next_state

examples/hex_snowflake/hex_snowflake/model.py

@@ -1,4 +1,5 @@
 import mesa
+from mesa.experimental.cell_space import HexGrid
 
 from .cell import Cell
 
@@ -15,19 +16,17 @@ def __init__(self, width=50, height=50):
         """
         super().__init__()
         # Use a hexagonal grid, where edges wrap around.
-        self.grid = mesa.space.HexSingleGrid(width, height, torus=True)
+        self.grid = HexGrid((width, height), capacity=1, torus=True)
 
         # Place a dead cell at each location.
-        for contents, pos in self.grid.coord_iter():
-            cell = Cell(pos, self)
-            self.grid.place_agent(cell, pos)
+        for entry in self.grid.all_cells:
+            cell = Cell(entry, self)
 
         # activate the center(ish) cell.
-        centerishCell = self.grid[width // 2][height // 2]
-
-        centerishCell.state = 1
-        for a in centerishCell.neighbors:
-            a.isConsidered = True
+        centerish_cell = self.grid[(width // 2, height // 2)]
+        centerish_cell.agents[0].state = 1
+        for a in centerish_cell.neighborhood.agents:
+            a.is_considered = True
 
         self.running = True