import argparse import csv import datetime import itertools import os import sys import time from typing import List import traci from parse import search from shapely.geometry import LineString import actions from config import Config from model import Area, Vehicle, Lane, TrafficLight, Phase, Logic, Emission # Absolute path of the directory the script is in SCRIPTDIR = os.path.dirname(__file__) def init_grid(simulation_bounds, areas_number, window_size): grid = list() width = simulation_bounds[1][0] / areas_number height = simulation_bounds[1][1] / areas_number for i in range(areas_number): for j in range(areas_number): # bounds coordinates for the area : (xmin, ymin, xmax, ymax) ar_bounds = ((i * width, j * height), (i * width, (j + 1) * height), ((i + 1) * width, (j + 1) * height), ((i + 1) * width, j * height)) name = 'Area ({},{})'.format(i, j) area = Area(ar_bounds, name, window_size) grid.append(area) traci.polygon.add(area.name, ar_bounds, (255, 0, 0)) return grid def get_all_lanes() -> List[Lane]: lanes = [] for lane_id in traci.lane.getIDList(): polygon_lane = LineString(traci.lane.getShape(lane_id)) initial_max_speed = traci.lane.getMaxSpeed(lane_id) lanes.append(Lane(lane_id, polygon_lane, initial_max_speed)) return lanes def parse_phase(phase_repr): duration = search('duration: {:f}', phase_repr) min_duration = search('minDuration: {:f}', phase_repr) max_duration = search('maxDuration: {:f}', phase_repr) phase_def = search('phaseDef: {}\n', phase_repr) if phase_def is None: phase_def = '' else: phase_def = phase_def[0] return Phase(duration[0], min_duration[0], max_duration[0], phase_def) def add_data_to_areas(areas: List[Area]): lanes = get_all_lanes() for area in areas: for lane in lanes: # add lanes if area.rectangle.intersects(lane.polygon): area.add_lane(lane) for tl_id in traci.trafficlight.getIDList(): # add traffic lights if lane.lane_id in traci.trafficlight.getControlledLanes(tl_id): logics = [] for l in traci.trafficlight.getCompleteRedYellowGreenDefinition(tl_id): # add logics phases = [] for phase in traci.trafficlight.Logic.getPhases(l): # add phases to logics phases.append(parse_phase(phase.__repr__())) logics.append(Logic(l, phases)) area.add_tl(TrafficLight(tl_id, logics)) def compute_vehicle_emissions(veh_id): co2 = traci.vehicle.getCO2Emission(veh_id) co = traci.vehicle.getCOEmission(veh_id) nox = traci.vehicle.getNOxEmission(veh_id) hc = traci.vehicle.getHCEmission(veh_id) pmx = traci.vehicle.getPMxEmission(veh_id) return Emission(co2, co, nox, hc, pmx) def get_all_vehicles() -> List[Vehicle]: vehicles = list() for veh_id in traci.vehicle.getIDList(): veh_pos = traci.vehicle.getPosition(veh_id) vehicle = Vehicle(veh_id, veh_pos) vehicle.emissions = compute_vehicle_emissions(veh_id) vehicles.append(vehicle) return vehicles def get_emissions(grid: List[Area], vehicles: List[Vehicle], current_step, config, logger): for area in grid: total_emissions = Emission() for vehicle in vehicles: if vehicle.pos in area: total_emissions += vehicle.emissions area.emissions_by_step.append(total_emissions) if area.sum_emissions_into_window(current_step, config.window_size) >= config.emissions_threshold: if config.limit_speed_mode and not area.limited_speed: logger.info(f'Action - Decreased max speed into {area.name} by {config.speed_rf * 100}%') actions.limit_speed_into_area(area, vehicles, config.speed_rf) if config.adjust_traffic_light_mode and not area.tls_adjusted: logger.info( f'Action - Decreased traffic lights duration by {config.trafficLights_duration_rf * 100}%') actions.adjust_traffic_light_phase_duration(area, config.trafficLights_duration_rf) if config.lock_area_mode and not area.locked: if actions.count_vehicles_in_area(area): logger.info(f'Action - {area.name} blocked') actions.lock_area(area) if config.weight_routing_mode and not area.weight_adjusted: actions.adjust_edges_weights(area) traci.polygon.setFilled(area.name, True) else: actions.reverse_actions(area) traci.polygon.setFilled(area.name, False) def get_reduction_percentage(ref, total): return (ref - total) / ref * 100 def export_data_to_csv(config, grid): csv_dir = os.path.join(SCRIPTDIR, 'csv') if not os.path.exists(csv_dir): os.mkdir(csv_dir) now = datetime.datetime.utcnow().isoformat() with open(os.path.join(csv_dir, f'{now}.csv'), 'w') as f: writer = csv.writer(f) # Write CSV headers writer.writerow(itertools.chain(('Step',), (a.name for a in grid))) emissions = (a.emissions_by_step for a in grid) step = 0 for em in emissions: writer.writerow(itertools.chain((step,), (e.value() for e in em))) step += 1 def run(config, logger): grid = list() try: traci.start(config.sumo_cmd) logger.info(f'Loaded simulation file : {config._SUMOCFG}') logger.info('Loading data for the simulation') start = time.perf_counter() grid = init_grid(traci.simulation.getNetBoundary(), config.areas_number, config.window_size) add_data_to_areas(grid) loading_time = round(time.perf_counter() - start, 2) logger.info(f'Data loaded ({loading_time}s)') logger.info('Simulation started...') step = 0 while step < config.n_steps: # traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() vehicles = get_all_vehicles() get_emissions(grid, vehicles, step, config, logger) step += 1 print(f'step = {step}/{config.n_steps}', end='\r') finally: traci.close(False) export_data_to_csv(config, grid) simulation_time = round(time.perf_counter() - start, 2) logger.info(f'End of the simulation ({simulation_time}s)') logger.info(f'Real-time factor : {config.n_steps / simulation_time}') total_emissions = Emission() for area in grid: total_emissions += area.sum_all_emissions() logger.info(f'Total emissions = {total_emissions.value()} mg') if not config.without_actions_mode: ref = config.get_ref_emissions() if not (ref is None): global_diff = (ref.value() - total_emissions.value()) / ref.value() logger.info(f'Global reduction percentage of emissions = {global_diff * 100} %') logger.info(f'-> CO2 emissions = {get_reduction_percentage(ref.co2, total_emissions.co2)} %') logger.info(f'-> CO emissions = {get_reduction_percentage(ref.co, total_emissions.co)} %') logger.info(f'-> Nox emissions = {get_reduction_percentage(ref.nox, total_emissions.nox)} %') logger.info(f'-> HC emissions = {get_reduction_percentage(ref.hc, total_emissions.hc)} %') logger.info(f'-> PMx emissions = {get_reduction_percentage(ref.pmx, total_emissions.pmx)} %') def add_options(parser): parser.add_argument("-f", "--configfile", type=str, default='configs/default_config.json', required=False, help='Choose your configuration file from your working directory') parser.add_argument("-save", "--save", action="store_true", help='Save the logs into the logs folder') parser.add_argument("-steps", "--steps", type=int, default=200, required=False, help='Choose the simulated time (in seconds)') parser.add_argument("-ref", "--ref", action="store_true", help='Launch a reference simulation (without acting on areas)') parser.add_argument("-gui", "--gui", action="store_true", help="Set GUI mode") def main(args): parser = argparse.ArgumentParser(description="") add_options(parser) args = parser.parse_args(args) config = Config() config.import_config_file(args.configfile) config.init_traci() logger = config.init_logger(save_logs=args.save) if args.ref: config.without_actions_mode = True logger.info(f'Reference simulation') if args.steps: config.n_steps = args.steps if args.gui: config._SUMOCMD = "sumo-gui" config.check_config() logger.info(f'Loaded configuration file : {args.configfile}') logger.info(f'Simulated time : {args.steps}s') run(config, logger) if __name__ == '__main__': main(sys.argv[1:])