def run(): global current_hour """execute the TraCI control loop""" traci.init(PORT) src = [ Source("D2",100,1), Source("D2",100,2), Source("D2",100,3), Source("L16",100,51), Source("L14",50,25), Source("V4",0,30) ] dest = [ Destination("V4",150), Destination("V4",100), Destination("D8",5), Destination("V4",150), Destination("D1",10), Destination("D1",20) ] stops = [ ChargingStation(0,"D6",50,2,10,[0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5]) , ChargingStation(1,"V2",50,2,8,[0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5]) ] types = ["CarA", "CarA", "CarD", "CarB", "CarC", "CarC"] #number of elechtric vehicle insterted veh_count = 0 vehicles = [] temp_vehs = [] for i in range(6): vehicles.append(Electric_Vehicle(veh_count,src[i],dest[i],types[i],1000,temp_vehs)) veh_count+=1 center = Center(stops,vehicles) for s in stops: center.seller_report(s) temp_toDel = False while vehicles != []: traci.simulationStep() if traci.simulation.getCurrentTime()/1000 % 1000 == 0 and traci.simulation.getCurrentTime()>0: current_hour += 1 print '[HOUR]', current_hour deleteTempVehicles(temp_vehs) for v in vehicles: if (v.updateState(dest) == 1 and not v.reported): center.buyer_report(v,stops,current_hour,temp_vehs) center.assign(v,stops) v.assinged = v.stopToCharge() v.reported = True if (v.toDel): vehicles.remove(v) if v.reported and not v.assinged: v.assinged = v.stopToCharge() traci.close() sys.stdout.flush()
def run(): create_simulation_scenario() if mode == "train": for i in range(200): if random.uniform(0, 1) > 0.5: accident_cars.add("veh" + str(i)) client_socket = socket.socket() client_socket.connect(('127.0.0.1', 9999)) traci.init(PORT) step = 0 client_socket.send(scenario + "," + mode + "," + time + "\n") message = client_socket.recv(1024).splitlines()[0] print message cars_in_perimeter = set() while traci.simulation.getMinExpectedNumber() > 0: manage_car_set(cars_in_perimeter) send_data_to_rsu(client_socket, cars_in_perimeter) traci.simulationStep() step += 1 if mode == "run": sleep(0.2) traci.close() client_socket.close()
def run_genetic_algorithm(): sumoProcessCmd = run_sumo(SUMO) traci.init(PORT) generate_tollgates() traci.close() sumoProcessCmd.wait() run_simulation()
def run(): """execute the TraCI control loop""" traci.init(PORT) # track the duration for which the green phase of the vehicles has been # active greenTimeSoFar = 0 # whether the pedestrian button has been pressed activeRequest = False # main loop. do something every simulation step until no more vehicles are # loaded or running while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() # decide wether there is a waiting pedestrian and switch if the green # phase for the vehicles exceeds its minimum duration if not activeRequest: activeRequest = checkWaitingPersons() if traci.trafficlights.getPhase(TLSID) == VEHICLE_GREEN_PHASE: greenTimeSoFar += 1 if greenTimeSoFar > MIN_GREEN_TIME: # check whether someone has pushed the button if activeRequest: # switch to the next phase traci.trafficlights.setPhase( TLSID, VEHICLE_GREEN_PHASE + 1) # reset state activeRequest = False greenTimeSoFar = 0 sys.stdout.flush() traci.close()
def main(): sumoCmd = [sumoBinary, "-c", sumoConfig] traci.start(sumoCmd) # 开始仿真 simulationSteps = 0 Phaseflag = 0 while simulationSteps < 1000: # 仿真1000个步长 traci.simulationStep() # 执行一步仿真 # 获取仿真环境中当前仿真步的实时信息 print('红绿灯路口西侧排队车辆数目:', traci.lanearea.getJamLengthVehicle('W')) print('红绿灯路口西侧排队长度:', traci.lanearea.getJamLengthMeters('W')) print('红绿灯路口东侧排队车辆数目:', traci.lanearea.getJamLengthVehicle('E')) print('红绿灯路口东侧排队长度:', traci.lanearea.getJamLengthMeters('E')) print('红绿灯路口北侧排队车辆数目:', traci.lanearea.getJamLengthVehicle('N')) print('红绿灯路口北侧排队长度:', traci.lanearea.getJamLengthMeters('N')) print('红绿灯路口南侧排队车辆数目:', traci.lanearea.getJamLengthVehicle('S')) print('红绿灯路口南侧排队长度:', traci.lanearea.getJamLengthMeters('S')) # 红绿灯控制程序 # 所控红绿灯的相位顺序为:东西直行南北禁行(30秒),南北直行东西禁行(30秒) if simulationSteps % 30 == 0: if Phaseflag % 2 == 0: traci.trafficlight.setPhase('3', 0) # 改变红绿灯的相位为东西直行南北禁行 else: traci.trafficlight.setPhase('3', 1) # 改变红绿灯的相位为南北直行东西禁行 Phaseflag += 1 simulationSteps += 1 traci.close() # 结束仿真
def main(args): sumoBinary = sumolib.checkBinary('sumo') sumo_call = [sumoBinary, "-c", "data/hello.sumocfg", "--remote-port", str(PORT_TRACI), "--netstate-dump", "rawdump.xml", "--no-step-log"] sumoProcess = subprocess.Popen( sumo_call, stdout=sys.stdout, stderr=sys.stderr) traci.init(PORT_TRACI) for step in range(161): traci.simulationStep() if step == 120: print(traci.vehicle.getDistance('Stapler_00')) traci.vehicle.setRoute('Stapler_00', ('ed1', 'ed5')) print(traci.vehicle.getRoute('Stapler_00')) assert(traci.vehicle.getRoute('Stapler_00') == ['ed0', 'ed1', 'ed5']) print(traci.vehicle.getDistance('Stapler_00')) if step == 122: assert(traci.vehicle.getRoute('Stapler_00') == ['ed0', 'ed1', 'ed5']) print(traci.vehicle.getDistance('Stapler_00')) traci.vehicle.setRouteID('Stapler_00', "short") print(traci.vehicle.getRoute('Stapler_00')) print(traci.vehicle.getDistance('Stapler_00')) traci.close() sumoProcess.wait()
def init(manager, forTest=False): optParser = OptionParser() optParser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="tell me what you are doing") optParser.add_option("-g", "--gui", action="store_true", dest="gui", default=False, help="run with GUI") optParser.add_option("-c", "--cyber", action="store_true", dest="cyber", default=False, help="use small cybercars instead of big busses") optParser.add_option("-d", "--demand", type="int", dest="demand", default=15, help="period with which the persons are emitted") optParser.add_option("-b", "--break", type="int", dest="breakstep", metavar="TIMESTEP", help="let a vehicle break for %s seconds at TIMESTEP" % BREAK_DELAY) (options, args) = optParser.parse_args() sumoExe = SUMO if options.gui: sumoExe = SUMOGUI sumoConfig = "%s%02i.sumocfg" % (PREFIX, options.demand) if options.cyber: sumoConfig = "%s%02i_cyber.sumocfg" % (PREFIX, options.demand) sumoProcess = subprocess.Popen([sumoExe, sumoConfig], stdout=sys.stdout, stderr=sys.stderr) traci.init(PORT) traci.simulation.subscribe() setting.manager = manager setting.verbose = options.verbose setting.cyber = options.cyber setting.breakstep = options.breakstep try: while setting.step < 100 or statistics.personsRunning > 0: doStep() statistics.evaluate(forTest) finally: traci.close() sumoProcess.wait()
def run(): """execute the TraCI control loop""" traci.init(PORT) step = 0 num_cars = -1 parkable_lanes = [] parked_cars = [] for lane_id in traci.lane.getIDList(): if PARKING_EDGE_TWO_LABEL in lane_id: parkable_lanes.append(lane_id) while traci.simulation.getMinExpectedNumber() > 0: num_cars += 1 traci.simulationStep() traci.vehicle.add("parking_{}".format(num_cars), "right") if len(parkable_lanes) >0: parking_target = "" parking_target = random.choice(parkable_lanes) print parking_target traci.vehicle.changeTarget("parking_{}".format(num_cars), "1i_parking_lane_2_2")#parking_target[:-2]) parkable_lanes.remove(parking_target) parked_cars.append("parking_{}".format(num_cars)) step += 1 traci.close() sys.stdout.flush()
def run(edges, connections, speedChanges, optimalization, nogui): '''execute the TraCI control loop''' traci.init(PORT) if not nogui: traci.gui.trackVehicle('View #0', '0') #print 'route: {0}'.format(traci.vehicle.getRoute('0')) destination = traci.vehicle.getRoute('0')[-1] edgesPoll = list(edges) time = traci.simulation.getCurrentTime() while traci.simulation.getMinExpectedNumber() > 0: if optimalization: change_edge_speed(edgesPoll, edges, speedChanges) edge = traci.vehicle.getRoadID('0') if edge in edges and traci.vehicle.getLanePosition('0') >= 0.9 * traci.lane.getLength(traci.vehicle.getLaneID('0')): shortestPath = graph.dijkstra(edge, destination, edges, get_costs(edges), connections) #print 'dijkstra: {0}'.format(shortestPath) traci.vehicle.setRoute('0', shortestPath) else: if len(speedChanges) > 0: edge, speed = speedChanges.pop() traci.edge.setMaxSpeed(edge, speed) else: change_edge_speed(edgesPoll, edges, []) traci.simulationStep() time = traci.simulation.getCurrentTime() - time traci.close() sys.stdout.flush() return time
def runSingle(traciEndTime, viewRange, module, objID): seen1 = 0 seen2 = 0 step = 0 sumoProcess = subprocess.Popen("%s -c sumo.sumocfg %s" % (sumoBinary, addOption), shell=True, stdout=sys.stdout) # time.sleep(20) traci.init(PORT) traci.poi.add("poi", 400, 500, (1,0,0,0)) traci.polygon.add("poly", ((400, 400), (450, 400), (450, 400)), (1,0,0,0)) subscribed = False while not step>traciEndTime: responses = traci.simulationStep() near1 = set() if objID in module.getContextSubscriptionResults(): for v in module.getContextSubscriptionResults()[objID]: near1.add(v) vehs = traci.vehicle.getIDList() pos = {} for v in vehs: pos[v] = traci.vehicle.getPosition(v) shape = None egoPos = None if hasattr(module, "getPosition"): egoPos = module.getPosition(objID) elif hasattr(module, "getShape"): shape = module.getShape(objID) elif module == traci.edge: # it's a hack, I know, but do we really need to introduce edge.getShape? shape = traci.lane.getShape(objID+"_0") near2 = set() for v in pos: if egoPos: if math.sqrt(dist2(egoPos, pos[v])) < viewRange: near2.add(v) if shape: lastP = shape[0] for p in shape[1:]: if math.sqrt(distToSegmentSquared(pos[v], lastP, p)) < viewRange: near2.add(v) lastP = p if not subscribed: module.subscribeContext(objID, traci.constants.CMD_GET_VEHICLE_VARIABLE, viewRange, [traci.constants.VAR_POSITION] ) subscribed = True else: seen1 += len(near1) seen2 += len(near2) for v in near1: if v not in near2: print "timestep %s: %s is missing in subscribed vehicles" % (step, v) for v in near2: if v not in near1: print "timestep %s: %s is missing in surrounding vehicles" % (step, v) step += 1 print "Print ended at step %s" % (traci.simulation.getCurrentTime() / DELTA_T) traci.close() sys.stdout.flush() print "seen %s vehicles via suscription, %s in surrounding" % (seen1, seen2)
def run_ere(scenario_name, closed_roads, s_time, duration): """ This is to enable the enroute event scenario using TraCI :param scenario_name: the name of the scenario :param closed_roads: the list of closed road id :param s_time: the starting time stamp for the road closure in seconds :param duration: the road closure duration in seconds """ sumo_net = net.readNet(load_map(scenario_name)) pre_sp_lim = [] for i in closed_roads: pre_sp_lim.append(sumo_net.getEdge(i).getSpeed()) s_time += traci.simulation.getCurrentTime()/1000 e_time = s_time + duration while traci.simulation.getMinExpectedNumber() > 0: cur_step = traci.simulation.getCurrentTime()/1000 if cur_step == s_time: for i in closed_roads: traci.edge.setMaxSpeed(i, 0.1) if cur_step == e_time: for seq, rid in enumerate(closed_roads): traci.edge.setMaxSpeed(rid, pre_sp_lim[seq]) traci.simulationStep() traci.close() sys.stdout.flush()
def run(): """execute the TraCI control loop""" traci.init(PORT) programPointer = len(PROGRAM) - 1 step = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() programPointer = min(programPointer + 1, len(PROGRAM) - 1) numPriorityVehicles = traci.inductionloop.getLastStepVehicleNumber("0") if numPriorityVehicles > 0: if programPointer == len(PROGRAM) - 1: # we are in the WEGREEN phase. start the priority phase # sequence programPointer = 0 elif PROGRAM[programPointer] != WEYELLOW: # horizontal traffic is already stopped. restart priority phase # sequence at green programPointer = 3 else: # we are in the WEYELLOW phase. continue sequence pass traci.trafficlights.setRedYellowGreenState( "0", PROGRAM[programPointer]) step += 1 traci.close() sys.stdout.flush()
def run(): traci.init(int(PORT)) step = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() step += 1 traci.close()
def traciSimulation(port): ''' Execute the TraCI control loop on the SUMO simulation. :param port: The port used for communicating with your sumo instance :return: The end second time of the simulation ''' try: # Init the TraCI server traci.init(port) # TraCI runs the simulation step by step step = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() step += 1 except traci.TraCIException as ex: logger.fatal("Exception in simulation step %d: %s" % (step, ex.message)) return -1 except traci.FatalTraCIError as ex: logger.fatal("Fatal error in simulation step %d: %s" % (step, ex.message)) return -1 else: return step + 1 finally: # Close the TraCI server traci.close()
def beginEvaluate(self): """ Given the parameters during initialization, we run the simulator to get the fitness using port num to identify a connection """ traci.init(self.portNum, 10, "localhost", str(self.portNum)) #traverse all the traffic lights for i in xrange(len(self.trafficLightIdList)): #traverse all the traffic lights tlsLogicList = traci.trafficlights.getCompleteRedYellowGreenDefinition(self.trafficLightIdList[i]) #One traffic light has only one phase list now tlsLogicList = tlsLogicList[0] #each traffic light has several phases phaseList = [] #traverse all the phase for j in xrange(len(tlsLogicList._phases)): # print self.individual.genes[i].times[j] phaseList.append(traci.trafficlights.Phase(self.individual.genes[i].times[j], self.individual.genes[i].times[j], self.individual.genes[i].times[j], tlsLogicList._phases[j]._phaseDef)) tlsLogicList._phases = phaseList traci.trafficlights.setCompleteRedYellowGreenDefinition(self.trafficLightIdList[i], tlsLogicList) totalNumPassed = 0 for _ in xrange(600): traci.simulationStep() totalNumPassed = totalNumPassed + traci.simulation.getArrivedNumber() traci.close() self.fitness = totalNumPassed return totalNumPassed
def run(run_time): ## execute the TraCI control loop traci.init(PORT) programPointer = 0 # initiates at start # len(PROGRAM) - 1 # initiates at end step = 0 flow_count = 0 first_car = True prev_veh_id = ' ' pointer_offset = 0 car_speeds = [] while traci.simulation.getMinExpectedNumber() > 0 and step <= run_time*(1/step_length): traci.simulationStep() # advance a simulation step programPointer = int(math.floor(step/(int(1/step_length))))%len(PROGRAM) - pointer_offset sensor_data = traci.inductionloop.getVehicleData("sensor") if len(sensor_data) != 0: flow_increment,prev_veh_id = flowCount([sensor_data],["sensor"],prev_veh_id) car_speeds.append(traci.vehicle.getSpeed(sensor_data[0][0])) flow_count += flow_increment if first_car: #if its the first car, record the time that it comes in first_time = sensor_data[0][2] print first_time first_car = False if step < 600: #24960, let queue accumulate traci.trafficlights.setRedYellowGreenState("0", ALLRED) else: traci.trafficlights.setRedYellowGreenState("0",PROGRAM[programPointer]) step += 1 #print str(step) print "\n \n" print "-------------------------------------------------------- \n" print "Total number of cars that have passed: " + str(flow_count) tau = np.diff(leaving_times) print "Total throughput extrapolated to 1hr: " + str(flow_count*(3600/(run_time-first_time))) print "Average car speed: " + str(np.mean(car_speeds)) print "Max Theoretical throughput: " + str(3600/min(min(tau))) print "Min Theoretical throughput: " + str(3600/max(max(tau))) # print tau # print "Mean tau: " + str(np.mean(tau)) + "\n" # print "Var tau: " + str(np.var(tau)) + "\n" # print "Standard Dev tau: " + str(np.std(tau)) +"\n" traci.close() sys.stdout.flush() return [np.mean(tau),np.var(tau),np.std(tau)]
def initialize_state(): sumoProcessCmd = run_sumo(SUMO) traci.init(PORT) select_valid_edges() genetic.initialize() state.initialized = True traci.close() sumoProcessCmd.wait()
def run(run_time): ## execute the TraCI control loop traci.init(PORT) programPointer = 0 # initiates at start # len(PROGRAM) - 1 # initiates at end step = 0 flow_count = 0 first_car = True prev_veh_id = ' ' leaving_times = [] car_speeds = [] while traci.simulation.getMinExpectedNumber() > 0 and step <= run_time*(1/step_length): traci.simulationStep() # advance a simulation step programPointer = (step*int(1/step_length))%len(PROGRAM) sensor_data = traci.inductionloop.getVehicleData("sensor") if len(sensor_data) != 0: if first_car: #if its the first car, record the time that it comes in first_time = sensor_data[0][2] print first_time first_car = False veh_id = sensor_data[0][0] if veh_id != prev_veh_id: #if the vehicle coming in has a different id than the previous vehicle, count it towards total flow flow_count += 1 car_speeds.append(traci.inductionloop.getLastStepMeanSpeed("sensor")) if sensor_data[0][3] != -1: #if the vehicle is leaving the sensor, record the time it left leaving_times.append(sensor_data[0][2]) prev_veh_id = veh_id traci.trafficlights.setRedYellowGreenState("13", PROGRAM[programPointer]) step += 1 #print str(step) print "\n \n" print "-------------------------------------------------------- \n" print "Total number of cars that have passed: " + str(flow_count) tau = np.diff(leaving_times) print "Total throughput extrapolated to 1hr: " + str(flow_count*(3600/(run_time-first_time))) print "Max Theoretical throughput: " + str(3600/tau_effective(max(car_speeds))) print "Min Theoretical throughput: " + str(3600/tau_effective(min(car_speeds))) print tau print "Mean tau: " + str(np.mean(tau)) + "\n" print "Var tau: " + str(np.var(tau)) + "\n" print "Standard Dev tau: " + str(np.std(tau)) +"\n" traci.close() sys.stdout.flush() return [np.mean(tau),np.var(tau),np.std(tau)]
def run(): """execute the TraCI control loop""" step = 0 while traci.simulation.getMinExpectedNumber() > 0: step += 1 traci.simulationStep() traci.close() sys.stdout.flush()
def finish_sim(self): print 'finish_sim' for demandobj in self.parent.demand.get_demandobjects(): print ' finish_sim', demandobj.ident # demandobj.finish_sim(self) traci.close() print ' traci closed.' self.get_attrsman().status.set('success') return True
def runSingle(traciEndTime): step = 0 sumoProcess = subprocess.Popen("%s -c used.sumocfg %s" % (sumoBinary, addOption), shell=True, stdout=sys.stdout) traci.init(PORT) while not step>traciEndTime: traci.simulationStep() step += 1 print "Print ended at step %s" % (traci.simulation.getCurrentTime() / DELTA_T) traci.close() sys.stdout.flush()
def run(): """execute the TraCI control loop""" traci.init(PORT) step = 0 while traci.simulation.getMinExpectedNumber() > 0 and step < 100: traci.simulationStep() step += 1 if step == 4: traci.trafficlights.setProgram("center", "0") traci.close() sys.stdout.flush()
def end(self): signal.signal(signal.SIGALRM, _timeOutHandler) signal.alarm(_wait_in_s) try: traci.close() self.sumoProcess.wait() except Exception, exc: print exc self.sumoProcess.terminate() if "" in traci._connections: traci._connections[""].close() del traci._connections[""]
def _generate_rerouters(self): """ Compute the rerouters for each parking lot for SUMO. """ traci.start([sumolib.checkBinary('sumo'), '--no-step-log', '-n', self._sumo_net]) distances = collections.defaultdict(dict) for parking_a in self._parking_areas.values(): for parking_b in self._parking_areas.values(): if parking_a['id'] == parking_b['id']: continue if parking_a['edge'] == parking_b['edge']: continue route = None try: route = traci.simulation.findRoute( parking_a['edge'], parking_b['edge']) except traci.exceptions.TraCIException: route = None cost = None if route and route.edges: cost = route.travelTime else: cost = None distances[parking_a['id']][parking_b['id']] = cost traci.close() # select closest parking areas for pid, dists in distances.items(): list_of_dist = [tuple(reversed(x)) for x in dists.items() if x[1] is not None] list_of_dist = sorted(list_of_dist) rerouters = [(pid, 0.0)] for distance, parking in list_of_dist: if len(rerouters) > self._num_alternatives: break if distance > self._dist_alternatives: break rerouters.append((parking, distance)) if not list_of_dist: logging.fatal('Parking %s has 0 neighbours!', pid) self._sumo_rerouters[pid] = { 'rid': pid, 'edge': self._parking_areas[pid]['edge'], 'rerouters': rerouters, } logging.debug('Computed %d rerouters.', len(self._sumo_rerouters.keys()))
def step(self): # print "step", self.simtime,self.simtime_end,self.simtime >= self.simtime_end traci.simulationStep() self.process_step() self.get_logger().w(100.0*self.simtime/self.duration, key='progress') self.simtime += self.time_step if self.simtime >= self.simtime_end: print ' end of simulation reached, start closing traci', self.simtime traci.close() print ' traci closed' self.get_attrsman().status.set('success') return True
def __inner_run__(self, output_file): if self._options.gui: sumoBinary = checkBinary('sumo-gui') self.__sumoProcess = subprocess.Popen( [sumoBinary,"-W", "-n", self.conf.network_file, "-r", self.conf.route_file, "--tripinfo-output", output_file, "--remote-port", str(self.conf.port), "--gui-settings-file", self.conf.gui_setting_file, "--step-length", "1", "-v", "true", "--time-to-teleport", "-1"], stdout = sys.stdout, stderr=sys.stderr) time.sleep(20) else: sumoBinary = checkBinary('sumo') self.__sumoProcess = subprocess.Popen( [sumoBinary, "-W", "-n", self.conf.network_file, "-r", self.conf.route_file, "--tripinfo-output", output_file, "--remote-port", str(self.conf.port), "--step-length", "1", "-v", "true", "--time-to-teleport", "-1"], stdout = sys.stdout, stderr=sys.stderr) time.sleep(20) traci.init(self.conf.port) self.initIteration() while True: traci.simulationStep() if traci.simulation.getMinExpectedNumber() <= 0: break self.stepProcess() if traci.simulation.getCurrentTime() % self.conf.short_term_sec == 0: self.can_change_lane_list = [] self.want_chage_vehicle_list = [] self.endIteration() traci.close() if self._options.gui: os.system('pkill sumo-gui') sys.stdout.flush()
def main(args): init_traci() step = -1 while True: step += 1 traci.simulationStep() if step == 140: traci.vehicle.resume('Stapler_00') if step == 160: traci.close() break
def runSingle(traciEndTime, sumoEndTime=None): step = 0 opt = addOption if sumoEndTime is not None: opt += (" --end %s" % sumoEndTime) sumoProcess = subprocess.Popen( "%s -c sumo.sumocfg %s" % (sumoBinary, opt), shell=True, stdout=sys.stdout) traci.init(PORT) while not step > traciEndTime: traci.simulationStep() step += 1 print("Print ended at step %s" % (traci.simulation.getCurrentTime() / DELTA_T)) traci.close() sys.stdout.flush()
def HandleShutdownEvent(self, event) : try : idlist = traci.vehicle.getIDList() for v in idlist : traci.vehicle.remove(v) traci.close() sys.stdout.flush() self.SumoProcess.wait() self.__Logger.info('shut down') except : exctype, value = sys.exc_info()[:2] self.__Logger.warn('shutdown failed with exception type %s; %s' % (exctype, str(value)))
def sim(): step = 0 while step < 86400: traci.simulationStep() xy=[] vehicles = traci.vehicle.getIDList() for v in vehicles: x=112.96771+(traci.vehicle.getPosition(v)[0]+1509.33)/98838.1145 y=28.193671+(traci.vehicle.getPosition(v)[1]-105.97)/106287.597 xy.append([x,y]) return xy time.sleep(10) step += 10 traci.close()
def run(isTesting): """execute the TraCI control loop""" step = 0 YELLOW_PHASE = 4 RED_PHASE = 2 site4235_detector_delay = [] site4235_LOOP_COUNT = 11 for i in range(0, site4235_LOOP_COUNT + 1): # initiliaze array of 0s site4235_detector_delay.append(0) lanesForPhases_s4235 = { # key = phase, values = lanes with green lights 0: [1, 2, 3, 9, 10, 11], #A 1: [1, 2, 3, 4], #B 2: [6, 7] #C } detector_delay_s4219 = [] site4219_LOOP_COUNT = 21 ignored_phases_s4219 = [ 20, 21, 22 ] # could automate this I guess? if not in dict TODO for i in range(0, site4219_LOOP_COUNT + 1): # initiliaze array of 0s detector_delay_s4219.append(0) lanesForGroupsForPhases_s4219 = { # key = phase, values = lanes with green lights 0: [0, 1], #A 1: [1, 6, 7], #B 2: [0, 2], #C 3: [3, 8], #D 4: [3, 4, 7], #E 5: [4, 5, 7], #F 6: [6, 2, 7] #G } lanesForGroups_s4219 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [ 11, 12 ], # such that, a right turn lane can be replaced by oncoming traffic 1: [1, 2], 2: [13, 14], 3: [15, 16, 17], 4: [7, 8], 5: [9, 10], 6: [3, 4], 7: [5, 6], 8: [18, 19] } conflictingGroups_s4219 = { # TODO automate this from lanesForGroupsForPhases_s4219 (necessary?) 0: [3, 4, 5, 6, 7, 8], 1: [2, 3, 4, 5, 8], 2: [1, 3, 4, 5, 8], 3: [0, 1, 2, 3, 5, 6], 4: [0, 1, 2, 6, 8], 5: [0, 1, 2, 3, 6, 8], 6: [0, 3, 4, 5, 8], 7: [1, 8], 8: [1, 2, 4, 5, 6, 7] } earliestDeadline_s4219 = 0 earliestDeadlineGroup_s4219 = 0 waitTime_s4219 = 0 activeTraffic_s4219 = [] for i in range(0, len(lanesForGroups_s4219)): # initiliaze array of 99s activeTraffic_s4219.append(99) detector_delay_s4220 = [] site4220_LOOP_COUNT = 15 ignored_phases_s4220 = [ 3, 8, 11 ] # could automate this I guess? if not in dict TODO for i in range(0, site4220_LOOP_COUNT + 1): # initiliaze array of -1s detector_delay_s4220.append(0) lanesForGroupsForPhases_s4220 = { # key = phase, values = lanes with green lights 0: [1, 5], #A 1: [5, 6, 0], #B 2: [1, 2], #C 3: [3, 4], #D 4: [2, 6] #E } lanesForGroups_s4220 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [1, 2], 1: [4, 5, 6], 2: [7], 3: [9], 4: [10], 5: [12, 13, 14], 6: [15] } conflictingGroups_s4220 = { # TODO automate this from lanesForGroupsForPhases_s4220 (necessary?) 0: [1, 4], 1: [0, 6, 4, 3], 2: [5, 4, 3], 3: [0, 1, 2, 5, 6], 4: [0, 1, 2, 5, 6], 5: [2, 3, 4], 6: [2, 3, 4, 5] } earliestDeadline_s4220 = 0 earliestDeadlineGroup_s4220 = 0 waitTime_s4220 = 0 activeTraffic_s4220 = [] for i in range(0, len(lanesForGroups_s4220)): # initiliaze array of 99s activeTraffic_s4220.append(99) next_phase_s4220 = 0 detector_delay_s4221 = [] site4221_LOOP_COUNT = 18 ignored_phases_s4221 = [ 6, 10, 14 ] # could automate this I guess? if not in dict TODO for i in range(0, site4221_LOOP_COUNT + 1): # initiliaze array of -1s detector_delay_s4221.append(0) lanesForGroupsForPhases_s4221 = { # key = phase, values = lanes with green lights 0: [3, 7], #A 1: [3, 4], #B 2: [7, 8, 0], #C 3: [1, 2, 0], #D 4: [5, 6], #E 5: [4, 8, 0] #f } lanesForGroups_s4221 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [1, 2], 1: [3], 2: [4, 5], 3: [7, 8], 4: [9], 5: [11, 12], 6: [13], 7: [15, 16], 8: [17, 18] } conflictingGroups_s4221 = { # TODO automate this from lanesForGroupsForPhases_s4221 (necessary?) 0: [3, 6], 1: [3, 4, 6, 7, 8], 2: [3, 4, 5, 7, 8], 3: [0, 1, 2, 5, 6, 8], 4: [1, 2, 5, 6, 7], 5: [2, 3, 4, 7, 8], 6: [0, 1, 2, 3, 4, 7, 8], 7: [1, 2, 4, 5, 6], 8: [1, 2, 3, 5, 6] } earliestDeadline_s4221 = 0 earliestDeadlineGroup_s4221 = 0 waitTime_s4221 = 0 activeTraffic_s4221 = [] for i in range(0, len(lanesForGroups_s4221)): # initiliaze array of 99s activeTraffic_s4221.append(99) next_phase_s4221 = 0 MINIMUM_TRAFFIC_ACTIVITY = 3 traci.trafficlight.setPhase("5861321343", 0) #RL stuff if isTesting == "1": e = 0.0 else: e = 0.5 rng = str(datetime.datetime.now().time())[6:8] random.seed(rng) stateActionValuesFile = open("stateActionValues.csv", "r") stateActionValues = stateActionValuesFile.readlines() stateActionValuesFile.close() saveStateActions = open("stateActions.csv", "w") takeMove = True transitionCounter_s4219 = 0 currentActivePhase = traci.trafficlight.getPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) transition_s2419 = chr(65 + currentActivePhase) + "-" + chr( 65 + currentActivePhase) + "-1" # eg. A-A-1 move = currentActivePhase while step <= 600: traci.simulationStep() # add in other traffic lights #static edf algo # ----------------------------------------------------------------------SITE 4221-------------------------------------------------------------------------------------------------- phase_s4221 = traci.trafficlight.getPhase( "cluster_25953432_313863435_313863521_314053282" ) # phase indexing starts at 0 if (phase_s4221 in lanesForGroupsForPhases_s4221.keys() ): # if not a transition phase waitTime_s4221 += 1 # current phase wait time transitionCounter_s4221 = 0 for i in range(0, len(lanesForGroups_s4221)): if i in lanesForGroupsForPhases_s4221[phase_s4221]: groupActivity = [] for lane in lanesForGroups_s4221[i]: groupActivity.append( int( traci.inductionloop.getTimeSinceDetection( "site4221_" + str(lane)))) detector_delay_s4221[lane] = 0 activeTraffic_s4221[i] = min(groupActivity) else: for lane in lanesForGroups_s4221[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4221_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4221[lane] = detector_delay_s4221[ lane] + 1 # increment loopDetectorDelay earliestDeadline_s4221 = detector_delay_s4221.index( max(detector_delay_s4221)) switchPhase_s4221 = True for group in lanesForGroups_s4221: # find which group the EDF lane belongs to if earliestDeadline_s4221 in lanesForGroups_s4221[group]: earliestDeadlineGroup_s4221 = group for group in lanesForGroupsForPhases_s4221[ phase_s4221]: # do not switch phase if any conflicting lane has traffic, all inactive groups automatically are 99 if group != 0: if activeTraffic_s4221[group] < MINIMUM_TRAFFIC_ACTIVITY: switchPhase_s4221 = False #if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[phase_s4221]: # switchPhase_s4221 = False if earliestDeadline_s4221 == 0: switchPhase_s4221 = False if waitTime_s4221 == 180: switchPhase_s4221 = True if switchPhase_s4221 == True: transitionCounter = 0 # build new phase secondDeadline = -1 secondaryDeadlineGroup_s4221 = earliestDeadlineGroup_s4221 for i in range( 0, len(lanesForGroupsForPhases_s4221) ): # find the secondary group to create new phase if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: for group in lanesForGroupsForPhases_s4221[i]: if group != earliestDeadlineGroup_s4221: for lane in lanesForGroups_s4221[group]: if detector_delay_s4221[ lane] >= secondDeadline: secondDeadline = detector_delay_s4221[ lane] secondaryDeadlineGroup_s4221 = group for i in range(0, len(lanesForGroupsForPhases_s4221) ): # find the [hase containing both groups if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: if secondaryDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: next_phase_s4221 = i prev_phase_s4221 = phase_s4221 transition = chr(65 + phase_s4221) + "-" + chr( 65 + next_phase_s4221) + "-1" # eg. A-C-1 if phase_s4221 != next_phase_s4221: logics = traci.trafficlight.getAllProgramLogics( "cluster_25953432_313863435_313863521_314053282") names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str(transition): transitionID = i - 1 traci.trafficlight.setPhase( "cluster_25953432_313863435_313863521_314053282", transitionID) #change to transition for group in lanesForGroups_s4221: # find which group the EDF lane belongs to if next_phase_s4221 in lanesForGroups_s4221[group]: next_group_s4221 = group leftTurn_phase = traci.trafficlight.getPhase("313863797") if ( next_phase_s4221 == 0 or next_phase_s4221 == 1 or next_phase_s4221 == 4 ) and leftTurn_phase == 0: # should it be green for 4? # if traffic is turning left and should not in next phase, switch to red light traci.trafficlight.setPhase("313863797", 1) elif ( next_phase_s4221 == 2 or next_phase_s4221 == 3 or next_phase_s4221 == 5 ) and leftTurn_phase == 2: # if traffic can turn left, switch to green light traci.trafficlight.setPhase("313863797", 3) else: # if active phase is transition phase switchPhase_s4221 = False waitTime_s4221 = 0 for group in lanesForGroupsForPhases_s4221[ prev_phase_s4221]: # reset the traffic activity level of each active phase group activeTraffic_s4221[group] = 99 if transitionCounter_s4221 < YELLOW_PHASE: # while lights are still yellow switchPhase_s4221 = False #for lane in lanesForGroups_s4221[group]: # detector_delay_s4221[lane] = 0 elif transitionCounter_s4221 == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "cluster_25953432_313863435_313863521_314053282", next_phase_s4221) #change to next phase transitionCounter_s4221 = transitionCounter_s4221 + 1 # ----------------------------------------------------------------------SITE 4220-------------------------------------------------------------------------------------------------- phase_s4220 = traci.trafficlight.getPhase( "gneJ41") # phase indexing starts at 0 if (phase_s4220 in lanesForGroupsForPhases_s4220.keys() ): # if not a transition phase waitTime_s4220 += 1 # current phase wait time transitionCounter_s4220 = 0 for i in range(0, len(lanesForGroups_s4220)): if i in lanesForGroupsForPhases_s4220[phase_s4220]: groupActivity = [] for lane in lanesForGroups_s4220[i]: groupActivity.append( int( traci.inductionloop.getTimeSinceDetection( "site4220_" + str(lane)))) detector_delay_s4220[lane] = 0 activeTraffic_s4220[i] = min(groupActivity) else: for lane in lanesForGroups_s4220[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4220_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4220[lane] = detector_delay_s4220[ lane] + 1 # increment loopDetectorDelay earliestDeadline_s4220 = detector_delay_s4220.index( max(detector_delay_s4220)) switchPhase_s4220 = True for group in lanesForGroups_s4220: # find which group the EDF lane belongs to if earliestDeadline_s4220 in lanesForGroups_s4220[group]: earliestDeadlineGroup_s4220 = group for group in lanesForGroupsForPhases_s4220[ phase_s4220]: # do not switch phase if any conflicting lane has traffic, all inactive groups automatically are 99 if activeTraffic_s4220[group] < MINIMUM_TRAFFIC_ACTIVITY: switchPhase_s4220 = False #if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[phase_s4220]: # switchPhase_s4220 = False if earliestDeadline_s4220 == 0: switchPhase_s4220 = False if waitTime_s4220 == 180: switchPhase_s4220 = True if switchPhase_s4220 == True: transitionCounter = 0 # build new phase secondDeadline = -1 secondaryDeadlineGroup_s4220 = earliestDeadlineGroup_s4220 for i in range( 0, len(lanesForGroupsForPhases_s4220) ): # find the secondary group to create new phase if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: for group in lanesForGroupsForPhases_s4220[i]: if group != earliestDeadlineGroup_s4220: for lane in lanesForGroups_s4220[group]: if detector_delay_s4220[ lane] >= secondDeadline: secondDeadline = detector_delay_s4220[ lane] secondaryDeadlineGroup_s4220 = group for i in range(0, len(lanesForGroupsForPhases_s4220) ): # find the [hase containing both groups if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: if secondaryDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: next_phase_s4220 = i prev_phase_s4220 = phase_s4220 transition_s4220 = chr(65 + phase_s4220) + "-" + chr( 65 + next_phase_s4220) + "-1" # eg. A-C-1 if phase_s4220 != next_phase_s4220: logics = traci.trafficlight.getAllProgramLogics("gneJ41") names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str( transition_s4220): transitionID = i - 1 traci.trafficlight.setPhase( "gneJ41", transitionID) #change to transition for group in lanesForGroups_s4220: # find which group the EDF lane belongs to if next_phase_s4220 in lanesForGroups_s4220[group]: next_group_s4220 = group else: # if active phase is transition phase switchPhase_s4220 = False waitTime_s4220 = 0 for group in lanesForGroupsForPhases_s4220[ prev_phase_s4220]: # reset the traffic activity level of each active phase group activeTraffic_s4220[group] = 99 if transitionCounter_s4220 < YELLOW_PHASE: # while lights are still yellow switchPhase_s4220 = False #for lane in lanesForGroups_s4220[group]: # detector_delay_s4220[lane] = 0 elif transitionCounter_s4220 == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "gneJ41", next_phase_s4220) #change to next phase transitionCounter_s4220 = transitionCounter_s4220 + 1 # ----------------------------------------------------------------------SITE 4219-------------------------------------------------------------------------------------------------- #https://sumo.dlr.de/docs/Simulation/Output/Summary.html for each step reward # e1 output can be used if timesteps can be changed to 1 per step # Files: rl-runner, stateActionValues.xml, actions.xml, summary.xml, episodeStates.xml, updateTable.xml #States: # Loop detectors groups high/low (2^8) * # or time since last activation? 4s = 4^8 # max expected demand group (9 options) * # (and 2nd max? (8 options)) # Current phase (7 options) * # -sum of exit lane detector_delays? would indicate the load on adjacent junctions # state space size = 4,194,000 or 16,384 # can hard-code minimum activity time to reduce state size (but kind of goes against RL) #Actions: # Do nothing, transition to new phase (must stay in new phase for >=1s, transitoining to phase B will affect the reward for state B) #Rewards: # -vehicles halting # or -meanSpeedRelative, # not -sum(detector_delay_s4219) as this won't give total time spent waiting? # during that state (divide by total steps between actions?) #Algorithm: # Expected return of next move = Sum(nextMaxGroup&&nextPhase)[loopDetectorsOff->loopDetectorsOn] # e-greedy policy for training: e = .05 = %chance of taking random move. 1-e = .95 = %chance of taking move with max expected reward currentPhase_s4219 = traci.trafficlight.getPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) groupActivity_s4219 = [] for i in range(0, len(lanesForGroups_s4219)): if i in lanesForGroupsForPhases_s4219[ move]: # if group in current phase for lane in lanesForGroups_s4219[ i]: # reset delay for each lane detector_delay_s4219[lane] = 0 else: for lane in lanesForGroups_s4219[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4219_" + str(lane)) ) == 0: # if vehicle waiting on any lane in group detector_delay_s4219[lane] += 1 # increment delay time for group in lanesForGroupsForPhases_s4219[move]: for lane in lanesForGroups_s4219[ group]: #if getTimeSinceDetection > 0? groupActivity_s4219.append( int( traci.inductionloop.getTimeSinceDetection("site4219_" + str(lane)))) carsFlowing = min(groupActivity_s4219) carsFlowing = min(carsFlowing, 9) earliestDeadline_s4219 = detector_delay_s4219.index( max(detector_delay_s4219)) for group in lanesForGroups_s4219: if earliestDeadline_s4219 in lanesForGroups_s4219[group]: earliestDeadlineGroup_s4219 = group currentState = str(carsFlowing) + str(currentActivePhase) + str( earliestDeadlineGroup_s4219) if takeMove: # when takeMove is true, the move is made on the same timestep #print("take move") transitionCounter_s4219 = 0 if random.random() < e: # take random move move = random.randint(0, 6) else: # for the expected max demand group, find the values of all the phases for that group if step <= 300: maxGroup = 4 else: maxGroup = 4 # group 4 is currently max for both timesteps, ^this method needs to change (automating routeslist would help for this) # can this be more efficient? put stateActionValues into panda dataFrame > moveValue = -9999 i = 0 stateInDec = (int(currentState[0]) * 9 * 7) + ( int(currentState[1]) * 9) + int( currentState[2], 9) #convert the state to its row no equivalent #print(stateInDec) actions = stateActionValues[stateInDec].split(",", 8)[1:8] #print(actions) i = 0 for action in actions: actions[i] = float(action) i += 1 move = actions.index(max(actions)) transition_s2419 = chr(65 + currentPhase_s4219) + "-" + chr( 65 + move) + "-1" # eg. A-C-1 if move != currentPhase_s4219: logics = traci.trafficlight.getAllProgramLogics( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str(transition_s2419): transitionID_s4219 = i - 1 traci.trafficlight.setPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525", transitionID_s4219) #change to transition takeMove = False # do not take moves while transitioning phase leftTurn_phase = traci.trafficlight.getPhase("5861321343") if ( move == 0 or move == 2 or move == 3 ) and leftTurn_phase == 0: # if traffic is turning left and should not in next phase, switch to red light traci.trafficlight.setPhase("5861321343", 1) elif ( move == 1 or move == 4 or move == 5 or move == 6 ) and leftTurn_phase == 2: # if traffic can turn left, switch to green light traci.trafficlight.setPhase("5861321343", 3) #otherwise, do nothing. Reset duration of phase? #saveStateActions.write(transition_s2419 +","+ currentLoopsState +","+ str(currentActivePhase) +"\n")#TODO: add max group else: #need to account for left turn traffic light transitionCounter_s4219 += 1 if transitionCounter_s4219 == YELLOW_PHASE + RED_PHASE: currentActivePhase = move takeMove = True traci.trafficlight.setPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525", move) #change to next phase currentState = str(carsFlowing) + str(currentActivePhase) + str( earliestDeadlineGroup_s4219) #in order: current phase, index of longest waiting group, loop states[8 bits], activity in current phase[1 bit], action #print(currentState +","+ str(move)) saveStateActions.write(currentState + "," + str(move) + "\n") #TODO: add max group # ----------------------------------------------------------------------SITE 4235-------------------------------------------------------------------------------------------------- site4235_phase = traci.trafficlight.getPhase( "cluster_1707799581_314056954_5931861577" ) # phase indexing starts at 0 for i in range(1, site4235_LOOP_COUNT): # for each loop detector if (i != 5) and (i != 8): # ignore lanes 5 and 8 if int( traci.inductionloop.getLastStepVehicleNumber( "site4235_" + str(i))) > 0 or site4235_detector_delay[ i] > 0: # if getLastStepVehicleNumber>0, site4235_detector_delay[i] = site4235_detector_delay[ i] + 1 # increment loopDetectorDelay if (site4235_phase in lanesForPhases_s4235.keys()): # if not a transition phase activeTraffic = 99 for i in lanesForPhases_s4235[site4235_phase]: site4235_detector_delay[ i] = 0 # reset loopDetectorDelay for loops in current phase if i != 1 and i != 2 and i != 3: # ignore non conflicting traffic if int( traci.inductionloop.getTimeSinceDetection( "site4235_" + str(i))) < activeTraffic: activeTraffic = int( traci.inductionloop.getTimeSinceDetection( "site4235_" + str(i))) if activeTraffic > MINIMUM_TRAFFIC_ACTIVITY: # if no traffic through active lanes, switch to transition phase for max(loopDetectorDelay) activeTraffic = 0 transitionCounter = 0 site4235_prev_phase = site4235_phase earliestDeadline = site4235_detector_delay.index( max(site4235_detector_delay)) # build next phase if earliestDeadline == 9 or earliestDeadline == 10 or earliestDeadline == 11: #this can be changed with lanesForGroups_s4235 (TODO) site4235_next_phase = 0 #A if site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 7) #change to B-A elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 11) #change to C-A elif earliestDeadline == 4: # loop detector no. 4 site4235_next_phase = 1 #B if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 3) #change to A-B elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 13) #change to C-B elif earliestDeadline == 6 or earliestDeadline == 7: site4235_next_phase = 2 #C if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 5) #change to A-C elif site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 9) #change to B-C elif earliestDeadline == 1 or earliestDeadline == 2 or earliestDeadline == 3: if site4235_detector_delay[4] > max( site4235_detector_delay[9:11] ): # compare conflicting lanes site4235_next_phase = 1 #B if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 3) #change to A-B elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 13) #change to C-B else: site4235_next_phase = 0 #A if site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 7) #change to B-A elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 11) #change to C-A else: # if active phase is transition phase if transitionCounter < YELLOW_PHASE: # while lights are still yellow for i in lanesForPhases_s4235[site4235_prev_phase]: site4235_detector_delay[i] = 0 elif transitionCounter == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", site4235_next_phase) #change to next phase transitionCounter = transitionCounter + 1 #add for case where lights change with no traffic? step += 1 traci.close() sys.stdout.flush()
def close(self): if self.f is not None: self.f.close() traci.close()
def runQFS(): stateVect = [[]] policyPi = [] for i in range(0, 80, 1): policyPi.insert(i, random.randint(0, 5)) QSA = np.random.rand(81, 6) currTLS = [] Actions = [20, 25, 30, 20, 25, 30] avgTime = [] numVehs = [] avgTime.clear() numVehs.clear() EPSILON = 0.20 ALPHA = 0.05 GAMMA = 0.9 step = 0 stateNorth = 0 stateSouth = 0 stateEast = 0 stateWest = 0 currAction = 0 reward = 0 totWaittimeSoFar = 0 curWaittime = 0 totVehsSoFar = 0 currVehsHere = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() # Determine the state stateNorth = traci.lane.getLastStepOccupancy('nc_0') stateSouth = traci.lane.getLastStepOccupancy('sc_0') stateEast = traci.lane.getLastStepOccupancy('ec_0') stateWest = traci.lane.getLastStepOccupancy('wc_0') tlsPhase = traci.trafficlight.getPhase("center") stateVect.insert(step, [getState(stateNorth), getState(stateEast), getState(stateSouth), getState(stateWest), getPhase(tlsPhase), 0, 0, 0]) index = getStateIndex(stateVect[step]) reward = getStateReturn(stateVect[step]) # Take Action if random.uniform(0, 1) < EPSILON: currAction = random.randint(0, 5) else: currAction = np.argmax(QSA[index]) # Storage stateVect[step][5] = index stateVect[step][6] = currAction stateVect[step][7] = reward # Control Simulation if currAction > 2: phaseToChange = 2 else: phaseToChange = 0 currTLS = traci.trafficlight.getCompleteRedYellowGreenDefinition("center") currTLS[0].phases[phaseToChange].duration = Actions[currAction] currTLS[0].phases[phaseToChange].minDur = Actions[currAction] currTLS[0].phases[phaseToChange].maxDur = Actions[currAction] traci.trafficlight.setCompleteRedYellowGreenDefinition("center", currTLS[0]) # The Update if step > 0 and step % 75 == 0: episodeStates = [[]] index = 0 A = 0 R = 0 for t in range(0, 74, 1): episodeStates.insert(t, stateVect[step-74+t]) for t in range(0, 73, 1): S = episodeStates[t] R = S[7] A = S[6] index = S[5] Sprime = episodeStates[t+1] indexPrime = Sprime[5] QSA[index][A] = QSA[index][A] + ALPHA * (R + (GAMMA * max(QSA[indexPrime])) - QSA[index][A]) policyPi[index] = np.argmax(QSA[index]) step += 1 curWaittime = traci.edge.getWaitingTime('nc') + traci.edge.getWaitingTime('ec') + traci.edge.getWaitingTime('sc') + traci.edge.getWaitingTime('wc') totWaittimeSoFar = totWaittimeSoFar + curWaittime avgTime.append(totWaittimeSoFar/step) currVehsHere = traci.simulation.getArrivedNumber() totVehsSoFar = totVehsSoFar + currVehsHere numVehs.append(totVehsSoFar) traci.close() sys.stdout.flush() return step, avgTime, numVehs
def stop_sumo(self): if self.sumo_running: traci.close() sys.stdout.flush() self.sumo_running = False
def simulation_startup(self): rospy.loginfo("Entered simulation_startup. num_vehicles: %d", self.num_vehicles) rospy.set_param('done', False) sumo_startup = [ 'sumo-gui', '-c', self.dirname + '/graph_sumo/{}.sumocfg'.format(self.graph_name) ] rospy.loginfo(sumo_startup) # print 'Click Play button only on ensuring that the patrolling algorithm is running' traci.start(sumo_startup) rospy.loginfo("Simulation Startup Occured") #Click Play Button in the GUI, if GUI # pool = Pool(1) #CHECKING BATTERY LEVELS rospy.sleep(40) # p1 = pool.apply_async(self.battery_check_func()) # print("Thread started") while traci.simulation.getTime() <= self.min_time: #print traci.simulation.getTime() vehicles = traci.vehicle.getIDList() rospy.loginfo("VEHICLES : %s", str(vehicles)) for itr_robot_i in self.robot_ids: if self.updated[itr_robot_i]: #print 'here', t.updated #robot_numeral_id = robot_string_2_robot_num[itr_robot_i] if itr_robot_i not in vehicles: rospy.loginfo("Seq of routes of %s : %s", itr_robot_i, self.seq_of_routes[itr_robot_i]) route_id = itr_robot_i + str(random()) traci.route.add(routeID=route_id, edges=self.seq_of_routes[itr_robot_i]) traci.vehicle.add(vehID=itr_robot_i, routeID=route_id, typeID="type1") #traci.vehicle.setColor(str(i),color_dict[i]) self.stopped_already[itr_robot_i] = False rospy.loginfo("Added vehicle %s", str(itr_robot_i)) else: e = traci.vehicle.getRoute(itr_robot_i) if traci.vehicle.isStopped(itr_robot_i) and e[ -1] == self.seq_of_routes[itr_robot_i][0]: traci.vehicle.resume(itr_robot_i) traci.vehicle.setRoute( vehID=itr_robot_i, edgeList=self.seq_of_routes[itr_robot_i]) self.stopped_already[itr_robot_i] = False else: print("\n") print("\n******************************** Seq: " + itr_robot_i + "--" + str(self.seq_of_routes[itr_robot_i])) self.updated[itr_robot_i] = False srvs = TaskDoneSrv() srvs.stamp = traci.simulation.getTime() srvs.node_id = [] srvs.robot_id = [] for ith_robot in self.robot_ids: vehicles = traci.vehicle.getIDList() if ith_robot in vehicles: last_edge = traci.vehicle.getRoadID(ith_robot) print("\nLast edge: " + str(last_edge)) if last_edge.find(':') == -1: last_node = int(last_edge[:last_edge.find('to')]) print("Last node: " + str(last_node)) # if traci.vehicle.isStopped(str(i)) and not t.stopped_already[i]: if traci.vehicle.isStopped(ith_robot): stop_node = int(last_edge[last_edge.find('to') + 2:]) print("Stop node: " + str(stop_node)) srvs.node_id.append(str(stop_node)) srvs.robot_id.append(ith_robot) # self.last_nodes[i] = stop_node self.stopped_already[ith_robot] = True elif not traci.vehicle.isStopped( ith_robot ) and self.last_nodes[ith_robot] != last_node: total_len = traci.lane.getLength(last_edge + '_0') cur_len = traci.vehicle.getLanePosition(ith_robot) if cur_len < total_len / 2: stop_pos = traci.lane.getLength( self.seq_of_routes[ith_robot][-1] + '_0') traci.vehicle.setStop( vehID=ith_robot, edgeID=self.seq_of_routes[ith_robot][-1], pos=stop_pos, duration=2000.) #msg.node_id.append(int(last_node)) srvs.node_id.append(str(last_node)) srvs.robot_id.append(ith_robot) self.last_nodes[ith_robot] = last_node if len(srvs.node_id) > 0: rospy.loginfo_throttle( 1, 'Task done node_ids are ' + str(srvs.node_id)) print( self.sumo_to_pmm_proxy(srvs.stamp, srvs.node_id, srvs.robot_id)) for vehicle_in_sumo in traci.vehicle.getIDList(): print(vehicle_in_sumo) if vehicle_in_sumo not in self.robot_ids: traci.vehicle.remove(vehicle_in_sumo, 0x03) del self.seq_of_routes[vehicle_in_sumo] del self.updated[vehicle_in_sumo] del self.last_nodes[vehicle_in_sumo] del self.stopped_already[vehicle_in_sumo] self.num_vehicles = self.num_vehicles - 1 if sum(self.stopped_already.values()) == 0: traci.simulationStep() rospy.logwarn('simulation startup exiting') rospy.set_param('done', True) traci.close()
def test(flags, configs, sumoConfig): from Env.Env import TL3x3Env from Agent.dqn import Trainer from Env.MultiEnv import GridEnv from utils import save_params, load_params, update_tensorboard # init test setting sumoBinary = checkBinary('sumo-gui') sumoCmd = [sumoBinary, "-c", sumoConfig] # setting the rl list tl_rl_list = configs['tl_rl_list'] MAX_STEPS = configs['max_steps'] reward = 0 traci.start(sumoCmd) agent = Trainer(configs) # setting the replay if flags.replay_name is not None: agent.load_weights(flags.replay_name) configs = load_params(configs, flags.replay_name) env = TL3x3Env(configs) step = 0 # state initialization state = env.get_state() # agent setting total_reward = 0 arrived_vehicles = 0 action_distribution = tuple() with torch.no_grad(): while step < MAX_STEPS: action = agent.get_action(state) action_distribution += action env.step(action) # action 적용함수 for _ in range(20): # 10초마다 행동 갱신 env.collect_state() traci.simulationStep() step += 1 traci.trafficlight.setRedYellowGreenState(tl_rl_list[0], 'y' * 28) for _ in range(5): traci.simulationStep() env.collect_state() step += 1 reward = env.get_reward() next_state = env.get_state() # agent.save_replay(state, action, reward, next_state) state = next_state total_reward += reward step += 1 if step == MAX_STEPS: done = True # agent.update(done) # no update in # loss += agent.get_loss() # 총 loss arrived_vehicles += traci.simulation.getArrivedNumber( ) # throughput traci.simulationStep() # if step % 200 == 0: agent.target_update() traci.close() print('======== return: {} arrived number:{}'.format( total_reward, arrived_vehicles))
def run(): """execute the TraCI control loop""" step = 0 YELLOW_PHASE = 4 RED_PHASE = 2 site4235_detector_delay = [] site4235_LOOP_COUNT = 11 for i in range(0, site4235_LOOP_COUNT + 1): # initiliaze array of 0s site4235_detector_delay.append(0) lanesForPhases_s4235 = { # key = phase, values = lanes with green lights 0: [1, 2, 3, 9, 10, 11], #A 1: [1, 2, 3, 4], #B 2: [6, 7] #C } detector_delay_s4219 = [] site4219_LOOP_COUNT = 21 ignored_phases_s4219 = [ 20, 21, 22 ] # could automate this I guess? if not in dict TODO for i in range(0, site4219_LOOP_COUNT + 1): # initiliaze array of 0s detector_delay_s4219.append(0) lanesForGroupsForPhases_s4219 = { # key = phase, values = lanes with green lights 0: [0, 1], #A 1: [1, 6, 7], #B 2: [0, 2], #C 3: [3, 8], #D 4: [3, 4, 7], #E 5: [4, 5, 7], #F 6: [6, 2, 7] #G } lanesForGroups_s4219 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [ 11, 12 ], # such that, a right turn lane can be replaced by oncoming traffic 1: [1, 2], 2: [13, 14], 3: [15, 16, 17], 4: [7, 8], 5: [9, 10], 6: [3, 4], 7: [5, 6], 8: [18, 19] } conflictingGroups_s4219 = { # TODO automate this from lanesForGroupsForPhases_s4219 (necessary?) 0: [3, 4, 5, 6, 7, 8], 1: [2, 3, 4, 5, 8], 2: [1, 3, 4, 5, 8], 3: [0, 1, 2, 3, 5, 6], 4: [0, 1, 2, 6, 8], 5: [0, 1, 2, 3, 6, 8], 6: [0, 3, 4, 5, 8], 7: [1, 8], 8: [1, 2, 4, 5, 6, 7] } earliestDeadline_s4219 = 0 earliestDeadlineGroup_s4219 = 0 waitTime_s4219 = 0 activeTraffic_s4219 = [] currentActivePhase_s4219 = 0 for i in range(0, len(lanesForGroups_s4219)): # initiliaze array of 99s activeTraffic_s4219.append(99) detector_delay_s4220 = [] site4220_LOOP_COUNT = 15 ignored_phases_s4220 = [ 3, 8, 11 ] # could automate this I guess? if not in dict TODO for i in range(0, site4220_LOOP_COUNT + 1): # initiliaze array of -1s detector_delay_s4220.append(0) lanesForGroupsForPhases_s4220 = { # key = phase, values = lanes with green lights 0: [1, 5], #A 1: [5, 6, 0], #B 2: [1, 2], #C 3: [3, 4], #D 4: [2, 6] #E } lanesForGroups_s4220 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [1, 2], 1: [4, 5, 6], 2: [7], 3: [9], 4: [10], 5: [12, 13, 14], 6: [15] } conflictingGroups_s4220 = { # TODO automate this from lanesForGroupsForPhases_s4220 (necessary?) 0: [1, 4], 1: [0, 6, 4, 3], 2: [5, 4, 3], 3: [0, 1, 2, 5, 6], 4: [0, 1, 2, 5, 6], 5: [2, 3, 4], 6: [2, 3, 4, 5] } earliestDeadline_s4220 = 0 earliestDeadlineGroup_s4220 = 0 waitTime_s4220 = 0 activeTraffic_s4220 = [] for i in range(0, len(lanesForGroups_s4220)): # initiliaze array of 99s activeTraffic_s4220.append(99) next_phase_s4220 = 0 detector_delay_s4221 = [] site4221_LOOP_COUNT = 18 ignored_phases_s4221 = [ 6, 10, 14 ] # could automate this I guess? if not in dict TODO for i in range(0, site4221_LOOP_COUNT + 1): # initiliaze array of -1s detector_delay_s4221.append(0) lanesForGroupsForPhases_s4221 = { # key = phase, values = lanes with green lights 0: [3, 7], #A 1: [3, 4], #B 2: [7, 8, 0], #C 3: [1, 2, 0], #D 4: [5, 6], #E 5: [4, 8, 0] #f } lanesForGroups_s4221 = { # which lanes are grouped together, this is useful for finding when a lane group is no longer active 0: [1, 2], 1: [3], 2: [4, 5], 3: [7, 8], 4: [9], 5: [11, 12], 6: [13], 7: [15, 16], 8: [17, 18] } conflictingGroups_s4221 = { # TODO automate this from lanesForGroupsForPhases_s4221 (necessary?) 0: [3, 6], 1: [3, 4, 6, 7, 8], 2: [3, 4, 5, 7, 8], 3: [0, 1, 2, 5, 6, 8], 4: [1, 2, 5, 6, 7], 5: [2, 3, 4, 7, 8], 6: [0, 1, 2, 3, 4, 7, 8], 7: [1, 2, 4, 5, 6], 8: [1, 2, 3, 5, 6] } earliestDeadline_s4221 = 0 earliestDeadlineGroup_s4221 = 0 waitTime_s4221 = 0 activeTraffic_s4221 = [] for i in range(0, len(lanesForGroups_s4221)): # initiliaze array of 99s activeTraffic_s4221.append(99) next_phase_s4221 = 0 MINIMUM_TRAFFIC_ACTIVITY = 3 traci.trafficlight.setPhase("5861321343", 0) traci.trafficlight.setPhase("313863797", 0) while step <= 600: #while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() # add in other traffic lights #static edf algo # ----------------------------------------------------------------------SITE 4221-------------------------------------------------------------------------------------------------- phase_s4221 = traci.trafficlight.getPhase( "cluster_25953432_313863435_313863521_314053282" ) # phase indexing starts at 0 if (phase_s4221 in lanesForGroupsForPhases_s4221.keys() ): # if not a transition phase waitTime_s4221 += 1 # current phase wait time transitionCounter_s4221 = 0 # purely for transition phases for i in range(0, len(lanesForGroups_s4221)): if i in lanesForGroupsForPhases_s4221[phase_s4221]: groupActivity = [] for lane in lanesForGroups_s4221[i]: groupActivity.append( int( traci.inductionloop.getTimeSinceDetection( "site4221_" + str(lane)))) detector_delay_s4221[lane] = 0 activeTraffic_s4221[i] = min(groupActivity) else: for lane in lanesForGroups_s4221[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4221_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4221[lane] = detector_delay_s4221[ lane] + 1 # increment loopDetectorDelay earliestDeadline_s4221 = detector_delay_s4221.index( max(detector_delay_s4221)) switchPhase_s4221 = True for group in lanesForGroups_s4221: # find which group the EDF lane belongs to if earliestDeadline_s4221 in lanesForGroups_s4221[group]: earliestDeadlineGroup_s4221 = group for group in lanesForGroupsForPhases_s4221[ phase_s4221]: # do not switch phase if any conflicting lane has traffic, all inactive groups automatically are 99 if group != 0: if activeTraffic_s4221[group] < MINIMUM_TRAFFIC_ACTIVITY: switchPhase_s4221 = False #if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[phase_s4221]: # switchPhase_s4221 = False if earliestDeadline_s4221 == 0: switchPhase_s4221 = False if waitTime_s4221 == 180: #TODO: revise waiting time switchPhase_s4221 = True if switchPhase_s4221 == True: transitionCounter = 0 # build new phase secondDeadline = -1 secondaryDeadlineGroup_s4221 = earliestDeadlineGroup_s4221 for i in range( 0, len(lanesForGroupsForPhases_s4221) ): # find the secondary group to create new phase if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: for group in lanesForGroupsForPhases_s4221[i]: if group != earliestDeadlineGroup_s4221: for lane in lanesForGroups_s4221[group]: if detector_delay_s4221[ lane] >= secondDeadline: secondDeadline = detector_delay_s4221[ lane] secondaryDeadlineGroup_s4221 = group for i in range(0, len(lanesForGroupsForPhases_s4221) ): # find the [hase containing both groups if earliestDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: if secondaryDeadlineGroup_s4221 in lanesForGroupsForPhases_s4221[ i]: next_phase_s4221 = i prev_phase_s4221 = phase_s4221 transition = chr(65 + phase_s4221) + "-" + chr( 65 + next_phase_s4221) + "-1" # eg. A-C-1 if phase_s4221 != next_phase_s4221: logics = traci.trafficlight.getAllProgramLogics( "cluster_25953432_313863435_313863521_314053282") names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str(transition): transitionID = i - 1 traci.trafficlight.setPhase( "cluster_25953432_313863435_313863521_314053282", transitionID) #change to transition phase_s4221 = traci.trafficlight.getPhase( "cluster_25953432_313863435_313863521_314053282") leftTurn_phase = traci.trafficlight.getPhase("313863797") if ( next_phase_s4221 == 0 or next_phase_s4221 == 1 or next_phase_s4221 == 4 ) and leftTurn_phase == 0: # if traffic is turning left and should not in next phase, switch to red light traci.trafficlight.setPhase("313863797", 1) elif ( next_phase_s4221 == 2 or next_phase_s4221 == 3 or next_phase_s4221 == 5 ) and leftTurn_phase == 2: # if traffic can turn left, switch to green light traci.trafficlight.setPhase("313863797", 3) else: # if active phase is transition phase switchPhase_s4221 = False waitTime_s4221 = 0 for i in range(0, len(lanesForGroups_s4221)): for lane in lanesForGroups_s4221[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4221_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4221[lane] = detector_delay_s4221[ lane] + 1 # increment loopDetectorDelay if transitionCounter_s4221 == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "cluster_25953432_313863435_313863521_314053282", next_phase_s4221) #change to next phase transitionCounter_s4221 = transitionCounter_s4221 + 1 # ----------------------------------------------------------------------SITE 4220-------------------------------------------------------------------------------------------------- phase_s4220 = traci.trafficlight.getPhase( "gneJ41") # phase indexing starts at 0 if (phase_s4220 in lanesForGroupsForPhases_s4220.keys() ): # if not a transition phase waitTime_s4220 += 1 # current phase wait time transitionCounter_s4220 = 0 for i in range(0, len(lanesForGroups_s4220)): if i in lanesForGroupsForPhases_s4220[phase_s4220]: groupActivity = [] for lane in lanesForGroups_s4220[i]: groupActivity.append( int( traci.inductionloop.getTimeSinceDetection( "site4220_" + str(lane)))) detector_delay_s4220[lane] = 0 activeTraffic_s4220[i] = min(groupActivity) else: for lane in lanesForGroups_s4220[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4220_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4220[lane] = detector_delay_s4220[ lane] + 1 # increment loopDetectorDelay earliestDeadline_s4220 = detector_delay_s4220.index( max(detector_delay_s4220)) switchPhase_s4220 = True for group in lanesForGroups_s4220: # find which group the EDF lane belongs to if earliestDeadline_s4220 in lanesForGroups_s4220[group]: earliestDeadlineGroup_s4220 = group for group in lanesForGroupsForPhases_s4220[ phase_s4220]: # do not switch phase if any conflicting lane has traffic, all inactive groups automatically are 99 if activeTraffic_s4220[group] < MINIMUM_TRAFFIC_ACTIVITY: switchPhase_s4220 = False #if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[phase_s4220]: # switchPhase_s4220 = False if earliestDeadline_s4220 == 0: switchPhase_s4220 = False if waitTime_s4220 == 180: switchPhase_s4220 = True if switchPhase_s4220 == True: transitionCounter = 0 # build new phase secondDeadline = -1 secondaryDeadlineGroup_s4220 = earliestDeadlineGroup_s4220 for i in range( 0, len(lanesForGroupsForPhases_s4220) ): # find the secondary group to create new phase if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: for group in lanesForGroupsForPhases_s4220[i]: if group != earliestDeadlineGroup_s4220: for lane in lanesForGroups_s4220[group]: if detector_delay_s4220[ lane] >= secondDeadline: secondDeadline = detector_delay_s4220[ lane] secondaryDeadlineGroup_s4220 = group for i in range(0, len(lanesForGroupsForPhases_s4220) ): # find the [hase containing both groups if earliestDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: if secondaryDeadlineGroup_s4220 in lanesForGroupsForPhases_s4220[ i]: next_phase_s4220 = i prev_phase_s4220 = phase_s4220 transition = chr(65 + phase_s4220) + "-" + chr( 65 + next_phase_s4220) + "-1" # eg. A-C-1 if phase_s4220 != next_phase_s4220: logics = traci.trafficlight.getAllProgramLogics("gneJ41") names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str(transition): transitionID = i - 1 traci.trafficlight.setPhase( "gneJ41", transitionID) #change to transition for group in lanesForGroups_s4220: # find which group the EDF lane belongs to if next_phase_s4220 in lanesForGroups_s4220[group]: next_group_s4220 = group else: # if active phase is transition phase switchPhase_s4220 = False waitTime_s4220 = 0 for group in lanesForGroupsForPhases_s4220[ prev_phase_s4220]: # reset the traffic activity level of each active phase group activeTraffic_s4220[group] = 99 if transitionCounter_s4220 < YELLOW_PHASE: # while lights are still yellow switchPhase_s4220 = False #for lane in lanesForGroups_s4220[group]: # detector_delay_s4220[lane] = 0 elif transitionCounter_s4220 == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "gneJ41", next_phase_s4220) #change to next phase transitionCounter_s4220 = transitionCounter_s4220 + 1 # ----------------------------------------------------------------------SITE 4219-------------------------------------------------------------------------------------------------- phase_s4219 = traci.trafficlight.getPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) # phase indexing starts at 0 if (phase_s4219 in lanesForGroupsForPhases_s4219.keys() ): # if not a transition phase waitTime_s4219 += 1 # current phase wait time transitionCounter_s4219 = 0 # purely for transition phases for i in range(0, len(lanesForGroups_s4219)): if i in lanesForGroupsForPhases_s4219[ currentActivePhase_s4219]: groupActivity = [] for lane in lanesForGroups_s4219[i]: groupActivity.append( int( traci.inductionloop.getTimeSinceDetection( "site4219_" + str(lane)))) detector_delay_s4219[lane] = 0 activeTraffic_s4219[i] = min(groupActivity) else: for lane in lanesForGroups_s4219[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4219_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4219[lane] = detector_delay_s4219[ lane] + 1 # increment loopDetectorDelay earliestDeadline_s4219 = detector_delay_s4219.index( max(detector_delay_s4219)) switchPhase_s4219 = True for group in lanesForGroups_s4219: # find which group the EDF lane belongs to if earliestDeadline_s4219 in lanesForGroups_s4219[group]: earliestDeadlineGroup_s4219 = group for group in lanesForGroupsForPhases_s4219[ phase_s4219]: # do not switch phase if any conflicting lane has traffic, all inactive groups automatically are 99 if group != 7: if activeTraffic_s4219[group] < MINIMUM_TRAFFIC_ACTIVITY: switchPhase_s4219 = False #if earliestDeadlineGroup_s4219 in lanesForGroupsForPhases_s4219[phase_s4219]: # switchPhase_s4219 = False if earliestDeadline_s4219 == 0: switchPhase_s4219 = False if waitTime_s4219 == 180: #TODO: revise waiting time switchPhase_s4219 = True if switchPhase_s4219 == True: transitionCounter = 0 # build new phase secondDeadline = -1 secondaryDeadlineGroup_s4219 = earliestDeadlineGroup_s4219 for i in range( 0, len(lanesForGroupsForPhases_s4219) ): # find the secondary group to create new phase if earliestDeadlineGroup_s4219 in lanesForGroupsForPhases_s4219[ i]: for group in lanesForGroupsForPhases_s4219[i]: if group != earliestDeadlineGroup_s4219: for lane in lanesForGroups_s4219[group]: if detector_delay_s4219[ lane] >= secondDeadline: secondDeadline = detector_delay_s4219[ lane] secondaryDeadlineGroup_s4219 = group for i in range(0, len(lanesForGroupsForPhases_s4219) ): # find the [hase containing both groups if earliestDeadlineGroup_s4219 in lanesForGroupsForPhases_s4219[ i]: if secondaryDeadlineGroup_s4219 in lanesForGroupsForPhases_s4219[ i]: next_phase_s4219 = i prev_phase_s4219 = phase_s4219 transition = chr(65 + phase_s4219) + "-" + chr( 65 + next_phase_s4219) + "-1" # eg. A-C-1 if phase_s4219 != next_phase_s4219: logics = traci.trafficlight.getAllProgramLogics( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) names = str(logics[0].getPhases()).split("name='") for i in range(1, len(names)): if str(names[i].split("'")[0]) == str(transition): transitionID = i - 1 traci.trafficlight.setPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525", transitionID) #change to transition phase_s4219 = traci.trafficlight.getPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525" ) leftTurn_phase = traci.trafficlight.getPhase("5861321343") if ( next_phase_s4219 == 0 or next_phase_s4219 == 2 or next_phase_s4219 == 3 ) and leftTurn_phase == 0: # if traffic is turning left and should not in next phase, switch to red light traci.trafficlight.setPhase("5861321343", 1) elif ( next_phase_s4219 == 1 or next_phase_s4219 == 4 or next_phase_s4219 == 5 or next_phase_s4219 == 6 ) and leftTurn_phase == 2: # if traffic can turn left, switch to green light traci.trafficlight.setPhase("5861321343", 3) else: # if active phase is transition phase switchPhase_s4219 = False waitTime_s4219 = 0 for i in range(0, len(lanesForGroups_s4219)): for lane in lanesForGroups_s4219[i]: if int( traci.inductionloop.getTimeSinceDetection( "site4219_" + str(lane)) ) == 0: # if getLastStepVehicleNumber>0, detector_delay_s4219[lane] = detector_delay_s4219[ lane] + 1 # increment loopDetectorDelay if transitionCounter_s4219 == YELLOW_PHASE + RED_PHASE - 1: currentActivePhase_s4219 = next_phase_s4219 traci.trafficlight.setPhase( "cluster_25977365_314059191_314060044_314061754_314061758_314062509_314062525", next_phase_s4219) #change to next phase transitionCounter_s4219 = transitionCounter_s4219 + 1 # ----------------------------------------------------------------------SITE 4235-------------------------------------------------------------------------------------------------- site4235_phase = traci.trafficlight.getPhase( "cluster_1707799581_314056954_5931861577" ) # phase indexing starts at 0 for i in range(1, site4235_LOOP_COUNT): # for each loop detector if (i != 5) and (i != 8): # ignore lanes 5 and 8 if int( traci.inductionloop.getLastStepVehicleNumber( "site4235_" + str(i))) > 0 or site4235_detector_delay[ i] > 0: # if getLastStepVehicleNumber>0, site4235_detector_delay[i] = site4235_detector_delay[ i] + 1 # increment loopDetectorDelay if (site4235_phase in lanesForPhases_s4235.keys()): # if not a transition phase activeTraffic = 99 for i in lanesForPhases_s4235[site4235_phase]: site4235_detector_delay[ i] = 0 # reset loopDetectorDelay for loops in current phase if i != 1 and i != 2 and i != 3: # ignore non conflicting traffic if int( traci.inductionloop.getTimeSinceDetection( "site4235_" + str(i))) < activeTraffic: activeTraffic = int( traci.inductionloop.getTimeSinceDetection( "site4235_" + str(i))) if activeTraffic > MINIMUM_TRAFFIC_ACTIVITY: # if no traffic through active lanes, switch to transition phase for max(loopDetectorDelay) activeTraffic = 0 transitionCounter = 0 site4235_prev_phase = site4235_phase earliestDeadline = site4235_detector_delay.index( max(site4235_detector_delay)) # build next phase if earliestDeadline == 9 or earliestDeadline == 10 or earliestDeadline == 11: #this can be changed with lanesForGroups_s4235 (TODO) site4235_next_phase = 0 #A if site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 7) #change to B-A elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 11) #change to C-A elif earliestDeadline == 4: # loop detector no. 4 site4235_next_phase = 1 #B if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 3) #change to A-B elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 13) #change to C-B elif earliestDeadline == 6 or earliestDeadline == 7: site4235_next_phase = 2 #C if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 5) #change to A-C elif site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 9) #change to B-C elif earliestDeadline == 1 or earliestDeadline == 2 or earliestDeadline == 3: if site4235_detector_delay[4] > max( site4235_detector_delay[9:11] ): # compare conflicting lanes site4235_next_phase = 1 #B if site4235_phase == 0: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 3) #change to A-B elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 13) #change to C-B else: site4235_next_phase = 0 #A if site4235_phase == 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 7) #change to B-A elif site4235_phase == 2: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", 11) #change to C-A else: # if active phase is transition phase if transitionCounter < YELLOW_PHASE: # while lights are still yellow for i in lanesForPhases_s4235[site4235_prev_phase]: site4235_detector_delay[i] = 0 elif transitionCounter == YELLOW_PHASE + RED_PHASE - 1: traci.trafficlight.setPhase( "cluster_1707799581_314056954_5931861577", site4235_next_phase) #change to next phase transitionCounter = transitionCounter + 1 #add for case where lights change with no traffic? step += 1 traci.close() sys.stdout.flush()
def close(self): """Override in your subclass to perform any necessary cleanup. Environments will automatically close() themselves when garbage collected or when the program exits. """ traci.close()
def closer(self): #Meant for forced close ops. traci.close(False)
def runSingle(traciEndTime, viewRange, module, objID): seen1 = 0 seen2 = 0 step = 0 sumoProcess = subprocess.Popen("%s -c sumo.sumocfg %s" % (sumoBinary, addOption), shell=True, stdout=sys.stdout) # time.sleep(20) traci.init(PORT) traci.poi.add("poi", 400, 500, (1, 0, 0, 0)) traci.polygon.add("poly", ((400, 400), (450, 400), (450, 400)), (1, 0, 0, 0)) subscribed = False while not step > traciEndTime: responses = traci.simulationStep() near1 = set() if objID in module.getContextSubscriptionResults(): for v in module.getContextSubscriptionResults()[objID]: near1.add(v) vehs = traci.vehicle.getIDList() pos = {} for v in vehs: pos[v] = traci.vehicle.getPosition(v) shape = None egoPos = None if hasattr(module, "getPosition"): egoPos = module.getPosition(objID) elif hasattr(module, "getShape"): shape = module.getShape(objID) elif module == traci.edge: # it's a hack, I know, but do we really need to introduce # edge.getShape? shape = traci.lane.getShape(objID + "_0") near2 = set() for v in pos: if egoPos: if math.sqrt(dist2(egoPos, pos[v])) < viewRange: near2.add(v) if shape: lastP = shape[0] for p in shape[1:]: if math.sqrt(distToSegmentSquared(pos[v], lastP, p)) < viewRange: near2.add(v) lastP = p if not subscribed: module.subscribeContext(objID, traci.constants.CMD_GET_VEHICLE_VARIABLE, viewRange, [traci.constants.VAR_POSITION]) subscribed = True else: seen1 += len(near1) seen2 += len(near2) for v in near1: if v not in near2: print("timestep %s: %s is missing in subscribed vehicles" % (step, v)) for v in near2: if v not in near1: print( "timestep %s: %s is missing in surrounding vehicles" % (step, v)) step += 1 print("Print ended at step %s" % (traci.simulation.getCurrentTime() / DELTA_T)) traci.close() sumoProcess.wait() sys.stdout.flush() print("uncheck: seen %s vehicles via subscription, %s in surrounding" % (seen1, seen2)) if seen1 == seen2: print("Ok: Subscription and computed are same") else: print("Error: subscribed number and computed number differ")
def stop_sumo(self): if self.sumo_running: traci.close() self.sumo_running = False
def run(algorithm): """execute the TraCI control loop""" step = 0 # if algorithm == 0: #hardcoded # print("hardcoded") # ## # vehiclesPast = 0 #need to count like that cause otherwise it only checks per 10 secs # #traci.trafficlight.setPhase("A", 2) #trial 1 # traci.trafficlight.setPhase("A", 0) #trial 2 # ## # while traci.simulation.getMinExpectedNumber() > 0: # #trial 1 (induction loops) # # if traci.trafficlight.getPhase("A") == 2: # # # if there are more than 2 cars have passed the induction loop (thus waiting), make it green # # if traci.inductionloop.getLastStepVehicleNumber("nA1") > 0 or traci.inductionloop.getLastStepVehicleNumber("nA0") > 0: # # vehiclesPast += 1 # # if vehiclesPast > 2: # # traci.trafficlight.setPhase("A", 0) # # vehiclesPast = 0 # # else: # # traci.trafficlight.setPhase("A", 2) # ## # #trial 2 lane area detectors # if traci.trafficlight.getPhase("A") == 0: # if traci.lanearea.getLastStepHaltingNumber("wA0") > 2: # traci.trafficlight.setPhase("A", 2) # else: # traci.trafficlight.setPhase("A", 0) # traci.simulationStep() # step += 1 if algorithm == 1: # q-learning print("q-learning") # create "q-table" qtable = create_qtable(18, 2) # 6 states, 2 actions total_reward = 0 state = get_state() epsilon = 0.9 alpha = 0.01 # 1 gamma = 0.01 # 0 waiting_cars_array = [] time_step = 0 waiting_cars = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.trafficlight.setPhase("A", 2) action = choose_action(state, qtable, epsilon) if action == 0: traci.trafficlight.setPhase("A", 2) else: traci.trafficlight.setPhase("A", 0) for i in range(10): # changing this makes difference traci.simulationStep() step += 10 time_step += 1 next_state = get_state() reward = calc_reward() total_reward += reward # to plot the total number of cars waiting for every 100 time steps if time_step < 10: waiting_cars += -1 * reward else: waiting_cars += -1 * reward waiting_cars_array.append(waiting_cars) waiting_cars = 0 time_step = 0 qtable = update_table(qtable, reward, state, action, alpha, gamma, next_state) # print(qtable) # print(reward) # qtable[state,action] = reward state = next_state epsilon -= 0.01 # this might be something else print("total reward: %i" % total_reward) waiting_cars_array = np.hstack(waiting_cars_array) plot(waiting_cars_array) # print(rewards) else: # original total_reward = 0 waiting_cars_array = [] time_step = 0 waiting_cars = 0 while traci.simulation.getMinExpectedNumber() > 0: # traci.simulationStep() # step += 1 for i in range(10): # changing this makes difference traci.simulationStep() step += 10 time_step += 1 reward = calc_reward() # print("reward: %i" % reward) total_reward += reward # to plot the total number of cars waiting for every 100 time steps if time_step < 10: waiting_cars += -1 * reward else: waiting_cars += -1 * reward # print("waiting_cars %i" % waiting_cars) waiting_cars_array.append(waiting_cars) waiting_cars = 0 time_step = 0 print("total reward: %i" % total_reward) waiting_cars_array = np.hstack(waiting_cars_array) plot(waiting_cars_array) traci.close() sys.stdout.flush()
def run(): global id2tls, id2car, edge2tls, tls2edges, e2oppoe traci.init(PORT) step = simulationStartTime Tls.traci = traci Car.traci = traci Tls.tls2ph2time = get_tls2duration() tlslist = traci.trafficlights.getIDList() if iprintinfo > 0: print '>>> tlslist\n', tlslist directory = 'outfile' + str(PORT) if not os.path.exists(directory): os.makedirs(directory) # fd=open(directory+'/tlslist.txt','w') for tls in tlslist: tmp = Tls(tls) tmp.setProgram('p1') tmp.setOutputDir(directory + '/') id2tls[tls] = tmp # fd.write(tls+'.txt\n') # fd.close() edge2tls = get_edge2tls() if iprintinfo > 1: print '>>> edge2tls', edge2tls tls2edges = get_tls2edges() if iprintinfo > 1: print '>>> tls2edges', tls2edges alledges = traci.edge.getIDList() for eid in alledges[:]: # deep copy! if eid.startswith(":"): alledges.remove(eid) else: getoppositeedge(eid) Car.edge2tls = edge2tls Car.tls2edges = tls2edges Car.e2oppoe = e2oppoe Car.id2car = id2car tmpcar = None while step <= simulationEndTime: traci.simulationStep() step += 1 print "\n>> -- step: ", step teleport = traci.simulation.getStartingTeleportIDList() for vid in teleport: if iprintstep >= 2: print('teleport=', teleport) id2car[vid].remove(step) try: deadlist = traci.simulation.getArrivedIDList() if iprintstep >= 2: print('deadlist=', deadlist) for vid in deadlist: id2car[vid].setDead(step) vnum = traci.vehicle.getIDCount() if iprintstep > 0: print('vnum=' + str(vnum)) except: if iprintstep > 0: print('traci deadlist WRONG step=', step) newcars = traci.simulation.getDepartedIDList() if iprintstep >= 2: print('newcars=', newcars) for vid in newcars: tmp = Car(vid) tmp.subscribe(varlistroute) tmp.setStartTime(step) tmp.setOutputFile(directory + "/" + str(hash(vid) % numlog)) id2car[vid] = tmp for tlsid in tlslist: # all tls list id2tls[tlsid].updataPhase(step) for vid in traci.vehicle.getIDList(): id2car[vid].process(step) lid, lpo, spd = id2car[vid].getLanePosSpeed() if lid not in lane2len.keys(): lane2len[lid] = traci.lane.getLength(lid) if spd < 2 * Car.minSpeed and lpo > 100 and lane2len[ lid] - lpo < 100: # candidate if lid not in lane2vq.keys(): lane2vq[lid] = [] # remdist, spd, vid lane2vq[lid].append([lane2len[lid] - lpo + Car.VLen, spd, vid]) vp = "a1" for vid in traci.vehicle.getIDList(): tmpcar = id2car[vid] tlsid = tmpcar.getTls() tls2 = "" #tmpcar.get2ndTls() if tlsid != "": lid, lpo, spd = tmpcar.getLanePosSpeed() pred = id2tls[tlsid].getFuturePhaseSeq(step + 150) if iprintverb or vp == vid: print(tmpcar.id, tlsid, pred) if lid not in lane2vq.keys(): vq = [] else: vq = lane2vq[lid] if iprintverb or vp == vid: print("Queue", lid, sorted(vq)) if tls2 == "": tmpcar.adjustSpeedGivenPhasePred(pred, vq) else: pred = id2tls[tls2].getFuturePhaseSeq(step + 300) tmpcar.adjustSpeedGivenPhasePred(pred, vq) if iprintverb or vp == vid: print(var_dic_to_str(tmpcar.getSubscriptionResults())) id2car[vid].set_iprint(1) for lid in lane2vq.keys(): # need to refresh queue len lane2vq[lid] = [] traci.close() sys.stdout.flush()
def run(env): rou_curr= "12to"+str(random.choice([13])) env.reset(rou_curr) sumo_step=1.0 bn=[0, 17, 30, 31, 32, 33] cr=0.0 rl_step=1.0 idle=np.zeros((36,1)) v_idle=[[] for _ in range(36)] edge=[0] ga=[] gav=[] ss=[] prev_node=env.state while traci.simulation.getMinExpectedNumber()>0: traci.simulationStep() idle+=1 for i in bn: idle[i]=0 edge=traci.vehicle.getRoadID('veh0') if edge and (edge[0]!=':'): curr_node= edge.split('to') curr_node=int(curr_node[1]) elif edge[0]==':': curr_node=edge[1:].split('_') curr_node=int(curr_node[0]) env.state=curr_node # Action decision on new edge if prev_node!=curr_node: print(edge) print('p_node:',prev_node, 'c_node:',curr_node) print('Veh angle: ', traci.vehicle.getAngle('veh0')) rou_step=[] prev_reward=env.reward_out(idle, prev_node)[0] print('reward on prev step: ', prev_reward) v_idle[int(prev_node)].append(prev_reward.copy()) avg_v_idl, max_v_idl, sd_v_idl, glo_v_idl, glo_max_v_idl, glo_sd_v_idl, glo_idl, glo_max_idl = eval_met(idle, v_idle,sumo_step, 36) print('global avg node visit idleness: ', glo_v_idl, '\nglobal max node visit idleness: ', glo_max_v_idl) print('global avg instant idleness: ', glo_idl, '\nglobal max instant idleness: ', glo_max_idl) gav.append(glo_v_idl) ga.append(glo_idl) ss.append(sumo_step) cr+=prev_reward acr=cr/sumo_step idle[int(prev_node)]=0 print(idle.reshape(6,6)) lane = traci.vehicle.getLaneID('veh0') links = traci.lane.getLinks(lane, extended=False) s_lanes = [i[0] for i in links] n_edges=[] n_nodes=[] for nodes in s_lanes: n_edges.append(nodes.split('_')[0]) for edges in n_edges: n_nodes.append(int(edges.split('to')[1])) print(n_edges, n_nodes) env.set_actionSpace(n_edges) action=env.sample() # next_state, reward, action = env.step(action, idle) #print('action: ', action, 'next_state: ', next_state, 'reward: ', reward) rou_step.append(rou_curr) rou_step.append(action) print('next_route: ', rou_step) print(':::::::::::::to next node::::::::::::::::') traci.vehicle.setRoute(vehID = 'veh0', edgeList = rou_step) rou_curr=action prev_node=curr_node sumo_step+=1 if sumo_step ==20000: break plt.plot(ss,ga, "-r", linewidth=0.6,label="Global Average Idleness") plt.plot(ss,gav, "-b", linewidth=4, label="Global Average Node Visit Idleness") plt.legend(loc="lower right") up=np.ceil(max(ga)/20)*20 plt.yticks(np.linspace(0,up,(up/20)+1, endpoint=True)) plt.xlabel('Unit Time') plt.ylabel('Idleness') plt.title('Performance') traci.close() plt.show() sys.stdout.flush()
def run_one_episode_training(self, episode, total_episodes): # gen random route. simu_type = genorator.gen_route(episode, is_random = True) print('Training on random route with type: ', self.get_simu_type_str(simu_type)) self._epsilon = 1.0 - (episode / constants.total_ep_for_epislon) # setup epsilon traci.start(self._sumoCmd) # then, start sumo # INIT some vars: self._steps = 0 self._sum_intersection_queue = 0 # increases every step/seconds tot_neg_reward = 0 # total negative reward pre_wait_time = 0 # # INIT my vars: action = 0 # initial action old_action = 0 state = self._get_state(self.I) action_count = [0,0] # cal percent of actions good_bad_count = [0,0] # count good bad actions # run 1 simulation (maxsteps) while self._steps < self._max_steps: # reset current_wait_time: current_wait_time = 0 # select action (select index of action, then edit action_time) action = self._choose_action(state) # just count numb of taken actions. action_count[action] += 1 # ================================ Take action ==================================================================== if self._steps != 0 and old_action != action: # just set traffic_light in sumo self._set_yellow_phase(old_action) # ver 1: fixed yellow. # current_wait_time = self._simulate(self._yellow_duration) # ver 2: dynamic yellow. yellow_duration_new = self.cal_yellow_duration(old_action) current_wait_time = self._simulate(yellow_duration_new) self._set_green_phase(action) current_wait_time = self._simulate(self._green_duration) # ================================================================================================================= # get next_state and reward next_state = self._get_state(self.I) reward = pre_wait_time - current_wait_time if reward < 0: tot_neg_reward += reward good_bad_count[1] += 1 else: good_bad_count[0] += 1 # save tuple: self._memory.add_sample((state, action, reward, next_state)) # training: self._replay() # reassign: pre_wait_time = current_wait_time state = next_state old_action = action # print eval_this_action = 'Good action' if (reward>=0) else 'Bad Action' print('step: ', self._steps, '|',self._max_steps,' || action: ', self.get_action_name(action), ': ',eval_this_action,' || negative reward: ', tot_neg_reward) print('percent of actions: ', np.array(action_count)/sum(action_count)) print("Total negative reward: {}, Eps: {}".format(tot_neg_reward, self._epsilon)) # append data self._save_stats(simu_type,tot_neg_reward) # save array to disk: self.save_all_arrays() # close gui. traci.close(wait = False)
reward2 = traci.edge.getLastStepHaltingNumber( '2si') + traci.edge.getLastStepHaltingNumber('1si') for i in range(10): stepz += 1 traci.trafficlight.setPhase('cluster_1933306735_2322926274_2322926295_2322926370', 0) reward1 += traci.edge.getLastStepVehicleNumber( '4si') + traci.edge.getLastStepVehicleNumber('3si') reward2 += traci.edge.getLastStepHaltingNumber( '2si') + traci.edge.getLastStepHaltingNumber('1si') waiting_time += (traci.edge.getLastStepHaltingNumber('1si') + traci.edge.getLastStepHaltingNumber( '2si') + traci.edge.getLastStepHaltingNumber('3si') + traci.edge.getLastStepHaltingNumber('4si')) traci.simulationStep() new_state = sumoInt.getState() reward = reward1 - reward2 agent.remember(state, action, reward, new_state, False) # Randomly Draw 32 samples and train the neural network by RMS Prop algorithm if(len(agent.memory) > batch_size): agent.replay(batch_size) mem = agent.memory[-1] del agent.memory[-1] agent.memory.append((mem[0], mem[1], reward, mem[3], True)) log.write('episode - ' + str(e) + ', total waiting time - ' + str(waiting_time) + ', number of cycles - ' + str(num_cycles) + '\n') log.close() print('episode - ' + str(e) + ' total waiting time - ' + str(waiting_time) + ' number of cycles - ' + str(num_cycles)) agent.save('reinf_traf_control_' + str(e) + '.h5') traci.close(wait=False) sys.stdout.flush()
async def run(self): # try: emission_classes = list(self.veh_dist.keys()) emission_weights = list(self.veh_dist.values()) box_ids = list(bremicker_boxes.keys()) detector_steps = [step * 600 for step in range(0, self.df_traffic.shape[0])] self.df_traffic = self.df_traffic.fillna(0) self.df_traffic = self.df_traffic.reset_index() self.df_traffic = self.df_traffic[box_ids] self.df_traffic.index = pd.Series(self.df_traffic.index).apply(lambda x: x * 600) print('traffic:', self.df_traffic) print('detector steps:', detector_steps) current_step = 0 detected_vehicles = {} while traci.simulation.getMinExpectedNumber() > 0: if current_step > (self.timesteps * 1.2): print("[SUMO] Simulation took to long. Aborting after %s simulated seconds" % str(current_step)) break for box_id in box_ids: if box_id in detected_vehicles: detected_vehicles[box_id] += traci.inductionloop.getLastStepVehicleNumber("det_%s_0" % box_id) + traci.inductionloop.getLastStepVehicleNumber("det_%s_1" % box_id) else: detected_vehicles[box_id] = traci.inductionloop.getLastStepVehicleNumber("det_%s_0" % box_id) + traci.inductionloop.getLastStepVehicleNumber("det_%s_1" % box_id) # print(detected_vehicles) traci.simulationStep() if current_step in detector_steps: step = detector_steps.pop(0) for box_id in box_ids: max_vehicles = self.df_traffic[box_id].max() vehicle_threshold = self.df_traffic.loc[step][box_id] needed_vehicles = detected_vehicles[box_id] - vehicle_threshold veh_ids = list(traci.inductionloop.getLastStepVehicleIDs("det_%s_0" % box_id)) veh_ids += list(traci.inductionloop.getLastStepVehicleIDs("det_%s_1" % box_id)) veh_ids = list(dict.fromkeys(veh_ids)) loaded_routes = traci.route.getIDList() print('detected vehicles until now', detected_vehicles) print('current step: ', step) print('vehicle number too much/low: needed vehicles: %s' % str(needed_vehicles)) # while needed_vehicles > 0: # #remove vehicles # veh = veh_ids.pop(0) # # print("[TRACI] removed vehicle %s" % veh) # traci.vehicle.remove(veh) # needed_vehicles -= 1 while needed_vehicles < 0: # add vehicles veh = veh_ids.pop(0) if len(veh_ids) != 0 else randrange(1, max_vehicles + 1, 1) route_id = traci.vehicle.getRouteID(veh) if len(veh_ids) != 0 else choice(loaded_routes) # new_id = datetime.datetime.today().timestamp() new_id = time.time() # print("[TRACI] added vehicle id: %s_%s" % (str(veh), str(new_id))) # print("[TRACI] added vehicle route id", str(route_id)) traci.vehicle.add( vehID='%s_%s' % (str(veh), str(new_id)), routeID=route_id, typeID=choices(emission_classes, weights=emission_weights)[0] ) needed_vehicles += 1 detected_vehicles[box_id] = 0 current_step += 1 # except Exception as e: # raise Exception('[SUMO] An error occurred while running the simulation: %s' % str(e)) # finally: traci.close() sys.stdout.flush() return
def close(self): traci.close()
def run(self): # first, generate the route file for this simulation and set up sumo self._traffic_gen.generate_routefile(1234) traci.start(self._sumoCmd) # inits self._steps = 0 old_action = 3 self._waiting_times = {} self._sum_intersection_queue = 0 action = 0 current_total_wait = 0 current_total_wait_road = [0, 0, 0, 0] cycle_start = 0 old_total_wait = 0.0001 n_cars = 0 while self._steps < self._max_steps: n_cars += self._get_total_no_of_cars() # waiting time = seconds waited by a car since the spawn in the environment, cumulated for every car in incoming lanes current_total_wait_road[0] += self._get_waiting_times(["NtoC"]) current_total_wait_road[1] += self._get_waiting_times(["EtoC"]) current_total_wait_road[2] += self._get_waiting_times(["StoC"]) current_total_wait_road[3] += self._get_waiting_times(["WtoC"]) current_total_wait += self._get_waiting_times() self._cumulative_wait_store[self._steps] = self._get_waiting_times( ) / self._get_total_no_of_cars() self._no_of_cars[self._steps] = self._get_total_no_of_cars() # if the chosen phase is different from the last phase, activate the yellow phase if self._steps != 0 and old_action != action: self._set_yellow_phase(old_action) self._simulate(self._yellow_duration) # execute the phase selected before self._set_green_phase(self._action_order[action]) self._simulate(self._green_duration[self._action_order[action]]) # saving variables for later old_action = self._action_order[action] action += 1 if action == 4: for i in range(4): current_total_wait_road[i] /= n_cars current_total_wait /= n_cars action = 0 self._k += 1 self._total_wait_time_store[self._k] = self._mu_store[ self._k - 1] * (self._k - 1) + current_total_wait self._mu_store.append(self._total_wait_time_store[self._k] / self._k) vk = current_total_wait - self._mu_store[self._k] self._sigma_store.append(np.sqrt((vk * vk) / self._k)) x = self._mu_store[ self._k - 1] + self._c * self._sigma_store[self._k - 1] self._recompute_green_duration(current_total_wait, current_total_wait_road, x) self._current_waiting_time_vs_no_of_cars[ self._sum_intersection_queue] = current_total_wait self._total_wait_vs_no_of_cars[ self. _sum_intersection_queue] = self._total_wait_time_store[ self._k] self._sum_intersection_queue = 0 old_total_wait = current_total_wait current_total_wait = 0 current_total_wait_road[0] = 0 current_total_wait_road[1] = 0 current_total_wait_road[2] = 0 current_total_wait_road[3] = 0 n_cars = 0 self._cycle_duration.append(self._steps - cycle_start) cycle_start = self._steps traci.close()
def run(): """execute the TraCI control loop""" """ This stuff powers through the fist 2 steps""" step = 0 traci.simulationStep() traci.simulationStep() step += 2 traci.vehicle.add("bike", "bike1", typeID='typeBike') #Adds bike to simulation traci.vehicle.setSpeed("bike", 0) oldTLSID = '' warnCounter = 0 warnRepeat = 0 savedLight = '' carsWarned = False warningTriggered = False while True: starttime = time.time() updatePosition() upcominglights = traci.vehicle.getNextTLS("bike") if len(upcominglights) > 0: tank = str( upcominglights[0][0]) # tank holds the current traficlight ID, #trafic light identification logic will have to be tied to this variable LightLocation( tank ) # this pulls the trafic light location out and stores it in variables for usage greenz( tank ) #has to be here beacuse flask crashes traci if it is after the simulation step #this must be processed in the simulation, can1t be done in the webserver it will break things #likely because it is not thread safe if upcominglights[0][ 2] < 30 and BikeSpeed > 0: #Check if cyclist is going for it to trigger warning beacon warnRepeat = 8 savedLight = tank warningTriggered = True if warnRepeat > 0: warnCars(savedLight) warnRepeat -= 1 if warnRepeat == 0 and warningTriggered == True: #Reset cars clearCars() warningTriggered = False # if carsWarned == True and tank != oldTLSID and step-warnCounter > 5: # clearCars(oldTLSID) # carsWarned = False # elif upcominglights[0][2] < 12 and BikeSpeed > 0: #Check if cyclist is crossing intersection for warning beacon # oldTLSID = tank # warnCars(tank) # warnCounter = step # carsWarned = True traci.simulationStep() step += 1 time.sleep(1.0 - ((time.time() - starttime) % 1.0)) traci.close()
def runner(pid, t1, t2, t3, t4): #def runner(pid): options = get_options() # this script has been called from the command line. It will start sumo as a # server, then connect and run if options.nogui: sumoBinary = checkBinary('sumo') else: sumoBinary = checkBinary('sumo-gui') #假设是所需的,完整的数据 #with open('C:\\Users\\Mr.Du\\Desktop\\BH_f\\0903\\megerate0903.json','r') as load_f: with open('C:\\Users\\Mr.Du\\Desktop\\help\\megerate0902.json', 'r') as load_f: megerate = json.load(load_f) redtime_A = 12 redtime_B = 10 redtime_D = 10 #信号灯ID tlsID_A = '30885212' tlsID_B = '5535842383' tlsID_D = '1877642863' #车道数 Num_A = 4 Num_B = 2 Num_D = 2 j = 0 #处于第几个20秒 p_A = [] p_B = [] p_D = [] #存储信号灯相位 # this is the normal way of using traci. sumo is started as a # subprocess and then the python script connects and runs traci.start([ 'sumo-gui', "-c", r"C:\Users\Mr.Du\Desktop\help\BH.sumocfg", "--output-prefix", str(pid) ]) #traci.start(['sumo', "-c", r"C:\Users\Mr.Du\Desktop\BH_f\0903\BH.sumocfg", "--output-prefix", str(pid)]) for step in range(0, 18600): '''if step%20 == 0:#0.1步长 r_A = megerate['Anzac'][j] r_B = megerate['Boundary'][j] r_D = megerate['Deception'][j]#每20s重新计算一次merge rate;此时步长为1 j = j+1 redtime_A = max(min(cal_redtime(r_A, Num_A), redtime_A+10), redtime_A-5) redtime_B = max(min(cal_redtime(r_B, Num_B), redtime_B+10), redtime_B-5) redtime_D = max(min(cal_redtime(r_D, Num_D), redtime_D+10), redtime_D-5)''' traci.simulationStep() '''p_A.append(traci.trafficlight.getPhase(tlsID_A)) p_B.append(traci.trafficlight.getPhase(tlsID_B)) p_D.append(traci.trafficlight.getPhase(tlsID_D)) #第一步的时候不能进行以下计算 if step != 0: if p_A[step] == 2 and (p_A[step-1] == 0 or p_A[step-1] == 1): #进入红灯,但是只能是刚进入 traci.trafficlight.setPhaseDuration(tlsID_A, redtime_A)#每个周期都设置一下红灯时长 if p_B[step] == 2 and (p_B[step-1] == 0 or p_B[step-1] == 1): #进入红灯,但是只能是刚进入 traci.trafficlight.setPhaseDuration(tlsID_B, redtime_B)#每个周期都设置一下红灯时长 if p_D[step] == 2 and (p_D[step-1] == 0 or p_D[step-1] == 1): #进入红灯,但是只能是刚进入 traci.trafficlight.setPhaseDuration(tlsID_D, redtime_D)'''#每个周期都设置一下红灯时长 '''vehicles = traci.inductionloop.getLastStepVehicleIDs('815 SB_0')+traci.inductionloop.getLastStepVehicleIDs('815 SB_1')+traci.inductionloop.getLastStepVehicleIDs('815 SB_2') for v in vehicles: traci.vehicle.updateBestLanes(v) vehicles = traci.inductionloop.getLastStepVehicleIDs('814 SB_0')+traci.inductionloop.getLastStepVehicleIDs('814 SB_1')+traci.inductionloop.getLastStepVehicleIDs('814 SB_2') for v in vehicles: traci.vehicle.updateBestLanes(v) vehicles = traci.inductionloop.getLastStepVehicleIDs('813 SB_0')+traci.inductionloop.getLastStepVehicleIDs('813 SB_1')+traci.inductionloop.getLastStepVehicleIDs('813 SB_2') for v in vehicles: traci.vehicle.updateBestLanes(v)''' if step > 5400: vehicles1 = traci.edge.getLastStepVehicleIDs('444071858.7') '''vehicles12 = traci.edge.getLastStepVehicleIDs('577463657') vehicles13 = traci.edge.getLastStepVehicleIDs('444071852') vehicles14 = traci.edge.getLastStepVehicleIDs('583369727#1')''' vehicles2 = traci.edge.getLastStepVehicleIDs( '444071862') #从该路段开始修改车辆属性 vehicles3 = traci.edge.getLastStepVehicleIDs('444071865') vehicles4 = traci.edge.getLastStepVehicleIDs('M2.4') for v in vehicles1: sigma = max(min(random.normalvariate(0.2, 0.1), 1), 0) #生成随机sigma,在0,1之间 tau1 = max(random.normalvariate(t1, 0.3), 0) traci.vehicle.setTau(v, tau1) traci.vehicle.setImperfection(v, sigma) '''for v in vehicles12: tau2 = max(random.normalvariate(1.35, 0.2), 0) traci.vehicle.setTau(v, tau2) for v in vehicles13: tau2 = max(random.normalvariate(1.4, 0.2), 0) traci.vehicle.setTau(v, tau2) for v in vehicles14: tau2 = max(random.normalvariate(1.36, 0.2), 0) traci.vehicle.setTau(v, tau2)''' for v in vehicles2: tau2 = max(random.normalvariate(t2, 0.3), 0) traci.vehicle.setTau(v, tau2) for v in vehicles3: tau3 = max(random.normalvariate(t3, 0.3), 0) traci.vehicle.setTau(v, tau3) for v in vehicles4: tau4 = max(random.normalvariate(t4, 0.3), 0) traci.vehicle.setTau(v, tau4) traci.close() #return p_A, p_B, p_D return
def main(): # read inputs argParser = initOptions() options = argParser.parse_args() r_all = {} rv_dict = {} memory_problems = [0] # start traci if options.sumocfg: run_traci = [ options.sumo, "-c", options.sumocfg, '--tripinfo-output.write-unfinished' ] else: run_traci = [ options.sumo, '--net-file', '%s' % options.network, '-r', '%s,%s' % (options.reservations, options.taxis), '-l', 'log.txt', '--device.taxi.dispatch-algorithm', 'traci', '--tripinfo-output', '%s' % options.output, '--tripinfo-output.write-unfinished' ] if options.gui_settings: run_traci.extend(['-g', '%s' % options.gui_settings]) traci.start(run_traci) # execute the TraCI control loop step = traci.simulation.getTime() + 10 v_type = None rerouting = True while rerouting: traci.simulationStep(step) # get vType for route calculation if not v_type: fleet = traci.vehicle.getTaxiFleet(-1) v_type = traci.vehicle.getTypeID(fleet[0]) # get new reservations r_id_new = [] for x in traci.person.getTaxiReservations(1): # search direct travel time direct = int( traci.simulation.findRoute(x.fromEdge, x.toEdge, v_type, x.depart, routingMode=0).travelTime) # add new reservation attributes setattr(x, 'direct', direct) # direct travel time setattr(x, 'vehicle', False) # id of assigned vehicle setattr(x, 'delay', 0) # difference between assigned pick up time and real one setattr( x, 'tw_pickup', [x.depart, x.depart + options.max_wait]) # pickup time window # drop off time window if x.direct * options.drf < options.drf_min: setattr(x, 'tw_dropoff', [ x.tw_pickup[0] + direct, x.tw_pickup[1] + direct + options.drf_min ]) else: setattr(x, 'tw_dropoff', [ x.tw_pickup[0] + direct, x.tw_pickup[1] + direct * options.drf ]) # add id to new reservations r_id_new.append(x.id) # add reservation to list r_all[x.id] = x # unassigned reservations r_id_unassigned = [x.id for x_id, x in r_all.items() if not x.vehicle] # if reservations pending if r_id_unassigned: if options.debug: print('\nRun dispatcher') if r_id_new: print('New reservations: ', r_id_new) print('Unassigned reservations: ', list(set(r_id_unassigned) - set(r_id_new))) # get fleet fleet = traci.vehicle.getTaxiFleet(-1) if set(fleet) != set(fleet) & set( traci.vehicle.getIDList()): # TODO manage teleports print("\nVehicle %s is being teleported, skip to next step" % (set(fleet) - set(traci.vehicle.getIDList()))) step += options.sim_step continue # if a vehicle is being teleported skip to next step # remove reservations already served r_id_current = [x.id for x in traci.person.getTaxiReservations(0)] r_id_served = list(set(r_all.keys()) - set(r_id_current)) [r_all.pop(key) for key in r_id_served] [ rv_dict.pop(key) for key in list(rv_dict) if set(r_id_served) & set(rv_dict[key][2]) ] # reservations already picked up r_id_picked = [x.id for x in traci.person.getTaxiReservations(8)] # search request-vehicles pairs if options.debug: print('Calculate RV-Graph') get_rv(options, r_id_new, r_id_picked, r_id_served, r_all, fleet, v_type, rv_dict, step) # search trips (rtv graph) # TODO define/import algorithm before to avoid checking each time # Maybe a list with the function as element and get the element (0, 1, 2) if options.debug: print('Calculate RTV-Graph') if options.rtv_algorithm == '0': rtv_dict, r_id_rtv, memory_problems = rtvAlgorithm.exhaustive_search( options, r_id_unassigned, r_id_picked, r_all, fleet, v_type, rv_dict, step, memory_problems) elif options.rtv_algorithm == '1': rtv_dict, r_id_rtv = rtvAlgorithm.simple( options, r_id_unassigned, r_id_picked, r_id_served, r_all, fleet, v_type, rv_dict, step) elif options.rtv_algorithm == '2': rtv_dict, r_id_rtv = rtvAlgorithm.simple_rerouting( options, r_id_unassigned, r_id_picked, r_id_served, r_all, fleet, v_type, rv_dict, step) # rtv_dict, r_id_rtv = get_rtv(options, r_id_unassigned, r_id_picked, r_id_served, r_all, # fleet, v_type, rv_dict, step) if len(rtv_dict) == 0: step += options.sim_step continue # if no routes found elif len(rtv_dict.keys()) == 1: # if one vehicle darp, assign route best_routes = list(rtv_dict.keys()) else: # if multiple vehicle darp, solve ILP with pulp vehicle_constraints = {} request_constraints = {} costs = {} trips = list(rtv_dict.keys() ) # list of all trips for ILP solution parse # add bonus_cost to trip cost (makes trips with more served requests cheaper than splitting # the requests to more vehicles with smaller trips if both strategies would yield a similar cost) for idx, trip_id in enumerate(trips): # rtv_dict[route] = [travel_time, v_bin, r_bin, value] # TODO specific cost for vehicle can be consider here bonus_cost = (sum(rtv_dict[trip_id][2]) + 1) * options.cost_per_trip costs.update({idx: rtv_dict[trip_id][0] + bonus_cost }) # generate dict with cost # generate dict with vehicle used in the trip vehicle_constraints.update({idx: rtv_dict[trip_id][1]}) # generate dict with served requests in the trip request_constraints.update({idx: rtv_dict[trip_id][2]}) if options.debug: print('Solve ILP') ilp_result = ilp_solve(options, len(fleet), len(r_id_rtv), costs, vehicle_constraints, request_constraints) # parse ILP result best_routes = [ trips[int(route_index)] for route_index in ilp_result ] # assign routes to vehicles for route_id in best_routes: stops = route_id.replace('y', '') stops = stops.replace('z', '') stops = stops.split("_") # first check if route different or better (when no optimal solution) than already assigned current_route = [] try: # get current route for taxi_stop in traci.vehicle.getStops(stops[0]): sub_stops = taxi_stop.actType.split( ",") # if more than 1 reservation in stop for sub_stop in sub_stops: current_route.append(sub_stop.split(" ")[2][1:-1]) except: current_route = ['None'] if current_route == stops[1:]: # route is the same continue elif set(current_route) == set( stops[1:]) and len(current_route) == len(stops[1:]): # if route serve same request, check if new is faster tt_current_route = 0 edges = [ taxi_stops.lane.split("_")[0] for taxi_stops in traci.vehicle.getStops(stops[0]) ] # TODO check next_act update edges.insert( 0, traci.vehicle.getLaneID( stops[0]).split("_")[0]) # add current edge for idx, edge in enumerate(edges[:-1]): # TODO default stop time ticket #6714 tt_current_route += int( traci.simulation.findRoute( edge, edges[idx + 1], v_type, step, routingMode=0).travelTime) + 60 tt_new_route = rtv_dict[route_id][0] if tt_new_route >= tt_current_route: continue # current route better than new found if options.debug: print('Dispatch: ', route_id) traci.vehicle.dispatchTaxi(stops[0], stops[1:]) # assign vehicle to requests # TODO to avoid major changes in the pick-up time when assigning new passengers, # tw_pickup should be updated, whit some constant X seconds, e.g. 10 Minutes for x_id in set(stops[1:]): x = r_all[x_id] x.vehicle = stops[0] # TODO ticket #8385 if step > options.end_time or (traci.simulation.getMinExpectedNumber() <= 0 and not traci.person.getIDList()): rerouting = False step += options.sim_step if options.rtv_algorithm == 0: # if exhaustive search if sum(memory_problems) == 0: print('Optimal solution found.') else: print( 'The maximal specified calculation time has been exceeded. Solution could be not optimal.' ) print('DRT simulation ended') traci.close()
def runQFA(): stateVect = [[]] # policyPi = [] # for i in range(0, 80, 1): # policyPi.insert(i, random.randint(0, 5)) QSA = np.random.rand(6, 1) # QdashSA = np.array(np.random.rand(1, 6)) # Returns = [[0]*6 for x in range(81)] phiSA = [[0]*13 for x in range(6)] for i in range(6): phiSA[i][12] = 1 theta = np.array(np.random.rand(13, 1)) # thetaDash = np.array(np.random.rand(13, 1)) currTLS = [] Actions = [20, 25, 30, 20, 25, 30] # Actions = [30, 60, 120, 30, 60, 120] avgTime = [] numVehs = [] avgTime.clear() numVehs.clear() EPSILON = 0.20 ALPHA = 0.05 GAMMA = 0.9 step = 0 stateNorth = 0 stateSouth = 0 stateEast = 0 stateWest = 0 currAction = 0 reward = 0 totWaittimeSoFar = 0 curWaittime = 0 totVehsSoFar = 0 currVehsHere = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() # print(QSA) stateNorth = traci.lane.getLastStepOccupancy('nc_0') stateSouth = traci.lane.getLastStepOccupancy('sc_0') stateEast = traci.lane.getLastStepOccupancy('ec_0') stateWest = traci.lane.getLastStepOccupancy('wc_0') tlsPhase = traci.trafficlight.getPhase("center") currTLS = traci.trafficlight.getCompleteRedYellowGreenDefinition("center") # Determine the state lenFeature = (getState(stateNorth) + getState(stateEast) + getState(stateSouth) + getState(stateWest))*1.0 / 8 timeFeature = getSwitchTime(tlsPhase, currTLS, traci.simulation.getTime()) reward = -1.0 * (lenFeature + timeFeature) # Take epsilon-greedy action if random.uniform(0, 1) < EPSILON: currAction = random.randint(0, 5) else: currAction = np.argmax(QSA) # Storage phiSA[currAction][currAction*2] = lenFeature phiSA[currAction][currAction*2 + 1] = timeFeature # QSA = np.array(np.random.rand(1, 6)) stateVect.insert(step, [lenFeature, timeFeature, 0, 0]) stateVect[step][3] = currAction stateVect[step][2] = reward # Control simulation if currAction > 2: phaseToChange = 2 else: phaseToChange = 0 # currTLS = traci.trafficlight.getCompleteRedYellowGreenDefinition("center") currTLS[0].phases[phaseToChange].duration = Actions[currAction] currTLS[0].phases[phaseToChange].minDur = Actions[currAction] currTLS[0].phases[phaseToChange].maxDur = Actions[currAction] traci.trafficlight.setCompleteRedYellowGreenDefinition("center", currTLS[0]) # The Update if step > 0 and step % 75 == 0: episodeStates = [[]] A = 0 R = 0 for t in range(0, 74, 1): episodeStates.insert(t, stateVect[step-74+t]) for t in range(0, 73, 1): S = episodeStates[t] R = S[2] A = S[3] Sprime = episodeStates[t+1] QSA = np.matmul(phiSA, theta) QdashSA = getQdash(phiSA, Sprime, theta) # print(Sprime) gradWqsa = [0]*13 for i in range(13): for j in range(6): gradWqsa[i] = gradWqsa[i] + phiSA[j][i] # for i in range(6): # print(phiSA[i]) # print(gradWqsa) # break err = R + GAMMA * max(QdashSA) - QSA[A] const = ALPHA * err for i in range(13): theta[i] = theta[i] + const * gradWqsa[i] # print(theta) # print(phiSA, sep='\n') # print(np.matrix(phiSA)) # print('\n'.join(['\t'.join([str(cell) for cell in row]) for row in phiSA])) step += 1 curWaittime = traci.edge.getWaitingTime('nc') + traci.edge.getWaitingTime('ec') + traci.edge.getWaitingTime('sc') + traci.edge.getWaitingTime('wc') totWaittimeSoFar = totWaittimeSoFar + curWaittime avgTime.append(totWaittimeSoFar/step) currVehsHere = traci.simulation.getArrivedNumber() totVehsSoFar = totVehsSoFar + currVehsHere numVehs.append(totVehsSoFar) traci.close() # print(phi) sys.stdout.flush() return step, avgTime, numVehs
print("convertRoad2D", traci.simulation.convert2D("o", 0.)) print("convertRoad3D", traci.simulation.convert3D("o", 0.)) print("convertRoadGeo", traci.simulation.convert2D("o", 0., toGeo=True)) print("convertRoadGeoAlt", traci.simulation.convert3D("o", 0., toGeo=True)) print("convert2DGeo", traci.simulation.convertGeo(488.65, 501.65)) print("convertGeo2D", traci.simulation.convertGeo(12, 48, True)) print("convert2DRoad", traci.simulation.convertRoad(488.65, 501.65)) print("convertGeoRoad", traci.simulation.convertRoad(12, 48.1, True)) print("distance2D", traci.simulation.getDistance2D(488.65, 501.65, 498.65, 501.65)) print( "drivingDistance2D", traci.simulation.getDistance2D(488.65, 501.65, 498.65, 501.65, isDriving=True)) print("distanceRoad", traci.simulation.getDistanceRoad("o", 0., "2o", 0.)) print("drivingDistanceRoad", traci.simulation.getDistanceRoad("o", 0., "2o", 0., isDriving=True)) print("clearing pending") traci.simulation.clearPending() print("save simstate") traci.simulation.saveState("state.xml") for step in range(6): print("step", step) traci.simulationStep() print(traci.simulation.getSubscriptionResults()) traci.close() sumoProcess.wait()
def close(self): traci.close() self.time = 0
def city_dqn_test(flags, sumoCmd, configs): # Environment Setting from Agent.super_dqn import Trainer from Env.CityEnv import CityEnv # init test setting if flags.replay_name is not None: # 여기앞에 configs 설정해도 의미 없음 configs = load_params(configs, flags.replay_name) configs['replay_epoch'] = str(flags.replay_epoch) configs['mode'] = 'test' phase_num_matrix = torch.tensor( # 각 tl이 갖는 최대 phase갯수 [ len(configs['traffic_node_info'][index]['phase_duration']) for _, index in enumerate(configs['traffic_node_info']) ]) sumoCmd += ['--seed', '1'] agent = Trainer(configs) agent.save_params(configs['time_data']) agent.load_weights(flags.replay_name) # init training NUM_AGENT = configs['num_agent'] TL_RL_LIST = configs['tl_rl_list'] MAX_PHASES = configs['max_phase_num'] MAX_STEPS = configs['max_steps'] OFFSET = torch.tensor( configs['offset'], # i*10 device=configs['device'], dtype=torch.int) TL_PERIOD = torch.tensor(configs['tl_period'], device=configs['device'], dtype=torch.int) # state initialization # agent setting # check performance avg_waiting_time = 0 avg_part_velocity = 0 avg_velocity = 0 arrived_vehicles = 0 part_velocity = list() waiting_time = list() total_velocity = list() # travel time travel_time = list() with torch.no_grad(): step = 0 traci.start(sumoCmd) env = CityEnv(configs) # Total Initialization actions = torch.zeros((NUM_AGENT, configs['action_size']), dtype=torch.int, device=configs['device']) # Mask Matrix : TL_Period가 끝나면 True mask_matrix = torch.ones((NUM_AGENT), dtype=torch.bool, device=configs['device']) # MAX Period까지만 증가하는 t t_agent = torch.zeros((NUM_AGENT), dtype=torch.int, device=configs['device']) t_agent -= OFFSET # Action configs['offset']on Matrix : 비교해서 동일할 때 collect_state, 없는 state는 zero padding action_matrix = torch.zeros((NUM_AGENT, MAX_PHASES), dtype=torch.int, device=configs['device']) # 노란불 3초 해줘야됨 action_index_matrix = torch.zeros( (NUM_AGENT), dtype=torch.long, device=configs['device']) # 현재 몇번째 phase인지 action_update_mask = torch.eq( # action이 지금 update해야되는지 확인 t_agent, action_matrix[0, action_index_matrix]).view(NUM_AGENT) # 0,인 이유는 인덱싱 # 최대에 도달하면 0으로 초기화 (offset과 비교) clear_matrix = torch.eq(t_agent % TL_PERIOD, 0) t_agent[clear_matrix] = 0 # action 넘어가야된다면 action index증가 (by tensor slicing) action_index_matrix[action_update_mask] += 1 action_index_matrix[clear_matrix] = 0 # mask update, matrix True로 전환 mask_matrix[clear_matrix] = True mask_matrix[~clear_matrix] = False # state initialization state = env.collect_state(action_update_mask, action_index_matrix, mask_matrix) total_reward = 0 # agent setting arrived_vehicles = 0 a = time.time() while step < MAX_STEPS: # action 을 정하고 actions = agent.get_action(state, mask_matrix) if mask_matrix.sum() > 0: print(actions.transpose(1, 2)) # action형태로 변환 # 다음으로 넘어가야할 시점에 대한 matrix action_matrix = env.calc_action(action_matrix, actions, mask_matrix) # 누적값으로 나타남 # environment에 적용 # action 적용함수, traci.simulationStep 있음 env.step(actions, mask_matrix, action_index_matrix, action_update_mask) # 전체 1초증가 # traci는 env.step에 step += 1 t_agent += 1 # 최대에 도달하면 0으로 초기화 (offset과 비교) clear_matrix = torch.eq(t_agent % TL_PERIOD, 0) # 넘어가야된다면 action index증가 (by tensor slicing) # action 넘어가야된다면 action index증가 (by tensor slicing) for idx, _ in enumerate(TL_RL_LIST): action_update_mask[ idx] = torch.eq( # update는 단순히 진짜 현시만 받아서 결정해야됨 t_agent[idx], action_matrix[idx, action_index_matrix[idx]].view( -1)) # 0,인 이유는 인덱싱 action_index_matrix[action_update_mask] += 1 # agent의 최대 phase를 넘어가면 해당 agent의 action index 0으로 초기화 action_index_matrix[clear_matrix] = 0 # mask update, matrix True로 전환 t_agent[clear_matrix] = 0 mask_matrix[clear_matrix] = True mask_matrix[~clear_matrix] = False # check performance for _, interests in enumerate(configs['interest_list']): # delete 중복 dup_list = list() for interest in interests: inflow = interest['inflow'] outflow = interest['outflow'] # 신호군 흐름 if inflow != None and inflow not in dup_list: # 차량의 대기시간, 차량이 있을 때만 if traci.edge.getLastStepVehicleNumber(inflow) != 0: waiting_time.append( traci.edge.getWaitingTime(inflow)) #/float( #traci.edge.getLastStepVehicleNumber(inflow))) # 차량의 평균속도 # part_velocity.append( # traci.edge.getLastStepMeanSpeed(inflow)) tmp_travel = traci.edge.getTraveltime(inflow) if tmp_travel <= 500 and tmp_travel != -1: # 이상한 값 거르기 travel_time.append(tmp_travel) dup_list.append(inflow) if outflow != None and outflow not in dup_list: if traci.edge.getLastStepVehicleNumber(outflow) != 0: # part_velocity.append( # traci.edge.getLastStepMeanSpeed(interest['outflow'])) tmp_travel = traci.edge.getTraveltime(outflow) if tmp_travel <= 500 and tmp_travel != -1: # 이상한 값 거르기 travel_time.append(tmp_travel) dup_list.append(interest['outflow']) # edge_list=traci.edge.getIDList() # for edgeid in edge_list: # if traci.edge.getLastStepVehicleNumber(edgeid) !=None: # total_velocity.append(traci.edge.getLastStepMeanSpeed(edgeid)) next_state = env.collect_state(action_update_mask, action_index_matrix, mask_matrix) state = next_state # info arrived_vehicles += traci.simulation.getArrivedNumber() b = time.time() traci.close() print("time:", b - a) avg_part_velocity = torch.tensor(part_velocity, dtype=torch.float).mean() avg_velocity = torch.tensor(total_velocity, dtype=torch.float).mean() avg_part_velocity = torch.tensor(part_velocity, dtype=torch.float).mean() avg_travel_time = torch.tensor(travel_time, dtype=torch.float).mean() avg_waiting_time = torch.tensor(waiting_time, dtype=torch.float).mean() print( '======== arrived number:{} avg waiting time:{},avg velocity:{} avg_part_velocity: {} avg_travel_time: {}' .format(arrived_vehicles, avg_waiting_time, avg_velocity, avg_part_velocity, avg_travel_time)) print("Reward: {}".format(env.cum_reward.sum()))
tl_list.append(connection[2]) return tl_list #lust= import_datasets() #tls= extract_tl_ids(lust.iloc[0]) #print tls #connections = dataset[5]==[from,to,tl,dir,state] if True: TLSID = "0" while step < 1000: simulationStep() arrived_vehicles_in_last_step = simulation.getArrivedNumber() departed_vehicles_in_last_step = simulation.getDepartedNumber() current_simulation_time_ms = simulation.getCurrentTime() print arrived_vehicles_in_last_step phase = trafficlights.getPhase(TLSID) trafficlights.setRedYellowGreenState(TLSID, "grrrrrrrrrrr") lanes = trafficlights.getControlledLanes(TLSID) print len(lanes) #for lane in lanes: # print lane print phase #if traci.inductionloop.getLastStepVehicleNumber("0") > 0: # traci.trafficlights.setRedYellowGreenState("0", "GrGr") step += 1 close()
def stop_sumo(self): traci.close()
def main(): # Use the global parameters for iteration steps. Maybe their value varies. global time_steps global min_step global max_step # Parse the input commands. params = ConfigurationInput().parse() verbose = False if params.has_key(VERBOSE): verbose = True # If unbounded time step is added, turn the time steps to unlimited if params.has_key(UNBOUNDED_STEP): time_steps = -1 min_step = -1 max_step = -1 else: if params.has_key(STEP_LIMIT): steps = int(params[STEP_LIMIT].pop()) if ge(steps, 0): time_steps = steps if params.has_key(START_STEP): startStep = int(params[START_STEP].pop()) if ge(startStep, 0): min_step = startStep if params.has_key(END_STEP): endStep = int(params[END_STEP].pop()) if le(endStep, time_steps): max_step = endStep if ge(max_step, time_steps) or le(max_step, min_step): max_step = time_steps if ge(min_step, max_step) or ge(min_step, time_steps): min_step = 0 if params.has_key(NET): # Open the net file to get the static data from net. netFile = params[NET].pop() net = sumolib.net.readNet(netFile) else: # we have a input error. print "Error: Parameter -net was not set or parameters are invalid." print "Try " + sys.argv[0] + " --help\n" exit() # Blank space is the default format string separator separator = ' ' if params.has_key(SEPARATOR): sep = params[SEPARATOR].pop() if not eq(sep, None): if eq(sep.lower(), TAB): separator = '\t' elif eq(sep.lower(), BLANK): separator = ' ' elif eq(sep.lower(), COMMA): separator = ',' # Breaks the full option in various type of outputs if params.has_key(FULL): for key in ALL_PARAMS: if not params.has_key(key): params[key] = [] del params[FULL] elif (EDGE_PARAMS.isdisjoint(params.keys()) and VEHICLE_PARAMS.isdisjoint(params.keys()) and TRAFFIC_LIGHT_PARAMS.isdisjoint(params.keys()) and NODE_PARAMS.isdisjoint(params.keys())): # we have a input error. print "Error: You need to choose at least one of output parameters(Vehicle, Edge, Traffic Lights)." print "Try " + sys.argv[0] + " --help\n" exit() if params.has_key(PORT): port = int(params[PORT].pop()) # For the use of SUMO with traci-hub. if ge(port, 0): traci.init(port) else: traci.init(DEFAULT_PORT) else: # For the use of SUMO without traci-hub. traci.init(DEFAULT_PORT) # If some edges parameter is common if not EDGE_PARAMS.isdisjoint(params.keys()): # Instantiate the monitor of edges. edgeMonitor = EdgeMonitor() edgeMonitor.minStep = min_step edgeMonitor.maxStep = max_step # Search for the edge id's list, and filter it, removing all the id's # that refers to lanes (initiates with ':') traciEdgeList = traci.edge.getIDList() traciEdgeList = filter(lambda x: x.find(':') == -1, traciEdgeList) commonKeys = EDGE_PARAMS.intersection(params.keys()) edgeIdSet = set() # At this point, we have to recognize all the input type for the edges, # if the all parameter for edges is inserted, it is necessary to add all # the types of edges output and the list of ids. if EDGE_ALL in commonKeys: listValues = params.get(EDGE_ALL,[]) # The key is giving but no parameter, so we need to add some edges if eq(len(listValues),0): listValues = traciEdgeList for key in EDGE_PARAMS.difference(set([EDGE_ALL])): edgeMonitor.addEdgesIdOutput(listValues, key) params[key] = copy(listValues) edgeIdSet.update(listValues) del params[EDGE_ALL] else: for key in commonKeys: listValues = params.get(key,'') # The key is giving but no parameter, so we need to add some edges if eq(len(listValues),0): listValues = traciEdgeList edgeMonitor.addEdgesIdOutput(listValues, key) params[key] = copy(listValues) edgeIdSet.update(listValues) # Creates a list with all edge id's that exists and are inserted by user edgeIdList = list(edgeIdSet.intersection(traciEdgeList)) # Warranty that we have some edges to evaluate, taking all the edges if eq(len(edgeIdList), 0): edgeIdList = traciEdgeList # Creates and inserts the initialized edges in the monitor. for edgeId in edgeIdList: # Ignore every edge that not correspond to a full edge, in that case # , the junction lanes. if not edgeId.startswith(":"): edgeSumoLib = net.getEdge(edgeId) fromNode = edgeSumoLib._from._id toNode = edgeSumoLib._to._id lengthEdge = edgeSumoLib.getLength() edge = Edge(edgeId, fromNode, toNode, lengthEdge, verbose) edge.minStep = min_step edge.maxStep = max_step edgeMonitor.addEdge(edge) if not VEHICLE_PARAMS.isdisjoint(params.keys()): # Instantiate the monitor of vehicles. vehicleMonitor = VehicleMonitor() vehicleMonitor.minStep = min_step vehicleMonitor.maxStep = max_step # Search for the vehicle id's list. traciVehicleList = traci.vehicle.getIDList() commonKeys = VEHICLE_PARAMS.intersection(params.keys()) vehicleIdSet = set() # At this point, we have to recognize all the input type for the # vehicles, if the all parameter for vehicles is inserted, it is # necessary to add all the types of vehicles output and the list of ids. if (VEHICLE_ALL in commonKeys): listValues = params.get(VEHICLE_ALL,[]) # The key is giving but no parameter, so we need to add some # vehicles. if eq(len(listValues),0): listValues = traciVehicleList for key in VEHICLE_PARAMS.difference(set([VEHICLE_ALL])): vehicleMonitor.addVehiclesIdOutput(listValues, key) params[key] = copy(listValues) vehicleIdSet.update(listValues) del params[VEHICLE_ALL] else: for key in commonKeys: listValues = params.get(key,[]) # The key is giving but no parameter, so we need to add some # vehicles. if eq(len(listValues),0): listValues = traciVehicleList vehicleMonitor.addVehiclesIdOutput(listValues, key) params[key] = copy(listValues) vehicleIdSet.update(listValues) # Creates a list with all vehicle id's that exists and are inserted by # user. vehicleIdList = list(vehicleIdSet.intersection(traciVehicleList)) # Warranty that we have some vehicles to evaluate, taking all the # vehicles. if eq(len(vehicleIdList), 0): vehicleIdList = traciVehicleList # Creates and inserts the initialized vehicles in the monitor. for vehicleId in vehicleIdList: if not vehicleMonitor.hasVehicleById(vehicleId): vehicle = Vehicle(vehicleId) vehicle.minStep = min_step vehicle.maxStep = max_step vehicle.departure = 0 vehicleMonitor.addVehicle(vehicle) if not TRAFFIC_LIGHT_PARAMS.isdisjoint(params.keys()): # Instantiate the monitor of traffic lights. trafficLightsMonitor = TrafficLightsMonitor() trafficLightsMonitor.minStep = min_step trafficLightsMonitor.maxStep = max_step # Search for the traffic lights id's list. traciTrafficLightsList = traci.trafficlights.getIDList() commonKeys = TRAFFIC_LIGHT_PARAMS.intersection(params.keys()) trafficLightsIdSet = set() # At this point, we have to recognize all the input type for the traffic # lights, if the all parameter for traffic lights is inserted, it is # necessary to add all the types of traffic lights output and the list # of ids. if TRAFFIC_LIGHT_ALL in commonKeys: listValues = params.get(TRAFFIC_LIGHT_ALL,[]) # The key is giving but no parameter, so we need to add some traffic # lights if eq(len(listValues),0): listValues = traciTrafficLightsList for key in TRAFFIC_LIGHT_PARAMS.difference(set([TRAFFIC_LIGHT_ALL])): trafficLightsMonitor.addTrafficLightsIdOutput(listValues, key) params[key] = copy(listValues) trafficLightsIdSet.update(listValues) del params[TRAFFIC_LIGHT_ALL] else: for key in commonKeys: listValues = params.get(key,'') # The key is giving but no parameter, so we need to add some # traffic lights if eq(len(listValues),0): listValues = traciTrafficLightsList trafficLightsMonitor.addTrafficLightsIdOutput(listValues, key) params[key] = copy(listValues) trafficLightsIdSet.update(listValues) # Creates a list with all traffic lights id's that exists and are # inserted by user trafficLightsIdList = list(trafficLightsIdSet.intersection(traciTrafficLightsList)) # Warranty that we have some traffic lights to evaluate, taking all the # traffic lights if eq(len(trafficLightsIdList), 0): trafficLightsIdList = traciTrafficLightsList for trafficLightsId in trafficLightsIdList: # Instantiate the traffic lights object and add some data. trafficLights = TrafficLights(trafficLightsId) # Simulation steps interval trafficLights.minStep = min_step trafficLights.maxStep = max_step # Controlled lanes trafficLights.controlledLanes = traci.trafficlights.getControlledLanes(trafficLightsId) # Controlled links trafficLights.controlledLinks = traci.trafficlights.getControlledLinks(trafficLightsId) # Complete logic and phases of the semaphore programList = traci.trafficlights.getCompleteRedYellowGreenDefinition(trafficLightsId) # Take the first and unique program in the list while len(programList) > 0: phases = [] program = programList.pop() if program: # Instantiate the logic program helper class for traffic # lights. trafficLightsProgram = TrafficLightsProgram() trafficLightsProgram.id = program._subID trafficLightsProgram.programType = program._type trafficLightsProgram.subParameter = program._subParameter trafficLightsProgram.currentPhaseIndex = program._currentPhaseIndex # Take the phases of the signal state for phase in program._phases: ph = Phase(phase._duration, phase._duration1, phase._duration2, phase._phaseDef) phases.append(ph) trafficLightsProgram.phases = phases # Adds the semaphore program to the traffic lights trafficLights.addLogicProgram(trafficLightsProgram) # Inserts the initialised traffic lights in the monitor. trafficLightsMonitor.addTrafficLights(trafficLights) if not NODE_PARAMS.isdisjoint(params.keys()): pass ## reroute test # traci.route.add( # "sp_route1", # ["south/center", "center/north", "north/center", "center/south"] # ) # traci.route.add( # "sp_route2", # ["center/south", "south/center", "center/north", "north/center"] # ) # traci.route.add( # "sp_route3", # ["north/center", "center/south", "south/center", "center/north"] # ) # traci.route.add( # "sp_route4", # ["center/north", "north/center", "center/south","south/center"] # ) # traci.vehicle.add("special", "sp_route1", 0) # For each iteration of the simulation. timeStep = 0 timeStepFinal = 0 # Creating the clone summary output data = ["#step"] data.append("loaded") data.append("departed") data.append("running") data.append("arrived") summaryData = [separator.join(data)] totalLoaded = 0 totalDeparted = 0 totalArrived = 0 # # Simulation beginning # while True: # All vehicles have arrived if timeStep > 5 and totalArrived == totalDeparted: traci.close() break # The maximum time step has been reached if not eq(time_steps,-1) and gt(timeStep, max_step): traci.close() break try: # Executes one step traci.simulationStep() totalLoaded += traci.simulation.getLoadedNumber() totalDeparted += traci.simulation.getDepartedNumber() totalArrived += traci.simulation.getArrivedNumber() totalRunning = totalDeparted - totalArrived data = [] # clear list data.append(str(timeStep)) data.append(str(totalLoaded)) data.append(str(totalDeparted)) data.append(str(totalRunning)) data.append(str(totalArrived)) summaryData.append(separator.join(data)) # # All vehicles have arrived # if timeStep > 5 and totalArrived == totalDeparted: # traci.close() # break # # # The maximum time step has been reached # if not eq(time_steps,-1) and gt(timeStep, max_step): # traci.close() # break # except traci.FatalTraCIError as message: # print message # traci.close() # #exit() # break # One step execution of evaluation if (ge(timeStep, min_step) and le(timeStep, max_step)) or eq(time_steps,-1): if not EDGE_PARAMS.isdisjoint(params.keys()): # Updates the edges in the monitor with the data of simulation # in this step. for edgeId in edgeIdList: edgeMonitor.updateEdge( timeStep, edgeId, traci.edge.getLastStepVehicleNumber(edgeId), traci.edge.getLastStepMeanSpeed(edgeId), traci.edge.getLastStepHaltingNumber(edgeId), traci.edge.getLastStepLength(edgeId), traci.edge.getLastStepOccupancy(edgeId) ) if not VEHICLE_PARAMS.isdisjoint(params.keys()): # Search for the vehicle id's list. traciVehicleList = traci.vehicle.getIDList() commonKeys = VEHICLE_PARAMS.intersection(params.keys()) vehicleIdSet = set() for key in commonKeys: listValues = params.get(key,[]) # The key is giving but no parameter, so we need to add some # vehicles if not listValues: # Takes the actual list of vehicles in simulation listValues = traciVehicleList # and adds to the output list. vehicleMonitor.addVehiclesIdOutput(listValues, key) vehicleIdSet.update(listValues) # Creates a list with all vehicle id's that exists and are # inserted by user vehicleIdList = list(vehicleIdSet) # Warranty that we have some vehicles to evaluate, taking all # the vehicles if not vehicleIdList: vehicleIdList = traciVehicleList # Creates and inserts the initialized vehicles in the monitor. # Updates the vehicles in the monitor with the data of # simulation in this step. for vehicleId in vehicleIdList: if not vehicleMonitor.hasVehicleById(vehicleId): # Insert the new vehicle vehicle = Vehicle(vehicleId) vehicle.minStep = min_step vehicle.maxStep = max_step vehicle.departure = timeStep vehicleMonitor.addVehicle(vehicle) # #reroute test # if "special" in vehicleIdList: # #print traci.vehicle.getRoadID("special") # if traci.vehicle.getRoadID("special") == "south/center": # traci.vehicle.setRouteID("special", "sp_route1") # elif traci.vehicle.getRoadID("special") == "center/north": # traci.vehicle.setRouteID("special", "sp_route4") # elif traci.vehicle.getRoadID("special") == "north/center": # traci.vehicle.setRouteID("special", "sp_route3") # elif traci.vehicle.getRoadID("special") == "center/south": # traci.vehicle.setRouteID("special", "sp_route2") #TODO: ainda precisa corrigir aqui, para evitar que o '-' fique sendo inserido regularmente for vehicleId in vehicleMonitor.getVehiclesIdList(): # The current simulation vehicles if vehicleId in traci.vehicle.getIDList(): edgeId = traci.vehicle.getRoadID(vehicleId) if net.hasEdge(edgeId): edgeLength = net.getEdge(edgeId).getLength() else: edgeId = '-' edgeLength = 0 vehicleMonitor.updateVehicle( timeStep, vehicleId, traci.vehicle.getSpeed(vehicleId), traci.vehicle.getRouteID(vehicleId), traci.vehicle.getRoute(vehicleId), edgeId, edgeLength ) for vehicleId in traci.simulation.getArrivedIDList(): if vehicleMonitor.hasVehicleById(vehicleId): vehicleMonitor.updateArrivedVehicle(timeStep, vehicleId) timeStepFinal +=1 if not TRAFFIC_LIGHT_PARAMS.isdisjoint(params.keys()): # Updates the traffic lights in the monitor with the data of # simulation in this step. for trafficLightsId in trafficLightsIdList: lanes = trafficLightsMonitor.getTrafficLightsLanesById(trafficLightsId) haltingVehicles = [traci.lane.getLastStepHaltingNumber(laneId) for laneId in lanes] trafficLightsMonitor.updateTrafficLights( timeStep, trafficLightsId, haltingVehicles ) # dynamics # # assumed time to next switch # traci.trafficlights.getNextSwitch(trafficLightsId) # # index of the current phase index request # traci.trafficlights.getPhase(trafficLightsId) # # traffic light states, encoded as rRgGyYoO # print traci.trafficlights.getRedYellowGreenState(trafficLightsId) # trafficLightsMonitor.updateEdge( # timeStep, trafficLightsId # ) if not NODE_PARAMS.isdisjoint(params.keys()): pass timeStep += 1 # End of simulation by closing the SUMO simulator. except traci.FatalTraCIError as message: print message traci.close() #exit() break # After completed the generation of data for the simulation, save in the file. uniqueId = str(abs(hash(random()))) # summary copy output fileSummary = FileManager(createName(uniqueId, '', summary=True)) fileSummary.addData("\n".join(summaryData)) # Instantiate the file objects for future manipulate. if not EDGE_PARAMS.isdisjoint(params.keys()): fileEval = FileManager(createName(uniqueId, EDGE_ALL, True)) fileEval.addData(edgeMonitor.toStringEvaluate(separator)) for param in EDGE_PARAMS: if params.has_key(param): fileBase = FileManager(createName(uniqueId, param)) fileBase.addData(edgeMonitor.toString(param,separator)) if not VEHICLE_PARAMS.isdisjoint(params.keys()): # TODO: needs a verification # Update all the vehicles arrived time for vehicles that not have really # arrived at end of simulation. vehicleMonitor.update(timeStepFinal) fileEval = FileManager(createName(uniqueId, VEHICLE_ALL, True)) fileEval.addData(vehicleMonitor.toStringEvaluate(separator)) for param in VEHICLE_PARAMS: if params.has_key(param): fileBase = FileManager(createName(uniqueId, param)) fileBase.addData(vehicleMonitor.toString(param,separator)) if not TRAFFIC_LIGHT_PARAMS.isdisjoint(params.keys()): fileEval = FileManager(createName(uniqueId, TRAFFIC_LIGHT_ALL, True)) fileEval.addData(trafficLightsMonitor.toStringEvaluate(separator)) for param in TRAFFIC_LIGHT_PARAMS: if params.has_key(param): fileBase = FileManager(createName(uniqueId, param)) fileBase.addData(trafficLightsMonitor.toString(param,separator)) if not NODE_PARAMS.isdisjoint(params.keys()): # TODO: need development pass exit()
def close(): """ Closes traci client. """ traci.close()