def __init__(self, height=50, width=50):
'''
Create a new playing area of (height, width) cells.
'''
# Set up the grid and schedule.
# Use SimultaneousActivation which simulates all the cells
# computing their next state simultaneously. This needs to
# be done because each cell's next state depends on the current
# state of all its neighbors -- before they've changed.
self.schedule = SimultaneousActivation(self)
# Use a hexagonal grid, where edges wrap around.
self.grid = HexGrid(height, width, torus=True)
# Place a dead cell at each location.
for (contents, x, y) in self.grid.coord_iter():
cell = Cell((x, y), self)
self.grid.place_agent(cell, (x, y))
self.schedule.add(cell)
# activate the center(ish) cell.
centerishCell = self.grid[width // 2][height // 2]
centerishCell.state = 1
for a in centerishCell.neighbors:
a.isConsidered = True
self.running = True
def __init__(self, height=50, width=50, server = True, num_steps = 1000):
'''
Create a new playing area of (height, width) cells.
'''
# Set up the grid and schedule.
# Use SimultaneousActivation which simulates all the cells
# computing their next state simultaneously. This needs to
# be done because each cell's next state depends on the current
# state of all its neighbors -- before they've changed.
self.schedule = SimultaneousActivation(self)
self.num_steps = num_steps
# Use a hexagonal grid, where edges wrap around.
self.grid = HexGrid(height, width, torus=True)
self.server = server
# Place a dead cell at each location.
for (contents, x, y) in self.grid.coord_iter():
cell = Cell((x, y), self)
self.grid.place_agent(cell, (x, y))
self.schedule.add(cell)
# activate the center(ish) cell.
centerishCell = self.grid[width // 2][height // 2]
centerishCell.state = 1
for a in centerishCell.neighbors:
a.isConsidered = True
self.running = True
#Datacollector -- default for this model is no data collection, but one can use OABM to assign one.
#so this is an empty DataCollector instance from MESA
self.datacollector = DataCollector()
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
width = 3
height = 5
self.grid = HexGrid(width, height, torus=True)
self.agents = []
counter = 0
for x in range(width):
for y in range(height):
if TEST_GRID[x][y] == 0:
continue
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def __init__(self, height=150, width=150):
"""
Create a new playing area of (height, width) cells.
"""
# Set up the grid and schedule.
# Use SimultaneousActivation which simulates all the cells
# computing their next state simultaneously. This needs to
# be done because each cell's next state depends on the current
# state of all its neighbors -- before they've changed.
self.schedule = SimultaneousActivation(self)
# Use a hexagonal grid, where edges wrap around.
self.grid = HexGrid(height, width, torus=True)
# Place a dead cell at each location.
for (contents, x, y) in self.grid.coord_iter():
cell = Cell((x, y), self)
self.grid.place_agent(cell, (x, y))
self.schedule.add(cell)
data = self.get_data("../data/input24.txt")
# activate the center(ish) cell.
centerishCell = self.grid[width // 2][height // 2]
centerishPos = (width // 2, height // 2)
for d in data:
pos = self.find_cell(centerishPos, d)
c = self.grid[pos[0]][pos[1]]
c.toggle()
for a in c.neighbors:
a.isConsidered = True
#centerishCell.state = Cell.ALIVE
#for a in centerishCell.neighbors:
# a.isConsidered = True
print(self.count_type(self, Cell.ALIVE))
self.running = True
def __init__(self, N=20, height=21, width=21, push_ratio = 0.5):
super().__init__()
self.height = height
self.width = width
self.num_agents = N
self.exit_x = self.width - 1
self.exit_y = round(self.height/2)
self.push_probs = np.array([[0.,0.],[1.,0.5]])
self.grid = HexGrid(self.width, self.height, torus=False)
self.schedule = RandomActivation(self)
# decide for ID whether it is a pusher
is_pusher = np.zeros(N, dtype = int)
idx = self.random.sample([i for i in range(N)], int(push_ratio * N))
is_pusher[idx] = 1
# Add N pedestrians
taken_pos = []
for i in range(self.num_agents):
# Add the agent to a random grid cell
while True:
x = self.random.randrange(1, self.grid.width-1)
y = self.random.randrange(1, self.grid.height-1)
pos = (x,y)
if not pos in taken_pos:
break
a = Pedestrian(i, self, pos, self.exit_x, self.exit_y, is_pusher[i])
self.schedule.add(a)
self.grid.place_agent(a, pos)
taken_pos.append(pos)
print(len(taken_pos))
# Place vertical walls
for i in range(self.height):
# Left
x=0
y=i
if x == self.exit_x and y == self.exit_y:
e = Exit(self, (x, y))
#self.schedule.add(e)
self.grid.place_agent(e, (x, y))
else:
w = Wall(self, (x, y))
#self.schedule.add(w)
self.grid.place_agent(w, (x, y))
# Right
x=self.width-1
y=i
# One exit
if x == self.exit_x and y == self.exit_y:
e = Exit(self, (x, y))
#self.schedule.add(e)
self.grid.place_agent(e, (x, y))
else:
w = Wall(self, (x, y))
#self.schedule.add(w)
self.grid.place_agent(w, (x, y))
# Place horizontal walls
for i in range(self.width):
# Up
x=i
y=0
if x == self.exit_x and y == self.exit_y:
e = Exit(self, (x, y))
#self.schedule.add(e)
self.grid.place_agent(e, (x, y))
else:
w = Wall(self, (x, y))
#self.schedule.add(w)
self.grid.place_agent(w, (x, y))
# Down
x=i
y=self.height-1
# One exit
if x == self.exit_x and y == self.exit_y:
#e = Exit(self, (x, y))
#self.schedule.add(e)
#self.grid.place_agent(e, (x, y))
continue
else:
w = Wall(self, (x, y))
#self.schedule.add(w)
self.grid.place_agent(w, (x, y))
self.data_collector = DataCollector({
"Evacuees": lambda m: self.count_evacuees(),
"Evacuated": lambda m: self.count_evacuated()
})
# this is required for the data_collector to work
self.running = True
self.data_collector.collect(self)