another batch of models

Author: quaquel

examples/charts/charts/agents.py

@@ -9,9 +9,7 @@
     Center for Connected Learning and Computer-Based Modeling,
     Northwestern University, Evanston, IL.
 """
-
-from .random_walk import RandomWalker
-
+from mesa.spaces import CellAgent
 
 class Bank:
     """Note that the Bank class is not a Mesa Agent, but just a regular Python
@@ -44,10 +42,10 @@ def bank_balance(self):
 
 
 # subclass of RandomWalker, which is subclass to Mesa Agent
-class Person(RandomWalker):
-    def __init__(self, model, moore, bank, rich_threshold):
+class Person(CellAgent):
+    def __init__(self, model, bank, rich_threshold):
         # init parent class with required parameters
-        super().__init__(model, moore=moore)
+        super().__init__(model)
         # the amount each person has in savings
         self.savings = 0
         # total loan amount person has outstanding
@@ -67,14 +65,14 @@ def do_business(self):
         bank can loan them any money"""
         if self.savings > 0 or self.wallet > 0 or self.bank.bank_to_loan > 0:
             # create list of people at my location (includes self)
-            my_cell = self.model.grid.get_cell_list_contents([self.pos])
+            my_cell = [a for a in self.cell.agents if not a == self]
             # check if other people are at my location
             if len(my_cell) > 1:
                 # set customer to self for while loop condition
                 customer = self
                 while customer == self:
-                    """select a random person from the people at my location
-                    to trade with"""
+                    # select a random person from the people at my location
+                    # to trade with
                     customer = self.random.choice(my_cell)
                 # 50% chance of trading with customer
                 if self.random.randint(0, 1) == 0:
@@ -178,7 +176,7 @@ def take_out_loan(self, amount):
 
     def step(self):
         # move to a cell in my Moore neighborhood
-        self.random_move()
+        self.move_to(self.cell.neighborhood().select_random_cell())
         # trade
         self.do_business()
         # deposit money or take out a loan

examples/charts/charts/model.py

@@ -14,6 +14,7 @@
 import numpy as np
 
 from .agents import Bank, Person
+from mesa.spaces import OrthogonalMooreGrid
 
 """
 If you want to perform a parameter sweep, call batch_run.py instead of run.py.
@@ -100,7 +101,7 @@ def __init__(
         self.width = width
         self.init_people = init_people
 
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=True)
+        self.grid = OrthogonalMooreGrid((self.width, self.height), torus=True)
         # rich_threshold is the amount of savings a person needs to be considered "rich"
         self.rich_threshold = rich_threshold
         self.reserve_percent = reserve_percent
@@ -126,9 +127,9 @@ def __init__(
             # set x, y coords randomly within the grid
             x = self.random.randrange(self.width)
             y = self.random.randrange(self.height)
-            p = Person(self, True, self.bank, self.rich_threshold)
+            p = Person(self, self.bank, self.rich_threshold)
             # place the Person object on the grid at coordinates (x, y)
-            self.grid.place_agent(p, (x, y))
+            p.move_to(self.grid[(x, y)])
 
         self.running = True
         self.datacollector.collect(self)

examples/charts/charts/random_walk.py

@@ -7,34 +7,28 @@
 import mesa
 
 
-class ColorCell(mesa.Agent):
+class ColorCell(mesa.spaces.CellAgent):
     """
     Represents a cell's opinion (visualized by a color)
     """
 
     OPINIONS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
 
-    def __init__(self, pos, model, initial_state):
+    def __init__(self, model, initial_state):
         """
         Create a cell, in the given state, at the given row, col position.
         """
         super().__init__(model)
-        self._row = pos[0]
-        self._col = pos[1]
-        self._state = initial_state
-        self._next_state = None
+        self.state = initial_state
+        self.next_state = None
 
     def get_col(self):
         """Return the col location of this cell."""
-        return self._col
+        return self.cell.coordinate[0]
 
     def get_row(self):
         """Return the row location of this cell."""
-        return self._row
-
-    def get_state(self):
-        """Return the current state (OPINION) of this cell."""
-        return self._state
+        return self.cell.coordinate[1]
 
     def determine_opinion(self):
         """
@@ -43,22 +37,22 @@ def determine_opinion(self):
         A choice is made at random in case of a tie
         The next state is stored until all cells have been polled
         """
-        _neighbor_iter = self.model.grid.iter_neighbors((self._row, self._col), True)
-        neighbors_opinion = Counter(n.get_state() for n in _neighbor_iter)
+        neighbors = self.cell.neighborhood().agents
+        neighbors_opinion = Counter(n.state for n in neighbors)
         # Following is a a tuple (attribute, occurrences)
         polled_opinions = neighbors_opinion.most_common()
         tied_opinions = []
         for neighbor in polled_opinions:
             if neighbor[1] == polled_opinions[0][1]:
                 tied_opinions.append(neighbor)
 
-        self._next_state = self.random.choice(tied_opinions)[0]
+        self.next_state = self.random.choice(tied_opinions)[0]
 
     def assume_opinion(self):
         """
         Set the state of the agent to the next state
         """
-        self._state = self._next_state
+        self.state = self.next_state
 
 
 class ColorPatches(mesa.Model):
@@ -72,18 +66,17 @@ def __init__(self, width=20, height=20):
         The agents next state is first determined before updating the grid
         """
         super().__init__()
-        self._grid = mesa.space.SingleGrid(width, height, torus=False)
+        self._grid = mesa.spaces.OrthogonalMooreGrid((width, height), torus=False)
 
         # self._grid.coord_iter()
         #  --> should really not return content + col + row
         #  -->but only col & row
         # for (contents, col, row) in self._grid.coord_iter():
         # replaced content with _ to appease linter
-        for _, (row, col) in self._grid.coord_iter():
-            cell = ColorCell(
-                (row, col), self, ColorCell.OPINIONS[self.random.randrange(0, 16)]
+        for cell in self._grid.all_cells:
+            agent = ColorCell(self, ColorCell.OPINIONS[self.random.randrange(0, 16)]
             )
-            self._grid.place_agent(cell, (row, col))
+            agent.move_to(cell)
 
         self.running = True
 

examples/color_patches/color_patches/model.py

@@ -1,28 +1,27 @@
 import mesa
 
 
-class Cell(mesa.Agent):
+class Cell(mesa.spaces.CellAgent):
     """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, 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.state = init_state
-        self._nextState = None
+        self._next_state = None
 
     @property
-    def isAlive(self):
+    def is_alive(self):
         return self.state == self.ALIVE
 
     @property
     def neighbors(self):
-        return self.model.grid.iter_neighbors((self.x, self.y), True)
+        return self.cell.neighborhood().agents
 
     def determine_state(self):
         """
@@ -35,19 +34,19 @@ def determine_state(self):
 
         # Get the neighbors and apply the rules on whether to be alive or dead
         # at the next tick.
-        live_neighbors = sum(neighbor.isAlive for neighbor in self.neighbors)
+        live_neighbors = sum(neighbor.is_alive for neighbor in self.neighbors)
 
         # Assume nextState is unchanged, unless changed below.
-        self._nextState = self.state
-        if self.isAlive:
+        self._next_state = self.state
+        if self.is_alive:
             if live_neighbors < 2 or live_neighbors > 3:
-                self._nextState = self.DEAD
+                self._next_state = self.DEAD
         else:
             if live_neighbors == 3:
-                self._nextState = self.ALIVE
+                self._next_state = self.ALIVE
 
     def assume_state(self):
         """
         Set the state to the new computed state -- computed in step().
         """
-        self.state = self._nextState
+        self.state = self._next_state

examples/conways_game_of_life/conways_game_of_life/cell.py

@@ -15,15 +15,15 @@ def __init__(self, width=50, height=50):
         """
         super().__init__()
         # Use a simple grid, where edges wrap around.
-        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+        self.grid = mesa.spaces.OrthogonalMooreGrid((width, height), torus=True)
 
         # Place a cell at each location, with some initialized to
         # ALIVE and some to DEAD.
-        for contents, (x, y) in self.grid.coord_iter():
-            cell = Cell((x, y), self)
+        for cell in self.grid.all_cells:
+            cell_agent = Cell(self)
             if self.random.random() < 0.1:
-                cell.state = cell.ALIVE
-            self.grid.place_agent(cell, (x, y))
+                cell_agent.state = cell_agent.ALIVE
+            cell_agent.move_to(cell)
 
         self.running = True