def launch_basic(): width = 15 height = 10 num_agents = 2 pixel_ratio = 50 grid = CanvasGrid(agent_draw, width, height, width * pixel_ratio, height * pixel_ratio) server = ModularServer(ShapesModel, [grid], "Basic Example", num_agents, width, height) server.max_steps = 0 server.port = 8888 server.launch()
def launch_shape_model(): width = 15 height = 10 num_agents = 2 pixel_ratio = 50 grid = CanvasGrid(agent_draw, width, height, width * pixel_ratio, height * pixel_ratio) server = ModularServer(ShapeExample, [grid], "Shape Model Example", {"N": num_agents, "width": width, "height": height}) server.max_steps = 0 server.port = 8521 server.launch()
class TestModularServer(TestCase): """ Test server for testing """ def portrayal(self, cell): return { "Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0, "x": 0, "y": 0, "Color": "black" } def setUp(self): self.user_params = { 'width': 1, 'height': 1, 'key1': UserSettableParameter('number', "Test Parameter", 101), 'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10) } self.viz_elements = [ CanvasGrid(self.portrayal, 10, 10, 20, 20), TextElement(), # ChartModule([{"Label": "Wolves", "Color": "#AA0000"}, # Todo - test chart module # {"Label": "Sheep", "Color": "#666666"}]) ] self.server = ModularServer(MockModel, self.viz_elements, "Test Model", model_params=self.user_params) def test_canvas_render_model_state(self): test_portrayal = self.portrayal(None) test_grid_state = defaultdict(list) test_grid_state[test_portrayal['Layer']].append(test_portrayal) state = self.server.render_model() assert state[0] == test_grid_state def test_text_render_model_state(self): state = self.server.render_model() assert state[1] == '<b>VisualizationElement goes here</b>.' def test_user_params(self): print(self.server.user_params) assert self.server.user_params == { 'key1': UserSettableParameter('number', "Test Parameter", 101).json, 'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10).json }
def main(x_size, y_size): """ This function sets up a canvas to graphically represent the model 'MoneyModel' and a chart, than it runs the server and runs the model in model.py in the browser """ grid = CanvasGrid(agent_portrayal, x_size, y_size, 500, 500) chart = ChartModule([{"Label": "Gini", "Color": "Black"}], data_collector_name='datacollector') # the simulation uses a class DataCollector, that collects the data and # relays it from self.datacollector to the webpage server = ModularServer(MoneyModel, [grid, chart], "abcEconomics and MESA integrated", x_size * y_size, x_size, y_size) server.port = 8534 # change this number if address is in use server.launch()
def setUp(self): self.user_params = { 'width': 1, 'height': 1, 'key1': UserSettableParameter('number', "Test Parameter", 101), 'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10) } self.viz_elements = [ CanvasGrid(self.portrayal, 10, 10, 20, 20), TextElement(), # ChartModule([{"Label": "Wolves", "Color": "#AA0000"}, # Todo - test chart module # {"Label": "Sheep", "Color": "#666666"}]) ] self.server = ModularServer(MockModel, self.viz_elements, "Test Model", model_params=self.user_params)
from mesa.visualization.modules import CanvasGrid from mesa.visualization.modules import ChartModule from mesa.visualization.ModularVisualization import ModularServer from MoneyModel import MoneyModel def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5} if agent.wealth > 0: portrayal["Color"] = "red" portrayal["Layer"] = 0 else: portrayal["Color"] = "grey" portrayal["Layer"] = 1 portrayal["r"] = 0.2 return portrayal grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500) chart = ChartModule([ {"Label": "Gini", "Color": "Black"}], data_collector_name='datacollector' ) server = ModularServer(MoneyModel, [grid, chart], "Money Model", 100, 10, 10) server.port = 8888 server.launch()
portrayal["Layer"] = 2 portrayal["Shape"] = "rect" elif type(agent) is IsraelRear: color = ISRAEL_REAR_COLOR portrayal["Color"] = color size = 1.0 portrayal["r"] = portrayal["w"] = portrayal["h"] = size portrayal["Layer"] = 3 portrayal["Shape"] = "rect" return portrayal canvas_element = SeparationBarrierGrid(israeli_palestinian_portrayl, 40, 40, 600, 600) greed = 4 server = ModularServer(SeparationBarrierModel, [canvas_element], "Separation Barrier - Greed Level %d" % (greed), height=40, width=40, settlement_density = 0.3, palestinian_density = 0.2, settlers_violence_rate = 0.01, settler_vision = 5, palestinian_vision = 5, settlers_growth_rate = 0.01, suicide_rate = 0.001, greed_level=greed, ) server.port = 6666 server.launch()
from mesa.visualization.UserParam import UserSettableParameter from .model import ForestFire COLORS = {"Fine": "#00AA00", "On Fire": "#880000", "Burned Out": "#000000"} def forest_fire_portrayal(tree): if tree is None: return portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0} (x, y) = tree.get_pos() portrayal["x"] = x portrayal["y"] = y portrayal["Color"] = COLORS[tree.condition] return portrayal canvas_element = CanvasGrid(forest_fire_portrayal, 100, 100, 500, 500) tree_chart = ChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()]) pie_chart = PieChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()]) model_params = { "height": 100, "width": 100, "density": UserSettableParameter("slider", "Tree density", 0.65, 0.01, 1.0, 0.01) } server = ModularServer(ForestFire, [canvas_element, tree_chart, pie_chart], "Forest Fire", model_params)
elif agent.type == "exploiter": return { "Shape": "circle", "Filled": "true", "Layer": 0.2, "Color": "red", "r": 0.5, } else: return { "Shape": "rect", "Filled": "true", "Layer": 0, "Color": "green", "w": 1, "h": 1, } grid = CanvasGrid(agent_portrayal, 100, 100, 800, 800) chart = ChartModule([{ "Label": "Num_Explorer", "Color": "Black" }, { "Label": "Num_Exploiter", "Color": "Red" }], data_collector_name='datacollector') server = ModularServer(World, [grid, chart], "Demo", {"N": 100, "coop": 0.5}) # server = ModularServer(World, [grid], "Demo", {"N": 100, "coop": 0.5})
10, description='Cost of screening for COVID-19'), 'hospitalization_cost': UserSettableParameter( 'slider', 'Hospitalization Cost', 30000, 1000, 90000, 1000, description= 'Cost of Hospitalization in the case of severe or critical conditions') } server = ModularServer(InfectionModel, [network, MyTextElement(), chart], 'COVID-19 ABM Economic Evaluation Model', model_params) server.port = 8521 server.launch() # def get_column_data(model): # """pivot the model dataframe to get states count at each step""" # agent_state = model.datacollector.get_agent_vars_dataframe() # X = pd.pivot_table(agent_state.reset_index(),index='Step',columns='State',aggfunc=np.size,fill_value=0) # labels = ['Susceptible','Infected','Removed'] # X.columns = labels[:len(X.columns)] # return X # def plot_states_bokeh(model,title=''): # """Plot cases per country"""
chart_smart = ChartModule([{ "Label": "SmartMedicine", "Color": "black" }], data_collector_name='datacollector') chart_rad = ChartModule([{ "Label": "RadoznalostSum", "Color": "black" }], data_collector_name='datacollector') server = ModularServer( CancerModel, [grid, chart, chart_speed, chart_smart, chart_rad], "Cancer Model", { "cancer_cells_number": KOLICINA_CELIJA, "cure_number": BROJ_LEKOVA, "eat_values": eat_values, "verovatnoca_mutacije": VEROVATNOCA_MUTACIJE }) server.port = 8523 server.launch() #1. popunjavamo sve delove sa healthy cells check_input #2. implementiramo brzine, random choice brzine #### lista brzina i onda svaki agent kojeg stavljamo ima random brzinu #### mislim da je to ok svakako cemo do nekog balansa doci # sad treba da mutiramo i eliminiramo u svakom koraku #znaci u steps bude da se izracuna ta fitness funkcija, a ko proguta otrov ce dobiti nagradu # za sada cemo samo ubijati npr 5% najgorih tj. 5% najboljih cemo umnoziti
model_type = RPSModel model_labels = [{ "Label": "Rock", "Color": "red" }, { "Label": "Paper", "Color": "green" }, { "Label": "Scissors", "Color": "blue" }] model_visualisation = [ grid, chart_populations(model_labels), chart_scores(model_labels), evolving_agents() ] if model_config['probability_mutation'] > 0: model_visualisation.append(mutating_agents()) server = ModularServer(model_cls=model_type, visualization_elements=model_visualisation, name=model_name, model_params={"config": model_config}) server.verbose = False logger.critical("Started server.")
def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5} if agent.wealth > 0: portrayal["Color"] = "red" portrayal["Layer"] = 0 else: portrayal["Color"] = "grey" portrayal["Layer"] = 1 portrayal["r"] = 0.2 return portrayal grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500) chart = ChartModule([{ "Label": "Gini", "Color": "Black" }], data_collector_name='datacollector') server = ModularServer(MoneyModel, [grid, chart], "Money Model", { "N": 50, "width": 10, "height": 10 }) server.port = 8521 # The default server.launch()
class WealthTable(TextElement): ''' Display a text count of how many happy agents there are. ''' def __init__(self): super().__init__() def render(self, model): result = tabulate([[i, v.wealth] for i, v in enumerate(model.schedule.agents)]) return result score_table = ScoreTable() wealth_table = WealthTable() server = ModularServer(MoneyModel, [ grid, chart, price_chart, participation_chart, wealth_chart, max_score_chart, fluctuation_chart, producer_pie_chart, strategy_pie_chart, speculator_pie_chart, ], "Minority game with producers and speculators", model_params) server.port = 8521 server.launch()
"viral_load_probability": viral_load_probability, "behavioral_factors_lbl": UserSettableParameter('static_text', value = "Behavioral Factors"), "wearing_masks": wearing_masks, "social_distance_limit": social_distance_limit, "health_factors_lbl": UserSettableParameter('static_text', value = "Health Factors"), "natural_immunity": natural_immunity, "exercise": exercise, "preexisting_conditions": preexisting_conditions, "policy_lbl": UserSettableParameter('static_text', value = "Policy Restrictions"), "minority_restrictions": minority_restrictions, "adult_restrictions": adult_restrictions, } components = [ total_cases_element, active_cases_element, recovered_element, canvas_element, summary_element, summary_chart, infected_chart ] server = ModularServer( SimulationEnvironment, components, "COVID19 Agent Based Model with Multi-Objective Optimization for Vaccine Distribution", model_params ) server.port = PORT
# server.py from mesa.visualization.modules import CanvasGrid from mesa.visualization.ModularVisualization import ModularServer from intro import MoneyModel def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "Layer": 0, "Color": "red", "r": 0.5} return portrayal grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500) server = ModularServer(MoneyModel, [grid], "Money Model", {"N": 100, "width": 10, "height": 10}) server.port = 8521 server.launch()
value="Random", choices=["Random", "Neighborhood", "Clusters"]), "mobility_speed": UserSettableParameter("choice", "Mobility", value="low", choices=["test", "low", "high"]), "weeks_to_second_release": UserSettableParameter("choice", "Weeks til second release", value=4, choices=[2, 4, 6, 8]) } if model_params["grid_area"].value == "Demo": grid_height = md.GRID_HEIGHT_DEMO grid_width = md.GRID_WIDTH_DEMO elif model_params["grid_area"].value == "Small": grid_height = md.GRID_HEIGHT_SMALL grid_width = md.GRID_WIDTH_SMALL elif model_params["grid_area"].value == "Large": grid_height = md.GRID_HEIGHT_LARGE grid_width = md.GRID_WIDTH_LARGE canvas_element = CanvasGrid(virus_draw, grid_height, grid_width, 500, 500) server = ModularServer(Virus, [ canvas_element, agent_count_element, susceptible_element, exposed_element, infectious_element, recovered_element, dead_element, chart ], "Team Virus: COVID-19", model_params)
from mesa.visualization.modules import CanvasGrid, ChartModule from mesa.visualization.ModularVisualization import ModularServer from mesa.visualization.UserParam import UserSettableParameter from Models.PluralityModel import PluralityModel from Models.InstantRunoffModel import InstantRunoffModel from Models.PrefrenceModel import PrefrenceModel from Portrayals.AgentPortrayel import agent_portrayal from Modules.HistogramModule import HistogramModule # Interactive visulization grid = CanvasGrid(agent_portrayal, 100, 100, 500, 500) histogram = HistogramModule(list(range(10)), 200, 500) params = { "n_partys": UserSettableParameter("slider", "Party's Amount", 10, 3, 10), "n_voters": UserSettableParameter("slider", "Voters Amount", 1000, 10, 9990) } server = ModularServer(PrefrenceModel, [grid, histogram], 'Prefrence Model', model_params=params)
agents[0].wealth), } for (node_id, agents) in G.nodes.data('agent')] portrayal['edges'] = [{'id': edge_id, 'source': source, 'target': target, 'color': '#000000', } for edge_id, (source, target) in enumerate(G.edges)] return portrayal grid = NetworkModule(network_portrayal, 500, 500, library='sigma') chart = ChartModule([ {"Label": "Gini", "Color": "Black"}], data_collector_name='datacollector' ) model_params = { "num_agents": UserSettableParameter('slider', "Number of agents", 7, 2, 10, 1, description="Choose how many agents to include in the model"), "num_nodes": UserSettableParameter('slider', "Number of nodes", 10, 3, 12, 1, description="Choose how many nodes to include in the model, with at " "least the same number of agents") } server = ModularServer(BoltzmannWealthModelNetwork, [grid, chart], "Money Model", model_params) server.port = 8521
0.4, 0.0, 1.0, 0.1, description='Frequency the nodes check whether they are infected by ' 'a virus'), 'recovery_chance': UserSettableParameter( 'slider', 'Recovery Chance', 0.3, 0.0, 1.0, 0.1, description='Probability that the virus will be removed'), 'gain_resistance_chance': UserSettableParameter( 'slider', 'Gain Resistance Chance', 0.5, 0.0, 1.0, 0.1, description='Probability that a recovered agent will become ' 'resistant to this virus in the future'), } server = ModularServer(VirusModel, [network, MyTextElement(), chart], 'Virus Model', model_params) server.port = 8521
portrayal["text"] = round(agent.energy, 1) portrayal["text_color"] = "White" elif type(agent) is GrassPatch: if agent.fully_grown: portrayal["Color"] = "#00AA00" else: portrayal["Color"] = "#D6F5D6" portrayal["Shape"] = "rect" portrayal["Filled"] = "true" portrayal["Layer"] = 0 portrayal["w"] = 1 portrayal["h"] = 1 return portrayal canvas_element = CanvasGrid(wolf_sheep_portrayal, 20, 20, 500, 500) chart_element = ChartModule([{ "Label": "Wolves", "Color": "#AA0000" }, { "Label": "Sheep", "Color": "#666666" }]) server = ModularServer(WolfSheepPredation, [canvas_element, chart_element], "WolfSheep", grass=True) # server.launch()
from mesa.visualization.modules import CanvasGrid from mesa.visualization.modules import ChartModule from mesa.visualization.ModularVisualization import ModularServer from money_model import MoneyModel def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5} if agent.wealth > 0: portrayal["Color"] = "red" portrayal["Layer"] = 0 else: portrayal["Color"] = "grey" portrayal["Layer"] = 1 portrayal["r"] = 0.2 return portrayal grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500) chart = ChartModule([ {"Label": "Gini", "Color": "Black"}], data_collector_name='datacollector' ) server = ModularServer(MoneyModel, [grid, chart], "Money Model", 100, 10, 10) server.port = 8521 server.launch()
from model_randomWalk import * from mesa.visualization.modules import CanvasGrid from mesa.visualization.ModularVisualization import ModularServer def agent_portrayal(agent): portrayal = { "Shape": "circle", "Filled": "true", "Layer": 0, "Color": "red", "r": 0.5 } return portrayal grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500) server = ModularServer(RWModel, [grid], "Money Model", {}) server.port = 8522 # The default server.launch()
from ForestFireFire import ForestFireModel def agent_portrayal(agent): portrayal = {"Shape": "rect", "Filled": "true", "w": 1, "h": 1} if agent.status == "burning": portrayal["Color"] = "red" portrayal["Layer"] = 0 elif agent.status == "occupied": portrayal["Color"] = "green" portrayal["Layer"] = 1 elif agent.status == "empty": portrayal["Color"] = "black" portrayal["Layer"] = 2 return portrayal L = 10 p = 0.6 grid = CanvasGrid(agent_portrayal, L, L, 500, 500) server = ModularServer(ForestFireModel, [grid], "Forest Fire Model", { "L": L, "p": p }) server.port = 8521 # The default server.launch()
data_collector_name="datacollector") wage_households_sum_chart = ChartModule([{"Label" : "sum_wage", "Color": "Green"}], data_collector_name="datacollector") kapital_firm_chart = ChartModule([{"Label" : "KapitalF", "Color": "Red"}], data_collector_name="datacollector") kapital_bank_chart = ChartModule([{"Label" : "KapitalB", "Color": "Blue"}], data_collector_name="datacollector") diff1 = ChartModule([{"Label" : "diff", "Color": "Blue"}], data_collector_name="datacollector") server = ModularServer(BtcModel, [kapital_households_chart, kapital_households_global_chart ,kapital_households_risk_averse_chart, kapital_households_speculator_chart], "Btc Model", {"n_households":20, "df3": 'pfebtc.xlsx'}) #server2 = ModularServer(SinuModel, #[kapital_households_global_chart], #"SinuModel", #{"n_households":20, "df3": 'pfebtc.xlsx', "list_kapital_global": server.kapital_global_btcModel}) #server.port = 8523 #The default #server.launch()
''' if agent is None: return portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0} if agent.a_type == 0: portrayal["Color"] = "Red" elif agent.a_type == 1: portrayal["Color"] = "Blue" elif agent.a_type == 2: portrayal["Color"] = "Green" elif agent.a_type == 3: portrayal["Color"] = "Yellow" elif agent.a_type == 4: portrayal["Color"] = "Orange" elif agent.a_type == 5: portrayal["Color"] = "Purple" elif agent.a_type == 6: portrayal["Color"] = "Black" elif agent.a_type == 7: portrayal["Color"] = "Brown" return portrayal happy_element = HappyElement() canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500) happy_chart = ChartModule([{"Label": "happy", "Color": "Black"}]) server = ModularServer(SchellingModel, [canvas_element, happy_element, happy_chart], "Schelling", 50, 50, 0.8, [.6, .2, .2]) server.launch()
from mesa.visualization.ModularVisualization import ModularServer from .model import BoidModel from .SimpleContinuousModule import SimpleCanvas def boid_draw(agent): return {"Shape": "circle", "r": 2, "Filled": "true", "Color": "Red"} boid_canvas = SimpleCanvas(boid_draw, 500, 500) model_params = { "N": 100, "width": 100, "height": 100, "speed": 5, "vision": 10, "separation": 2 } server = ModularServer(BoidModel, [boid_canvas], "Boids", model_params)
"Label": "Gini", "Color": "Black" }], data_collector_name='datacollector') model_params = { "num_agents": UserSettableParameter( 'slider', "Number of agents", 7, 2, 10, 1, description="Choose how many agents to include in the model"), "num_nodes": UserSettableParameter( 'slider', "Number of nodes", 10, 3, 12, 1, description="Choose how many nodes to include in the model, with at " "least the same number of agents") } server = ModularServer(BoltzmannWealthModelNetwork, [grid, chart], "Money Model", model_params) server.port = 8521
"Filled": "true" } if type(agent) is Citizen: color = AGENT_QUIET_COLOR if agent.condition == "Quiescent" else \ AGENT_REBEL_COLOR color = JAIL_COLOR if agent.jail_sentence else color portrayal["Color"] = color portrayal["r"] = 0.8 portrayal["Layer"] = 0 elif type(agent) is Cop: portrayal["Color"] = COP_COLOR portrayal["r"] = 0.5 portrayal["Layer"] = 1 return portrayal model_params = dict(height=40, width=40, citizen_density=.7, cop_density=.074, citizen_vision=7, cop_vision=7, legitimacy=.8, max_jail_term=1000) canvas_element = CanvasGrid(citizen_cop_portrayal, 40, 40, 480, 480) server = ModularServer(EpsteinCivilViolence, [canvas_element], "Epstein Civil Violence", model_params)
for (x, y) in product(range(self.grid.width), range(self.grid.height)): if self.grid[x][y]: a = list(self.grid[x][y])[0] if a.die: self.grid.remove_agent(a) self.schedule.remove(a) for na in new_agents: self.i += 1 a = ConwayAgent(self.i, self) self.grid.place_agent(a, na) self.schedule.add(a) def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "Layer": 0, "Color": "red", "r": 0.5} return portrayal grid = CanvasGrid(agent_portrayal, 100, 100, 500, 500) server = ModularServer(ConveyModel, [grid], "Convey Model", {"N": 2000, "width": 100, "height": 100}) server.port = 8521 # The default server.launch()
'target': target, 'color': '#000000', } for i, (source, target, _) in enumerate(G.edges(data=True))] return portrayal grid = NetworkModule(network_portrayal, 500, 500, library='sigma') # chart = ChartModule([ # {"Label": "Gini", "Color": "Black"}], # data_collector_name='datacollector' # ) model_params = { "num_agents": UserSettableParameter( 'slider', "Number of agents", 7, 2, 50, 1, description="Choose how many agents to include in the model"), # "num_nodes": UserSettableParameter('slider', "Number of nodes", 10, 3, 12, 1, # description="Choose how many nodes to include in the model, with at " # "least the same number of agents") } server = ModularServer(MoneyModel, [grid], "Money Model", model_params) server.port = 8521
def schelling_draw(agent): ''' Portrayal Method for canvas ''' if agent is None: return portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0} if agent.type == 0: portrayal["Color"] = "Red" else: portrayal["Color"] = "Blue" return portrayal happy_element = HappyElement() canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500) happy_chart = ChartModule([{"Label": "happy", "Color": "Black"}]) model_params = { "height": 20, "width": 20, "density": UserSettableParameter("slider", "Agent density", 0.8, 0.1, 1.0, 0.1), "minority_pc": UserSettableParameter("slider", "Fraction minority", 0.2, 0.00, 1.0, 0.05), "homophily": UserSettableParameter("slider", "Homophily", 3, 0, 8, 1) } server = ModularServer(SchellingModel, [canvas_element, happy_element, happy_chart], "Schelling", model_params) server.launch()
parameters = json.load(open(config_file)) height = parameters["height"] width = parameters["width"] def eco_model_portrayal(patch): if patch is None: return portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0} (x, y) = patch.get_pos() portrayal["x"] = x portrayal["y"] = y portrayal["Color"] = COLORS[patch.condition] return portrayal # add sliders b_slider = UserSettableParameter('slider', "Establishment probability (b)", 0, 0, 1, 0.01) m_slider = UserSettableParameter('slider', "Mortality probability vegetated sites (m)", 0, 0.005, 1, 0.001) canvas_element = CanvasGrid(eco_model_portrayal, height, width, 500, 500) patch_chart = ChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()]) model_params = { "b": b_slider, "m": m_slider, "config_file": config_file } server = ModularServer(EcoModel, [canvas_element, patch_chart], "Ecosystem Dynamics", model_params)
# Instantiate canvas grid with width and height in cells/pixels grid = CanvasGrid(agent_portrayal, width, height, arena_size, arena_size) # Create a chart for the total amount of chemical chart1 = ChartModule([{ "Label": "Total_Chem", "Color": "Black" }], data_collector_name='datacollector') chart2 = ChartModule([{ "Label": "Average_Distance", "Color": "Red" }], data_collector_name='datacollector') # Create and launch the server server = ModularServer( SlimeModel, # the model to feed in [grid, chart1, chart2], # the list of objects to include in the viz "Slime Model", # title { "pop": slime_population, "width": width, "height": height }) # arguments for the model server.port = 8251 # the default port server.launch()
def server_instance(): canvas_element = CanvasGrid(element_portrayal, args["width"], args["height"], args["width"]*10, args["height"]*10) return ModularServer(ProtestModel, [canvas_element], "UCT Protests", **args)
else: portrayal["Color"] = "#e5f5e0" if type(agent) is Shrub: portrayal["Shape"] = "circle" portrayal["r"] = 0.8 portrayal["Layer"] = 1 if agent.biomass > 0.6: portrayal["Color"] = "#6E2C00" elif agent.biomass > 0.3: portrayal["Color"] = "#DC7633" else: portrayal["Color"] = "#EDBB99" if type(agent) is Grazers: portrayal["Shape"] = "circle" portrayal["Color"] = "#AA0000" portrayal["r"] = 0.5 portrayal["Layer"] = 2 portrayal["text"] = agent.unique_id portrayal["text_color"] = "Yellow" return portrayal canvas_element = CanvasGrid(grazer_portrayal, width, height, canvas_width=500, canvas_height=500) chart_element = ChartModule([{"Label": "Grass biomass", "Color": "#31a354"}, {"Label": "Shrub biomass", "Color": "#6E2C00"}]) model_param = {"width": width, "height": height, "num_grazer": 10, "dens_grass": 0.35} server = ModularServer(GrAM, [canvas_element, chart_element], "GrAM", model_param) server.launch()
CANVAS_WIDTH = GRID_COLS * CELL_SIZE def color_patch_draw(cell): ''' This function is registered with the visualization server to be called each tick to indicate how to draw the cell in its current state. :param cell: the cell in the simulation :return: the portrayal dictionary. ''' assert cell is not None portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0} portrayal["x"] = cell.get_col() portrayal["y"] = cell.get_row() portrayal["Color"] = _COLORS[cell.get_state()] return portrayal CANVAS_ELEMENT = CanvasGrid(color_patch_draw, GRID_COLS, GRID_ROWS, CANVAS_HEIGHT, CANVAS_WIDTH) SERVER = ModularServer(ColorPatchModel, [CANVAS_ELEMENT], "Color Patches", GRID_ROWS, GRID_COLS) SERVER.launch()
def agent_portrayal(agent): portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5} if agent.reserve > 5: portrayal["Color"] = "red" portrayal["Layer"] = 0 else: portrayal["Color"] = "grey" portrayal["Layer"] = 1 portrayal["r"] = 0.2 return portrayal grid = CanvasGrid(agent_portrayal, 10, 11, 500, 500) chart = ChartModule([{ "Label": "gini", "Color": "Black" }], data_collector_name='dc') server = ModularServer(ForageModel, [grid, chart], name="OysterCatcher Model", model_params={ "n_agents": 15, "width": 10, "height": 11 }) server.launch()
from mesa.visualization.ModularVisualization import ModularServer from congestion import CampusModel from SimpleContinuousModule import SimpleCanvas def student_draw(agent): portrayal = { "Shape": "circle", "Color": "red", "Filled": "true", "Layer": 0, "r": 0.5 } return portrayal campus_canvas = SimpleCanvas(student_draw, 500, 500) model_params = {"N": 12, "width": 50, "height": 50} server = ModularServer(CampusModel, [campus_canvas], "Campus Congestion", model_params)
# portrayal['Color'] = sugar_color[0] if agent.pollution > 80: portrayal['Color'] = 'Black' elif agent.pollution > 35: portrayal['Color'] = 'Red' elif agent.pollution > 18: portrayal['Color'] = 'DarkOrange' elif agent.pollution > 5: portrayal['Color'] = 'Orange' elif agent.pollution > 0: portrayal['Color'] = 'Yellow' else: portrayal['Color'] = 'White' if type(agent) is ScapeAgent: portrayal = {'Shape':'circle', 'r':.7, 'Filled':'true', 'Layer':1} # log(round(agent.wealth),round(model.total_wealth)) if agent.wealth <= 0: portrayal['Color'] = 'Red' else: portrayal['Color'] = 'Green' return portrayal if __name__=='__main__': canvas_element = CanvasGrid(scape_draw, 50, 50, 800, 800) total_wealth = ChartModule([{'Label':'Wealth', 'Color':'Blue'}]) agent_count = ChartModule([{'Label':'Agents', 'Color': 'Blue'}]) server = ModularServer(SugarscapeModel, [canvas_element, total_wealth], 'Sugarscape') server.launch()
if type(agent) is Bean: portrayal["Color"] = "cornflowerblue" elif type(agent) is Corn: portrayal["Color"] = "blueviolet" elif type(agent) is Soy: portrayal["Color"] = "forestgreen" elif type(agent) is Bug: portrayal["Shape"] = "circle" portrayal["Color"] = "tomato" portrayal["r"] = 1 portrayal["Layer"] = 1 return portrayal bean = {"Label": "Bean", "Color": "cornflowerblue"} corn = {"Label": "Corn", "Color": "blueviolet"} soy = {"Label": "Soy", "Color": "forestgreen"} bug = {"Label": "Bug", "Color": "tomato"} canvas = CanvasGrid(food_portrayal, width, height) chart_count = ChartModule([bean, corn, soy, bug]) model_params = {"strategy": "stick"} server = ModularServer(Foraging, [canvas, chart_count], name="Foraging", model_params) server.launch()
def __init__(self): pass def render(self, model): return "Happy agents: " + str(model.happy) def schelling_draw(agent): ''' Portrayal Method for canvas ''' if agent is None: return portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0} if agent.type == 0: portrayal["Color"] = "Red" else: portrayal["Color"] = "Blue" return portrayal happy_element = HappyElement() canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500) happy_chart = ChartModule([{"Label": "unhappy", "Color": "Black"}]) server = ModularServer(SchellingModel, [canvas_element, happy_element, happy_chart], "Schelling", 20, 20, 0.8, 0.2, 4) server.verbose = False server.port = 8889 server.launch()