def init_server(model_parameters): pydemic_canvas = SimpleCanvas(agent_draw, config.canvas_height, config.canvas_width) server = ModularServer(PyDemicModel, [pydemic_canvas], name="PyDemic", model_params=model_parameters) server.launch()
def run(model, parameters, visual, back = False): """ Execute the simulation with visual representation. Args: parameters: Parameters associated with the simulation model and others such as grid size. model: Model that is simulated. visual: JS files with the visualization elements that are included in the JavaScript browser visualization template. back: Python file working as backend visualization. """ backEndVisualization = BackEndVisualization(int(parameters['width']), int(parameters['height']), 500, 500, visual) path = os.path.abspath(soba.__file__) path = path.rsplit('/', 1)[0] local_handler = (r'/local/(.*)', tornado.web.StaticFileHandler, {"path": path}) external_handler = (r'/external/(.*)', tornado.web.StaticFileHandler, {"path": ""}) ModularServer.handlers = ModularServer.handlers[:-1] ModularServer.handlers = ModularServer.handlers + [local_handler] + [external_handler] if back != False: server = ModularServer(model, [backEndVisualization, back], name="Simulation", model_params=parameters) else: server = ModularServer(model, [backEndVisualization], name="Simulation", model_params=parameters) server.port = 7777 server.launch()
def visualize(args): ppd = 8 #pixels per dimension width = 150 height = 140 countR = int(round(height * width / 25 * 3)) # avg 3 Rabits per each 5x5 cells square countF = int(round(height * width / 25 * 1)) # avg 1 Fox per each 5x5 cells square grid = MyCanvasGrid(rabit_portrayal, fox_portrayal, terain_portrayal, width, height, width * ppd, height * ppd) FoxesNr = {"Label": "FoxesNr", "Color": "red"} RabitsNr = {"Label": "RabitsNr", "Color": "blue"} chart_count = ChartModule([FoxesNr, RabitsNr], data_collector_name='datacollector') server = ModularServer( Field, [grid, chart_count], "Rabit VS Fox Model", { "width": width, "height": height, "num_rabits": countR, "num_foxes": countF, "mode": Mode.Visualization, "seed": 999 }) server.port = 8521 # The default server.launch()
def visualization_grid(width, height, highS, middleS, lowS, edu_setting=False, cureProb=0.1, cureProbFac=2/1440, mutateProb=0.0050, diseaseRate=0.2): """ Launch grid visualization on server. width: Width of the grid. height: Height of the grid. highS: Number of agents with high sociability. middleS: Number of agents with middle sociability. lowS: Number of agents with low sociability. edu_setting: If true, agents will follow a schedule and sit in classrooms, else they will move freely through an open grid. cureProb: Probability of agent getting better. cureProbFac: Factor of cureProb getting higher. mutateProb: Probability of a disease mutating. diseaseRate: Rate at which the disease spreads """ grid = CanvasGrid(agent_portrayal, width, height, width*10, height*10) server = ModularServer(DiseaseModel, [grid], "Disease Model", {"highS": highS, "middleS": middleS, "lowS": lowS, "width": width, "height": height, "edu_setting": edu_setting, "cureProb": cureProb, "cureProbFac": cureProbFac, "mutateProb": mutateProb, "diseaseRate": diseaseRate}) server.port = 8521 # The default server.launch()
def StartSimulation(fieldSize): grid = CanvasGrid(agent_portrayal, fieldSize, fieldSize, 500, 500) chart = ChartModule([{ "Label": "Suma przeżytych rund każdej jednostki do kosztu całej armii - czerwoni", "Color": "Red" }, { "Label": "Suma przeżytych rund każdej jednostki do kosztu całej armii - niebiescy", "Color": "Blue" }], data_collector_name='datacollector') chart_hp = ChartModule([{ "Label": "Punkty życia armii czerwonej", "Color": "Red" }, { "Label": "Punkty życia armii niebieskiej", "Color": "Blue" }], data_collector_name='datacollector_health') server = ModularServer(Battlefield, [grid, chart, chart_hp], "Draw Model", { "width": fieldSize, "height": fieldSize }) server.port = 8521 # The default server.launch()
def __init__(self, model): #super().__init__(model=model) self.model = model grid = CanvasGrid(self.agent_portrayal, 50, 50, 500, 500) chart = ChartModule([{ "Label": "Emergence", "Color": "Black" }], data_collector_name='datacollector') server = ModularServer(ComplexClusteringModel, visualization_elements=[grid, chart], name="Ant Model", model_params={ "mid": model.middel, "num_ants": model.num_ants, "density_of_particels": model.density_of_particels, "step_size": model.step_size, "jumping_distance": model.jumping_distance, "perceptionRadius": model.perceptionRadius, "particleThreshhold": model.particleThreshhold, "kPlus": model.kPlus, "kMinus": model.kMinus }) server.port = 8525 # The default server.launch() pass
def main(): """ The main running function. :return: 0 on success """ ln_slider = UserSettableParameter('slider', "Number of L. Niger Agents", NUM_LNIGER, 0, 300, 1) fj_slider = UserSettableParameter('slider', "Number of F. Japonica Agents", NUM_FJAPON, 0, 300, 1) mk_slider = UserSettableParameter('slider', "Number of M. Kuricola Colonies", NUM_MK_COL, 0, 100, 1) ft_slider = UserSettableParameter('slider', "Number of F. Tropicalis Colonies", NUM_FT_COL, 0, 100, 1) # Instantiate the grid the agents will be moving on grid = CanvasGrid(agent_portrayal, GRID_WIDTH, GRID_HEIGHT, 500, 500) if VISUALIZE_MODEL: # Open the visualization server server = ModularServer( AntModel, [grid], "L. Niger Model", { "num_ln": ln_slider, "num_fj": fj_slider, "num_mk_col": mk_slider, "num_ft_col": ft_slider, "width": GRID_WIDTH, "height": GRID_HEIGHT }) server.port = 8521 server.launch() else: for j in range(NUM_SIMS): sim_time_sum = 0 print("Model Initialization #", str(j)) s = time() model = AntModel(NUM_LNIGER, NUM_FJAPON, NUM_MK_COL, NUM_FT_COL, GRID_WIDTH, GRID_HEIGHT) e = time() sim_time_sum += e - s print(e - s) for i in range(STEP_COUNT): if i % 10 == 0: print(j, "Step", i) s = time() model.step() e = time() sim_time_sum += e - s if i % 10 == 0: print(e - s) print("Model #", str(j), "complete. Total time", str(sim_time_sum)) df = model.data_collector.get_agent_vars_dataframe() df = df.dropna(axis=0) df.to_csv(path_or_buf="raw_new/out" + str(j) + ".csv") return 0
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 dynamic_run(params: dict): if params['show_grid']: # visual grid on which agents move grid = CanvasGrid(agent_portrayal, params['grid_width'], params['grid_height'], 500, 500) visualization_elements.insert(0, grid) server = ModularServer(InfectionModel, visualization_elements, "Infection Model", {"params": params}) server.port = 8521 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()
def simulate_scenario(world, tsp_seqs, last_sim_step): model_params = { "world": world, "tsp_seqs": tsp_seqs, "last_sim_step": last_sim_step } task_element = TaskElement() canvas_element = CanvasGrid(warehouse_draw, world.width, world.height, 700, 420) server = ModularServer(Warehouse, [canvas_element, task_element], "MAPD simulation", model_params) server.launch()
def __init__(self, model): # super().__init__(model=model) grid = CanvasGrid(self.agent_portrayal, 50, 50, 500, 500) server = ModularServer(SimpleClusteringModel, visualization_elements=[grid], name="Ant Model", model_params={"mid": model.middel, "num_ants": model.num_ants, "density_of_particels": model.density_of_particels, "step_size": model.step_size, "jumping_distance": model.jumping_distance}) server.port = 8525 # The default server.launch() pass
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(ShapesModel, [grid], "Shape Model Example", num_agents, width, height) server.max_steps = 0 server.port = 8521 server.launch()
def start_server(): grid = CanvasGrid( agent_portrayal, 30, # amount of horizontal cells 30, # amount of vertical cells 500, # canvas width 500) # canvas height chart_infections = ChartModule([{ "Label": "current infections", "Color": "Red" }, { "Label": "current cured", "Color": "Green" }], data_collector_name="data_collector") chart_total = ChartModule([{ "Label": "total infections", "Color": "Red" }, { "Label": "total deaths", "Color": "Black" }, { "Label": "total cured", "Color": "Green" }], data_collector_name="data_collector") chart_current = ChartModule([{ "Label": "new infections", "Color": "Red" }, { "Label": "current cured", "Color": "Green" }], data_collector_name="data_collector") chart_deaths = ChartModule([{ "Label": "total deaths", "Color": "Black" }], data_collector_name="data_collector") server = ModularServer( EpidemicModel, [grid, chart_current, chart_infections, chart_total, chart_deaths], "Epidemic simulation") server.launch(8521, True)
def viz_run(width, height, elev_cells, veg_cells, tracking_type): grid = CanvasGrid(agent_portrayal, width, height, 1200, 900) chart = ChartModule([{"Label": "Pack Health", "Color": "Black"}], canvas_height=200, canvas_width=500, data_collector_name='datacollector') chart2 = ChartModule([{"Label": "Pack Average Track Error", "Color": "Black"}], canvas_height=200, canvas_width=500, data_collector_name='datacollector') server = ModularServer(WolfModel, [grid, chart, chart2], "WolfSim", {"N": 25, "width": width, "height": height, "elev": elev_cells, "veg": veg_cells, "tracking_type": tracking_type}) server.port = 8520 # The defaul server.launch()
def main(): network = NetworkModule(network_portrayal, 500, 500, library='d3') N = 10 percInfect = 0.5 percRecover = 0.25 server = ModularServer(DiseaseModel, [network], "Disease Model", { "N": N, "percInfect": percInfect, "percRecover": percRecover }) server.port = 8521 # The default server.launch()
def launch_shape_model(): width = 50 height = 17 num_agents = 2 pixel_ratio = 10 grid = CanvasGrid(agent_draw, width, height, width * pixel_ratio, height * pixel_ratio) server = ModularServer(ShapesModel, [grid], "Shape Model Example", model_params={ 'N': num_agents, 'width': width, 'height': height }) server.max_steps = 0 server.port = 8888 server.launch()
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 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", {'num_agents': 1000, 'x_size': x_size, 'y_size': y_size}) server.port = 8534 # change this number if address is in use server.launch()
def launch_server( config: ParsedConfig, rpcPort: str, chainId: int, simulationId: str, client: TokesimClient, ) -> None: model_spec = config.config_class_ref.get_spec(config.model_params) ethereum_config = EthereumModelConfig( config=config, model_spec=model_spec, rpcPort=rpcPort, chainId=chainId, simulationId=simulationId, ) simulation_config = SimulationConfig( config=ethereum_config, width=100, height=100, simulationId=simulationId, client=client, ) server = ModularServer( config.class_ref, config.dashboard_class_ref.get_elements(simulation_config), "Linear Bonded Token Model: Minority Majority Game", { "config": simulation_config.config, "width": simulation_config.width, "height": simulation_config.height, "simulationId": simulation_config.simulationId, "client": client, }, ) server.description = """ This Example Token Contract models a linear token curve where the function mimiced directly tracks the token supply by a constant factor of 10000. price = 10000 * x ; Where X = the total supply of tokens in the market. The agents are playing a mixed minority majority game. Where 40% follow the majority when known, and 60% follow the minority when known. These types of games have been used to simulate stock market pricing changes """ server.launch()
def run_interactive_visualization(model, model_params, agent_portrayal, grid_width, grid_height, pixel_width=500, pixel_height=500, additional_modules=[], port=8531, title="SynBioSoc ABM"): grid = CanvasGrid(agent_portrayal, grid_width, grid_height, canvas_width=pixel_width, canvas_height=pixel_height) modules = [grid] modules.extend(additional_modules) server = ModularServer(model, modules, title, model_params) server.port = port server.launch()
def run(configuration, seed=None): """ Run the mesa server :param configuration: configuration used by the model. :param seed: random seed. By default None. """ """ to get results for multiple iterations, run underlying code and add this to default.json in configurations: "inf_threshold": 50, "active_threshold_t": 0.5, "graph_type": "GraphType.ERDOS_RENYI.name" """ #batch_run = BatchRunner(CivilViolenceModel, fixed_parameters = config, iterations = 10) #batch_run.run_all() #data = batch_run.get_model_vars_dataframe() #data.head() random.seed(seed) model_params = get_user_model_parameters() # By updating model_params with configuration after getting the user settable parameters, # it let us provide fixed values for our model which won't be overwritten by the user choice. # Just remove attribute from the configuration file to get user interface back. model_params.update( configuration ) # Overwritten user parameters don't appear in the graphic interface model_params.update({'seed': seed}) server = ModularServer(CivilViolenceModel, get_visualization_elements(model_params, show_network=False), name="Civil violence with network model", model_params=model_params) print(model_params) server.port = 8521 server.launch()
if agent.masked == True: portrayal['Filled'] = 'true' if agent.infected == True: portrayal['Color'] = 'red' if agent.immune == True: portrayal['Color'] = 'green' return portrayal grid = CanvasGrid(agent_portrayal, 50, 50, 500, 500) line_charts = ChartModule([{ 'Label': 'Susceptible', 'Color': 'lightblue' }, { 'Label': 'Infected', 'Color': 'red' }, { 'Label': 'Recovered & Immune', 'Color': 'green' }]) server = ModularServer(CovidModel, [grid, line_charts], 'COVID Simulation Model', model_params) server.port = 8521 # default port if unspecified 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 run_visual(): def network_portrayal(G): portrayal = dict() portrayal["nodes"] = [] for n in G.nodes.data(): portrayal["nodes"].append({ "size": node_size_based_on_crowd(n), "color": n[1]["color"], }) portrayal["edges"] = [] for source, target in G.edges: portrayal["edges"].append({ "source": source, "target": target, "color": "black", "width": 1, }) return portrayal class Time(TextElement): def render(self, model): time = model.date return str(time) network = NetworkModule(network_portrayal, 800, 800, library="d3") chart = ChartModule([{ "Label": "infected", "Color": "Green" }, { "Label": "healthy", "Color": "Red" }, { "Label": "recovered", "Color": "Blue" }], data_collector_name='datacollector') model_params = { "p_nodes": UserSettableParameter("number", "prob nodes", value=0.04), "healthy_N": UserSettableParameter("slider", "amount healthy", 95, 1, 500), "sick_N": UserSettableParameter("slider", "amount sick", 5, 1, 500), "altruism": UserSettableParameter("slider", "altruism", 10, 1, 100), "infect_score_lower": UserSettableParameter("slider", "infect_score_lower", -40, -100, 100, 10), "infect_score_upper": UserSettableParameter("slider", "infect_score_upper", -20, -100, 100) } model_params["network_params"] = [ (model_params["healthy_N"].value + model_params["sick_N"].value, "House", "Grey"), (15, "Work", "yellow"), (5, "School", "green"), (3, "Shop", "Brown"), (3, "Bar", "Brown"), (3, "Park", "Brown"), (1, "University", "Red") ] server = ModularServer(BaseModel, [network, Time(), chart], "Infected model", model_params) server.port = 8521 # The default server.launch()
}, { "Label": "Bin3", "Color": "Blue" }, { "Label": "Bin4", "Color": "Blue" }], scope="model") model_params = { "memory_size": UserSettableParameter("slider", "Memory Size", memory_size, 1, 15, 1), "number_strategies": UserSettableParameter("slider", "Number of Strategies", number_strategies, 1, 20, 1), "number_persons": UserSettableParameter("slider", "Number of Persons", number_persons, 1, 200, 1), "overcrowding_threshold": UserSettableParameter("slider", "Overcrowding Threshold", overcrowding_threshold, 1, 120, 1) } server = ModularServer(ElFarolModel, [ crowded_element, grid, chart, reward_element, hist_agents_reward, hist_reward_agents ], "El Farol Model", model_params) # porta 8521 é a porta default server.launch(port=8579)
def create_server(numb_agents, width, height, expose, recover, rate, prop_worker, prop_student, prop_retire, hubs, homes, schools, workplaces, home_capacity, school_capacity, work_capacity, entertain, shops, stationary_agents=[], moving_agents=[], preventative_toggle=False, stage_threshold=[0.2, 0.5, 0.7], vacc_rate=0.5, export_results=False, filename="log.csv", port=0): #Colors={"Healthy":"#66cd00","Exposed":"#ffd700","Infected":"#b22222","Recovered":"#9932cc"} grid = CanvasGrid(agent_portrayal, width, height, 800, 500) chart_element = ChartModule([{ "Label": label, "Color": color } for (label, color) in Colors.items()]) server = ModularServer( Model, [grid, Legend(), chart_element], # [grid], "Disease Model", { "N": numb_agents, "width": width, "height": height, "expose": expose, "recover": recover, "rate": rate, "prop1": prop_worker, "prop2": prop_student, "prop3": prop_retire, "hubs": hubs, "homes": homes, "schools": schools, "workplaces": workplaces, "home_max": home_capacity, "school_max": school_capacity, "work_max": work_capacity, "entertain": entertain, "shops": shops, "infect_agent_station": stationary_agents, "infect_agent_move": moving_agents, "preventative_measures_active": preventative_toggle, "stage_thresholds": stage_threshold, "vacc_rate": vacc_rate, "export_results": export_results, "filename": str(filename) + ".csv" }) server.port = port server.launch()
wiggle_angle = 60 number_particles = 2500 probability_of_sticking = 1 neighbor_influence = False num_seeds = 1 grid_size = round(2 * round(math.sqrt(number_particles))) "700 é o tamanho do grid em pixels" grid = CanvasGrid(agent_portrayal, grid_size, grid_size, 700, 700) model_params = { "wiggle_angle": UserSettableParameter("slider", "Wiggle Angle", wiggle_angle, 0, 100, 1), "number_particles": UserSettableParameter("slider", "Number of Particles", number_particles, 1, 5000, 1), "probability_of_sticking": UserSettableParameter("slider", "Probability of Sticking Probability", probability_of_sticking, 0, 1, 0.05), "neighbor_influence": UserSettableParameter("checkbox", "Neighbor Influence", neighbor_influence), "num_seeds": UserSettableParameter("slider", "Number of Seeds", num_seeds, 1, 10, 1) } server = ModularServer(DLAModel, [grid], "DLA Model", model_params) # porta 8521 é a porta default server.launch(port=8505)
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 render(self, model): return "Average similarity: " + str(model.similar) class ResidenceElement(TextElement): def __init__(self): pass def render(self, model): return "Average residence length: " + str(model.avg_residence) happy_element = HappyElement() similar_element = SimilarElement() residence_element = ResidenceElement() grid = CanvasGrid(agent_portrayal, 50, 50, 400, 400) happy_chart = ChartModule([{"Label": "Happy", "Color": "Black"}]) similar_chart = ChartModule([{"Label": "Similar", "Color": "Red"}]) residence_chart = ChartModule([{"Label": "Residence", "Color": "Blue"}]) ''' trad_server = ModularServer(TradModel,[grid, similar_element, similar_chart, happy_element, happy_chart], "Traditional Model", {"width":50, "height":50, "num_agents":2125}) trad_server.verbose = False trad_server.port = 8889 trad_server.launch() ''' new_server = ModularServer(NewModel,[grid, similar_element, similar_chart, happy_element, happy_chart, residence_element, residence_chart], "New Model", {"width":50, "height":50, "num_agents":2125}) new_server.verbose = False new_server.port = 8889 new_server.launch()
''' kapital_households_chart = ChartModule([{ "Label": "KapitalH", "Color": "Blue" }], data_collector_name="datacollector") rate_chart = ChartModule([{ "Label": "Rate", "Color": "Black" }], data_collector_name="sinu_datacollector") kapital_households_global_chart = ChartModule( [{ "Label": "KapitalG", "Color": "Red" }], data_collector_name="datacollector") server2 = ModularServer( SinuModel, [kapital_households_chart, kapital_households_global_chart, rate_chart], "SinuModel", { "n_households": 20, "df3": 'pfebtc.xlsx', "list_kapital_global": btc_model.kapital_global_btcModel }) server2.port = 8524 #The default server2.launch()
def launch(width, height, port=None): model_params = { 'starting_settlements': UserSettableParameter('slider', 'starting_settlements', value=14, min_value=5, max_value=20, description='Initial Number of Settlements'), 'starting_households': UserSettableParameter( 'slider', 'starting_households', value=7, min_value=1, max_value=10, description='Initial Number of Households per Settlement'), 'starting_household_size': UserSettableParameter( 'slider', 'starting_household_size', value=5, min_value=1, max_value=10, description='Initial Number of Workers in each Household'), 'starting_grain': UserSettableParameter( 'slider', 'starting_grain', value=3000, min_value=100, max_value=8000, description='Initial Grain Supply of Households'), 'min_ambition': UserSettableParameter('slider', 'min_ambition', value=0.1, min_value=0.0, max_value=1.0, step=0.1, description='Minimum Household Ambition'), 'min_competency': UserSettableParameter('slider', 'min_competency', value=0.5, min_value=0.0, max_value=1.0, step=0.1, description='Minimum Household Competency'), 'generational_variation': UserSettableParameter( 'slider', 'generational_variation', value=0.9, min_value=0.0, max_value=1.0, step=0.1, description='Generational Variation in Ambition and Competency'), 'knowledge_radius': UserSettableParameter('slider', 'knowledge_radius', value=5, min_value=5, max_value=40, description='Household Knowledge Radius'), 'population_growth_rate': UserSettableParameter('slider', 'pop_growth_rate', value=0.1, min_value=0.0, max_value=0.5, step=0.01, description='Population Growth Rate'), 'distance_cost': UserSettableParameter('slider', 'distance_cost', value=10, min_value=1, max_value=15, step=1, description='Distance Cost'), 'allow_rental': UserSettableParameter('checkbox', 'allow_rental', value=False, description='Allow Land Rental'), 'land_rental_rate': UserSettableParameter('slider', 'land_rental_rate', value=0.5, min_value=0.3, max_value=0.6, step=0.05, description='Land Rental Rate'), 'fallow_limit': UserSettableParameter('slider', 'fallow_limit', value=4, min_value=0, max_value=10, step=1, description='Fallow Limit'), 'annual_competency_increase': UserSettableParameter( 'slider', 'annual_competency_increase', value=0, min_value=0, max_value=10, step=0.25, description='Annual Competency Increase Percentage'), 'w': width, 'h': height } visualisation_elements = [] # grid visualisation visualisation_elements.append( EgyptGrid(__agent_portrayal__, width, height, 500, 500)) # datacollector graphs visualisation_elements.append( ChartModule([{ 'Label': 'Gini', 'Color': 'Black' }], data_collector_name='datacollector')) visualisation_elements.append( ChartModule([{ 'Label': 'Total Wealth', 'Color': 'Black' }], data_collector_name='datacollector')) visualisation_elements.append( ChartModule([{ 'Label': 'Mean Settlement Wealth', 'Color': 'Black' }], data_collector_name='datacollector')) visualisation_elements.append( ChartModule([{ 'Label': 'Total Population', 'Color': 'Black' }], data_collector_name='datacollector')) visualisation_elements.append( ChartModule([{ 'Label': 'Mean Settlement Population', 'Color': 'Black' }], data_collector_name='datacollector')) server = ModularServer(EgyptModel, visualisation_elements, 'Egypt Model', model_params) server.launch(port)
CELL_SIZE = 10 CANVAS_HEIGHT = GRID_ROWS * CELL_SIZE 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 launch_city_model(): city_map = [] with open("city_map_21x21.txt", "r") as f: for line in f: l = [] for cell in line.strip().split('\t'): l.append(cell) city_map.append(l) height = len(city_map) width = len(city_map[0]) num_agents = 6 pixel_ratio = 5 city_roads, city_blocks, passenger_blocks, routes = getRoads( city_map, height, width) n_slider = UserSettableParameter('slider', "Number of Cabs", 5, 1, 10, 1) passenger_population = UserSettableParameter('slider', "Passenger Population", .1, 0, 1, .05) passenger_pooling = UserSettableParameter('slider', "Passenger Pooling %", .5, 0, 1, .1) # grid = CanvasGrid(agent_draw, width, height, # width * pixel_ratio, height * pixel_ratio) grid = CanvasGrid(agent_draw, width, height, 500, 500) chart_element = ChartModule([{ "Label": "Normal Passenger", "Color": "#000000" }, { "Label": "Pooling Passenger", "Color": "#0033cc" }, { "Label": "Average", "Color": "#990000" }]) chart_element_cars_carpooling = ChartModule([{ "Label": "Cars carpooling", "Color": "#0033cc" }, { "Label": "Cars not carpooling", "Color": "#000000" }, { "Label": "Empty cars", "Color": "#ffff33" }]) passengers_traveling = ChartModule([{ "Label": "Passengers Travelling (not pooling)", "Color": "#000000" }, { "Label": "Passengers Travelling (pooling)", "Color": "#0033cc" }, { "Label": "Passengers Travelling", "Color": "#19ff00" }]) over_travelled = ChartModule([{ "Label": "Overtravelled (in percentage)", "Color": "#990000" }]) server = ModularServer( CityModel, [ grid, chart_element, chart_element_cars_carpooling, passengers_traveling, over_travelled ], "SOAS Project - Rafael Bianchi", { "N": n_slider, "PassengerPopulation": passenger_population, "PassengerPooling": passenger_pooling, "PassengerBlocks": passenger_blocks, "width": width, "height": height, "city_map": city_map, "roads": city_roads, "city_blocks": city_blocks, "routes": routes }) server.max_steps = 0 server.port = 8521 server.launch()
def run_model( input_file, output_file, n_processors, class_id=None, all_classes=True, webserver=False, model_params=None, test_mode=False, speedup=1, ): input_filepath = os.path.join(os.getcwd(), input_file) all_data = InputData(input_filepath) class_ids = all_data.get_class_ids() if webserver: if all_classes: click.echo("Cannot run over all classes in webserver mode (yet!)") sys.exit(2) else: if not all_classes: if class_id not in class_ids: click.echo( f"Invalid class ID {class_id}. Valid classes are: {class_ids}" ) sys.exit(1) if not webserver: class_ids = [class_id] output_data_writer = OutputDataWriter(output_file) # Get data first to determine grid size model_initial_state = ModelState(0, 0, 0, 0, 0) logging.info("Running on classes: %s", ", ".join([str(i) for i in class_ids])) if not model_params: model_params = DEFAULT_MODEL_PARAMS if test_mode: model_params.maths_ticks_mean = 10 model_params.maths_ticks_sd = 0.1 model_params.ticks_per_home_day = 10 # To ensure each thread in the BatchProcessor gets a different random # number generator, we use a seed sequence to generate a new seed for # each instance of SimModel (one per class), as they run on parallel # processors in batch mode, and we need to ensure they don't all produce # the same numbers # We use a non-reproducible seed sequence to ensure changes to parameters # are not masked by the random numbers generated ss = np.random.SeedSequence() # If we want the rngs to be reproducible in batch mode, we can use the # following to get a SeedSequence (see # https://albertcthomas.github.io/good-practices-random-number-generators/) # random_number_generator = np.random.default_rng(2021) # ss = random_number_generator.bit_generator._seed_seq # Create an rng for each class rngs = [np.random.default_rng(s) for s in ss.spawn(len(class_ids))] if webserver: canvas_grid = create_canvas_grid(14, 14) css_element = CssElement() pupil_element = PupilMonitorElement() class_element = ClassMonitorElement() max_speedup = round(model_params.maths_ticks_mean / 100) * 100 summary_filepath = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "classes_input", "sample_class_summaries.csv", ) summary_data = None if os.path.isfile(summary_filepath): summary_data = pd.read_csv(summary_filepath) server = ModularServer( SimModel, [ sim_element, class_element, pupil_element, canvas_grid, sim_chart, css_element, ], "SimulatED", { "all_data": all_data, "model_initial_state": model_initial_state, "output_data_writer": output_data_writer, "model_params": model_params, "summary_data": summary_data, "canvas_grid": canvas_grid, "instructions": UserSettableParameter( "static_text", value= "<p>Classrooms in school are places when students learn and this model examines how this " "learning in mathematics changes over a year. As time passes students can be attentive (green), " "passive (yellow) or disruptive (red).</p>" "<p>There are some variables related to the classroom which you can change in the model using the " "option on the left. Then click Reset before setting it going. (Setting <em>Frames Per Second</em> " "to 0 runs the model at maximum speed.)</p>" "<p>Whilst the model runs you can watch individual students or the average score for the class." "Try changing the value of the parameters to improve class learning.</p>", ), "class_id": UserSettableParameter("choice", "Class ID", value=class_ids[0], choices=class_ids), "teacher_quality_mean": UserSettableParameter( "slider", "Teaching quality mean", model_params.teacher_quality_mean, 0, 5.0, 0.1, ), "teacher_control_mean": UserSettableParameter( "slider", "Teaching control mean", model_params.teacher_control_mean, 0.00, 5.0, 0.1, ), "random_select": UserSettableParameter( "slider", "Mean for random number used at each step", model_params.random_select, 0.00, 10.0, 0.1, ), "group_size": UserSettableParameter( "slider", "Size of each group of pupils", model_params.group_size, 1, 40, 1, ), "group_by_ability": UserSettableParameter( "checkbox", "Group pupils by ability (rather than at random)", model_params.group_by_ability, ), "speedup": UserSettableParameter( "slider", "How much to speed up (and approximate) the simulation", 1, 1, max_speedup, ), }, ) port = int(os.getenv("PORT", 4200)) server.launch(port=port, open_browser=False) else: print(f"BatchRunnerMP will use {n_processors} processors") batch_run = BatchRunnerMP( SimModel, variable_parameters={ "class_id_and_rng": list(zip(class_ids, rngs)), }, fixed_parameters={ "all_data": all_data, "model_initial_state": model_initial_state, "output_data_writer": output_data_writer, "model_params": model_params, "speedup": speedup, }, nr_processes=n_processors, iterations=1, max_steps=1000000, ) batch_run.run_all()