def load_obstacle_file(self, file_name: str): """ Reads in a JSON file and stores the obstacle data in the scene. The file must consist of one JSON object with keys 'obstacles', 'exits', and 'entrances' Every key must have a list of instances, each having a 'name', a 'begin' and a 'size'. Note that sizes are fractions of the scene size. A size of 0 is converted to 1 size unit. :param file_name: file name string of the JSON file :return: None """ with open(file_name, 'r') as json_file: data = json.loads(json_file.read()) margin = self.config['general'].getfloat('margin') cell_size = None if self.snap_obstacles: cell_size = np.array([self.config['general'].getfloat('cell_size_x'), self.config['general'].getfloat('cell_size_y')]) for obstacle_data in data["obstacles"]: begin = Point(self.size * obstacle_data['begin']) size = Size(self.size * obstacle_data['size']) name = obstacle_data["name"] self.obstacle_list.append(Obstacle(begin, size, name, margin, cell_size=cell_size)) if len(data['exits']) == 0: raise AttributeError('No exits specified in %s' % file_name) for exit_data in data['exits']: begin = Point(self.size * exit_data['begin']) size = self.size.array * np.array(exit_data['size']) name = exit_data["name"] cap = 0 if 'cap' in exit_data: cap = exit_data['cap'] * self.dt if cap < 1: ft.warn("Exit cap of %.2f per time step is too low low; must exceed 1.0") for dim in range(2): if size[dim] == 0.: size[dim] = 1. exit_obs = Exit(cap=cap, begin=begin, size=Size(size), name=name, margin=margin, cell_size=cell_size) self.exit_list.append(exit_obs) self.obstacle_list.append(exit_obs) for entrance_data in data['entrances']: begin = Point(self.size * entrance_data['begin']) size = self.size.array * np.array(entrance_data['size']) name = entrance_data["name"] spawn_rate = 2 * self.dt max_pedestrians = 8000 start_time = 0 if 'spawn_rate' in entrance_data: spawn_rate = entrance_data['spawn_rate'] * self.dt if max_pedestrians in entrance_data: max_pedestrians = entrance_data['max_pedestrians'] if 'start_time' in entrance_data: start_time = entrance_data['start_time'] for dim in range(2): if size[dim] == 0.: size[dim] = 1. entrance_obs = Entrance(begin=begin, size=Size(size), name=name, margin=margin,spawn_rate=spawn_rate, max_pedestrians=max_pedestrians, start_time=start_time, cell_size=cell_size) self.entrance_list.append(entrance_obs) self.obstacle_list.append(entrance_obs) if len(data['entrances']): self.on_step_functions.append(self.create_new_pedestrians)
def _prepare(self): if not self.visual_backend and not self.store_positions: functions.warn( "No results are logged. Ensure you want a headless simulation." ) # The order in which the following effects are added is important. for population in self.populations: self.on_step_functions.append(population.step) if 'repulsion' in self.effects: self.on_step_functions.append(self.effects['repulsion'].step) if 'fire' in self.effects: self.on_step_functions.append(self.effects['fire'].step) self.on_step_functions.append(self.scene.move) if 'separation' in self.effects: self.on_step_functions.append(self.effects['separation'].step) self.on_step_functions.append(self.scene.correct_for_geometry) self.on_step_functions.append(self.scene.find_finished) if self.store_positions: self.on_step_functions.append(self.logger.step) if self.visual_backend: self.vis = VisualScene(self.scene) self.on_step_functions.append(self.vis.loop) else: self.vis = NoVisualScene(self.scene) if self.inflow: self.on_step_functions.append(self._add_new_pedestrian_sometimes) self.vis.step_callback = self.step self.vis.finish_callback = self.finish self.scene.on_pedestrian_exit_functions.append(self._check_percentage) if self.params.max_time > 0: self.scene.on_pedestrian_exit_functions.append( self._check_max_time)
def _compute_initial_interface(self): """ Compute the initial zero interface; a potential field with zeros on exits and infinity elsewhere. Stores inside object. This method also validates exits. If no exit is found, the method raises an error. :return: None """ self.initial_interface = np.ones(self.grid_dimension) * np.inf valid_exits = {goal: False for goal in self.scene.exit_list} goals = self.scene.exit_list for i, j in np.ndindex(self.grid_dimension): cell_center = Point([(i + 0.5) * self.dx, (j + 0.5) * self.dy]) for goal in goals: if cell_center in goal: self.initial_interface[i, j] = 0 valid_exits[goal] = True self.exit_cell_set.add((i, j)) for obstacle in self.scene.obstacle_list: if not obstacle.accessible: if cell_center in obstacle: # self.initial_interface[i,j] = np.inf self.obstacle_cell_set.add((i, j)) if not any(valid_exits.values()): raise RuntimeError("No cell centers in exit. Redo the scene") if not all(valid_exits.values()): ft.warn("%s not properly processed" % "/" .join([repr(goal) for goal in self.scene.exit_list if not valid_exits[goal]]))
def __init__(self, args): np.seterr(all='raise') functions.VERBOSE = args.verbose self.scene = None self.step_functions = [] self.on_pedestrian_exit_functions = [] self.on_pedestrian_init_functions = [] self.finish_functions = [] config = configparser.ConfigParser() has_config = config.read(args.config_file) if not has_config: raise FileNotFoundError("Configuration file %s not found" % args.config_file) functions.EPS = config['general'].getfloat('epsilon') self.config = config if args.obstacle_file: config['general']['obstacle_file'] = args.obstacle_file # Initialization scene if args.number >= 0: config['general']['number_of_pedestrians'] = str(args.number) if args.configuration == 'uniform': self.scene = scene_module.Scene(config=config) elif args.configuration == 'top': self.scene = TopScene(barrier=0.8, config=config) elif args.configuration == 'center': self.scene = ImpulseScene(impulse_location=(0.5, 0.6), impulse_size=8, config=config) elif args.configuration == 'bottom': self.scene = TwoImpulseScene(impulse_locations=[(0.5, 0.4), (0.4, 0.2)], impulse_size=8, config=config) if not self.scene: raise ValueError("No scene has been initialized") # Initialization planner planner = Planner(self.scene) self.step_functions.append(planner.step) if args.store_positions: # filename = input('Specify storage file\n') import re filename = re.search('/([^/]+)\.json', config['general']['obstacle_file']).group(1) functions.log("Storing positions results in '%s%s'" % (config['general']['result_dir'], filename)) self.step_functions.append(lambda: self.store_positions_to_file(filename)) self.finish_functions.append(lambda: self.store_position_usage(filename)) self.finish_functions.append(self.store_exit_logs) if args.results: results = Result(self.scene) self.step_functions.append(results.on_step) self.on_pedestrian_exit_functions.append(results.on_pedestrian_exit) self.on_pedestrian_init_functions.append(results.on_pedestrian_entrance) self.finish_functions.append(results.on_finish) if not args.kernel: self.vis = VisualScene(self.scene) if args.step: self.vis.disable_loop() else: self.step_functions.append(self.vis.loop) else: if not (args.store_positions or args.results): functions.warn("No results are logged. Ensure you want a headless simulation.") self.vis = NoVisualScene(self.scene) self.scene.on_pedestrian_exit_functions += self.on_pedestrian_exit_functions self.scene.on_pedestrian_init_functions += self.on_pedestrian_init_functions self.vis.step_callback = self.step self.vis.finish_callback = self.finish