def __init__(self, height=20, width=20, density=0.8, minority_pc=0.2, homophily=3): self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(width, height, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": "happy"}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) # Set up agents for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.running = True self.datacollector.collect(self)
def __init__(self, N=2, width=20, height=10): self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) self.make_walker_agents() self.running = True
class ShapeExample(Model): def __init__(self, N=2, width=20, height=10): self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) self.make_walker_agents() self.running = True def make_walker_agents(self): unique_id = 0 while True: if unique_id == self.N: break x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) pos = (x, y) heading = self.random.choice(self.headings) # heading = (1, 0) if self.grid.is_cell_empty(pos): print("Creating agent {2} at ({0}, {1})".format( x, y, unique_id)) a = Walker(unique_id, self, pos, heading) self.schedule.add(a) self.grid.place_agent(a, pos) unique_id += 1 def step(self): self.schedule.step()
class TurtleModel(Model): def __init__(self, width: int = 5, height: int = 5): super().__init__() self.active_agent = Turtle(self.next_id(), self) self.active_agent.active = True self.grid = SingleGrid(width, height, True) self.grid.position_agent(self.active_agent, width // 2, height // 2) self.schedule = BaseScheduler(self) self.schedule.add(self.active_agent) def step(self): direction = self.random.choice([(1, 0), (-1, 0), (0, 1), (0, -1)]) self.active_agent.move(direction) def on_key(self, key): key_to_direction = { "ArrowUp": (0, 1), "ArrowDown": (0, -1), "ArrowLeft": (-1, 0), "ArrowRight": (1, 0), } direction = key_to_direction.get(key, "") if direction: self.active_agent.move(direction) def on_click(self, **kwargs): self.active_agent.active = False unique_id = kwargs.get("unique_id") for agent in self.schedule.agents: if agent.unique_id == unique_id: self.active_agent = agent self.active_agent.active = True
def __init__(self, width=50, height=50, proportion_producers=0.3, proportion_consumers=0.3): self.running = True self.schedule = BaseScheduler(self) self.grid = SingleGrid(width, height, torus=False) initial_activator = Producer("Initial activator", self, activated=True) center_coords = (math.floor(width / 2), math.floor(height / 2)) ## Rolled into the placement of other cells # self.schedule.add(initial_activator) # self.grid.place_agent(initial_activator, center_coords) # roll a die and place Producer, Consumer or undifferentiated cell for x in range(width): for y in range(height): roll = r.random() coords = (x, y) if coords == center_coords: agent = initial_activator elif roll <= proportion_producers: agent = Producer(coords, self) elif roll <= proportion_producers + proportion_consumers: agent = Consumer(coords, self) else: agent = Cell(coords, self) self.schedule.add(agent) self.grid.place_agent(agent, coords)
def setUp(self): self.space = SingleGrid(50, 50, False) self.agents = [] for i, pos in enumerate(TEST_AGENTS_GRID): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos)
def __init__(self, width=50, height=50, torus=True, num_bug=50, seed=42, strategy=None): super().__init__(seed=seed) self.number_of_bug = num_bug if not (strategy in ["stick", "switch"]): raise TypeError("'strategy' must be one of {stick, switch}") self.strategy = strategy self.grid = SingleGrid(width, height, torus) self.schedule = RandomActivation(self) data = { "Bean": lambda m: m.number_of_bean, "Corn": lambda m: m.number_of_corn, "Soy": lambda m: m.number_of_soy, "Bug": lambda m: m.number_of_bug, } self.datacollector = DataCollector(data) # create foods self._populate(Bean) self._populate(Corn) self._populate(Soy) # create bugs for i in range(self.number_of_bug): pos = self.grid.find_empty() bug = Bug(i, self) bug.strategy = self.strategy self.grid.place_agent(bug, pos) self.schedule.add(bug)
def __init__(self, n_students, n_active: int, width: int, height: int): self.running = True self.schedule = SimultaneousActivation(self) self.grid = SingleGrid(width, height, torus=False) self.n_students: int = n_students self._semester_gen = self._gen_semester_code() self.semester = next(self._semester_gen) self.ALL_GENDERS = gen_gender(self.n_students) # Majors self.F1SEQ1_MAJORS = gen_f1seq1_majors(self.n_students) self.major_switcher = MajorSwitch() # Adding Student to KSU Environment for i in range(self.n_students): # Percentage of student agent that will be active and the rest inactive per_active = n_active / 100 if np.random.binomial(1, per_active): student = Student(i, self, self.ALL_GENDERS[i]) student.majors.append(self.F1SEQ1_MAJORS[i]) else: student = Student(i, self, self.ALL_GENDERS[i], False) student.majors.append("N/A") self.schedule.add(student) self.grid.position_agent(student) self.datacollector = DataCollector( agent_reporters={ "GPA": "gpa", "ATTEMPTED_HRS": "attempted_hrs", "EARNED_HRS": "earned_hrs", "Major": "curr_major" })
def __init__(self, height=8, width=8, number_of_agents=2, schedule_type="Simultaneous", rounds=1,): # Model Parameters self.height = height self.width = width self.number_of_agents = number_of_agents self.step_count = 0 self.schedule_type = schedule_type self.payoffs = {("C", "C"): 3, ("C", "D"): 0, ("D", "C"): 5, ("D", "D"): 2} # Model Functions self.schedule = self.schedule_types[self.schedule_type](self) self.grid = SingleGrid(self.height, self.width, torus=True) # Find list of empty cells self.coordinates = [(x, y) for x in range(self.width) for y in range(self.height)] self.agentIDs = list(range(1, (number_of_agents + 1))) self.make_agents() self.running = True
class SchellingModel(Model): def __init__(self, height=20, width=20, tolerance=0.3, population=200): self.height = height self.width = width self.tolerance = tolerance self.population = population self.happy = 0 self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.running = True self.setup() def setup(self): occupied = [] for i in range(self.population): x = np.random.randint(0, self.width) y = np.random.randint(0, self.height) while [x, y] in occupied: x = np.random.randint(0, self.width) y = np.random.randint(0, self.height) occupied.append([x, y]) agent = SchellingAgent((x, y), self) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) def happy_ratio(self): agents = self.schedule.agents return self.happy / len(agents) def step(self): self.happy = 0 # Reset counter of happy agents self.schedule.step() if self.happy_ratio() > 0.99: self.running = False
def __init__(self, height=20, width=20, density=.8, group_ratio=.66, minority_ratio=.5, homophily=3): self.height = height self.width = width self.density = density self.group_ratio = group_ratio self.minority_ratio = minority_ratio self.homophily = homophily self.happy = 0 self.segregated = 0 self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.place_agents() self.datacollector = DataCollector({ 'happy': (lambda m: m.happy), 'segregated': (lambda m: m.segregated) }) self.running = True
class ShapesModel(Model): def __init__(self, N, width=20, height=10): self.running = True self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) self.make_walker_agents() def make_walker_agents(self): unique_id = 0 while True: if unique_id == self.N: break x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) pos = (x, y) heading = random.choice(self.headings) # heading = (1, 0) if self.grid.is_cell_empty(pos): print("Creating agent {2} at ({0}, {1})" .format(x, y, unique_id)) a = Walker(unique_id, self, pos, heading) self.schedule.add(a) self.grid.place_agent(a, pos) unique_id += 1 def step(self): self.schedule.step()
def __init__(self, N): self.num_agents = N self.i = 1 self.grid = SingleGrid(120, 120, True) self.grid1 = SingleGrid(120, 120, True) self.schedule = RandomActivation(self) self.schedule_dados = BaseScheduler(self) # Create agents for i in range(self.num_agents): a = Ant(i, self) self.schedule.add(a) x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) #z = np.asarray([x,y]) #print(z) plt.axis([-10, 125, -10, 125]) #plt.scatter(x,y) self.grid.place_agent(a, (x, y)) #create data for i in range(150): b = dado(i, self) self.schedule_dados.add(b) x = self.random.randrange(self.grid1.width) y = self.random.randrange(self.grid1.height) #print(x,y) z = np.asarray([x, y]) plt.axis([-10, 125, -10, 125]) plt.scatter(x, y) self.grid1.place_agent(b, (x, y))
def initialize_grid(self): """ Initializes the initial Grid """ self.grid = SingleGrid(width=self.width, height=self.height, torus=self.toric)
def __init__(self, width, height, eta, theta, gamma): super().__init__() self.grid = SingleGrid(width, height, True) self.schedule = RandomActivation(self) self.eta = eta self.theta = theta self.gamma = gamma self.nAgents = width * height self.avgA = self.A0 self.avgBD = theta * gamma / self.OMEGA self.avgN = (gamma * self.DELTA_T / (1 - math.exp(-self.avgA * self.DELTA_T))) for i in range(width): for j in range(height): newId = self.id + 1 newAgent = LatticeAgent(newId, self, [], (j, i)) self.schedule.add(newAgent) self.grid.position_agent(newAgent, j, i) self.id = newId + 1 for k in range(round(self.avgN * width * height)): acell = random.choice(self.schedule.agents) acell.burglers.append(Burgler())
def __init__(self, grid_height, grid_width, percentage_of_cell_alive): """ Constructor """ self.grid = SingleGrid(grid_width, grid_height, False) self.scheduler = SimultaneousActivation(self) self.number_of_agent = grid_width * grid_height # Creation of all agent for i in range(self.number_of_agent): # Randomly chooses the initial state of the agent (0 is alive and 1 is dead) # We use choices from the random module because it allows us to specify a distribution # (ie. a list of probability for each state). Choices will return a list with ne element # which is our state probability_alive = percentage_of_cell_alive / 100 probability_dead = 1 - probability_alive state = choices([0, 1], [probability_dead, probability_alive])[0] # Creating the agent and adding it to the scheduler agent = CellAgent(i, state, self) self.scheduler.add(agent) # Adding the new agent to the grid agent_coordinates = self.grid.find_empty() self.grid.place_agent(agent, agent_coordinates) # Define if the simulation is running or not self.running = True
def __init__(self, height=30, width=30, density=0.1, oxy_den_count=1): """ """ self.height = height self.width = width self.density = density self.schedule = RandomActivation(self) self.grid = SingleGrid(width, height, torus=True) self.datacollector = DataCollector( {"happy": "happy"}, # Model-level count of happy agents # For testing purposes, agent's individual x and y { "x": lambda a: a.pos[0], "y": lambda a: a.pos[1] }, ) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: agent = SchellingAgent((x, y), self) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.running = True self.datacollector.collect(self)
def __init__(self, n_agents: int, width: int, height: int, agent_reach_radius: int, prior_sample_size: int, initial_sd: float, start_p_h: float, *args: Any, **kwargs: Any) -> None: """ Create the model. :param n_agents: Number of agents to place. :param width: Width of the grid. :param height: Height of the grid. :param agent_reach_radius: Radius around the agent in which it can connect. :param prior_sample_size: Size of initial belief sample. :param initial_sd: Initial standard deviation of the agents' beliefs. :param start_p_h: Initial p|h value. """ super().__init__(*args, **kwargs) self.n_agents = n_agents self.agent_range = agent_reach_radius self.prior_sample_size = prior_sample_size self.initial_sd = initial_sd self.start_p_h = start_p_h self.grid = SingleGrid(width, height, torus=True) self.schedule = RandomActivation(self) print('Placing agents.') for i in range(self.n_agents): agent = ConspiracyAgent(i, self) self.schedule.add(agent) self.grid.position_agent(agent) print('Finished placing agents.')
def __init__(self, width, height, num_agents): self.schedule = RandomActivation(self) self.grid = SingleGrid(width, height, torus = True) self.num_agents = num_agents # to collect info about how many agents are happy, average similarity of neighbors, length of residence self.datacollector = DataCollector(model_reporters = {"Happy": lambda m: m.happy, "Similar": lambda m: m.similar, "Residence": lambda m: m.avg_residence}, agent_reporters = {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) self.avg_residence = 0 self.happy = 0 self.similar = 0 self.running = True for i in range(self.num_agents): # white if random.random() < 0.70: agent_type = 1 income = np.random.normal(54000, 41000) # black else: agent_type = 0 income = np.random.normal(32000, 40000) # add new agents agent = NewAgent(i, self, agent_type, income) self.schedule.add(agent) # assign the initial coords of the agents x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.position_agent(agent, (x, y))
def __init__(self, height=50, width=50, density=0.8, minority_pc=0.5, homophily=3): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent)
def __init__(self, N, length=100, lanes=1, timer=3): self.num_agents = N self.grid = SingleGrid(length, lanes, torus=True) model_stages = [ "acceleration", "braking", "randomisation", "move", "delete" ] self.schedule = StagedActivation(self, stage_list=model_stages) # Create agent for i in range(self.num_agents): agent = CarAgent(i, self, False) # Add to schedule self.schedule.add(agent) # Add to grid (randomly) self.grid.position_agent(agent) # Add the traffic light self.traffic_light = TrafficLight(0, self, timer, 20, 20) self.average_velocity = CarAgent.init_velocity self.datacollector = DataCollector(agent_reporters={ "Position": "pos", "Velocity": "velocity" }, model_reporters={ "Average Velocity": "average_velocity", "Amount of cars": "agent_count", "On Ramp Queue": get_on_ramp_queue, "Waiting Queue": get_waiting_queue }) self.running = True
def __init__(self, height, width, schedule_type, payoffs=None): ''' Create a new Spatial Prisoners' Dilemma Model. Args: height, width: Grid size. There will be one agent per grid cell. schedule_type: Can be "Sequential", "Random", or "Simultaneous". Determines the agent activation regime. payoffs: (optional) Dictionary of (move, neighbor_move) payoffs. ''' self.grid = SingleGrid(height, width, torus=True) self.schedule_type = schedule_type self.schedule = self.schedule_types[self.schedule_type](self) # Create agents for x in range(width): for y in range(height): agent = PDAgent((x, y), self) self.grid.place_agent(agent, (x, y)) self.schedule.add(agent) self.datacollector = DataCollector({ "Cooperating_Agents": lambda m: len([a for a in m.schedule.agents if a.move == "C"]) }) self.running = True self.datacollector.collect(self)
def __init__(self, height=20, width=20, density=0.8, minority_fraction=0.2, tolerance_threshold=4, seed=None): super().__init__(seed=seed) self.height = height self.width = width self.density = density self.minority_fraction = minority_fraction self.schedule = RandomActivation(self) self.grid = SingleGrid(width, height, torus=True) self.datacollector = DataCollector( model_reporters={'happy': count_happy}) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_fraction: agent_color = Color.RED else: agent_color = Color.BLUE agent = SchellingAgent((x, y), self, agent_color, tolerance_threshold) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent)
class WorldModel(Model): def __init__(self, N, width, height): self.grid = SingleGrid(height, width, True) self.schedule = RandomActivation(self) self.num_agents = N self.running = True for i in range(self.num_agents): ethnicity = random.choice(Ethnicities) a = PersonAgent(unique_id=i, model=self, ethnicity=int(ethnicity) ) self.schedule.add(a) # Add the agent to a random grid cell self.grid.position_agent(a) self.datacollector = DataCollector( agent_reporters={ "Nationalism": lambda a: a.nationalism, "X": lambda a: a.pos[0], "Y": lambda a: a.pos[1] } ) def step(self): self.datacollector.collect(self) self.schedule.step()
def __init__( self, height=20, width=20, density=0.8, minority_pc=0.2, homophily=3, education_boost=0, education_pc=0.2, seed=None, ): """Seed is used to set randomness in the __new__ function of the Model superclass.""" # pylint: disable-msg=unused-argument,super-init-not-called self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.education_boost = education_boost self.education_pc = education_pc self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": "happy"}, # Model-level count of happy agents # For testing purposes, agent's individual x and y { "x": lambda a: a.pos[0], "y": lambda a: a.pos[1] }, ) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x_coord = cell[1] y_coord = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent_homophily = homophily if self.random.random() < self.education_pc: agent_homophily += self.education_boost agent = SchellingAgent((x_coord, y_coord), self, agent_type, agent_homophily) self.grid.position_agent(agent, (x_coord, y_coord)) self.schedule.add(agent) self.running = True self.datacollector.collect(self)
class Schelling(Model): """ Model class for the Schelling segregation model. """ def __init__(self, height=20, width=20, density=0.8, schedule="RandomActivation", **kwargs): """""" self.height = height self.width = width self.density = density self.minority_pc = 0.4 self.homophily = 3 self.schedule = getattr(time, schedule)(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.running = True def step(self): """ Run one step of the model. If All agents are happy, halt the model. """ self.happy = 0 # Reset counter of happy agents self.schedule.step() if self.happy == self.schedule.get_agent_count(): self.running = False def on_click(self, x, y, agent_type, **kwargs): """Change agent type on click.""" self.grid[x][y].type = 1 if agent_type == 0 else 0 @property def Step(self): return self.schedule.steps
def __init__(self, config): ''' Create a new Spatial Game Model Args: self.dimension: GameGrid size. There will be one agent per grid cell. self.num_moves_per_set: The number of moves each player makes with each other before evolving self.game_type: The type of game to play self.game_mode: The mode of that game to play self.cull_score: The minimum score a player must achieve in order to survive ''' super().__init__() if config['square']: self.dimension = config['dimension'] self.grid = SingleGrid(self.dimension, self.dimension, torus=config['periodic_BC']) self.height = self.dimension self.width = self.dimension else: self.height = config['height'] self.width = config['width'] self.dimension = self.width self.grid = SingleGrid(self.width, self.height, torus=config['periodic_BC']) self.step_num = 0 self.num_moves_per_set = config['num_moves_per_set'] self.initial_population_sizes = config['initial_population_sizes'] self.biomes = config['biomes'] if self.biomes: self.biome_boundaries = biome_boundaries(self.initial_population_sizes, self.width) self.cull_score = config['cull_score'] self.kill_crowded = config['kill_crowded'] self.probability_adoption = config['probability_adoption'] self.probability_mutation = config['probability_mutation'] self.probability_exchange = config['probability_exchange'] self.probability_playing = config['probability_playing'] self.probability_death = config['probability_death'] self.agent_strategies = config['agent_strategies'] self.agent_moves = config['agent_moves'] self.schedule = RandomActivation(self) self.running = True # self.datacollector_populations = DataCollector() # self.datacollector_probabilities = DataCollector() self.num_mutating = 0 self.fraction_mutating = 0 self.num_dead = 0 self.num_dying = 0 self.num_evolving = 0 self.fraction_evolving = 0 self.crowded_players = []
class BikeShare(Model): """A model with some number of potential riders.""" global hours_per_day hours_per_day = 24 def __init__(self, N, M, width, height): # self.running = True self.num_agents = N # self.grid = MultiGrid(width, height, True) self.num_stations = M self.radius = np.int(np.sqrt(width * height)) self.grid = MultiGrid(width, height, True) self.grid_stations = SingleGrid(width, height, True) self.schedule = RandomActivation(self) self.timestamp = 0 # use to find days self.datestamp = 0 threshold = 0.8 # create agents for i in range(self.num_agents): a = BikeRider(i, self, threshold) self.schedule.add(a) # add the agent to a random grid cell x = np.random.randint(self.grid.width) y = np.random.randint(self.grid.height) self.grid.place_agent(a, (x, y)) for i in range(self.num_stations): s = BikeStation(i, self) self.schedule.add(s) # add the station to a random grid cell # x = np.random.randint(self.grid_stations.width) # y = np.random.randint(self.grid_stations.height) self.grid_stations.position_agent(s) # ensures one station max # self.grid.place_agent(s, s.pos) print ("Station " + str(s.unique_id) + "; " + str(s.pos)) # self.datacollector = DataCollector( # model_reporters={"Gini": compute_gini}, # agent_reporters={"Wealth": lambda a: a.wealth} # ) def step(self): '''Advance the model by 1 step: arbitrary unit of time. ''' # self.datacollector.collect(self) # print ("Step the schedule ...") # print (str(self.timestamp)) self.timestamp += 1 if self.timestamp % hours_per_day == 0: print ("\n**** new day " + str(self.datestamp)) self.datestamp += 1 self.timestamp = 0 self.schedule.step()
def __init__(self, N, width=20, height=10): self.running = True self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) load_scene('shape_model/crossing.txt', self.grid, self) """
def __init__(self, wiggle_angle, number_particles, probability_of_sticking, neighbor_influence, num_seeds): self.running = True # necessário para que o modelo seja chamado pelo servidor web self.wiggle_angle = wiggle_angle self.number_particles = number_particles " indica com que probabilidade uma partÃcula vermelha se torna verde " " e pára ao tocar uma partÃcula verde" self.probability_of_sticking = probability_of_sticking "indica se o número de vizinhos verdes influencia a probabilidade de" "grudar" self.neighbor_influence = neighbor_influence if num_seeds <= 0: # número de sementes deve ser positivo raise ValueError("Number of seeds should be greater than zero.") self.num_seeds = num_seeds "direções das particulas" "(1,0) direita; (0, 1) cima; (-1, 0) esquerda (0, -1) baixo" self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) self.schedule = BaseScheduler(self) "tamanho do grid definido em função do número de partÃculas, como na" "visualização; pode ser um valor comum aos dois" width = height = round(2 * round(math.sqrt(number_particles))) "apenas um agente por célula" self.grid = SingleGrid(width, height, True) "Cria as sementes" for i in range(self.num_seeds): if self.num_seeds == 1: """ Coloca a semente no centro do grid. O modelo final do NetLogo, com a extensão 3, não coloca uma semente unitária no centro, mas em uma posição aleatória também. """ x = round(self.grid.width / 2); y = round(self.grid.height / 2); "o angulo e o a probabilidade de colar não são relevantes, já" "que as sementes não se movem" particle = Particle(i, self, GREEN_COLOR, 0, (x, y)) self.grid.place_agent(particle, (x, y)) else: """ Coloca as sementes em posições aleatórias. A posição será atribuÃda pelo método position_agent """ particle = Particle(i, self, GREEN_COLOR, 0, (0, 0)) self.grid.position_agent(particle) self.schedule.add(particle) "Cria as partÃculas" for i in range(self.number_particles): "a posição será atribuÃda pelo método position_agent" heading = self.random.choice(self.headings) particle = Particle(i, self, RED_COLOR, heading, (0, 0)) self.grid.position_agent(particle) self.schedule.add(particle)
class PredatorPreyModel(Model): def __init__(self, N_predator, N_prey, width, height, random_seed=None, predator_probdiv=0.15, predator_probdie=0.2, predator_probdiv_init=0.25): self.num_predators = N_predator self.num_prey = N_prey self.num_ids = N_predator + N_prey self.grid = SingleGrid(width, height, False) self.schedule = RandomActivation(self) model_reporters = {} agent_reporters = {} used_pos_set = set() random.seed(a=random_seed) for i in range(self.num_predators): a = Predator(i, self, probdiv=predator_probdiv, probdie=predator_probdie, probdiv_init=predator_probdiv_init) # Generate x,y pos xcoor = int(random.random() * width) ycoor = int(random.random() * height) while str([xcoor, ycoor]) in used_pos_set: xcoor = int(random.random() * width) ycoor = int(random.random() * height) used_pos_set.add(str([xcoor, ycoor])) self.grid.position_agent(a, x=xcoor, y=ycoor) self.schedule.add(a) for i in range(self.num_prey): a = Prey(i + self.num_predators, self) # Generate x,y pos xcoor = int(random.random() * width) ycoor = int(random.random() * height) while str([xcoor, ycoor]) in used_pos_set: xcoor = int(random.random() * width) ycoor = int(random.random() * height) used_pos_set.add(str([xcoor, ycoor])) self.grid.position_agent(a, x=xcoor, y=ycoor) self.schedule.add(a) self.datacollector = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() self.datacollector.collect(self)
def __init__(self, height, width, depreciation_rate, mobility, status, stat_var, d_factor): # Set model parameters self.depreciation_rate = depreciation_rate self.mobility = mobility self.status = status self.stat_var = stat_var self.d_factor = d_factor self.height = height # Global tracking variables self.mean_income = 0.0 self.schedule = SimultaneousActivation(self) self.grid = SingleGrid(height, width, torus=False) self.datacollector = DataCollector(model_reporters={ "status": lambda m: m.status, "income": lambda m: m.mean_income, "condition": lambda m: m.mean_condition }, agent_reporters={ "x": lambda a: a.pos[0], "y": lambda a: a.pos[1] }) self.running = True self.hit_bottom = False self.last_bottom = 0 self.gent_time = None self.conditions = np.zeros((width, height)) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x, y = cell[1], cell[2] self.conditions[x, y] = bounded_normal(0.50, 0.1, 0.0, 1.0) # Income initially differs little from property conditions while True: income = self.conditions[x, y] + np.random.normal(0.0, 0.025) if income >= 0.0 and income <= 1.0: self.mean_income += income break agent = PropertyAgent((x, y), self, income) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.mean_condition = np.sum(self.conditions) / self.conditions.size self.mean_income /= self.conditions.size
class Schelling(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height=20, width=20, density=0.8, minority_pc=0.2, homophily=3): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": "happy"}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.running = True self.datacollector.collect(self) def step(self): ''' Run one step of the model. If All agents are happy, halt the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step() # collect data self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
class SchellingModel(Model): """ Model class for the Schelling segregation model. """ def __init__(self, height, width, density, minority_pc, homophily): """ """ self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.total_agents = 0 self.datacollector = DataCollector( {"unhappy": lambda m: m.total_agents - m.happy}, # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[X], "y": lambda a: a.pos[Y]}, ) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell, x, y in self.grid.coord_iter(): if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent(self.total_agents, agent_type) self.grid.position_agent(agent, x, y) self.schedule.add(agent) self.total_agents += 1 def step(self): """ Run one step of the model. If All agents are happy, halt the model. """ self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.total_agents: self.running = False
class PD_Model(Model): ''' Model class for iterated, spatial prisoner's dilemma model. ''' schedule_types = {"Sequential": BaseScheduler, "Random": RandomActivation, "Simultaneous": SimultaneousActivation} # This dictionary holds the payoff for this agent, # keyed on: (my_move, other_move) payoff = {("C", "C"): 1, ("C", "D"): 0, ("D", "C"): 1.6, ("D", "D"): 0} def __init__(self, height, width, schedule_type, payoffs=None): ''' Create a new Spatial Prisoners' Dilemma Model. Args: height, width: Grid size. There will be one agent per grid cell. schedule_type: Can be "Sequential", "Random", or "Simultaneous". Determines the agent activation regime. payoffs: (optional) Dictionary of (move, neighbor_move) payoffs. ''' self.running = True self.grid = SingleGrid(height, width, torus=True) self.schedule_type = schedule_type self.schedule = self.schedule_types[self.schedule_type](self) # Create agents for x in range(width): for y in range(height): agent = PD_Agent((x, y), self) self.grid.place_agent(agent, (x, y)) self.schedule.add(agent) self.datacollector = DataCollector({ "Cooperating_Agents": lambda m: len([a for a in m.schedule.agents if a.move == "C"]) }) def step(self): self.datacollector.collect(self) self.schedule.step() def run(self, n): ''' Run the model for a certain number of steps. ''' for _ in range(n): self.step()
class SchellingModel(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height, width, density, type_pcs=[.2, .2, .2, .2, .2]): ''' ''' self.height = height self.width = width self.density = density self.type_pcs = type_pcs self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.happy = 0 self.datacollector = DataCollector( {"happy": lambda m: m.happy}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) total_agents = self.height * self.width * self.density agents_by_type = [total_agents*val for val in self.type_pcs] for loc, types in enumerate(agents_by_type): for i in range(int(types)): pos = self.grid.find_empty() agent = SchellingAgent(pos, self, loc) self.grid.position_agent(agent, pos) self.schedule.add(agent) def step(self): ''' Run one step of the model. If All agents are happy, halt the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
def __init__(self, N, width=20, height=10): self.running = True self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) self.make_walker_agents()
def __init__(self, width=50, height=50, torus=True, num_bug=50, seed=42, strategy=None): super().__init__(seed=seed) self.number_of_bug = num_bug if not(strategy in ["stick", "switch"]): raise TypeError("'strategy' must be one of {stick, switch}") self.strategy = strategy self.grid = SingleGrid(width, height, torus) self.schedule = RandomActivation(self) data = {"Bean": lambda m: m.number_of_bean, "Corn": lambda m: m.number_of_corn, "Soy": lambda m: m.number_of_soy, "Bug": lambda m: m.number_of_bug, } self.datacollector = DataCollector(data) # create foods self._populate(Bean) self._populate(Corn) self._populate(Soy) # create bugs for i in range(self.number_of_bug): pos = self.grid.find_empty() bug = Bug(i, self) bug.strategy = self.strategy self.grid.place_agent(bug, pos) self.schedule.add(bug)
def __init__(self, height, width, schedule_type, payoffs=None): """ Create a new Spatial Prisoners' Dilemma Model. Args: height, width: Grid size. There will be one agent per grid cell. schedule_type: Can be "Sequential", "Random", or "Simultaneous". Determines the agent activation regime. payoffs: (optional) Dictionary of (move, neighbor_move) payoffs. """ self.running = True self.grid = SingleGrid(height, width, torus=True) self.schedule_type = schedule_type self.schedule = self.schedule_types[self.schedule_type](self) # Create agents for x in range(width): for y in range(height): agent = PD_Agent((x, y)) self.grid.place_agent(agent, (x, y)) self.schedule.add(agent) self.datacollector = DataCollector( {"Cooperating_Agents": lambda m: len([a for a in m.schedule.agents if a.move == "C"])} )
def setUp(self): self.space = SingleGrid(50, 50, False) self.agents = [] for i, pos in enumerate(TEST_AGENTS_GRID): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos)
class Foraging(Model): number_of_bean = 0 number_of_corn = 0 number_of_soy = 0 def __init__(self, width=50, height=50, torus=True, num_bug=50, seed=42, strategy=None): super().__init__(seed=seed) self.number_of_bug = num_bug if not(strategy in ["stick", "switch"]): raise TypeError("'strategy' must be one of {stick, switch}") self.strategy = strategy self.grid = SingleGrid(width, height, torus) self.schedule = RandomActivation(self) data = {"Bean": lambda m: m.number_of_bean, "Corn": lambda m: m.number_of_corn, "Soy": lambda m: m.number_of_soy, "Bug": lambda m: m.number_of_bug, } self.datacollector = DataCollector(data) # create foods self._populate(Bean) self._populate(Corn) self._populate(Soy) # create bugs for i in range(self.number_of_bug): pos = self.grid.find_empty() bug = Bug(i, self) bug.strategy = self.strategy self.grid.place_agent(bug, pos) self.schedule.add(bug) def step(self): self.schedule.step() self.datacollector.collect(self) if not(self.grid.exists_empty_cells()): self.running = False def _populate(self, food_type): prefix = "number_of_{}" counter = 0 while counter < food_type.density * (self.grid.width * self.grid.height): pos = self.grid.find_empty() food = food_type(counter, self) self.grid.place_agent(food, pos) self.schedule.add(food) food_name = food_type.__name__.lower() attr_name = prefix.format(food_name) val = getattr(self, attr_name) val += 1 setattr(self, attr_name, val) counter += 1
def __init__(self, height, width, palestinian_density, settlement_density, settlers_violence_rate, settlers_growth_rate, suicide_rate, greed_level, settler_vision=1, palestinian_vision=1, movement=True, max_iters=1000): super(SeparationBarrierModel, self).__init__() self.height = height self.width = width self.palestinian_density = palestinian_density self.settler_vision = settler_vision self.palestinian_vision = palestinian_vision self.settlement_density = settlement_density self.movement = movement self.running = True self.max_iters = max_iters self.iteration = 0 self.schedule = RandomActivation(self) self.settlers_violence_rate = settlers_violence_rate self.settlers_growth_rate = settlers_growth_rate self.suicide_rate = suicide_rate self.greed_level = greed_level self.total_violence = 0 self.grid = SingleGrid(height, width, torus=False) model_reporters = { } agent_reporters = { # "x": lambda a: a.pos[0], # "y": lambda a: a.pos[1], } self.dc = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) self.unique_id = 0 # Israelis and palestinans split the region in half for (contents, x, y) in self.grid.coord_iter(): if random.random() < self.palestinian_density: palestinian = Palestinian(self.unique_id, (x, y), vision=self.palestinian_vision, breed="Palestinian", model=self) self.unique_id += 1 self.grid.position_agent(palestinian, x,y) self.schedule.add(palestinian) elif ((y > (self.grid.height) * (1-self.settlement_density)) and random.random() < self.settlement_density): settler = Settler(self.unique_id, (x, y), vision=self.settler_vision, model=self, breed="Settler") self.unique_id += 1 self.grid.position_agent(settler, x,y) self.schedule.add(settler)
def __init__(self, height=20, width=20, density=.8, group_ratio=.66, minority_ratio=.5, homophily=3): self.height = height self.width = width self.density = density self.group_ratio = group_ratio self.minority_ratio = minority_ratio self.homophily = homophily self.happy = 0 self.segregated = 0 self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.place_agents() self.datacollector = DataCollector( {'happy': (lambda m: m.happy), 'segregated': (lambda m: m.segregated)}) self.running = True
def setUp(self): ''' Create a test non-toroidal grid and populate it with Mock Agents ''' self.grid = SingleGrid(3, 5, True) self.agents = [] counter = 0 for y in range(3): for x in range(5): if TEST_GRID[y][x] == 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 setUp(self): ''' Create a test non-toroidal grid and populate it with Mock Agents ''' width = 3 height = 5 self.grid = SingleGrid(width, height, 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, width, density, minority_pc, homophily): """ """ self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.total_agents = 0 self.datacollector = DataCollector( {"unhappy": lambda m: m.total_agents - m.happy}, # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[X], "y": lambda a: a.pos[Y]}, ) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell, x, y in self.grid.coord_iter(): if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent(self.total_agents, agent_type) self.grid.position_agent(agent, x, y) self.schedule.add(agent) self.total_agents += 1
def __init__(self, height, width, density, minority_pc, homophily): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": lambda m: m.happy}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent)
class TestSingleGrid(unittest.TestCase): def setUp(self): self.space = SingleGrid(50, 50, False) self.agents = [] for i, pos in enumerate(TEST_AGENTS_GRID): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos) def test_agent_positions(self): ''' Ensure that the agents are all placed properly. ''' for i, pos in enumerate(TEST_AGENTS_GRID): a = self.agents[i] assert a.pos == pos def test_remove_agent(self): for i, pos in enumerate(TEST_AGENTS_GRID): a = self.agents[i] assert a.pos == pos assert self.space.grid[pos[0]][pos[1]] == a self.space.remove_agent(a) assert a.pos is None assert self.space.grid[pos[0]][pos[1]] is None def move_agent(self): agent_number = 0 initial_pos = TEST_AGENTS_GRID[agent_number] final_pos = (7, 7) _agent = self.agents[agent_number] assert _agent.pos == initial_pos assert self.space.grid[initial_pos[0]][initial_pos[1]] == _agent assert self.space.grid[final_pos[0]][final_pos[1]] is None self.space.move_agent(_agent, final_pos) assert _agent.pos == final_pos assert self.space.grid[initial_pos[0]][initial_pos[1]] is None assert self.space.grid[final_pos[0]][final_pos[1]] == _agent
class SchellingModel(Model): '''Model class for Schelling segregation model''' def __init__(self, height=20, width=20, density=.8, group_ratio=.66, minority_ratio=.5, homophily=3): self.height = height self.width = width self.density = density self.group_ratio = group_ratio self.minority_ratio = minority_ratio self.homophily = homophily self.happy = 0 self.segregated = 0 self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.place_agents() self.datacollector = DataCollector( {'happy': (lambda m: m.happy), 'segregated': (lambda m: m.segregated)}) self.running = True def step(self): '''Run one step of model''' self.schedule.step() self.calculate_stats() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False def place_agents(self): for cell in self.grid.coord_iter(): x, y = cell[1:3] if random.random() < self.density: if random.random() < self.group_ratio: if random.random() < self.minority_ratio: group = 0 else: group = 1 else: group = 2 agent = SchellingAgent((x,y), group) self.grid.position_agent(agent, (x,y)) self.schedule.add(agent) for agent in self.schedule.agents: count = 0 for neighbour in self.grid.iter_neighbors(agent.pos, moore=False): if neighbour.group == agent.group: count += 1 agent.similar = count def calculate_stats(self): happy_count = 0 avg_seg = 0 for agent in self.schedule.agents: avg_seg += agent.similar if agent.similar >= self.homophily: happy_count += 1 self.happy = happy_count self.segregated = avg_seg/self.schedule.get_agent_count()
class TestSingleGrid(unittest.TestCase): ''' Test the SingleGrid object. Since it inherits from Grid, all the functionality tested above should work here too. Instead, this tests the enforcement. ''' def setUp(self): ''' Create a test non-toroidal grid and populate it with Mock Agents ''' width = 3 height = 5 self.grid = SingleGrid(width, height, 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 test_enforcement(self): ''' Test the SingleGrid empty count and enforcement. ''' assert len(self.grid.empties) == 9 a = MockAgent(100, None) with self.assertRaises(Exception): self.grid._place_agent((0, 1), a) # Place the agent in an empty cell self.grid.position_agent(a) # Test whether after placing, the empty cells are reduced by 1 assert a.pos not in self.grid.empties assert len(self.grid.empties) == 8 for i in range(10): self.grid.move_to_empty(a) assert len(self.grid.empties) == 8 # Place agents until the grid is full empty_cells = len(self.grid.empties) for i in range(empty_cells): a = MockAgent(101 + i, None) self.grid.position_agent(a) assert len(self.grid.empties) == 0 a = MockAgent(110, None) with self.assertRaises(Exception): self.grid.position_agent(a) with self.assertRaises(Exception): self.move_to_empty(self.agents[0])
class SeparationBarrierModel(Model): def __init__(self, height, width, palestinian_density, settlement_density, settlers_violence_rate, settlers_growth_rate, suicide_rate, greed_level, settler_vision=1, palestinian_vision=1, movement=True, max_iters=1000): super(SeparationBarrierModel, self).__init__() self.height = height self.width = width self.palestinian_density = palestinian_density self.settler_vision = settler_vision self.palestinian_vision = palestinian_vision self.settlement_density = settlement_density self.movement = movement self.running = True self.max_iters = max_iters self.iteration = 0 self.schedule = RandomActivation(self) self.settlers_violence_rate = settlers_violence_rate self.settlers_growth_rate = settlers_growth_rate self.suicide_rate = suicide_rate self.greed_level = greed_level self.total_violence = 0 self.grid = SingleGrid(height, width, torus=False) model_reporters = { } agent_reporters = { # "x": lambda a: a.pos[0], # "y": lambda a: a.pos[1], } self.dc = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) self.unique_id = 0 # Israelis and palestinans split the region in half for (contents, x, y) in self.grid.coord_iter(): if random.random() < self.palestinian_density: palestinian = Palestinian(self.unique_id, (x, y), vision=self.palestinian_vision, breed="Palestinian", model=self) self.unique_id += 1 self.grid.position_agent(palestinian, x,y) self.schedule.add(palestinian) elif ((y > (self.grid.height) * (1-self.settlement_density)) and random.random() < self.settlement_density): settler = Settler(self.unique_id, (x, y), vision=self.settler_vision, model=self, breed="Settler") self.unique_id += 1 self.grid.position_agent(settler, x,y) self.schedule.add(settler) def add_settler(self, pos): settler = Settler(self.unique_id, pos, vision=self.settler_vision, model=self, breed="Settler") self.unique_id += 1 self.grid.position_agent(settler, pos[0], pos[1]) self.schedule.add(settler) def set_barrier(self,victim_pos, violent_pos): #print("Set barrier - Greed level", self.greed_level) visible_spots = self.grid.get_neighborhood(victim_pos, moore=True, radius=self.greed_level + 1) furthest_empty = self.find_furthest_empty_or_palestinian(victim_pos, visible_spots) x,y = furthest_empty current = self.grid[y][x] #print ("Set barrier!!", pos, current) free = True if (current is not None and current.breed == "Palestinian"): #print ("Relocating Palestinian") free = self.relocate_palestinian(current, current.pos) if (free): barrier = Barrier(-1, furthest_empty, model=self) self.grid.position_agent(barrier, x,y) # Relocate the violent palestinian #violent_x, violent_y = violent_pos #if violent_pos != furthest_empty: # violent_palestinian = self.grid[violent_y][violent_x] # self.relocate_palestinian(violent_palestinian, furthest_empty) def relocate_palestinian(self, palestinian, destination): #print ("Relocating Palestinian in ", palestinian.pos, "To somehwhere near ", destination) visible_spots = self.grid.get_neighborhood(destination, moore=True, radius=palestinian.vision) nearest_empty = self.find_nearest_empty(destination, visible_spots) #print("First Nearest empty to ", palestinian.pos, " Is ", nearest_empty) if (nearest_empty): self.grid.move_agent(palestinian, nearest_empty) else: #print ("Moveing to random empty") if (self.grid.exists_empty_cells()): self.grid.move_to_empty(palestinian) else: return False return True def find_nearest_empty(self, pos, neighborhood): nearest_empty = None sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood) index = 0 while (nearest_empty is None and index < len(sorted_spots)): if self.grid.is_cell_empty(sorted_spots[index]): nearest_empty = sorted_spots[index] index += 1 return nearest_empty def find_furthest_empty_or_palestinian(self, pos, neighborhood): furthest_empty = None sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood) sorted_spots.reverse() index = 0 while (furthest_empty is None and index < len(sorted_spots)): spot = sorted_spots[index] if self.grid.is_cell_empty(spot) or self.grid[spot[1]][spot[0]].breed == "Palestinian" : furthest_empty = sorted_spots[index] index += 1 return furthest_empty def sort_neighborhood_by_distance(self, from_pos, neighbor_spots): from_x, from_y = from_pos return sorted(neighbor_spots, key = lambda spot: self.eucledean_distance(from_x, spot[0], from_y, spot[1], self.grid.width, self.grid.height)) def eucledean_distance(self, x1,x2,y1,y2,w,h): # http://stackoverflow.com/questions/2123947/calculate-distance-between-two-x-y-coordinates return math.sqrt(min(abs(x1 - x2), w - abs(x1 - x2)) ** 2 + min(abs(y1 - y2), h - abs(y1-y2)) ** 2) def step(self): """ Advance the model by one step and collect data. """ self.violence_count = 0 # for i in range(100): self.schedule.step() self.total_violence += self.violence_count # average = self.violence_count / 100 #print("Violence average %f " % average) print("Total Violence: ", self.total_violence)
class TestSingleGrid(unittest.TestCase): ''' Test the SingleGrid object. Since it inherits from Grid, all the functionality tested above should work here too. Instead, this tests the enforcement. ''' def setUp(self): ''' Create a test non-toroidal grid and populate it with Mock Agents ''' self.grid = SingleGrid(3, 5, True) self.agents = [] counter = 0 for y in range(3): for x in range(5): if TEST_GRID[y][x] == 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 test_enforcement(self): ''' Test the SingleGrid empty count and enforcement. ''' assert len(self.grid.empties) == 10 a = MockAgent(100, None) with self.assertRaises(Exception): self.grid._place_agent((1, 0), a) # Place the agent in an empty cell self.grid.position_agent(a) assert a.pos not in self.grid.empties assert len(self.grid.empties) == 9 for i in range(10): self.grid.move_to_empty(a) assert len(self.grid.empties) == 9 # Place agents until the grid is full for i in range(9): a = MockAgent(101 + i, None) self.grid.position_agent(a) assert len(self.grid.empties) == 0 a = MockAgent(110, None) with self.assertRaises(Exception): self.grid.position_agent(a) with self.assertRaises(Exception): self.move_to_empty(self.agents[0])