Exemple #1
1
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():
    """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()
Exemple #3
0
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()                                     # 结束仿真
Exemple #4
0
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
Exemple #5
0
def run():
	traci.init(int(PORT))
	step = 0
	while traci.simulation.getMinExpectedNumber() > 0:
		traci.simulationStep()
		step += 1
	traci.close()
Exemple #6
0
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()
Exemple #7
0
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()
Exemple #8
0
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()
Exemple #9
0
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()
Exemple #10
0
    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 
Exemple #11
0
def runSimulationStep(mtraci):
    """
    Runs one SUMO simulation step
    """
    mtraci.acquire()
    traci.simulationStep()
    mtraci.release()
Exemple #12
0
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()
Exemple #13
0
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()
Exemple #14
0
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 _createVehicle(self,vehID, laneID, pos=0):
     routeID = _edge(laneID)
     laneIndex = int( laneID[laneID.rfind('_')+1:] )
     traci.vehicle.add(vehID,routeID,pos=pos,lane=laneIndex)
     traci._sendIntCmd(traci.constants.CMD_SET_VEHICLE_VARIABLE,
                       traci.constants.VAR_SPEEDSETMODE, vehID, 0)
     traci.vehicle.setLaneChangeMode(vehID, 0)
     traci.simulationStep()
Exemple #16
0
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 step(self):
     self.performActions()
     traci.simulationStep()
     if self.gui:
         traci.gui.screenshot("View #0", "../../images/" + str(self.current_step) + ".png")
     self.current_step+=1
     self.makeObservations()
     self.computeRewards()
     self.storeLastActions()
def doStep():
    state.step += 1
    if setting.verbose:
        print("step",state.step)
    traci.simulationStep()
    # adding new vehicles, if any    
    departed = traci.simulation.getSubscriptionResults()[tc.VAR_DEPARTED_VEHICLES_IDS]    
    for v in departed:
        traci.vehicle.subscribe(v,dataFromTraciState)
        vehicleSetParams[v] = getSetParams(v)
        if v=='ego':
            thisv = egov
        else:
            thisv = alterv
        controllers[v] = Controllers.Inter1Constant(v, thisv)
        #getController(v, vehicleSetParams[v])
        if controllers[v] is not None:
            if setting.verbose:
                print("allowing forward and lane crashes for",v)
            traci._sendIntCmd(tc.CMD_SET_VEHICLE_VARIABLE, tc.VAR_SPEEDSETMODE,
                              v, controllers[v].speedMode)
            traci.vehicle.setLaneChangeMode(v, controllers[v].laneChangeMode)
    # gather vehicle states for this step
    vStates = {}
    for vehID, subs in traci.vehicle.getSubscriptionResults().iteritems():        
        tempParams = getFromSubscription(vehID, subs, dataFromTraciState)
        vStates[vehID] = VState( tempParams + vehicleSetParams[vehID] )
    #
    for vehID, vState in vStates.iteritems():
        sensor = sensorToUse(vState, realign=True)
        #
        for otherID, otherState in vStates.iteritems():
            if vehID != otherID:
                #
                # check for collisions
                if collisionCheck.check(vState, otherState):
                    #print "collision! pos",vState.x,vState.y,"step",state.step
                    if state.collisionOccurred <= 0:
                        state.collisionOccurred = state.step*.1
                    break
                #
                # update sensor
                sensor.addObstacle(otherState)
        #
        if setting.verbose:
            for vstat in sensor.getObstacles():
                print(vehID, "detects", vstat.x, vstat.y,"speed",vstat.speed)
        # store this vehicle movement
        output.add([[state.step*.1, vehID, vState.x, vState.y, vState.angle,
                     vState.speed]])
        # use data to decide speed
        if controllers[vehID] is not None:
            controllers[vehID].updateSpeed(vState.speed)
            commandedSpeed = controllers[vehID].nextStep(sensor.getObstacles())
            traci.vehicle.setSpeed(vehID, commandedSpeed)
            if setting.verbose:
                print("setting speed", commandedSpeed)
Exemple #19
0
def run():
    """execute the TraCI control loop"""
    step = 0
    while traci.simulation.getMinExpectedNumber() > 0:
        step += 1
        traci.simulationStep()

    traci.close()
    sys.stdout.flush()
Exemple #20
0
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()
Exemple #21
0
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()
Exemple #22
0
    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
Exemple #23
0
    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()
Exemple #24
0
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()
Exemple #25
0
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()
Exemple #26
0
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
Exemple #27
0
def check(vehID, steps=1):
    for i in range(steps):
        if i > 0:
            traci.simulationStep()
        try:
            print("%s vehicle %s on lane=%s pos=%s speed=%s" % (
                traci.simulation.getCurrentTime() / 1000.0,
                vehID,
                traci.vehicle.getLaneID(vehID),
                traci.vehicle.getLanePosition(vehID),
                traci.vehicle.getSpeed(vehID)))
        except traci.TraCIException:
            pass
    if steps > 1:
        print()
Exemple #28
0
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)
        no = traci.inductionloop.getLastStepVehicleNumber("0")
        if no > 0:
            programPointer = (0 if programPointer == len(PROGRAM)-1 else 3)
        traci.trafficlights.setRedYellowGreenState("0", PROGRAM[programPointer])
        step += 1
    traci.close()
    sys.stdout.flush()
def run(max_step=-1):
    
    """execute the TraCI control loop"""
    traci.init(PORT)
    step = 0
    # we start with phase 2 where EW has green
    #traci.trafficlights.setPhase("0", 0)
    #pdb.set_trace()
    while traci.simulation.getMinExpectedNumber() > 0:
        traci.simulationStep()
        step += 1
        if step > max_step and max_step > 0:
            break
    traci.close()
    sys.stdout.flush()
Exemple #30
0
def doStep():
    step.step += 1
    if setting.verbose:
        print "step", step.step
    traci.simulationStep()
    # adding new vehicles, if any    
    departed = traci.simulation.getSubscriptionResults()[tc.VAR_DEPARTED_VEHICLES_IDS]    
    for v in departed:
        traci.vehicle.subscribe(v,dataFromTraciState)
        vehicleSetParams[v] = getSetParams(v)
        controllers[v] = getController(v, vehicleSetParams[v])
        if controllers[v] is not None: #True
            if setting.verbose:
                print "allowing forward and lane crashes for",v
            traci._sendIntCmd(tc.CMD_SET_VEHICLE_VARIABLE, tc.VAR_SPEEDSETMODE, v, 22)
            traci.vehicle.setLaneChangeMode(v, 85)
            #traci.vehicle.changeLane(v, 0, 10000)
    # gather vehicle states for this step
    vStates = {}
    for vehID, subs in traci.vehicle.getSubscriptionResults().iteritems():        
        tempParams = getFromSubscription(vehID, subs, dataFromTraciState)
        vStates[vehID] = VState( tempParams + vehicleSetParams[vehID] )
    #
    for vehID, vState in vStates.iteritems():
        sensor = sensorToUse(vState)
        #
        for otherID, otherState in vStates.iteritems():
            if vehID != otherID:
                #
                # check for collisions
                if collisionCheck.check(vState, otherState):
                    print "collision! pos",vState.x,vState.y,"step",step.step
                    setting.collisionOccurred = True
                    break
                #
                # update sensor
                sensor.addObstacle(otherState)
        #
        if setting.verbose:
            for vstat in sensor.getObstacles():
                print vehID, "detects", vstat.x, vstat.y,"speed",vstat.speed
        # use data to decide speed
        if controllers[vehID] is not None:
            controllers[vehID].updateSpeed(vState.speed)
            commandedSpeed = controllers[vehID].nextStep(sensor.getObstacles())
            traci.vehicle.setSpeed(vehID, commandedSpeed)
            if setting.verbose:
                print "setting speed", commandedSpeed
Exemple #31
0
        try:
            print("%s vehicle %s on lane=%s pos=%s speed=%s" % (
                traci.simulation.getCurrentTime() / 1000.0,
                vehID,
                traci.vehicle.getLaneID(vehID),
                traci.vehicle.getLanePosition(vehID),
                traci.vehicle.getSpeed(vehID)))
        except traci.TraCIException:
            pass
    if steps > 1:
        print()


vehID = "v0"
traci.init(PORT)
traci.simulationStep()
check(vehID)
try:
    print("%s setStop for %s" %
          (traci.simulation.getCurrentTime() / 1000.0, vehID))
    traci.vehicle.setStop(vehID, "beg", pos=1.0, laneIndex=0, duration=5000)
except traci.TraCIException:
    pass
check(vehID, 10)

traci.simulationStep(21 * 1000)
vehID = "v1"
check(vehID)
try:
    print("%s setStop for %s" %
          (traci.simulation.getCurrentTime() / 1000.0, vehID))
Exemple #32
0
def run():
    print("RUN")

    # All simulation
    step = 0

    # Emissions
    NOx_total = 0
    NOx_control_zone = 0
    NOx_per_vehicle = []

    veh_total_number = 0
    total_kilometers = 0  # In all simulation
    vehicles_in_simulation = []  # Vehicles in each step
    km_per_vehicle = []  # all km per vehicle

    # Window
    # Each window 50 steps
    # Emissions in each window
    NOx_total_window = 0
    NOx_control_zone_window = 0
    # Variables in each window
    veh_total_number_window = 0
    vehicles_in_window = set()
    # All windows
    windows = []

    ## Case 1
    # Threshold:
    threshold = 14  # NOx_total in main_case_window = 28 => 28/2 = 14
    control_area_edges = [
        "gneE19_0", "-gneE19_0", "gneE21_0", "-gneE21_0", "gneE16_0",
        "-gneE16_0", "gneE17_0", "-gneE17_0", "gneE18_0", "-gneE18_0",
        "gneE22_0", "-gneE22_0", "gneE20_0", "-gneE20_0", "gneE15_0",
        "-gneE15_0", "gneE24_0", "-gneE24_0", "gneE25_0", "-gneE25_0",
        "gneE14_0", "-gneE14_0", "gneE23_0", "-gneE23_0"
    ]

    restrictionMode = False
    NOx_control_zone_restriction_mode = 0

    # Vehicles to control area
    vehs_load = traci.simulation.getLoadedIDList()
    for veh_load in vehs_load:
        if (veh_load != "simulation.findRoute"):
            traci.vehicle.setParameter(veh_load, "has.rerouting.device",
                                       "true")
            vClass_last = traci.vehicle.getVehicleClass(veh_load)
            edges_last = traci.vehicle.getRoute(veh_load)
            string_edge = edges_last[len(edges_last) - 1] + "_0"
            if (string_edge
                    in control_area_edges):  # Destination in control area
                traci.vehicle.setType(vehID=veh_load, typeID="authority")
                if (vClass_last == "evehicle"):
                    traci.vehicle.setEmissionClass(veh_load, "zero")

    while traci.simulation.getMinExpectedNumber(
    ) > 0:  # While there are cars (and waiting cars)
        # LAST STEP

        # Vehicles to control area
        vehs_load = traci.simulation.getLoadedIDList()
        for veh_load in vehs_load:
            if (veh_load != "simulation.findRoute"):
                traci.vehicle.setParameter(veh_load, "has.rerouting.device",
                                           "true")
                vClass_last = traci.vehicle.getVehicleClass(veh_load)
                edges_last = traci.vehicle.getRoute(veh_load)
                string_edge = edges_last[len(edges_last) - 1] + "_0"
                if (string_edge
                        in control_area_edges):  # Destination in control area
                    traci.vehicle.setType(vehID=veh_load, typeID="authority")
                    if (vClass_last == "evehicle"):
                        traci.vehicle.setEmissionClass(veh_load, "zero")

        # NEW STEP
        traci.simulationStep()  # Advance one time step: one second
        step += 1

        # Window
        if step != 0 and (
            (step % 50)
                == 0) and vehicles_in_window != []:  # Each window 50 steps

            for w in range(len(windows)):  # Discount NOx of the last window
                if windows[w][0] == step - 50:
                    print(NOx_control_zone_restriction_mode, windows[w][4])
                    NOx_control_zone_restriction_mode -= windows[w][4]
                    if (NOx_control_zone_restriction_mode < 0):
                        NOx_control_zone_restriction_mode = 0
                    print(NOx_control_zone_restriction_mode)
            #print(step)

            # Add variables for the last 50 steps
            windows.append([
                step, vehicles_in_window, veh_total_number_window,
                NOx_total_window, NOx_control_zone_window
            ])
            #windows.append([step, vehicles_in_window, veh_total_number_window, NOx_total_window, NOx_control_zone_restriction_mode])
            print(windows)

            # Reboot all
            NOx_total_window = 0
            NOx_control_zone_window = 0
            veh_total_number_window = 0
            vehicles_in_window = set()

        # MANAGE VEHICLES - All simulation
        id_vehicles_departed = traci.simulation.getDepartedIDList(
        )  # Vehicles in simulation
        id_list_vehicles_departed = list(id_vehicles_departed)

        if (id_list_vehicles_departed):  # if the list is not empty
            # All simulation:
            vehicles_in_simulation.extend(
                id_list_vehicles_departed
            )  # Add vehicles to the simulation list
            km_per_vehicle.extend(
                id_list_vehicles_departed)  # Add vehicles to the km list
            NOx_per_vehicle.extend(
                id_list_vehicles_departed)  # Add vehicles to the NOx list
            # Initialize NOx values for each vehicle:
            for lVeh in range(len(NOx_per_vehicle)):
                vehi = NOx_per_vehicle[lVeh]  # Select vehicle
                #print(len(NOx_per_vehicle[lVeh]))
                if (len(NOx_per_vehicle[lVeh]) != 2):  # If not initialized
                    NOx_per_vehicle[lVeh] = [vehi, 0]  # Initialized
                    #print(NOx_per_vehicle)

            # Per window:
            for veh in vehicles_in_simulation:
                vehicles_in_window.add(
                    veh)  # Add the vehicles in the window list
            veh_total_number_window = len(
                vehicles_in_window
            )  # Add vehicles to the vehicle window counter

            # Taking into account the vehicles that reach their destination:
        id_vehicles_arrived = traci.simulation.getArrivedIDList()
        for veh in id_vehicles_arrived:
            if veh in vehicles_in_simulation:  # If the vehicle has arrived then remove it from the simulation list
                vehicles_in_simulation.remove(veh)
                if veh in vehicles_in_window:
                    vehicles_in_window.remove(veh)

                veh_total_number += 1  # Update Vehicle Total Number in all simulation

        for veh in vehicles_in_simulation:  # For each vehicle
            # Emissions:
            # All simulation
            vehNOxEmission = traci.vehicle.getNOxEmission(
                veh)  # Return the NOx value per vehicle in each step
            NOx_total += vehNOxEmission
            for iNVeh in range(len(NOx_per_vehicle)):
                if veh in NOx_per_vehicle[iNVeh]:
                    NOx_per_vehicle[iNVeh][1] = float(
                        NOx_per_vehicle[iNVeh][1]
                    ) + vehNOxEmission  # Update the NOx value per vehicle

                # Per Window
            NOx_total_window += vehNOxEmission

            # Control Area:
            pos = traci.vehicle.getPosition(vehID=veh)  # (x,y)
            #print(pos, vehNOxEmission, veh)

            if (pos[1] <= 296 and pos[1] >= 3) and (
                    pos[0] >= 3 and pos[0] <= 296
            ):  # x=> 0, y=>1. If the vehicle is in the control area
                # All simulation:
                NOx_control_zone += vehNOxEmission
                #print("SI ", CO2_zona_control)

                # Per window:
                NOx_control_zone_window += vehNOxEmission

                # Control are:
                NOx_control_zone_restriction_mode += vehNOxEmission

            # Route lenght per vehicle

            rouIndex = traci.vehicle.getRouteIndex(veh)
            edges = traci.vehicle.getRoute(veh)

            if rouIndex == (len(edges) - 1):  # Only if is the last edge
                #print(edges, veh, rouIndex, edges[0],'-',edges[rouIndex])
                for iVeh in range(len(km_per_vehicle)):
                    #if veh in km_per_vehicle[iVeh]:
                    if km_per_vehicle[
                            iVeh] == veh:  # km_per_vehicle position selected for this vehicle
                        stage = traci.simulation.findRoute(
                            edges[0], edges[rouIndex])
                        rouLength = stage.length  # Route Length
                        km_per_vehicle[iVeh] = [veh, rouLength]
                        #print(km_per_vehicle)
            #print(veh, NOx_control_zone, NOx_total, pos)

            # Control area - Threshold:
            string_current_edge = edges[rouIndex] + "_0"
            if restrictionMode == True and traci.vehicle.getVehicleClass(
                    veh) != "authority":
                if (string_current_edge in control_area_edges
                    ):  #  current edge in control area
                    vClass_last2 = traci.vehicle.getVehicleClass(veh)
                    traci.vehicle.setType(vehID=veh, typeID="authority")
                    if (vClass_last2 != "passenger"):
                        traci.vehicle.setEmissionClass(veh, "zero")

            if restrictionMode == True:
                inList = False
                for edg in edges:
                    edgStrng = edg + "_0"
                    if edgStrng in control_area_edges:
                        inList = True
                if inList:
                    traci.vehicle.rerouteTraveltime(veh, True)

            print(veh, traci.vehicle.getTypeID(veh))

        #if auxSandra==0 and step != 0 and ((step % 50) == 0):

        if vehicles_in_simulation != [] and restrictionMode == False and NOx_control_zone_restriction_mode > threshold:
            print("CONTROL ZONE ON", NOx_control_zone_restriction_mode)
            #auxSandra = 1
            restrictionMode = True
            print("B")

            for aEd in control_area_edges:
                traci.lane.setDisallowed(
                    laneID=aEd, disallowedClasses=["passenger", "evehicle"])
                print("disa ", traci.lane.getDisallowed(laneID=aEd))
                traci.lane.setAllowed(laneID=aEd, allowedClasses=["authority"])
                print("alo ", traci.lane.getAllowed(laneID=aEd))
            """
            traci.lane.setDisallowed(laneID="gneE22_0", disallowedClasses=["passenger", "evehicle"])
            #traci.lane.setDisallowed(laneID="-gneE22_0", disallowedClasses=["passenger", "evehicle"])"""

        if (restrictionMode == True
                and NOx_control_zone_restriction_mode <= threshold):
            print("CONTROL ZONE OFF")
            restrictionMode = False
            for aEd in control_area_edges:
                traci.lane.setAllowed(
                    laneID=aEd,
                    allowedClasses=["authority", "passenger", "evehicle"])
            for veh in vehicles_in_simulation:
                traci.vehicle.rerouteTraveltime(veh, True)

        print(step, "NOx_control_zone: ", NOx_control_zone,
              ". NOx_control_zone_restriction_mode: ",
              NOx_control_zone_restriction_mode, ". NOx_total: ", NOx_total)

    minutes = round(step / 60, 3)
    for i in range(len(km_per_vehicle)):
        total_kilometers += km_per_vehicle[i][1]

    # Results:

    print(
        "[step,vehicles_in_window, veh_total_number_window, NOx_total_window, NOx_control_zone] :"
    )
    print(windows)
    print("NOx_per_vehicle: ", NOx_per_vehicle)
    print("NOx_total: ", NOx_total, ". NOx_control_zone", NOx_control_zone,
          ". NOx_control_zone_restriction_mode: ",
          NOx_control_zone_restriction_mode)
    print(veh_total_number, " vehicles - ", total_kilometers, " kilometers")
    print("In ", step, "seconds (", minutes, " minutes)")

    # TraCI
    traci.close()
    sys.stdout.flush()
Exemple #33
0
def run():
    """execute the TraCI control loop"""
    step = 0
    count = 0
    tempo = 0
    """ Number of executions"""
    while step < 1000:
        traci.simulationStep()
		
		#Se passou um veiculo. Ou seja um Contador
        if traci.inductionloop.getLastStepVehicleNumber("e1Detector_Faixa_7_0_0") > 0:
            count += 1
            print ('Numero de Veiculos', count)
            x = traci.trafficlight.getNextSwitch("Inter")
            # print (x)

        phase = traci.trafficlight.getPhaseDuration("Inter")
        print ('Duracao do Semaforo',phase)
			
        #Logica do semaforo
        #logic = traci.trafficlight.getCompleteRedYellowGreenDefinition('Inter')
        #print ('Logica do semaforo',logic)
        """[Logic(programID='0', type=0, currentPhaseIndex=2, phases=[Phase(duration=42.0, 
        state='GGGGrrrrGGGGgrrrr', minDur=42.0, maxDur=42.0, next=-1), Phase(duration=3.0, 
        state='yyyyrrrryyyyyrrrr', minDur=3.0, maxDur=3.0, next=-1), Phase(duration=42.0, 
        state='rrrrGGGGrrrrrGGGG', minDur=42.0, maxDur=42.0, next=-1), Phase(duration=3.0, 
        state='rrrryyyyrrrrryyyy', minDur=3.0, maxDur=3.0, next=-1)], subParameter={})]"""
		
        #Variavel Norte/Sul que soma o número de veículos nesse fluxo a cada timestep
        nor_sul=traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_7_0_0") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_7_1_1") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_7_2_2") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_3_0_0") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_3_1_1") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_3_2_2")
		
        #Variavel Leste/Oeste que soma o número de veículos nesse fluxo a cada timestep
        les_oes=traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_0_0") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_1_1") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_2_2") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_1_0_0") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_1_1_1") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_1_2_2")

        print ('Veiculos na via Norte/Sul: ',nor_sul)
        print ('Veiculos na via Leste/Oeste: ',les_oes)		
		
        z =	traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_0_0") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_1_1") + traci.lanearea.getLastStepVehicleNumber("e2Detector_Faixa_5_2_2")
        y = traci.lanearea.getJamLengthVehicle("e2Detector_Faixa_5_0_0") + traci.lanearea.getJamLengthVehicle("e2Detector_Faixa_5_1_1") + traci.lanearea.getJamLengthVehicle("e2Detector_Faixa_5_2_2")
        print ('Veiculos na Area', z)
        print ('Veiculos Parados', y)		
		
		#teste logica simples de mudança de fase (0 - nor sul, 1 - amarelo nor sul, 2 - les oes, 3 - amarelo les oes) - necessárias condições para mudança de fase ainda.
        #if nor_sul>les_oes:
        #    traci.trafficlight.setPhase('Inter',0)	
        #if les_oes>nor_sul:
        #    traci.trafficlight.setPhase('Inter',2)
        Dur_fase = (traci.trafficlight.getNextSwitch("Inter") - traci.simulation.getTime())
        if Dur_fase == 0:
            print('Duracao da fase ainda: ', (traci.trafficlight.getNextSwitch("Inter") - traci.simulation.getTime()))
            print('Tempo Parado Faixa 5: ', (traci.lane.getWaitingTime('Faixa_5_0')+traci.lane.getWaitingTime('Faixa_5_1')+traci.lane.getWaitingTime('Faixa_5_2')))
            tempo += traci.lane.getWaitingTime('Faixa_5_0')+traci.lane.getWaitingTime('Faixa_5_1')+traci.lane.getWaitingTime('Faixa_5_2')+ traci.lane.getWaitingTime('Faixa_1_0')+traci.lane.getWaitingTime('Faixa_1_1')+traci.lane.getWaitingTime('Faixa_1_2') + traci.lane.getWaitingTime('Faixa_3_0')+traci.lane.getWaitingTime('Faixa_3_1')+traci.lane.getWaitingTime('Faixa_3_2')+traci.lane.getWaitingTime('Faixa_7_0')+traci.lane.getWaitingTime('Faixa_7_1')+traci.lane.getWaitingTime('Faixa_7_2')

			
        step += 1
	
    print('Espera (s): ', tempo)
    #traci.junction.subscribeContext("Inter", tc.CMD_GET_VEHICLE_VARIABLE, 42, [tc.VAR_SPEED, tc.VAR_WAITING_TIME])
    #print('Results: ', traci.junction.getContextSubscriptionResults("Inter"))
	
    #scResults = traci.junction.getContextSubscriptionResults("Inter")
    #halting = 0
    #if scResults:
    #    relSpeeds = [d[tc.VAR_SPEED] / d[tc.VAR_ALLOWED_SPEED] for d in scResults.values()]
    #    # compute values corresponding to summary-output
    #    running = len(relSpeeds)
    #    halting = len([1 for d in scResults.values() if d[tc.VAR_SPEED] < 0.1])
    #    meanSpeedRelative = sum(relSpeeds) / running
    #    timeLoss = (1 - meanSpeedRelative) * running * stepLength
    #    print(traci.simulation.getTime(), timeLoss, halting)
   
    traci.close()
    sys.stdout.flush() 
        data_writer="MyPublisher::CameraControllWriter",
        output_buffer_size=10)

    print("DDS connection has established")

    while True:
        print("starting sumo gui")
        sumoBinary = "sumo-gui"
        sumoCmd = [sumoBinary, "-c", "osm.sumocfg"]  #,"--scale",'0.9'
        traci.start(sumoCmd)
        print("sumo gui has been started")

        print("starting the simulation")

        # warming up the simulation (because the simulation start without car)
        traci.simulationStep(1500)
        print("warm up has been finished")

        for i in range(6000):
            #wait 20 ms
            sleep(1 / sim_speed)
            #execute a simulation step
            traci.simulationStep()

            if traci.lanearea.getLastStepVehicleNumber("Camera1") > 0:
                try:
                    dds_streamer_output_buffer.put_nowait({
                        "destination": str(0),
                        "validdata": True
                    })
                except:
Exemple #35
0
    def run(self, i_run):
        """ Runs the simulation on both SUMO and Python layers

        Args:
            i_run (int): run number
        """
        # if there is a run configuration loaded use it to populate
        # parkingspaces in environment otherwise initialize new
        if not self._config.getRunCfg(str(i_run)):
            if self._sim_config.get("verbose"):
                print(
                    "* no run cfg found. Initializing random parking spaces.")
            self._environment.initParkingSpaces(i_run)

        elif self._config.isRunCfgOk(i_run):
            self._environment.loadParkingSpaces(i_run)
        else:
            return

        # if --routefile flag is provided, use the file for routing, otherwise
        # generate (and overwrite if exists) route file (reroute.rou.xml) for
        # this simulation run using the given number of parking search vehicles
        route_file = os.path.join(self._sim_config.get("resourcedir"),
                                  self._sim_config.get("routefile"))
        if not (os.path.isfile(route_file)
                and self._sim_config.get("forceroutefile")):
            generatePsvDemand(self._sim_config.get("vehicles"),
                              self._sim_config.get("resourcedir"),
                              self._sim_config.get("routefile"))

        # start sumo as a subprocess otherwise it wont work (because reasons)
        l_sumoProcess = open_sumo(self._sim_config)

        # execute the TraCI control loop
        traci.init(self._sim_config.get("sumoport"))

        # internal clock variable, start with 0
        step = 0

        # create empty list for parking search vehicles
        l_parkingSearchVehicles = []

        # compute phase 2 routing information (individual and cooperative)
        l_individualRoutes, l_cooperativeRoutes = self.computePhase2Routings()

        self.initPOI()
        self.updatePOIColors()

        # do simulation as long as vehicles are present in the network
        while traci.simulation.getMinExpectedNumber() > 0:
            # tell SUMO to do a simulation step
            traci.simulationStep()
            self.updatePOIColors()
            # increase local time counter
            step += 1
            # every 1000 steps: ensure local time still corresponds to SUMO
            if step != (traci.simulation.getCurrentTime() / 1000):
                print("TIMESTEP ERROR", step, "getCurrentTime",
                      traci.simulation.getCurrentTime())
            # if a new vehicle has departed in SUMO, create the corresponding
            # Python representation and remove the vehicles that have
            # disappeared in SUMO
            dep_list = traci.simulation.getDepartedIDList()
            # TODO: arr list is always empty? Possible bug i.e. we dont set
            # vehicles to arrived or something
            arr_list = traci.simulation.getArrivedIDList()
            l_departedVehicles = (x for x in dep_list if x not in arr_list)

            # TODO: from one debugging session I got the order of
            # parkinSearchVehicles = [veh0, veh1, veh3, veh2, veh4]
            # probably arr_list is not given in order...
            l_parkingSearchVehicles.extend(
                ParkingSearchVehicle(
                    vehID, self._environment, self._config, i_run, step,
                    self._environment._net.getEdge(l_individualRoutes[vehID]
                                                   [-1]).getToNode().getID(),
                    l_cooperativeRoutes[vehID], l_individualRoutes[vehID])
                for vehID in l_departedVehicles)

            # update status of all vehicles
            for psv in (v for v in l_parkingSearchVehicles
                        if v.is_parked() is False):
                psv.update(step)
                env_edges = self._environment._roadNetwork["edges"]
                for edge in env_edges:
                    oppositeEdgeID = env_edges[edge]["oppositeEdgeID"]
                    visitCount = (psv.traversed_route.count(str(edge)) +
                                  psv.traversed_route.count(oppositeEdgeID))
                    plannedCount = (psv.active_route.count(str(edge)) +
                                    psv.active_route.count(oppositeEdgeID))
                    env_edges[edge]["visitCount"][psv.name] = visitCount
                    env_edges[edge]["plannedCount"][psv.name] = plannedCount

                # if last edge, choose next possible edges to continue
                if psv.last_edge():
                    lastSegment = psv.current_route[-1]
                    succEdges = self._environment._net.getEdge(
                        lastSegment).getToNode().getOutgoing()

                    # calculate costs for every edge except opposite direction
                    # of current edge
                    succEdgeCost = {}
                    for edge in succEdges:
                        # consider all successor edges, BUT if no opposite edge
                        # exists, don't try to exclude it.
                        if lastSegment in self._environment._oppositeEdgeID:
                            if len(succEdges) == 1:
                                succEdgeCost[str(
                                    edge.getID())] = self.edgeCost(psv, edge)
                            elif not str(edge.getID(
                            )) == self._environment._oppositeEdgeID[
                                    lastSegment]:
                                succEdgeCost[str(
                                    edge.getID())] = self.edgeCost(psv, edge)
                            # TODO: there is missing else here?
                        else:
                            succEdgeCost[str(edge.getID())] = self.edgeCost(
                                psv, edge)

                    # calculate minima of succEdgeCost
                    minValue = min(succEdgeCost.values())
                    minKeys = [
                        key for key in succEdgeCost
                        if succEdgeCost[key] == minValue
                    ]

                    # choose randomly if costs are equal
                    p3_prob = self._vehicle_config["phase3randomprob"]
                    if random.random() < p3_prob:
                        next_link = random.choice(list(succEdgeCost.keys()))
                    else:
                        next_link = random.choice(minKeys)

                    psv.append_route(next_link)

            # break the while-loop if all SUMO vehicles have parked
            if remaining_vehicles(l_parkingSearchVehicles) == 0:
                if self._sim_config.get("verbose"):
                    print("SUCCESSFULLY PARKED:",
                          parked_vehicles(l_parkingSearchVehicles), "OUT OF",
                          self._sim_config.get("vehicles"))
                break

        sumo_close(l_sumoProcess)

        total_parked = parked_vehicles(l_parkingSearchVehicles)
        searchTimes = [veh.search_time for veh in l_parkingSearchVehicles]
        searchDistances = [
            veh.search_distance for veh in l_parkingSearchVehicles
        ]
        walkingTimes = [veh.walk_time for veh in l_parkingSearchVehicles]
        walkingDistances = [
            veh.walk_distance for veh in l_parkingSearchVehicles
        ]
        searchPhases = [veh.search_phase for veh in l_parkingSearchVehicles]

        # TODO: this should probably just return vehicles and leave processing
        # to other instances
        return (total_parked, searchTimes, walkingTimes, searchDistances,
                walkingDistances, searchPhases)
    def reset(self):
        self.startSUMO()

        self.addEgoVehicle()  # Add the ego car to the scene

        traci.simulationStep()
def start_sumo(sumo_cmd_str):
    traci.start(sumo_cmd_str)
    for i in range(20):
        traci.simulationStep()
Exemple #38
0
def run():
    traci.vehicle.add("add1",
                      "right",
                      "typeA",
                      departLane="1",
                      departPos="250")
    step = 0
    period = 20
    junction_x = traci.junction.getPosition("gneJ1")[0]
    offset = 5
    schedule_A = []
    schedule_B = []
    """execute the TraCI control loop"""
    # we start with phase 2 where EW has green
    # traci.trafficlight.setPhase("0", 2)
    while traci.simulation.getMinExpectedNumber(
    ) > 0:  # The number of vehicles which are in the net plus the ones still waiting to start.
        if traci.simulation.getLoadedNumber() > 0:
            for vehID in traci.simulation.getLoadedIDList():
                # print(vehID)
                traci.vehicle.setLaneChangeMode(vehID, 0b000000000000)
        # for vehID in traci.vehicle.getIDList():
        #     print(vehID + str(traci.vehicle.getPosition(vehID)))
        traci.simulationStep()
        step += 1
        currentTime = traci.simulation.getTime()
        print(currentTime)
        # if len(schedule_A) > 0:
        #     vehID = schedule_A[0][0]
        #     # print('x', traci.vehicle.getPosition(vehID)[0])
        #     if traci.vehicle.getPosition(vehID)[0] >= (junction_x) and schedule_A[0][1] <= currentTime:
        #         print(vehID, traci.vehicle.getPosition(vehID)[0], traci.vehicle.getStops(vehID))
        #         try:
        #             traci.vehicle.resume(vehID)
        #         except traci.exceptions.TraCIException:
        #             pass
        #         del schedule_A[0]
        # if len(schedule_B) > 0:
        #     vehID = schedule_B[0][0]
        #     # print('x', traci.vehicle.getPosition(vehID)[0])
        #     if traci.vehicle.getPosition(vehID)[0] >= (junction_x) and schedule_B[0][1] <= currentTime:
        #         print(vehID, traci.vehicle.getPosition(vehID)[0], traci.vehicle.getStops(vehID))
        #         try:
        #             traci.vehicle.resume(vehID)
        #         except traci.exceptions.TraCIException:
        #             pass
        #         del schedule_B[0]
        # print(traci.vehicle.getSpeed(schedule_A[0][0]))
        # break
        if len(schedule_A) > 0 and schedule_A[0][2] == False:
            d = schedule_A[0][1] - traci.simulation.getTime()
            print('stop', schedule_A[0][0])
            try:
                traci.vehicle.setStop(schedule_A[0][0],
                                      "E1",
                                      pos=junction_x,
                                      laneIndex=1,
                                      duration=d)
                schedule_A[0][2] = True
            except traci.exceptions.TraCIException:
                pass
        if len(schedule_B) > 0 and schedule_B[0][2] == False:
            d = schedule_B[0][1] - traci.simulation.getTime()
            print('stop', schedule_B[0][0])
            try:
                traci.vehicle.setStop(schedule_B[0][0],
                                      "E1",
                                      pos=junction_x,
                                      laneIndex=0,
                                      duration=d)
                schedule_B[0][2] = True
            except traci.exceptions.TraCIException:
                pass

        # if len(schedule_A) > 0:
        for i in schedule_A:
            if i[1] < traci.simulation.getTime():
                schedule_A.remove(i)

        # if len(schedule_B) > 0:
        for i in schedule_B:
            if i[1] < traci.simulation.getTime():
                schedule_B.remove(i)

        if step == period:
            if traci.lanearea.getLastStepVehicleNumber(
                    "dA") > 0 and traci.lanearea.getLastStepVehicleNumber(
                        "dB") > 0:
                a, b, id_a, id_b = compute_earliest_arrival(
                    junction_x, schedule_A, schedule_B)
                order_stack_A, order_stack_B = compute_entering_time(a, b)
                index_A = 1
                index_B = 1
                schedule_A = []
                schedule_B = []
                while len(order_stack_A) > 0:
                    top = order_stack_A.pop()
                    schedule_A.append([id_a[index_A], top[2], False])
                    print(id_a[index_A], 'enter =', top[2])
                    # if index_A == 1:
                    #     d = top[2]-currentTime
                    #     print('stop', id_a[index_A])
                    #     try:
                    #         traci.vehicle.setStop(id_a[1], "E1", pos=junction_x, laneIndex=1, duration=d)
                    #     except traci.exceptions.TraCIException:
                    #         pass
                    index_A += 1
                while len(order_stack_B) > 0:
                    top = order_stack_B.pop()
                    schedule_B.append([id_b[index_B], top[2], False])
                    print(id_b[index_B], 'enter =', top[2])
                    # if index_B == 1:
                    #     d = top[2]-currentTime
                    #     print('stop', id_b[index_B])
                    #     try:
                    #         traci.vehicle.setStop(id_b[1], "E1", pos=junction_x, laneIndex=0, duration=d)
                    #     except traci.exceptions.TraCIException:
                    #         pass
                    index_B += 1

            step = 0
        print(traci.simulation.getTime())
    traci.close()
    sys.stdout.flush()
def run():
    net = sumolib.net.readNet('campusmap.net.xml')
    oldUpcomingLightID = ''
    """execute the TraCI control loop"""
    step = 0

    #while traci.simulation.getMinExpectedNumber() > 0:
    traci.vehicle.add("bike", "bike1",
                      typeID='typeBike')  #Adds bike to simulation
    traci.vehicle.setSpeed("bike", 0)
    while True:
        radius = 0.1
        closestEdge = 0
        #lat, lon, bear, speed = get_GPS_data()
        #debugging
        if step == 1:
            data = (34.058250, -117.82232, 160, 5)
            fileObject = open("gps.pkl", "wb")
            pickle.dump(data, fileObject)
            fileObject.close()

        if step == 5:
            fileObject2 = open("gps.pkl", "r")
            data2 = pickle.load(fileObject2)
            print(data2)
            lat, lon, bear, speed = data2
            # lat = 34.058250
            # lon = -117.82232
            # bear = 160
            # speed= 5

            #bear = (bear+360) % 360	#convert -180 -- +180  to 0 - 360 angles
            x, y = net.convertLonLat2XY(lon, lat)
            #print(x)
            #print(y)

            edges = net.getNeighboringEdges(x, y, 0.6)
            # numedges = len(edges)
            # print(numedges)
            # for elem in edges:
            # print(elem)

            # pick the closest edge (FIX THIS)
            if len(edges) > 0:
                distancesAndEdges = sorted([(dist, edge)
                                            for edge, dist in edges])
                dist, closestEdge = distancesAndEdges[0]
                edge_id = closestEdge.getID()
                # temp = closestEdge.split(' ')
                # temp2 = temp[1].split('"')
                # print(temp2[-1])

        #update bike parameters
            traci.vehicle.moveToXY(
                "bike", edge_id, 0, x, y, angle=bear, keepRoute=1
            )  #(vehID, edge, lane index, x, y, angle, keepRoute 0-2)
            traci.vehicle.setSpeed("bike", speed)  #speed update
        timeRemainingInPhase = 0
        if step == 8:
            lights = traci.vehicle.getNextTLS("bike")
            newUpcomingLightID = str(lights[0][0])
            if newUpcomingLightID != oldUpcomingLightID:
                oldUpcomingLightID = newUpcomingLightID

                upcomingLightPhase = traci.trafficlights.getPhase(
                    newUpcomingLightID)
                nextLightProg = traci.trafficlights.getCompleteRedYellowGreenDefinition(
                    newUpcomingLightID)
                lightProg = str(nextLightProg[0])
                nextSwitch = traci.trafficlights.getNextSwitch(
                    newUpcomingLightID)
                timeRemainingInPhase += nextSwitch - traci.simulation.getCurrentTime(
                )

                p = multiprocessing.Process(target=timeWorker,
                                            args=(
                                                lightProg,
                                                upcomingLightPhase,
                                                timeRemainingInPhase,
                                            ))
                p.start()
        #print(step)

        if False:  #step > 6:
            lights = traci.vehicle.getNextTLS("bike")
            nextLightID = str(lights[0][0])
            nextSwitch = traci.trafficlights.getNextSwitch(nextLightID)

            #duration = traci.trafficlights.getPhaseDuration(nextLightID)
            #print(nextSwitch - traci.simulation.getCurrentTime())

        if False:  #step == 10:
            lat = 34.057634
            lon = -117.822184
            bear = 165
            speed = 2

            #34.057634, -117.822184

            #bear = (bear+360) % 360	#convert -180 -- +180  to 0 - 360 angles
            x, y = net.convertLonLat2XY(lon, lat)
            print(x)
            print(y)

            edges = net.getNeighboringEdges(x, y, 0.6)
            # numedges = len(edges)
            # print(numedges)
            # for elem in edges:
            # print(elem)
            # file = open('testfile.txt','w')

            # file.write(edges)
            # file.close()
            # for dist,edge in edges:
            # print(dist)
            # print('---'.join(edge))
            # pick the closest edge (FIX THIS)
            if len(edges) > 0:
                distancesAndEdges = sorted([(dist, edge)
                                            for edge, dist in edges])
                dist, closestEdge = distancesAndEdges[0]
                edge_id = closestEdge.getID()
                # temp = closestEdge.split(' ')
                # temp2 = temp[1].split('"')
                # print(temp2[-1])

        #update bike parameters
            traci.vehicle.moveToXY(
                "bike", edge_id, 0, x, y, angle=bear, keepRoute=1
            )  #(vehID, edge, lane index, x, y, angle, keepRoute 0-2)
            traci.vehicle.setSpeed("bike", speed)  #speed update
            #calcSpeed = get_best_speed("bike")	#calc best speed
            lights = traci.vehicle.getNextTLS("bike")
            print(lights)
            #parse light id
            for light in lights[0]:
                print(light)
            #getCompleteRedYellowGreenDefinition()

        traci.simulationStep()
        step += 1
    traci.close()
    sys.stdout.flush()
Exemple #40
0
def step():
    s = traci.simulation.getCurrentTime() / 1000
    traci.simulationStep()
    return s
def episode(RB_RLAlgorithm=None, Proudhon=None, episode_num=0):
    ########################
    # 1 inits
    done = False  # are we done with the episode or not
    step = 0  # step number
    errors_arrays = np.zeros(7)    # for error checking capability

    if (Proudhon is None):
        Proudhon = env(vehicles_list)  # vehicles_list = [LH, RB]
        ## -- ##
        Proudhon.reset()
        traci.load(["-c", Sumocfg_DIR, "--tripinfo-output", "tripinfo.xml", "--seed", str(Sumo_random_seed)])
        for vehc in vehicles_list:
            vehc.initialize()
        ## -- ##

    if (RB_RLAlgorithm is None):
        algo_params = q_learning_params  # from Config.py
        RB_RLAlgorithm = RLAlgorithm(Proudhon, algo_params=algo_params, load_q_table=load_q_table,
                                     test_mode_on=vis_update_params['test_mode_on'])  # Algorithm for RB Agent
    ## ######################

    ########################
    # 2 init measurements
    traci.simulationStep()  # After stepping
    Proudhon.get_emer_start_lane()

    # (communication from vehicle):
    getters(vehicles_list)  # measure all values from environment
    # (communication to environment):
    Proudhon.measure_full_state()  # measure all values into our agents
    # (communication to algorithm/agent):
    new_observed_state_for_this_agent = Proudhon.observed_state[0]

    # Chose Action from Feasible Actions:
    feasible_actions_for_current_state = Proudhon.get_feasible_actions(vehicles_list[1])
    chosen_action = RB_RLAlgorithm.pickAction(feasible_actions_for_current_state, new_observed_state_for_this_agent)
    RB_RLAlgorithm.applyAction(chosen_action, vehicles_list[1])  # Request Action on Agent

    episode_reward = 0
    episode_reward_list = []
    ########################

    # 3: MAIN LOOP
    if (episode_num % vis_update_params['every_n_episodes'] == 0):
        print(f'E:{episode_num: <{6}}|S:{0: <{4}} | '
              f'epsilon: {RB_RLAlgorithm.epsilon: <{31}} | '
              f'state: {[str(x)[:5] + " " * max(0, 5 - len(str(x))) for x in Proudhon.observed_state[0]]} |')

    while traci.simulation.getMinExpectedNumber() > 0:

        # 3.1: Store last states
        amb_last_velocity = Proudhon.emer.spd
        last_observed_state = Proudhon.observed_state
        last_observed_state_for_this_agent = last_observed_state[0]
        # ----------------------------------------------------------------#
        # 3.1.1: Store last picked action
        last_picked_action = chosen_action  # check_related_fcn

        # ----------------------------------------------------------------- #
        # 3.2:   M O V E      O N E      S I M U L A T I O N       S T E P
        # ----------------------------------------------------------------- #
        traci.simulationStep()  # actual action applying
        step += 1

        # TODO: Turn this into are_we_ok function
        if (vehicles_list[0].getL() != Proudhon.emer_start_lane):
            raise ValueError(
                f"Ambulance Changed lane from {Proudhon.emer_start_lane} to {vehicles_list[0].getL()} on step {step}. "
                f"\nAmbulance Should not change lane. Quitting.")

        # ----------------------------------------------------------------- #

        # 3.3: measurements and if we are done check
        getters(vehicles_list)
        Proudhon.measure_full_state()
        new_observed_state_for_this_agent = Proudhon.observed_state[0]

        done = Proudhon.are_we_done(full_state=Proudhon.full_state, step_number=step)
        if (step % vis_update_params['every_n_iters'] == 0 and episode_num % vis_update_params[
            'every_n_episodes'] == 0):  # print step info
            print(f'E:{episode_num: <{6}}|S:{step: <{4}} | '
                  f'reward : {str(Proudhon.reward)[:min(5, len(str(Proudhon.reward)))]: <{5}}, '
                  f'lastAction: {chosen_action : <{12}} | '
                  f'cumReward: ' + str(episode_reward)[:6] + ' ' * max(0, 6 - len(str(episode_reward))) +
                  f' | state: {[str(x)[:5] + " " * max(0, 5 - len(str(x))) for x in Proudhon.observed_state[0]]}, '
                  f'actionMethod: {RB_RLAlgorithm.action_chosing_method : <{14}}')

        # 3.3.1: checking if we are ok
        if (enable_checks):
            errors_arrays += are_we_ok(1, True, Proudhon, step, last_picked_action, last_observed_state_for_this_agent,
                      new_observed_state_for_this_agent)

        # 3.4: reward last step's chosen action
        reward = Proudhon.calc_reward(amb_last_velocity, done, step)
        episode_reward += reward  # for history
        episode_reward_list.append(reward)  # for history

        # 3.6: Feasibility check for current_state (for next step)
        feasible_actions_for_current_state = Proudhon.get_feasible_actions(vehicles_list[1])

        # 3.5: update q table using backward reward logic
        RB_RLAlgorithm.update_q_table(chosen_action, reward, new_observed_state_for_this_agent,
                                      last_observed_state_for_this_agent, feasible_actions_for_current_state)

        if (done):  # DO NOT REMOVE THIS (IT BREAKS IF WE ARE DONE)
            if (episode_num % vis_update_params['every_n_episodes'] == 0):
                if ( done == 1):  # TODO: Remove episode_end_reason outsisde the print check -- we might need it elsewehere
                    episode_end_reason = "max steps"
                elif (done == 2):
                    episode_end_reason = "ambulance goal"
                elif (done == 3):  # TODO: #TOFIX: What should be the state here?
                    episode_end_reason = "agent goal"
                else:
                    raise ValueError(f"Episode: {episode_num} done  is True ={done} but reason not known !")

                print(f'E:{episode_num: <{6}}|S:{step: <{4}} | '
                      f'reward : {str(Proudhon.reward)[:min(5, len(str(Proudhon.reward)))]: <{5}}, '
                      f'lastAction: {chosen_action : <{12}} | '
                      f'cumReward: ' + str(episode_reward)[:6] + ' ' * max(0, 6 - len(str(episode_reward))) +
                      f' | state: {[str(x)[:5] + " " * max(0, 5 - len(str(x))) for x in Proudhon.observed_state[0]]}, '
                      f'actionMethod: {RB_RLAlgorithm.action_chosing_method : <{14}}')
                if(enable_checks):


                    print( "non_requested_lane_change , acc_errors , dec_errors , _no_acc_errors , non_requested_speed_change ,change_left_errors , change_right_errors")

                    print(f"Error_happened_during_simulation {errors_arrays}")
            break

            # 3.7: Actually Choose Action from feasible ones (for next step)
        chosen_action = RB_RLAlgorithm.pickAction(feasible_actions_for_current_state, new_observed_state_for_this_agent)

        # 3.8: Request environment to apply new action (Request action on Agent for next step)
        # Action is still not applied here, but on #3.2
        RB_RLAlgorithm.applyAction(chosen_action, vehicles_list[1])

    # Episode end
    sys.stdout.flush()

    # 4: Update Epsilon after episode is done
    old_epsilon = RB_RLAlgorithm.epsilon
    RB_RLAlgorithm.epsilon = RB_RLAlgorithm.min_epsilon + (RB_RLAlgorithm.max_epsilon - RB_RLAlgorithm.min_epsilon) * \
                             np.exp(
                                 -RB_RLAlgorithm.decay_rate * episode_num)  # DONE: Change epsilon to update every episode not every iteration

    if (episode_num % vis_update_params['every_n_episodes'] == 0):
        print(f'\n\nE:{episode_num: <{6}}| END:{step: <{4}} | '
              f'finalCumReward: ' + str(episode_reward)[:6] + ' ' * max(0, 6 - len(str(episode_reward))) + " | "
                                                                                                           f'reason: {episode_end_reason: <{15}} | '
                                                                                                           f'old_eps: {old_epsilon: <{10}}, '
                                                                                                           f'new_eps: {RB_RLAlgorithm.epsilon: <{10}}')
        print('-' * 157)
        print('=' * 157)
        print('\n')

    if (vis_update_params['print_reward_every_episode'] and episode_num % vis_update_params['every_n_episodes'] != 0):
        print(f'E:{episode_num: <{6}}| END:{step: <{4}} | '
              f'finalCumReward: ' + str(episode_reward)[:6] + ' ' * max(0, 6 - len(str(episode_reward))) + " | ")

    return RB_RLAlgorithm, Proudhon, episode_reward, episode_reward_list, errors_arrays
Exemple #42
0
        """判断是否开始某个相位"""
        current_phase_id = traci.trafficlight.getPhase('J1')
        current_phase_duration = traci.trafficlight.getPhaseDuration('J1')
        next_switch = traci.trafficlight.getNextSwitch('J1')
        sim_time = traci.simulation.getTime()

        if next_switch - sim_time == current_phase_duration - 1:  # 开始直行某个相位
            if current_phase_id == 0:
                print('开始:东西直行相位')
                phase_0_extended = 0  # 恢复标志,即允许修改
            elif current_phase_id == 2:
                print('开始:南北直行相位')
            else:
                pass
        """执行仿真"""
        traci.simulationStep()
        step += 1
        """判断是否完成某个相位"""
        current_phase_id = traci.trafficlight.getPhase('J1')
        current_phase_duration = traci.trafficlight.getPhaseDuration('J1')
        next_switch = traci.trafficlight.getNextSwitch('J1')
        sim_time = traci.simulation.getTime()

        if next_switch == sim_time:  # 当前相位直行结束
            if current_phase_id == 0:
                print('结束:东西直行相位')
                if phase_0_extended == 0:
                    traci.trafficlight.setPhaseDuration('J1', 3)  # 加了3秒
                    phase_0_extended = 1  # 修改相位时长标识,修改标志后执行完该相位前,不再修改相位长度
            elif current_phase_id == 2:
                print('结束:南北直行相位')
    def execute(self, action):
        run = Assembler(self.carID)
        self.output = run.getTensor()
        #print(run.getTensor())

        if self.output is None:
            term = True
            return self.getObservation(), term, 0
        else:
            self.co2.append(traci.vehicle.getFuelConsumption(self.carID))

        rew = Reward('ego', run.getTraffic(), self.output,
                     run.getPrioritizedTraffic())

        coll, term = rew.collision_test()
        if term is True:
            self.setCollisionCounter()
            cost = coll
            return self.getObservation(), term, cost

        traci.vehicle.setSpeedMode('ego', 0)
        num_vec = traci.vehicle.getIDList()
        disruption = []
        for i in range(len(num_vec)):
            if num_vec[i] != 'ego':
                if traci.vehicle.getAcceleration(num_vec[i]) < 0:
                    disruption.append(traci.vehicle.getAcceleration(
                        num_vec[i]))

                traci.vehicle.setLaneChangeMode(num_vec[i], 512)

        self.disruptionIntensity.append(sum(disruption))
        ###
        #if i % 2 == 0:
        #traci.vehicle.setSpeedMode(num_vec[i], 23)

        carID = 'ego'
        act = Action(carID)
        if action == 0:
            act.decelerate()
            #print('dec')
        elif action == 1:
            act.accelerate()
            #print('acc')
        #elif action == 2:
        #   print('eme')
        #  act.emergency()
        else:
            act.remain()
            #print('rem')
        #print(traci.vehicle.getSpeed(self.carID))
        #gap, term = rew.emergency_gap_test()
        #wary = rew.wary_before_intersection()

        #win = rew.target()
        #brake = rew.emergency_brake()
        cost = rew.optimum_speed_deviation()  #+ gap #+ brake # #+ wary
        traci.simulationStep()
        #print(self.output)
        self.terminationTime.append(traci.simulation.getCurrentTime())
        #print(traci.simulation.getCurrentTime())

        return self.getObservation(), term, cost
Exemple #44
0
 def simulate_step(self):
     traci.simulationStep()
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
    secondDeadlineGroup_s4219 = 0
    waitTime_s4219 = 0
    activeTraffic_s4219 = []
    site4235_next_phase = 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)

    #RL stuff
    e = 0.0
    rng = str(datetime.datetime.now().time())[6:8]
    random.seed(rng)

    # make this a function
    #db_file = r"C:\Users\Elliot\Documents\GitHub\P4Project\_TiRakauDrive\RLv4.2\QTable.db"
    db_file = os.getcwd() + "\QTable.db"
    #print(db_file)
    conn = None
    try:
        conn = sqlite3.connect(db_file)
    except Error as e:
        print(e)
    cur = conn.cursor()

    db_file2 = os.getcwd() + "\\UCB.db"
    #print(db_file)
    conn2 = None
    try:
        conn2 = sqlite3.connect(db_file2)
    except Error as e:
        print(e)
    cur2 = conn2.cursor()

    totalEps = open("learningUpdates.csv", "r")
    t = 1
    for ep in totalEps:
        t += 1
    totalEps.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))
        detector_delay_s4219_sorted = sorted(detector_delay_s4219)
        secondDeadline_s4219 = detector_delay_s4219.index(
            detector_delay_s4219_sorted[-2])

        for group in lanesForGroups_s4219:
            if earliestDeadline_s4219 in lanesForGroups_s4219[group]:
                earliestDeadlineGroup_s4219 = group
            if secondDeadline_s4219 in lanesForGroups_s4219[group]:
                secondDeadlineGroup_s4219 = group

        currentState = str(next_phase_s4220) + str(
            secondDeadlineGroup_s4219) + str(carsFlowing) + str(
                currentActivePhase) + str(earliestDeadlineGroup_s4219)

        if takeMove:  # when takeMove is true, the move is made on the same timestep
            transitionCounter_s4219 = 0

            stateInDec = (int(currentState[0]) * 9 * 10 * 9 * 7) + (
                int(currentState[1]) * 10 * 9 *
                7) + (int(currentState[2]) * 9 *
                      7) + (int(currentState[3]) * 9) + int(
                          currentState[4],
                          9) + 1  #convert the state to its row no equivalent
            cur.execute("SELECT * FROM States WHERE rowid = " +
                        str(stateInDec))
            nextStateActions = cur.fetchone()

            cur2.execute("SELECT * FROM States WHERE rowid = " +
                         str(stateInDec))
            timesVisited = np.array(cur2.fetchone())
            ntArray = np.sqrt((2 * math.log(t)) / timesVisited)
            #print("qvals = " + str(nextStateActions))
            #print("UCB = " + str(ntArray))
            #print(t)
            nextStateActions += ntArray
            move = np.argmax(nextStateActions)

            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(next_phase_s4220) + str(
            secondDeadlineGroup_s4219) + 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 run():
    """execute the TraCI control loop"""

    traci.init(PORT)
    while traci.simulation.getMinExpectedNumber() > 0:
        #A=np.array([[0,0,0,0],[0,0,0,0],[0,0,0,0]])
        #d={}
        column_names = ['1', '2', '3', '4']
        row_names = ['_2', '_1', '_0']

        matrix = np.reshape((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), (3, 4))
        df = pd.DataFrame(matrix, columns=column_names, index=row_names)
        c_names = ['2', '1', '0']
        r_names = ['RS1', 'RS2', 'RS3', 'RS4']

        matrix1 = np.reshape(
            (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
            (4, 3))
        df1 = pd.DataFrame(matrix1, columns=c_names, index=r_names)

        traci.simulationStep()

        l = traci.lane.getIDList()

        RS1 = l[34:37]
        RS2 = l[37:40]
        RS3 = l[40:43]
        RS4 = l[43:46]
        RS = [RS1, RS2, RS3, RS4]
        for segment in RS:

            for lane in segment:
                veh_list = traci.lane.getLastStepVehicleIDs(lane)
                #print veh_list , lane
                le = rig = stra = 0
                for vehi in veh_list:
                    rou = traci.vehicle.getRoute(vehi)
                    if rou in left:
                        le = le + 1
                    elif rou in right:
                        rig = rig + 1
                    elif rou in straight:
                        stra = stra + 1
                print(le, rig, stra, lane)
                if '_2' in lane:

                    if stra == 0:

                        df['3']['_2'] = 1

                        df['2']['_1'] = 1
                        df['2']['_0'] = 1

                    elif rig == 0:
                        if stra != 0:
                            if le == 0:
                                df['2']['_2'] = 1

                                df['2']['_1'] = 1
                                df['2']['_0'] = 1

                    elif stra != 0:
                        if le != 0:
                            df['4']['_2'] = 1

                            df['4']['_1'] = 1
                            df['4']['_0'] = 1
                elif '_0' in lane:
                    if stra == 0:
                        df['1']['_0'] = 1
        print("******The Drift attribute Matrix is as follows******")
        print(df)
        #.plot()
        for segment in range(0, 4):

            for lane in RS[segment]:

                #finding the number of vehiles
                n = traci.lane.getLastStepVehicleNumber(lane)
                lane_ = lane[4:5]
                # Declare speed, acceleration, distnace and passing rate variables
                speed, accel, distance, ptime, prate = 0.0, 0.0, 0.0, 0.0, 0.0
                #getting the vehicle ids
                veh_list = traci.lane.getLastStepVehicleIDs(lane)
                #get last and second last vehicle ids
                #print("+++++++++++++++++")

                #print("+++++++++++++++++")

                # get the distance of the last vehicle from the intersection
                if not veh_list:
                    print(
                        "*********** veh_list is empty to show distance from junction"
                    )
                else:
                    #print("+++++++++++++++++")
                    distance = traci.vehicle.getDistance(veh_list[-1])
                    print("Distance from junction is " + str(distance))
                    #print ("+++++++++++++++")

                # get speed of last vehicle
                if not veh_list:
                    print("*********** veh_list is empty to show last speed ")
                else:
                    #print(" ?????????????????????????? ")
                    speed = traci.vehicle.getSpeed(veh_list[-1])
                    print("Speed of last vehicle is " + str(speed))
                    #print(" ?????????????????????????? ")
                '''for veh in veh_list:
             var_speed=traci.vehicle.getSpeed(veh)
             print(var_speed)'''

                #get acceleration of second last vehicle
                if not veh_list:
                    print(
                        "*********** veh_list is empty to show second last acceleration "
                    )
                else:
                    # print("###########################")
                    accel = traci.vehicle.getAccel(veh_list[-1])
                    print("Acceleration of second last vehicle is " +
                          str(accel))
                    #print("###########################")
                    #print acc

                #calculate the flow rate using the formula
                if not veh_list:
                    print(
                        "*********** veh_list is empty to show passing rate ")
                else:
                    ptime = (-speed + math.sqrt(
                        (speed * speed) + 2 * accel * distance)) / accel
                    print("Passing time is " + str(ptime))

                    ##########################################enter flow time matrix here
                    #col = ['2', '1', '0']
                    #row = ['RS1','RS2','RS3','RS4']

                    #matrix2 = np.reshape((0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), (4, 3))
                    #df2 = pd.DataFrame(matrix2, columns=col, index=row)

                    if ptime != 0:
                        prate = n / ptime

                    print("Flow rate is " + str(prate))
                    a = (str(lane_))
                    #print a
                    b = ('RS' + str(segment + 1))
                    #print b
                    df1[a][b] = prate
                    #df2[a][b]=ptime
        print("******The Flow rate Matrix is as follows******")
        print(df1)
        #df1.plot()

        X = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
        # 3x4 matrix
        Y = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
        # result is 3x4
        APR = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

        # iterate through rows of X
        for i in range(len(X)):
            # iterate through columns of Y
            for j in range(len(Y[0])):
                # iterate through rows of Y
                for k in range(len(Y)):
                    APR[i][j] += X[i][k] * Y[k][j]

        #for r in APR:
        #  print(r)

        print("******The aggregated flow rate is as follows******")
        for r in APR:
            print(APR)
        print("******The 16 Condition Matrices Printed below******")
        data1 = [[1, 0, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 1, 0]]
        TM1 = pd.DataFrame(data1, dtype=float)
        print(TM1)
        data2 = [[0, 0, 1, 0], [0, 0, 1, 0], [1, 0, 0, 0], [1, 0, 0, 0]]
        TM2 = pd.DataFrame(data2, dtype=float)
        print(TM2)
        data3 = [[0, 1, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
        TM3 = pd.DataFrame(data3, dtype=float)
        print(TM3)
        data4 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 0, 0], [0, 1, 0, 0]]
        TM4 = pd.DataFrame(data4, dtype=float)
        print(TM4)
        data5 = [[0, 0, 0, 1], [0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0]]
        TM5 = pd.DataFrame(data5, dtype=float)
        print(TM5)
        data6 = [[0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0], [1, 0, 0, 0]]
        TM6 = pd.DataFrame(data6, dtype=float)
        print(TM6)
        data7 = [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0]]
        TM7 = pd.DataFrame(data7, dtype=float)
        print(TM7)
        data8 = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]]
        TM8 = pd.DataFrame(data8, dtype=float)
        print(TM8)
        data9 = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]]
        TM9 = pd.DataFrame(data9, dtype=float)
        print(TM9)
        data10 = [[0, 1, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0]]
        TM10 = pd.DataFrame(data10, dtype=float)
        print(TM10)
        data11 = [[0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0], [1, 0, 0, 0]]
        TM11 = pd.DataFrame(data11, dtype=float)
        print(TM11)
        data12 = [[1, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]]
        TM12 = pd.DataFrame(data12, dtype=float)
        print(TM12)
        data13 = [[1, 0, 1, 0], [0, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]
        TM13 = pd.DataFrame(data13, dtype=float)
        print(TM13)
        data14 = [[0, 0, 0, 0], [1, 0, 1, 0], [1, 0, 0, 0], [1, 0, 0, 0]]
        TM14 = pd.DataFrame(data14, dtype=float)
        print(TM14)
        data15 = [[1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 1, 0], [0, 0, 0, 0]]
        TM15 = pd.DataFrame(data15, dtype=float)
        print(TM15)
        data16 = [[1, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [1, 0, 1, 0]]
        TM16 = pd.DataFrame(data16, dtype=float)
        print(TM16)
        #enter code here
        list_T = [
            TM1, TM2, TM3, TM4, TM5, TM6, TM7, TM8, TM9, TM10, TM11, TM12,
            TM13, TM14, TM15, TM16
        ]
        WAPR = []
        STOTAL = []
        for frame in list_T:

            #WAPR.append(np.matmul(APR,frame))
            WAPR.append(APR * frame)

        #print WAPR
        for frame in WAPR:
            STOTAL.append(frame.sum().sum())
        print(
            "******The following list contains the sum of flow rates for each ont f the 16 condition matrices when multiplied with aggregated flow rates******"
        )
        print(STOTAL)

        #plt.rcdefaults()

        #objects = ('TM1', 'TM2', 'TM3', 'TM4' , 'TM5' , 'TM6' , 'TM7' , 'TM8' , 'TM9' , 'TM10' , 'TM11' , 'TM12' , 'TM13' , 'TM14' , 'TM15' , 'TM16')
        #y_pos = np.arange(len(objects))
        #performance = STOTAL

        #plt.bar(y_pos, performance, align='center', alpha=0.5)
        #plt.xticks(y_pos, objects)
        #plt.ylabel('Total Passing Rate')
        #plt.title('Transition Matrix Selection')

        #plt.show()

        max_value = max(STOTAL)

        print(max_value)
        matrix_selection = STOTAL.index(max_value)
        #print matrix_selection
        print("#####The selected Condition matrix#####")
        print(list_T[matrix_selection])
        no_of_veh = traci.vehicle.getIDCount()

        print(no_of_veh)

        tgreen = no_of_veh / max_value

        if tgreen < 15:
            tgreen = 15
        elif tgreen > 150:
            tgreen = 150
        print("The Tgreen value after applying limits is as given below")
        print(tgreen)

        #t=traci.simulation.getCurrentTime()
        #list_of_max.append(max_value)
        #print list_of_max
        #print max(list_of_max)

        #print help(traci.trafficlights)
    # print(traci.trafficlights.getIDList())

    #traci.trafficlights.setRedYellowGreenState('0','rRGGGG')
    #traci.trafficlights.setPhaseDuration('0',tgreen)
    #print traci.trafficlights.getControlledLanes('0')
    #print "plzzz work"
    #print traci.trafficlights.getCompleteRedYellowGreenDefinition('0')
    #print "plzzz work"
    #print traci.trafficlights.getControlledLinks('0')
    #print "plzzz work"
    #print traci.trafficlights.getNextSwitch('0')
    #print "plzzz work"
    #print traci.trafficlights.getPhase('0')
    #print "plzzz work"
    #print traci.trafficlights.getPhaseDuration('0')
    #print "plzzz work"
    #print traci.trafficlights.getProgram('0')
    #print "plzzz work"
    #print traci.trafficlights.getRedYellowGreenState('0')
    #print "plzzz work"
    #traci.trafficlights.setLinkState('0','E10_0', 'E02_0', ':0_0_0','rRgGyYoOu')

#postioning of the dictionary think about it

    sys.stdout.flush()
    traci.close()
Exemple #47
0
def main():

    POIEdges = {    'Sathorn_Thai_1':['L197#1','L197#2'],
                    'Sathorn_Thai_2': ['L30', 'L58#1','L58#2'],
                    'Charoenkrung_1': ['L30032'],
                    'Charoenkrung_2': ['L60', 'L73', 'L10149#1','L10149#2'],
                    'Charoenkrung_3': ['L67'],
                    'Silom_1': ['L138'],
                    'Silom_2': ['L133.25'],
                    'Silom_3': ['L49'],
                    'Mehasak':['L64'],
                    'Surasak': ['L10130', 'L10189'],
                    'Charoen_Rat': ['L40']
                }
    percentage = ['1%', '5%', '10%', '15%', '20%', '25%', '30%', '35%', '40%', '45%', '50%','100%']
    frequency = [1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60]
    randomlist = []
    dirpath = os.getcwd()


    path = dirpath + 'RetrieveOnly100%DATAFROMSUMO_RANDOMSEED(One time)-DATASET-WithoutReplicatedVID/random.csv'
    myfile1 = open(path,'w', newline='')
    writer1 = csv.writer(myfile1)
    heading = ["Output File","random seed"]
    writer1.writerow(heading)
    myfile1.close()


    for outputFile in range(0,100):
        random_number = random.randint(50, 23423)

        #################### this code block is to keep random seed number permanently####################
        random_df = pd.read_csv(path)
        # print(random_df.columns)
        randomlist = random_df['random seed'].values.tolist()



        if len(randomlist) >=0:
            while random_number in randomlist:
                random_number = random.randint(50, 23423)

        #randomlist.append(r)

        myfile = open(path, 'a', newline='')
        writer = csv.writer(myfile)
        with myfile:

            writer.writerow([(outputFile+1),random_number])
            myfile.close()
        ##################################################################################################

        print(randomlist)

        print('Random Seed Number : ', random_number)
        os.mkdir(dirpath + '/'+ str(outputFile+1))

        createFile(POIEdges, percentage, frequency, str(outputFile+1))

        # sumoBinary = sumolib.checkBinary('sumo-gui')
        sumoBinary = sumolib.checkBinary('sumo')
        sumoCmd = [sumoBinary,
                   "--no-internal-links", 'true',
                   "--ignore-junction-blocker", '1',
                   '--start', 'true',
                   '--quit-on-end', 'true',
                   # "--random",'true',
                   "-c", "sathorn_w.sumo.cfg",
                   # '-a',"sathon_wide_tls_20160418_edited.add(upperSurasak)_withoutLaneclose.xml",
                   '-a', "sathon_wide_tls_20160418_edited.add.xml",
                   '--time-to-teleport', "-1",
                   '--seed', str(random_number),
                   '--no-warnings','true'
                   ]

        # sumoCmd = [sumoBinary, "-c", "sathorn_w.sumo.cfg",'-a',"sathon_wide_tls_20160418_edited.add.xml",'--time-to-teleport',"-1"]
        # sumoCmd = [sumoBinary, "-c", "sathorn_w.sumo.cfg"]
        traci.start(sumoCmd)


        step = 21600
        import time
        start_time = time.time()

        while step <= 32400:
            traci.simulationStep()
            for freq in frequency:

                if step % freq == 0:

                    for pcent in percentage:

                        percent = parseFloat(pcent)
                        for road, links in POIEdges.items():
                            temp = []
                            vList = []

                            for link in links:
                                IDs = list(traci.edge.getLastStepVehicleIDs(link))
                                vList.extend(IDs)
                                # print(vList)

                                temp.append(len(list(traci.edge.getLastStepVehicleIDs(link))))

                            ###### This code segment has issues about replicated vehicle IDs##########
                            # random_v = []
                            # g = (r(0, len(vList) - 1) for _ in range(int(len(vList) * (percent))))
                            # for i in g:
                            #     random_v.append(vList[i])
                            # print(percent,random_v)
                            ##########################################################################

                            random_v = random.sample(vList, int(len(vList) * (percent)))
                            # print(percent,random_v)
                            totalSpeed = 0.0
                            for v in random_v:
                                totalSpeed += float(traci.vehicle.getSpeed(v))

                            if (len(random_v)) > 0:
                                meanSpeed = float(totalSpeed / int(len(random_v)))
                            else:
                                meanSpeed = -1.00


                            format_time = datetime.strptime(getTime(float(step)), '%H:%M:%S')
                            time = format_time.time()

                            if meanSpeed * 3.6 <= 5 and meanSpeed >= 0:
                                low_meanSpeed = 1
                            else:
                                low_meanSpeed = 0

                            persistent_low_meanSpeed = 0

                            myfile = open(
                                dirpath + '/' + str(
                                    outputFile + 1) + '/' + road + '_' + str(
                                    freq) + '_' + pcent + '.csv', 'a', newline='')

                            writer = csv.writer(myfile)

                            with myfile:

                                writer.writerow(
                                    [time, step, *temp, int(len(random_v)), meanSpeed, low_meanSpeed,
                                     persistent_low_meanSpeed])
                                myfile.close()

            step += 1
        traci.close()
        import time
        print("--- %s seconds ---" % (time.time() - start_time))
Exemple #48
0
 def workerThread(self):
     try:
         traci.start([
             checkBinary("sumo-gui"), "-c", self.sumocfg,
             "--lateral-resolution", "0.32", "--collision.action", "warn",
             "--step-length",
             str(TS)
         ])
         # steal focus for keyboard input after sumo-gui has loaded
         # self.master.focus_force() # not working on all platforms
         # make sure ego vehicle is loaded
         traci.simulationStep()
         speed = traci.vehicle.getSpeed(self.egoID)
         angle = traci.vehicle.getAngle(self.egoID)
         traci.vehicle.setSpeedMode(self.egoID, 0)
         steerAngle = 0
         x, y = traci.vehicle.getPosition(self.egoID)
         traci.gui.trackVehicle(traci.gui.DEFAULT_VIEW, self.egoID)
         while traci.simulation.getMinExpectedNumber() > 0:
             try:
                 if eventQueue.qsize() == 0:
                     if steerAngle > 0:
                         steerAngle = max(0, steerAngle - 15 * TS)
                     else:
                         steerAngle = min(0, steerAngle + 15 * TS)
                     # print("revert steerAngle=%.2f" % steerAngle)
                 while eventQueue.qsize():
                     try:
                         msg = eventQueue.get(0)
                         if msg == 'up':
                             speed += TS * traci.vehicle.getAccel(
                                 self.egoID)
                         if msg == 'down':
                             speed -= TS * traci.vehicle.getDecel(
                                 self.egoID)
                         if msg == 'left':
                             steerAngle -= TS * 5
                         if msg == 'right':
                             steerAngle += TS * 5
                     except Queue.Empty:
                         pass
                 # move vehicle
                 speed = max(
                     -5, min(speed, traci.vehicle.getMaxSpeed(self.egoID)))
                 steerAngle = min(15, max(-15, steerAngle))
                 angle += steerAngle
                 angle = angle % 360
                 rad = -angle / 180 * math.pi + 0.5 * math.pi
                 x2 = x + math.cos(rad) * TS * speed
                 y2 = y + math.sin(rad) * TS * speed
                 traci.vehicle.setSpeed(self.egoID, speed)
                 traci.vehicle.moveToXY(self.egoID,
                                        "dummy",
                                        -1,
                                        x2,
                                        y2,
                                        angle,
                                        keepRoute=2)
                 x3, y3 = traci.vehicle.getPosition(self.egoID)
                 x, y = x2, y2
                 traci.simulationStep()
                 if VERBOSE:
                     print(
                         "old=%.2f,%.2f new=%.2f,%.2f found=%.2f,%.2f speed=%.2f steer=%.2f angle=%s rad/pi=%.2f cos=%.2f sin=%.2f"
                         % (x, y, x2, y2, x3, y3, speed, steerAngle, angle,
                            rad / math.pi, math.cos(rad), math.sin(rad)))
             except traci.TraCIException:
                 pass
         traci.close()
     except traci.FatalTraCIError:
         pass
     self.running = False
Exemple #49
0
def run():

    global ExtensionGiven
    global LastExtension
    global Extensions
    global RedShortenings
    global TotalExtraGreen
    global RedShortTrafficLight

    #Set simulation variables to 0
    step = 0
    x = 0
    RedShort = 0
    #This is to check if the current red light has already been shortened
    Redshortened = {
        "333": {
            3: 0,
            6: 0
        },
        "334": {
            3: 0,
            6: 0
        },
        "336": {
            0: 0,
        },
        "338": {
            3: 0,
            6: 0
        },
        "405": {
            0: 0,
            3: 0,
            9: 0
        },
        "409": {
            0: 0,
            3: 0,
            9: 0
        },
        "410": {
            3: 0,
            6: 0
        },
        "420": {
            3: 0
        }
    }
    #Gives the minimum phase time. The first key is the intersection number. The second key
    #in the nested dictionary is the phase number that can be shortened and the value tells us
    #what the minimum time for that phase is.
    #The extension key, tells which phase can be extended and by how much it can be extended. The phase
    #that can be extended is always in the first position(index 0) in the list and the extension time is
    #in the second position (index 1)
    MinimumPhaseTime = {
        "333": {
            3: 6,
            6: 6,
            "extension": [0, 30]
        },
        "334": {
            6: 15,
            3: 7,
            "extension": [0, 30]
        },
        "336": {
            0: 0,
            "extension": [3, 20]
        },
        "338": {
            3: 0,
            6: 0,
            "extension": [0, 30]
        },
        "405": {
            0: 15,
            3: 6,
            9: 8,
            "extension": [6, 30]
        },
        "409": {
            0: 12,
            3: 8,
            9: 10,
            "extension": [6, 25]
        },
        "420": {
            3: 12,
            "extension": [0, 30]
        }
    }
    #To check if the sixth phase has been shortened
    vehicleIDsBefore = {
    }  #This stores all the before the intersection detector values from the current step in the simulation
    vehicleIDsAfter = {
    }  #This stores all the after the intersection detector values from the current step in the simulation
    BusPriorityRequested = {
    }  #To check if there is buses in the intersection currently

    ExtraGreen = {
        "334": [
            0, 2, 14, 6
        ]  #[(0= no extra green, 1 = extra green ongoing; 2 extra green allowed to end, 3=extra green shortened),phase when it should continue normaly
        ,
        "409": [0, 8, 10,
                0]  # minimum time of extra green, phase that continues]
    }

    ExtraGreenRequest = {
        "334": [5, 0]  #[phase where extra green is applied, green phase]
        ,
        "409": [11, 6]
    }

    All_intersections = [
        "333", "334", "336", "338", "405", "409", "410", "420"
    ]

    #Create the variables
    for x in All_intersections:
        BusPriorityRequested[x] = []
        ExtensionGiven[x] = 0

    #Intersection 334

    while traci.simulation.getMinExpectedNumber() > 0:
        traci.simulationStep()
        step += 1

        #Retrieve loop data. Sometimes there are detectors for longer distances that needs to be added here.
        #60m: Remove: 334E_B3; add: 420W_B2,420E_B2, 334_B3
        #90m:  Remove: Add 420E_B2; Remove: 334E_B3
        #120m: Remove: 334E_B3,420E_B2, 334E_B3
        #In 150m: Remove:  409W_B2, 420E_B2,420W_B2; add: 334E_B3
        #180m: 409W_B2, 420E_B2,420W_B2; add: 334E_B3
        vehicleIDsBefore["333"] = traci.inductionloop.getLastStepVehicleIDs(
            "333E_B1") + traci.inductionloop.getLastStepVehicleIDs(
                "333E_B2") + traci.inductionloop.getLastStepVehicleIDs(
                    "333E_B3") + traci.inductionloop.getLastStepVehicleIDs(
                        "333W_B1") + traci.inductionloop.getLastStepVehicleIDs(
                            "333W_B2")
        vehicleIDsAfter["333"] = traci.inductionloop.getLastStepVehicleIDs(
            "333E_A1") + traci.inductionloop.getLastStepVehicleIDs(
                "333E_A2") + traci.inductionloop.getLastStepVehicleIDs(
                    "333W_A1") + traci.inductionloop.getLastStepVehicleIDs(
                        "333W_A2")

        vehicleIDsBefore["334"] = traci.inductionloop.getLastStepVehicleIDs(
            "334E_B1") + traci.inductionloop.getLastStepVehicleIDs(
                "334E_B2") + traci.inductionloop.getLastStepVehicleIDs(
                    "334E_B3") + traci.inductionloop.getLastStepVehicleIDs(
                        "334W_B1") + traci.inductionloop.getLastStepVehicleIDs(
                            "334W_B2")
        vehicleIDsAfter["334"] = traci.inductionloop.getLastStepVehicleIDs(
            "334E_A1") + traci.inductionloop.getLastStepVehicleIDs(
                "334E_A2") + traci.inductionloop.getLastStepVehicleIDs(
                    "334W_A1") + traci.inductionloop.getLastStepVehicleIDs(
                        "334W_A2")

        vehicleIDsBefore["336"] = traci.inductionloop.getLastStepVehicleIDs(
            "336E_B1") + traci.inductionloop.getLastStepVehicleIDs("336W_B1")
        vehicleIDsAfter["336"] = traci.inductionloop.getLastStepVehicleIDs(
            "336E_A1") + traci.inductionloop.getLastStepVehicleIDs("336W_A1")

        vehicleIDsBefore["338"] = traci.inductionloop.getLastStepVehicleIDs(
            "338E_B1") + traci.inductionloop.getLastStepVehicleIDs("338W_B1")
        vehicleIDsAfter["338"] = traci.inductionloop.getLastStepVehicleIDs(
            "338E_A1") + traci.inductionloop.getLastStepVehicleIDs("338W_A1")

        vehicleIDsBefore["405"] = traci.inductionloop.getLastStepVehicleIDs(
            "405E_B1") + traci.inductionloop.getLastStepVehicleIDs(
                "405W_B1") + traci.inductionloop.getLastStepVehicleIDs(
                    "405E_B2")
        vehicleIDsAfter["405"] = traci.inductionloop.getLastStepVehicleIDs(
            "405E_A1") + traci.inductionloop.getLastStepVehicleIDs("405W_A1")

        vehicleIDsBefore["409"] = traci.inductionloop.getLastStepVehicleIDs(
            "409E_B1") + traci.inductionloop.getLastStepVehicleIDs(
                "409W_B1"
            )  # + traci.inductionloop.getLastStepVehicleIDs("409W_B2")
        vehicleIDsAfter["409"] = traci.inductionloop.getLastStepVehicleIDs(
            "409E_A1") + traci.inductionloop.getLastStepVehicleIDs(
                "409E_A2") + traci.inductionloop.getLastStepVehicleIDs(
                    "409W_A1") + traci.inductionloop.getLastStepVehicleIDs(
                        "409W_A2")

        vehicleIDsBefore["410"] = traci.inductionloop.getLastStepVehicleIDs(
            "410E_B1") + traci.inductionloop.getLastStepVehicleIDs("410W_B1")
        vehicleIDsAfter["410"] = traci.inductionloop.getLastStepVehicleIDs(
            "410E_A1") + traci.inductionloop.getLastStepVehicleIDs("410W_A1")

        vehicleIDsBefore["420"] = traci.inductionloop.getLastStepVehicleIDs(
            "420E_B1"
        ) + traci.inductionloop.getLastStepVehicleIDs(
            "420W_B1"
        )  #+ traci.inductionloop.getLastStepVehicleIDs("420W_B2") + traci.inductionloop.getLastStepVehicleIDs("420E_B2")
        vehicleIDsAfter["420"] = traci.inductionloop.getLastStepVehicleIDs(
            "420E_A1") + traci.inductionloop.getLastStepVehicleIDs("420W_A1")

        #Check if any buses drove past a detector
        for intersection in vehicleIDsBefore:
            if "bus" in str(vehicleIDsBefore[intersection]):
                for vehicle in vehicleIDsBefore[intersection]:
                    if 'bus' in vehicle:
                        if vehicle not in BusPriorityRequested[intersection]:
                            BusPriorityRequested[intersection].append(vehicle)

        #Extra green
        for intersection in ExtraGreenRequest:
            if ExtraGreen[intersection][0] != 0:
                continue
            elif len(BusPriorityRequested[intersection]) != 0:
                if ExtraGreenRequest[intersection][0] == get_phase(
                        intersection
                ):  #Check if the current phase is the phase before the extra green can be implemented
                    if int(
                            traci.trafficlight.getNextSwitch(intersection) -
                            traci.simulation.getTime()
                    ) == 0:  #Switches to green phase
                        traci.trafficlight.setPhase(
                            intersection, ExtraGreenRequest[intersection][1])
                        ExtraGreen[intersection][0] = 1
                        TotalExtraGreen += 1

        #First Checks if there are any busses in the intersections
        #Checks if the current phase can be shorten and shortens it
        #The index(get_Phase) of the traffic phases can be seen in netedit or directly in the net-file.
        for intersection in MinimumPhaseTime:
            if len(BusPriorityRequested[intersection]
                   ) != 0:  #Checks if there is any buses in the intersection
                for phase in MinimumPhaseTime[intersection]:
                    if phase == get_phase(
                            intersection
                    ) and Redshortened[intersection][
                            phase] == 0 and intersection != "410":  #Checks if the current phase can be shortened and if it has already been shortened
                        RedShorter(intersection,
                                   MinimumPhaseTime[intersection][phase])
                        Redshortened[intersection][phase] = 1
                    elif phase == "extension" and ExtensionGiven[
                            intersection] != 1 and intersection != "410":  #Check if current intersection is allowed to have extension, check if there is an extension on going and check if it is an extra green.
                        if MinimumPhaseTime[intersection][phase][
                                0] == get_phase(intersection):
                            TrafficLightExtension(
                                intersection,
                                MinimumPhaseTime[intersection][phase][1])

        #Intersection 410, special case because the extension depends on what direction the bus is going
        #Did not do for 338 because extending phase 3 would go over the maximum time for turning direction
        if len(BusPriorityRequested["410"]) != 0:
            phase = get_phase("410")
            #Only for busses going east
            if "bus_W" not in str(
                    BusPriorityRequested["410"]):  #Only for busses going east
                #Shorten current phase
                if phase == 6 and Redshortened["410"][6] == 0:
                    RedShorter("410", 6)
                    Redshortened["410"][6] = 1
                #Extension
                elif phase == 0 and ExtensionGiven["410"] == 0:
                    TrafficLightExtension("410", 30)
                elif phase == 3 and ExtensionGiven["410"] == 0:
                    TrafficLightExtension("410", 30)
            else:
                #Shorten current phase, even if there is an extension for phase 3, while a bus is incoming from west,
                #it's not a problem because phase 3 will then be shortened. Happens when bus from both directions
                if phase == 3 and Redshortened["410"][3] == 0:
                    RedShorter("410", 20)
                    Redshortened["410"][3] = 1
                elif phase == 6 and Redshortened["410"][6] == 0:
                    RedShorter("410", 6)
                    Redshortened["410"][6] = 1
                #Extension
                elif phase == 0 and ExtensionGiven["410"] == 0:
                    TrafficLightExtension("410", 30)

        for intersection in vehicleIDsAfter:
            if "bus" in str(vehicleIDsAfter[intersection]):
                for x in vehicleIDsAfter[intersection]:
                    try:
                        BusPriorityRequested[intersection].remove(
                            x
                        )  #Removes bus from priority list, must be try because the bus sometimes triggers the detectors twice
                    except:
                        pass
                    if BusPriorityRequested[
                            intersection] == []:  #Checks that no other buses are in the same intersection at the moment.
                        if intersection in ExtensionGiven:
                            if ExtensionGiven[intersection] == 1:
                                ExtensionGiven[intersection] = 0
                                traci.trafficlight.setPhaseDuration(
                                    intersection, 0)
                        for TrafficPhase in Redshortened[intersection]:
                            if Redshortened[intersection][TrafficPhase] == 1:
                                Redshortened[intersection][TrafficPhase] = 0
                                RedShortenings += 1
                                RedShort = 1
                        if RedShort == 1:
                            RedShortTrafficLight += 1
                            RedShort = 0
                        if intersection in ExtraGreen:
                            if ExtraGreen[intersection][0] == 1:
                                ExtraGreen[intersection][0] = 2

        #This ends the extra green and keeps track of phases
        for intersection in ExtraGreen:
            #Shorten the phase if possible
            if ExtraGreen[intersection][0] == 2:
                RedShorter(intersection, ExtraGreen[intersection][2])
                ExtraGreen[intersection][0] = 3
            #Continue the cycle as it was before the extra green
            if ExtraGreen[intersection][0] == 3:
                if get_phase(intersection) == ExtraGreen[intersection][1]:
                    if int(
                            traci.trafficlight.getNextSwitch(intersection) -
                            traci.simulation.getTime()) == 0:
                        traci.trafficlight.setPhase(
                            intersection, ExtraGreen[intersection][3])
                        ExtraGreen[intersection][0] = 0

    traci.close()
    sys.stdout.flush()
    print("Extra Greens: ", TotalExtraGreen, "\nRedShortenings: ",
          RedShortenings, "\nRedShortInTrafficLight: ", RedShortTrafficLight,
          "\nExtensions: ", Extensions)
Exemple #50
0
def main():
    xmldoc = md.parse('../maps/kt2.net.xml')

    find_junction = xmldoc.getElementsByTagName('junction')
    find_edge = xmldoc.getElementsByTagName('edge')

    edge_num = len(find_edge)
    check = bool
    count = 0

    junc_list, from_node, to_node, edge_list = insertIntoList(
        find_junction, edge_num, find_edge)

    rank = len(junc_list)

    traci.start(sumoCmd)

    step = 0
    end = "e40"
    weight_list = []
    '''while step < 1:
        for i in range(len(edge_list)):
            weight = traci.edge.getTraveltime(edge_list[i])
            weight_list.append(weight)
        step += 1
        traci.simulationStep()'''

    while traci.simulation.getMinExpectedNumber() > 0:
        if step == 70:
            for i in range(len(edge_list)):
                weight = traci.edge.getTraveltime(edge_list[i])
                weight_list.append(weight)

            cost_matrix = createMatrix(junc_list, from_node, to_node,
                                       weight_list, check)

            aco = ACO(5, 100, 0.6, 0.4, 0.3, 10)
            graph = Graph(cost_matrix, rank)
            path, cost = aco.solve(graph)

            route = createRoute(path, junc_list)
            edge = selectEdges(edge_num, find_edge, route, count)

            traci.route.add("optRoute", edge)
            traci.vehicle.add('veh0', "optRoute", typeID='DEFAULT_VEHTYPE')
            traci.vehicle.setColor('veh0', (255, 0, 0))
            # traci.vehicle.setRoute('veh0', edge)

            while traci.simulation.getMinExpectedNumber() > 0:

                if "veh0" in traci.simulation.getArrivedIDList():
                    break
                traci.simulationStep()
            break

        step += 1
        traci.simulationStep()

    traci.close()

    display(cost, route, edge)
Exemple #51
0
def run(env):

    rou_curr0 = "0to" + str(random.choice([1, 5]))
    rou_curr1 = "24to" + str(random.choice([19, 23]))
    rou_curr = [rou_curr0, rou_curr1]
    env.reset(rou_curr0, rou_curr1)
    sumo_step = 1.0
    cr = [0.0, 0.0]
    rl_step = 1.0
    idle = [np.zeros((25, 1)), np.zeros((25, 1))]
    global_idl = np.zeros((25, 1))
    global_v_idl = [[] for _ in range(25)]
    v_idle = [[[] for _ in range(25)], [[] for _ in range(25)]]
    edge = [0, 0]
    prev_node = env.state
    curr_node = [0.0, 0.0]
    temp_n = [0., 0.]
    temp_p = [0, 24]
    ga = []
    gav = []
    ss = []
    while traci.simulation.getMinExpectedNumber() > 0:

        traci.simulationStep()
        idle[0] += 1
        idle[1] += 1
        global_idl += 1
        edge[0] = traci.vehicle.getRoadID('veh0')
        edge[1] = traci.vehicle.getRoadID('veh1')
        #print('veh edge data: ',edge)
        for i, ed in enumerate(edge):
            if ed and (ed[0] != ':'):
                curr_node[i] = ed.split('to')
                curr_node[i] = int(curr_node[i][1])
            elif ed[0] == ':':
                curr_node[i] = ed[1:].split('_')
                curr_node[i] = int(curr_node[i][0])
        env.state = curr_node.copy()
        #print('p_node:',prev_node, 'c_node:',curr_node, 'temp_p: ', temp_p, 'temp_n: ', temp_n)
        # Action decision on new edge
        for i in range(2):
            if prev_node[i] != curr_node[i]:
                temp_p[i] = prev_node[i]
                print(':::::::::::::to next node for', i, '::::::::::::::::')

                print('Veh angle: ', traci.vehicle.getAngle('veh' + str(i)))
                rou_step = []
                glo_reward = env.reward_out(global_idl, prev_node[i], i)[0]
                prev_reward = env.reward_out(idle[i], prev_node[i], i)[0]
                print('reward on prev step: ', prev_reward)
                v_idle[i][int(prev_node[i])].append(prev_reward.copy())
                global_v_idl[int(prev_node[i])].append(glo_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(
                    global_idl, global_v_idl, sumo_step, 25)
                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)
                #print(np.array(v_idle).reshape(5,5))
                gav.append(glo_v_idl)
                ga.append(glo_idl)
                ss.append(sumo_step)
                cr[i] += prev_reward
                #acr=cr/sumo_step
                #print('acr: ', acr)
                idle[i][int(prev_node[i])] = 0
                global_idl[int(prev_node[i])] = 0
                print('agent_', i, 'idleness:\n', idle[i].reshape(5, 5))
                print('global idleness:\n', global_idl.reshape(5, 5))
                # fa=[[True, True, True, True], [True, True, True, True]]
                # bool_f, j=forb_action(temp_p, curr_node, temp_n)
                # if j==0 or j==1:
                #     fa[j]= bool_f
                # print(fa)
                action = CR_patrol(idle[i], curr_node[i], env)
                next_state, reward, action = env.step(action, idle[i], i)
                temp_n[i] = next_state
                print('action: ', action, 'next_state: ', next_state,
                      'reward: ', reward)
                #print('curr_node after step: ',curr_node, env.state)
                rou_new = str(curr_node[i]) + 'to' + str(next_state)
                rou_step.append(rou_curr[i])
                rou_step.append(rou_new)
                print('next_route: ', rou_step)
                traci.vehicle.setRoute(vehID='veh' + str(i), edgeList=rou_step)
                rou_curr[i] = rou_new

        prev_node = curr_node.copy()
        #print('curr route: ',rou_curr)
        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) / 10) * 10
    plt.yticks(np.linspace(0, up, (up / 10) + 1, endpoint=True))
    plt.xlabel('Unit Time')
    plt.ylabel('Idleness')
    plt.title('Performance')
    traci.close()
    plt.show()
    sys.stdout.flush()
Exemple #52
0
    def simulation(self):

        lastNumDict = {}           #记录上一帧各个检测器的状态
        passedNumDict = {}         #记录各个检测器累积的车辆数
        for k,v in config.junction_detectors.items():
            for det in v:
                passedNumDict[det] = 0
        print("passedNumDict = ", passedNumDict)
        while True:
            # for vec_id in traci.vehicle.getIDList():
            #
            #     #订阅车辆信息:坐标,角度,车辆类型,颜色,速度
            #     traci.vehicle.subscribe(str(vec_id),
            #                             (tc.VAR_POSITION, tc.VAR_ANGLE, tc.VAR_TYPE, tc.VAR_COLOR, tc.VAR_SPEED))
            traci.simulationStep()                 #开始切帧


            # loopdata = traci.inductionloop.getInductionLoopStat()
            # lanedata = traci.lane.getLaneStat()
            # cross_data = [loopdata, lanedata]
            # print(cross_data)
            # result = traci.inductionloop.getLastStepVehicleNumber(self.inductionloopid)
            # print("getLastStepVehicleNumber = ", result)

            self.frame+=1                             #步长+1
            if not self.inductionloopid == '##':
                temp = traci.inductionloop.getContextSubscriptionResults(self.inductionloopid)
                #print(temp)
                if self.frame > 1:
                    for k, v in temp.items():
                        currStatus = v[16]
                        preStatus = lastNumDict[k][16]
                        if currStatus - preStatus == 1:
                            passedNumDict[k] += 1

                if self.frame % int(20 / config.steplength) == 0:   ##时长达到1分钟,将数据推出去
                    passedNumDictDup = copy.deepcopy(passedNumDict)
                    A_queuedata.flow_queue.put(passedNumDictDup)         ##将1分钟流量数据,推送到flow队列中,用别的线程进行处理
                    for k, v in config.junction_detectors.items():
                        for det in v:
                            passedNumDict[det] = 0
                    # if not self.lane == '##':
                    #     temp1 = traci.lane.getContextSubscriptionResults(self.lane)
                    #     print(temp1)

                    #print("更新后的passedNumDict1 = ", passedNumDict)
                lastNumDict = temp
                A_queuedata.det_queue.put(temp)

                        #print(currStatus, preStatus)
                        #print(k)
                #print(passedNumDict)
                #print("当来车时:", temp)
                #print(temp)             ##此处打印检测器是否检测到车辆的信息

                # for vec_id in traci.vehicle.getIDList():
                #     dic = traci.vehicle.getSubscriptionResults(vec_id)
                #     print(dic)           ##这里打印的是之前车辆订阅的信息:坐标,角度,车辆类型,颜色,速度
                #     if dic:
                #         #print(dic[66])
                #         x,y = dic[66]
                #         lon, lat = traci.simulation.convertGeo(x,y)
                        #print(lon,lat)


            q_size = A_queuedata.ryg_queue.qsize()
            while q_size > 0:
                print("        5.4、当前ryg_queue.qsize:", q_size)
                tlsID, newryg = A_queuedata.ryg_queue.get()
                traci.trafficlight.setRedYellowGreenState(tlsID, newryg)
                traci.trafficlight.setPhaseDuration(tlsID,999)
                print("        5.5、向sumo仿真系统中设置灯色信息及其持续时间:", (tlsID, newryg))
                q_size -= 1
            logitTime = self.frame * config.steplength
            realTime = time.perf_counter() - self.start
            diff = logitTime - realTime
            if(diff > 0):
                time.sleep(diff)
Exemple #53
0
    def step(self, action):
        # define action:
        # action  |     meaning
        #    0    |    go straight
        #    1    |    break down
        #    2    |    change left
        #    3    |    change right
        #    4    |    do nothing
        traci.vehicle.setSpeedMode(self.AgentId, 0)
        traci.vehicle.setLaneChangeMode(self.AgentId, 0)

        position = traci.vehicle.getSubscriptionResults(
            self.AgentId)[tc.VAR_POSITION]
        if (abs(position[0]) + abs(position[1])) < 999:
            self.maxLaneNumber = 2
        else:
            self.maxLaneNumber = 1

        self.end = 0
        reward = 0
        DistanceTravelled = 0
        if action == 0:
            maxSpeed = 16
            time = (maxSpeed - (traci.vehicle.getSubscriptionResults(
                self.AgentId)[tc.VAR_SPEED])) / self.AgentAccRate
            traci.vehicle.slowDown(self.AgentId, maxSpeed, 100 * time)
        elif action == 1:
            time = ((traci.vehicle.getSubscriptionResults(
                self.AgentId)[tc.VAR_SPEED]) - 0) / self.AgentDecRate
            traci.vehicle.slowDown(self.AgentId, 0, 100 * time)
        elif action == 2:
            laneindex = traci.vehicle.getSubscriptionResults(
                self.AgentId)[tc.VAR_LANE_INDEX]
            if laneindex < self.maxLaneNumber:
                traci.vehicle.changeLane(self.AgentId, laneindex + 1, 100)
            traci.vehicle.setSpeed(
                self.AgentId,
                traci.vehicle.getSubscriptionResults(
                    self.AgentId)[tc.VAR_SPEED])
        elif action == 3:
            laneindex = traci.vehicle.getSubscriptionResults(
                self.AgentId)[tc.VAR_LANE_INDEX]
            if laneindex > self.minLaneNumber:
                traci.vehicle.changeLane(self.AgentId, laneindex - 1, 100)
            traci.vehicle.setSpeed(
                self.AgentId,
                traci.vehicle.getSubscriptionResults(
                    self.AgentId)[tc.VAR_SPEED])
        elif action == 4:
            traci.vehicle.setSpeed(
                self.AgentId,
                traci.vehicle.getSubscriptionResults(
                    self.AgentId)[tc.VAR_SPEED])

        traci.simulationStep()
        self.VehicleIds = traci.vehicle.getIDList()

        if self.AgentId in self.VehicleIds:
            for vehId in self.VehicleIds:
                traci.vehicle.subscribe(vehId,
                                        (tc.VAR_SPEED, tc.VAR_POSITION,
                                         tc.VAR_LANE_INDEX, tc.VAR_DISTANCE))
                traci.vehicle.subscribeLeader(self.AgentId, 50)

            Vehicle_Params = traci.vehicle.getSubscriptionResults(self.AgentId)
            self.AutocarSpeed = Vehicle_Params[tc.VAR_SPEED]
            posAutox = Vehicle_Params[tc.VAR_POSITION]
            if math.sqrt((self.end_x - posAutox[0])**2 +
                         (self.end_y - posAutox[1])**2) < 30:
                self.end = 100

            self.state, breaklight, breakstop, wronglane = self.perception()
            reward = self.cal_reward(self.end, breaklight, breakstop,
                                     wronglane)
        else:
            #self.state = self.perception()
            self.end = 1
            reward = self.cal_reward(is_collision=self.end,
                                     breaklight=0,
                                     breakstop=0,
                                     wronglane=0)
            DistanceTravelled = 0

        return self.state, reward, self.end, DistanceTravelled
Exemple #54
0
def makeMove(state, action):

    traci.trafficlight.setPhase("0", action)

    # agent.simulateFrames(SIM_FRAMES)
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()
    traci.simulationStep()

    newState = getState()

    return newState
def runSimulation():
    '''runSimulation(CarsInSimulation) -> none'''
    while traci.simulation.getMinExpectedNumber() > 0:
        traci.simulationStep()
    traci.close()
Exemple #56
0
 def _sumo_step(self):
     traci.simulationStep()  
     self.get_departed_veh()
     self.get_travel_time()
    def run(self):
        traci.start(
            self.sumoCmd
        )  # Start SUMO. Comment out if running Driver as standalone module.

        # Run set-up script and acquire list of user defined rules and traffic light agents in simulation
        userDefinedRules = self.setUpTuple[0]
        trafficLights = self.setUpTuple[1]
        rule = None
        nextRule = None

        # Assign each traffic light an individual from their agent pool for this simulation run, and a starting rule
        for tl in trafficLights:
            tl.assignIndividual()

            rule = self.applicableUserDefinedRule(
                tl, userDefinedRules)  # Check user-defined rules

            # If no user-defined rules can be applied, get a rule from Agent Pool
            if rule == False:
                validRules = self.getValidRules(tl, tl.getAssignedIndividual())
                rule = tl.getNextRule(validRules[0], validRules[1],
                                      traci.simulation.getTime()
                                      )  # Get a rule from assigned Individual

                # if no valid rule applicable, apply the Do Nothing rule.
                if rule == -1:
                    # print("No valid rule. Do Nothing action applied.")
                    tl.doNothing()  # Update traffic light's Do Nothing counter
                    tl.getAssignedIndividual().updateFitnessPenalty(
                        False, 0)  # Update fitness penalty for individual

                else:
                    # If rule conditions are satisfied, apply its action. Otherwise, do nothing.
                    if not rule.hasDoNothingAction():
                        traci.trafficlight.setPhase(tl.getName(),
                                                    rule.getAction())
            else:
                self.applyUserDefinedRuleAction(
                    tl, traci.trafficlight.getPhaseName(tl.getName()), rule)

            tl.setCurrentRule(rule)  # Set current rule in traffic light

            # Simulation loop
        step = 0
        # Variables for rule rewards
        carsWaitingBefore = {}
        carsWaitingAfter = {}
        while traci.simulation.getMinExpectedNumber(
        ) > 0 and traci.simulation.getTime() < self.maxSimulationTime:
            traci.simulationStep(
            )  # Advance SUMO simulation one step (1 second)

            # Traffic Light agents reevaluate their state every 5 seconds
            if step % 5 == 0:
                # For every traffic light in simulation, select and evaluate new rule from its agent pool
                for tl in trafficLights:
                    carsWaitingBefore = tl.getCarsWaiting()
                    carsWaitingAfter = self.carsWaiting(tl)

                    nextRule = self.applicableUserDefinedRule(
                        tl, userDefinedRules
                    )  # Check if a user-defined rule can be applied

                    # If no user-defined rules can be applied, get a rule from Agent Pool
                    if nextRule == False:
                        validRules = self.getValidRules(
                            tl, tl.getAssignedIndividual())
                        nextRule = tl.getNextRule(
                            validRules[0], validRules[1],
                            traci.simulation.getTime(
                            ))  # Get a rule from assigned Individual

                        # if no valid rule applicable, apply the Do Nothing rule.
                        if nextRule == -1:
                            tl.doNothing(
                            )  # Update traffic light's Do Nothing counter
                            tl.getAssignedIndividual().updateFitnessPenalty(
                                False,
                                False)  # Update fitness penalty for individual

                            # If next rule is not a user-defined rule, update the weight of the last applied rule
                        else:
                            oldRule = tl.getCurrentRule()

                            # If applied rule isn't user-defined, update its weight
                            if oldRule not in userDefinedRules:
                                if oldRule != -1:
                                    ruleWeightBefore = oldRule.getWeight(
                                    )  # Used to calculate fitness penalty to individual
                                    oldRule.updateWeight(
                                        ReinforcementLearner.updatedWeight(
                                            oldRule, nextRule,
                                            self.getThroughputRatio(
                                                self.getThroughput(
                                                    tl, carsWaitingBefore,
                                                    carsWaitingAfter),
                                                len(carsWaitingBefore)),
                                            self.getWaitTimeReducedRatio(
                                                self.getThroughputWaitingTime(
                                                    tl, carsWaitingBefore,
                                                    carsWaitingAfter),
                                                self.getTotalWaitingTime(
                                                    carsWaitingBefore)),
                                            len(carsWaitingAfter) -
                                            len(carsWaitingBefore)))
                                    tl.getAssignedIndividual(
                                    ).updateFitnessPenalty(
                                        True,
                                        oldRule.getWeight() > ruleWeightBefore)
                                    print("Old weight was", ruleWeightBefore,
                                          "and new weight is",
                                          oldRule.getWeight())
                                    # Apply the next rule; if action is -1 then action is do nothing
                                if not nextRule.hasDoNothingAction():
                                    # print('Next rule action is', nextRule.getAction())
                                    traci.trafficlight.setPhase(
                                        tl.getName(), nextRule.getAction())

                                if nextRule.getType() == 0:
                                    print(
                                        "Applying TL action from RS! Action is",
                                        nextRule.getAction(), "\n\n")
                                else:
                                    print(
                                        "Applying TL action from RSint! Action is",
                                        nextRule.getAction(), "\n\n")

                    else:
                        self.applyUserDefinedRuleAction(
                            tl, traci.trafficlight.getPhaseName(tl.getName()),
                            nextRule)
                        # # print("Applying action of", nextRule.getConditions())

                    tl.setCurrentRule(
                        nextRule
                    )  # Update the currently applied rule in the traffic light
                    tl.updateCarsWaiting(
                        carsWaitingAfter
                    )  # Set the number of cars waiting count within the TL itself

            step += 1  # Increment step in line with simulator

            # Update the fitnesses of the individuals involved in the simulation based on their fitnesses
        simRunTime = traci.simulation.getTime()
        print("***SIMULATION TIME:", simRunTime, "\n\n")
        for tl in trafficLights:
            # # print(tl.getName(), "has these communicated intentions:", tl.getCommunicatedIntentions())
            i = tl.getAssignedIndividual()
            i.updateLastRunTime(simRunTime)
            print("Individual", i, "has a last runtime of", i.getLastRunTime())
            i.updateFitness(
                EvolutionaryLearner.rFit(i, simRunTime,
                                         i.getAggregateVehicleWaitTime()))

        traci.close()  # End simulation

        return self.setUpTuple[
            2]  # Returns all the agent pools to the main module
def learnDiscretization(daysToTrain):
    # """							SIMULATION 					"""
    dynamic = 0
    day = 0
    totalDays = daysToTrain

    # learning rates and discount factors
    gamma = 0.95
    # epsilons = [1, 0.99, 0.97, 0.93, 0.91, 0.89, 0.80, 0.75, 0.70, 0.6, 0.5, 0.45, 0.3, 0.20, 0.18, 0.17, 0.15, 0.10, 0.08, 0.05, 0.04, 0.02, 0.01, 0.01]

    # print 'len(epsilons) = ', len(epsilons)

    for day in range(totalDays):  # range(len(epsilons)+1): #len(alphas)

        # generate the random route schedule for the day
        arrivalRateGen.writeRoutes(day + 1)

        sumoProcess = subprocess.Popen(['sumo-gui.exe', "-c", "palm.sumocfg", \
         "--remote-port", str(PORT)], stdout=sys.stdout, stderr=sys.stderr)

        # sumoProcess = subprocess.Popen(['sumo.exe', "-c", "palm.sumocfg", "--fcd-output", \
        # 	"out.fcd.xml", "--tripinfo-output", "out.trip.xml", "--summary", "out.summary.xml", "--queue-output", "out.queue.xml", "--remote-port", str(PORT)], stdout=sys.stdout, stderr=sys.stderr)

        traci.init(PORT)

        dfObjVals = pd.DataFrame()
        dfQueueTracker = pd.DataFrame()
        dfWaitingTracker = pd.DataFrame()

        action = 0  # number of seconds over minimum that we decided to take in 5 buckets (0,1,2,4)
        lastAction = 0
        hod = 0
        currSod = 0
        epsilon = 1  # TODO - change epsilon dynamically?
        currPhaseID = 0
        secsThisPhase = 0

        while currSod < secondsInDay:

            if currPhaseID == int(traci.trafficlights.getPhase(
                    SL)) and currSod != 0:  # if phase HAS NOT changed
                secsThisPhase += 1  # increase the seconds in the currentPhase
            else:  # IF THE PHASE HAS CHANGED
                secsThisPhase = 0
                currPhaseID = int(traci.trafficlights.getPhase(SL))

            # STORE INFORMATION TO DETERMINE IF ITS TIME TO MAKE A DECISION

            # ARRAY TO MAP STATE:
            # (2) Hour of day (24)
            # (1) Light phase for decision (4) getPhase
            # (2) Num stopped cars X 4 getLastStepHaltingNumber
            # (3) Num vehicles in lane getLastStepVehicleNumber
            # (4) Cum waiting time x 4 getWaitingTime
            # (5) Last step mean speed X 4 getLastStepMeanSpeed

            if currPhaseID % 2 == 0 and secsThisPhase == 0:  # only collecting data when we come to the end of a yellow phase

                #============  HOD
                if hod != currSod / secondsInHour:
                    hod = int(currSod / secondsInHour)
                    print 'observation day = ', day
                    print 'hod = ', hod
                    # print 'len(stateData[h][1]) = ', len(stateData[hod][1])
                    # print 'int(sum(np.std(stateData[h][a], axis = 0))) = ', int(sum(np.std(stateData[hod][1], axis = 0)))
                    # print 'len(stateData[h][3]) = ', len(stateData[hod][3])
                    # print 'int(sum(np.std(stateData[h][a], axis = 0))) = ', int(sum(np.std(stateData[hod][3], axis = 0)))
                    # print 'len(stateData[h][5]) = ', len(stateData[hod][5])
                    # print 'int(sum(np.std(stateData[h][a], axis = 0))) = ', int(sum(np.std(stateData[hod][5], axis = 0)))
                    # print 'len(stateData[h][7]) = ', len(stateData[hod][7])
                    # print 'int(sum(np.std(stateData[h][a], axis = 0))) = ', int(sum(np.std(stateData[hod][7], axis = 0)))

                #============ currPhaseID

                #================= count halted vehicles (4 elements)

                for lane in listLanes:
                    laneQueueTracker[
                        lane] = traci.lane.getLastStepHaltingNumber(str(lane))
                    # laneQueueTracker[lane] = traci.lane.getLastStepVehicleNumber(str(lane))

                for edge in queueTracker.keys():
                    queueTracker[edge] = laneQueueTracker[
                        str(edge) + '_' +
                        str(0)] + laneQueueTracker[str(edge) + '_' + str(1)]
                    # inherently, we assume balancing here
                    # TODO - later chage this to only track

                # df = pd.DataFrame([[currSod,  queueTracker['8949170'], queueTracker['-164126513'], queueTracker['52016249'], queueTracker['-164126511']]])
                # dfQueueTracker = dfQueueTracker.append(df, ignore_index = True)

                # ================ count vehicles in lane

                for lane in listLanes:
                    laneNumVehiclesTracker[
                        lane] = traci.lane.getLastStepVehicleNumber(str(lane))

                for edge in numVehiclesTracker.keys():
                    numVehiclesTracker[edge] = laneNumVehiclesTracker[
                        str(edge) + '_' +
                        str(0)] + laneNumVehiclesTracker[str(edge) + '_' +
                                                         str(1)]

                # ================ cum waiting time in minutes

                for lane in listLanes:
                    laneWaitingTracker[lane] = traci.lane.getWaitingTime(
                        str(lane)) / 60
                for edge in waitingTracker.keys():
                    waitingTracker[edge] = laneWaitingTracker[
                        str(edge) + '_' +
                        str(0)] + laneWaitingTracker[str(edge) + '_' + str(1)]

                # df = pd.DataFrame([[currSod,  waitingTracker['8949170'], waitingTracker['-164126513'], waitingTracker['52016249'], waitingTracker['-164126511']]])
                # dfWaitingTracker = dfWaitingTracker.append(df, ignore_index = True)

                # ================ mean speed

                # for lane in listLanes:
                # 	laneMeanSpeedTracker[lane] = traci.lane.getLastStepMeanSpeed(str(lane))
                # for edge in meanSpeedTracker.keys():
                # 	meanSpeedTracker[edge] = (laneMeanSpeedTracker[str(edge) + '_' + str(0)] + laneMeanSpeedTracker[str(edge) + '_' + str(1)])/2

                # ============== CREATE A NEW ENTRY FOR OUR STATE TRACKER

                stateDataEntry = []
                for edge in listEdges:
                    stateDataEntry.append(queueTracker[edge])
                for edge in listEdges:
                    stateDataEntry.append(numVehiclesTracker[edge])
                for edge in listEdges:
                    stateDataEntry.append(waitingTracker[edge])
                # for edge in listEdges:
                # 	stateDataEntry.append(meanSpeedTracker[edge])

                if len(stateData[hod][currPhaseID]) == 0:
                    stateData[hod][currPhaseID] = np.array(stateDataEntry)
                else:
                    stateData[hod][currPhaseID] = np.vstack(
                        [stateData[hod][currPhaseID], stateDataEntry])

                # TRACK OBJECTIVE FUNCTION

                currObjValue = computeObjValue(queueTracker, waitingTracker)
                df = pd.DataFrame([[
                    currSod, currObjValue
                ]])  # todo - fix so plot shows the second of the day
                dfObjVals = dfObjVals.append(df, ignore_index=True)

                # print 'currPhaseID = ', currPhaseID
                # print 'secsThisPhase = ', secsThisPhase
                # print 'currSod = ', currSod
                # print 'hod = ', hod
                # print 'queueTracker = ', queueTracker
                # print 'waitingTracker = ', waitingTracker

            # # we can make a decision
            # if currPhaseID%2 == 0 and secsThisPhase%secsPerInterval == 0 and secsThisPhase >=4: # and currSod > 20000:
            # 	# print 'currPhaseID = ', currPhaseID
            # 	# print 'secsThisPhase = ', secsThisPhase

            # 	# arrayObjVals = np.append(arrayObjVals, currObjValue)
            # 	# arrayQueueSizes = np.append(arrayQueueSizes, queueTracker.values())
            # 	# if day > 0:
            # 	# 	dynamic = 1
            # 	if dynamic:
            # 	# CONTROL ACTION
            # 		phaseNum = traci.trafficlights.getPhase(SL)
            # 		currState = assignStateNum(phaseNum, queueTracker, waitingTracker, queueBuckets, waitingBuckets)

            # # reward = objective value; we want it to be as close to zero as possible (will always be negative)
            # reward = currObjValue - lastObjValue
            # lastObjValue = currObjValue

            # updateQValues(int(lastState), int(lastAction), int(currState), reward, alpha) # alpha controls whether we explore or exploit
            # updateQProbs(int(lastState), int(lastAction), epsilon)

            # # pick action
            # unigen = random.random()
            # if QProbs[currState,0] < unigen or secsThisPhase == 0:
            # 	action = 0 # stay in this phase
            # else:
            # 	action = 1 # change phases; transition to the next yellow phase immediately
            # # TODO - totally change the actions to be the number of seconds (# of 4-second time chunks we are choosing for the cycle)

            # 	traci.trafficlights.setPhase(SL, (int(currPhaseID) + 1)%8)
            # 	#TODO - tell the light how long to run for; not just whether or not to change

            # 	# print 'int(traci.trafficlights.getPhase(SL)) = ', int(traci.trafficlights.getPhase(SL))
            # df = pd.DataFrame([[currSod, secsThisPhase, currPhaseID, currState, lastState, action, currObjValue, lastObjValue, reward]]) # todo - fix so plot shows the second of the day
            # dfActions = dfActions.append(df, ignore_index=True)

            # lastState = currState
            # lastAction = action
            currSod += 1
            # print traci.vehicle.getIDList()
            traci.simulationStep()
        # print stateData
        # totalSize = 0
        # for i in actionPhases:
        # 	totalSize += len(stateData[0][i])
        # print 'totalSize = ', totalSize

        # for i in actionPhases:
        # 	print 'np.std(stateData[0][i], axis = 0) = ', np.std(stateData[0][i], axis = 0)
        # 	print 'sumvariability = ', sum(np.std(stateData[0][i], axis = 0))
        # 	print 'np.std(stateData[0][i], axis = 0) = ', np.std(stateData[0][i], axis = 0)
        # 	print 'sumstd = ', sum(np.std(stateData[0][i], axis = 0))
        # 	totalSize += len(stateData[0][i])

        traci.close(
        )  # TODO - fix; need to figure out how to plot multiple with different x-axes

        print 'dfObjVals = ', dfObjVals

        dfMean = dfObjVals.mean(axis=0)
        meanObjVal = dfMean[1]

        dfMedian = dfObjVals.median(axis=0)
        medianObjVal = dfMedian[1]
        # vMedian = dfMedian[1]

        dfMin = dfObjVals.min(axis=0)
        minObjVal = dfMin[1]

        listMeanObjVals.append(meanObjVal)
        listMedianObjVals.append(medianObjVal)
        listMinObjVals.append(minObjVal)

    for h in range(hoursInDay):  #TODo - change to hoursInDay
        for a in actionPhases:
            numClustersTracker[h][a] = int(sum(np.std(stateData[h][a],
                                                      axis=0)))  #
            print 'h = ', h
            print 'a = ', a
            print 'numClustersTracker[h][a] = ', numClustersTracker[h][a]

            dictClusterObjects[h][a] = KMeans(
                n_clusters=numClustersTracker[h][a])
            dictClusterObjects[h][a].fit(stateData[h][a])
            # result = dictClusterObjects[0][a].predict(stateData[0][a])
            # print 'result = ', result
            # print 'max(result) = ', max(result)

    # print 'hod = ', hod
    # print 'dictClusterObjects = ', dictClusterObjects
    print 'numClustersTracker = ', numClustersTracker
    totalClusters = 0
    for h in range(hoursInDay):  #TODO - change to hoursInDay
        for a in actionPhases:
            totalClusters += numClustersTracker[h][a]

    print 'totalClusters = ', totalClusters

    stateCounter = 0
    for h in range(hoursInDay):  #TODO - change to hoursInDay
        mapDiscreteStates[h] = {}
        for a in actionPhases:
            mapDiscreteStates[h][a] = {}
            for c in range(numClustersTracker[h][a]):
                mapDiscreteStates[h][a][c] = stateCounter
                stateCounter += 1
    print 'stateCounter = ', stateCounter
Exemple #59
0
def runQLearning():
    stateVect = [[]]
    policyPi = []
    for i in range(0, 80, 1):
        policyPi.insert(i, random.randint(0, 5))
    QSA = np.random.rand(81, 6)
    # Returns = [[0]*6 for x in range(81)]
    currTLS = []
    Actions = [20, 25, 30, 20, 25, 30]
    # Actions = [30, 60, 120, 30, 60, 120]
    totTime = []
    avgTime = []
    numVehs = []
    avgNumVehs = []
    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()
        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])
        currAction = policyPi[index]
        stateVect[step][5] = index
        stateVect[step][6] = currAction
        stateVect[step][7] = reward
        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])

        if step > 0 and step % 850 == 0:
            episodeStates = [[]]
            index = 0
            A = 0
            R = 0
            for t in range(0, 849, 1):
                episodeStates.insert(t, stateVect[step - 849 + t])
            for t in range(0, 848, 1):
                if random.uniform(0, 1) < EPSILON:
                    policyPi[index] = random.randint(0, 5)
                else:
                    policyPi[index] = np.argmax(QSA[index])

                S = episodeStates[t]
                R = S[7]
                A = S[6]
                index = S[5]

                Sprime = episodeStates[t + 1]
                # print(Sprime)
                indexPrime = Sprime[5]

                QSA[index][A] = QSA[index][A] + ALPHA * (
                    R + (GAMMA * max(QSA[indexPrime])) - QSA[index][A])

        step += 1
        curWaittime = traci.edge.getWaitingTime(
            'nc') + traci.edge.getWaitingTime(
                'ec') + traci.edge.getWaitingTime(
                    'sc') + traci.edge.getWaitingTime('wc')
        totWaittimeSoFar = totWaittimeSoFar + curWaittime
        totTime.append(totWaittimeSoFar)
        avgTime.append(totWaittimeSoFar / step)

        currVehsHere = traci.simulation.getArrivedNumber()
        totVehsSoFar = totVehsSoFar + currVehsHere
        numVehs.append(totVehsSoFar)
        avgNumVehs.append(totVehsSoFar / (step))
    traci.close()
    sys.stdout.flush()
    return step, totTime, avgTime, numVehs, avgNumVehs
Exemple #60
0
def dqnlearn(num_timesteps, num_simulations, *args, **kwargs):
    yellowTime = 3  # I have Warning: Vehicle '3.527' performs emergency stop at the end of lane for 3
    redTime = 0
    itBetweenDecision = int(
        (yellowTime + redTime + 3) / stepLength
    )  # each itteration is stepLength s, I need at least 3s of green time

    lightList = traci.trafficlight.getIDList()
    #obsLen = 2*4*3*2 # max of in and out lanes, 4 directions, 3 lanes per edges, 2 information per lane

    alg = []
    lanes = []
    lanesEdge = []
    OutLanes = []
    OutLanesEdge = []
    rewardsLength = 0
    for i, tl in enumerate(lightList):
        phases = traci.trafficlight.getCompleteRedYellowGreenDefinition(
            tl)[0].getPhases()
        num_phases = len(
            phases
        ) // 2  # The tl have 4 or 6 phases in their base program, so so it can be 2 or 3
        ph = []
        for phase in phases[::2]:  # skip yellow
            ph.append(phase._phaseDef)
        print('phase', ph)

        outlane = set()
        #outlanedic = {}
        for link in traci.trafficlight.getControlledLinks(tl):
            #print('link', link[0][0]) # incoming lane
            #print('link', link[0][1]) # outgoing lane
            outlane.add(link[0][1])  # outgoing lane
            #print('link', link[0][2])  # junction lane
            #print()
            #outlanedic[link[0][0]] = link[0][1] # I want to ensure it's the straight path, not the left or right turning one though, so I will use another way
        OutLanes.append(outlane)

        # get number of edges and number of lanes per edges
        # they are sorted by their order in the phase
        # To be coherent: obs must be sorted in the same order as hidden and
        # output. It works for obs since lanes are sorted in the same order as
        # phase. Now, we need to ensure it works also for hidden state (since it is sent)
        lanes.append(traci.trafficlight.getControlledLanes(
            tl))  # also needed to get neighbors
        #print('lanes', lanes[-1])
        lanesEdge.append([])
        edgeList = [None]
        oldlane = None
        OutLanesEdge.append([])
        for lane in lanes[-1]:  # 1st dim: tl, 2nd dim: one for each lane
            if lane == oldlane:
                continue
            oldlane = lane
            if traci.lane.getEdgeID(lane) == edgeList[-1]:
                lanesEdge[-1][-1].append(lane)
                #OutLanesEdge[-1].append(outlanedic[lane])
                #print(lane, outlanedic[lane])
            else:
                lanesEdge[-1].append([lane])
                #OutLanesEdge[-1].append([outlanedic[lane]])
                #print('new edge',lane, outlanedic[lane])
                edgeList.append(traci.lane.getEdgeID(lane))
        for iedge, edge in enumerate(
                edgeList[1:]
        ):  # get the 2 lanes that are before the junction where the road goes from 2 to 3 lanes (will need to be change for different road network)
            for ilane in range(2):
                lanesEdge[-1][iedge].append(
                    edge[:-1] + '_' +
                    str(ilane))  # I wrote that for this network. Not general

        edgeDic = {}
        for lane in outlane:  # it's a set so no repeat even though they aren't in the same order
            edge = traci.lane.getEdgeID(lane)
            if edge in edgeDic:
                OutLanesEdge[-1][edgeDic[edge]].append(lane)
                #print('old edge',lane, edgeDic[edge], edge)
            else:
                OutLanesEdge[-1].append([lane])
                edgeDic[edge] = len(OutLanesEdge[-1]) - 1
                #print('new edge',lane, edgeDic[edge], edge)

        print(lanesEdge[-1])
        print(OutLanesEdge[-1])
        #return None # stop here to look at the lanes
        obs, rw = getobs(
            tl, num_phases, lanesEdge[-1]
        )  #, OutLanesEdge[-1]) # first dim of lanesEdge is tl, 2nd dim is edge (direction), value is lane (3rd dim)
        alg.append(
            dqn.QLearner(num_phases=num_phases,
                         observation_shape=len(obs),
                         scope=str(i),
                         phases=ph,
                         timeBetweenDecision=itBetweenDecision * stepLength,
                         *args,
                         **kwargs))
        alg[i].last_obs = obs * itBetweenDecision  # because we will divide by that afterwards

    # neighTL = [] # I would like to know for sure which one is left and which one is right. Maybe use lanesEdge
    # # Comparing lanes in common doesn't work, because only incoming lanes are in the list
    # for i, tl in enumerate(lightList):
    # neigh = np.array([-1,-1]) # only 2 neighbors in this map
    # for j, tl2 in enumerate(lightList):
    # if i != j:


# #                if i == 0 and j == 4:
# #                    print(lanes[i])
# #                    print(OutLanes[j])
# #                    print(lanes[i][:len(lanes[i])//2])
# #                    print(lanes[i][len(lanes[i])//2:])
# #                    print(set(lanes[i][:len(lanes[i])//2]).intersection(OutLanes[j]))
# #                    print(set(lanes[i][len(lanes[i])//2:]).intersection(OutLanes[j]))
# #                    print()
# if len(set(lanes[i][:len(lanes[i])//2]).intersection(OutLanes[j]))>0:
# neigh[0] = j
# elif len(set(lanes[i][len(lanes[i])//2:]).intersection(OutLanes[j]))>0:
# neigh[1] = j
# #print('neighbor tl', i, neigh, tl)
# neighTL.append(neigh) # 1st dim of neighTL is tl, value is the neighbor tl (2nd dim)
# # 0,4,5,1,3,2 # 0 didn't get 4
# neighTL[0][1] = 4 # correct manually. Due to edge expanding from 3 lanes to 4 lanes
# # I will need a better way on another map

    saver = tf.train.Saver()  # create saver
    #saveFrequency = 10000
    saveFile = r"/model/A.ckpt"
    if False:  # put True here if I want to restore
        saver.restore(kwargs['session'], saveFile)
        print("Model restored.")
        for i in range(len(alg)):
            alg[i].model_initialized = True  # I believe it is initialized if it is restored

    episode_rewards = []
    action = np.empty_like(
        alg,
        int)  #  Need to save all actions and then use them to learn each q
    reward = np.empty((len(alg), 2), float)  # now I have 2 rewards
    # hid = np.empty((len(alg),kwargs['num_hidden']),float)
    # Hs = np.empty((len(alg),2*kwargs['num_hidden']),float) # 2 because each tl has 2 neighbors
    #it = 0
    for isim in range(num_simulations):
        for it in range(num_timesteps):
            for q in alg:
                q.t += 1  # upgrade timestep here
            #print(it, traci.simulation.getTime())
            #if (it+1) % saveFrequency == 0: # save model # Don't save for now
            #    saver.save(kwargs['session'], saveFile)
            #    print("Model saved.")
            if traci.simulation.getMinExpectedNumber() <= 0:
                print('Error: No more cars')
                break
            if it % itBetweenDecision == 0:
                if it > 0:  #not first time
                    episode_rewards.append(reward / itBetweenDecision)
                done = it > num_timesteps - itBetweenDecision  # done if it's the last action
                for i, tl in enumerate(lightList):
                    if it > 0:  #not first time
                        #info = None
                        #print('reward',reward[i], np.sum(reward[i]))
                        alg[i].replay_buffer.store_effect(
                            idx, action[i], np.sum(reward[i]), done)
                        #alg[i].replay_buffer.store_effect(idx, action[i], reward[i], done, Hs[i])
                        alg[i].update_model()

                    lastObs = alg[i].last_obs / itBetweenDecision
                    #idx = alg[i].replay_buffer.store_frame(lastObs, 2*kwargs['num_hidden'])
                    idx = alg[i].replay_buffer.store_frame(lastObs)
                    #lastObs = alg[i].replay_buffer.encode_recent_observation() # No need to encode, I'm not using context

                    if not alg[i].model_initialized:
                        alg[i].model_initialized = True
                        initialize_interdependent_variables(
                            alg[i].session, tf.global_variables(), {
                                alg[i].obs_t_ph: lastObs[np.newaxis, :],
                            })
                    #hid[i] = alg[i].session.run(alg[i].hid, feed_dict={alg[i].obs_t_ph:lastObs[np.newaxis,:]})

                alg[0].log_progress(episode_rewards,
                                    it)  # need to log only once.

                if done:
                    print('done')
                    continue  # no need to finish if it's done. it will be less than itBetweenDecision iterations

            # Choose action (with epsilon greedy)
                for i, tl in enumerate(lightList):
                    # h = []
                    # for ntl in neighTL[i]:
                    # if ntl != -1:
                    # h.append(hid[ntl,:])
                    # else:
                    # h.append(np.zeros((kwargs['num_hidden'],)))
                    # h = np.concatenate(h,axis=0)
                    # Hs[i] = h
                    if random.random() > alg[i].exploration.value(alg[i].t):
                        #q = alg[i].session.run(alg[i].q, feed_dict={alg[i].obs_t_ph:lastObs[np.newaxis,:],alg[i].tl_ph:h[np.newaxis,:]})
                        q = alg[i].session.run(alg[i].q,
                                               feed_dict={
                                                   alg[i].obs_t_ph:
                                                   lastObs[np.newaxis, :]
                                               })
                        action[i] = np.argmax(q, axis=1)
                        #print('chosen action', q, action[i])
                    else:
                        action[i] = alg[i].randomAction(
                        )  #random.randrange(alg[i].num_phases) # random integer
                        #print('random action', action[i], alg[i].num_phases)
                    alg[i].updatePhase(action[i])

                    current_phase = traci.trafficlight.getRedYellowGreenState(
                        tl)
                    newphase = alg[i].phases[action[i]]
                    #print(i, current_phase, newphase)
                    if newphase != current_phase:  # not same phase
                        traci.trafficlight.setPhaseDuration(
                            tl, yellowTime
                        )  # trying to force switch by putting duration to 0. Actually, 0 made it swtich to red, so let's try yellowtime
                        #program = traci.trafficlight.Logic(programID, type, currentPhaseIndex, phases=None, subParameter=None)
                        yellowphase = list(current_phase)
                        #redphase = list(current_phase)
                        for ichar, char in enumerate(current_phase):
                            if newphase[ichar] == 'r' and char != 'r':
                                yellowphase[ichar] = 'y'
                                #redphase[ichar] = 'r'
                        yellowphase = ''.join(yellowphase)
                        #redphase = ''.join(redphase) # Says duration are in miliseconds, but that was in 2012 they might have changed it
                        phases = [
                            traci.trafficlight.Phase(phaseDef=yellowphase,
                                                     duration=yellowTime,
                                                     duration1=yellowTime,
                                                     duration2=yellowTime),
                            #traci.trafficlight.Phase(phaseDef=redphase,duration=redTime,duration1=redTime,duration2=redTime),
                            traci.trafficlight.Phase(phaseDef=newphase,
                                                     duration=10000,
                                                     duration1=10000,
                                                     duration2=10000)
                        ]
                        program = traci.trafficlight.Logic(phases=phases,
                                                           subID='0',
                                                           type=0,
                                                           subParameter=0,
                                                           currentPhaseIndex=0)
                        traci.trafficlight.setCompleteRedYellowGreenDefinition(
                            tl, program)
                        #print(traci.trafficlight.getRedYellowGreenState(tl))

            traci.simulationStep()
            for i, tl in enumerate(lightList):
                #print('    ', i, traci.trafficlight.getRedYellowGreenState(tl), traci.trafficlight.getNextSwitch(tl), traci.trafficlight.getPhaseDuration(tl))
                obs, rw = getobs(tl, alg[i].num_phases,
                                 lanesEdge[i])  #,OutLanesEdge[i])
                #print('obs', obs)
                #print('rw', rw)
                if it % itBetweenDecision == 0:
                    alg[i].last_obs = obs
                    reward[i] = rw
                else:
                    alg[i].last_obs += obs
                    reward[i] += rw

        traci.close()
        saver.save(kwargs['session'], saveFile)
        print("Model saved.")
        print('End of one simulation', 'iteration this time',
              len(episode_rewards) - rewardsLength, 'mean reward',
              np.mean(episode_rewards[rewardsLength:], axis=0))
        rewardsLength = len(episode_rewards)

        traci.start([
            r"D:\InstalledProgram\SUMO\bin\sumo.exe", "-c", "conf2.sumocfg",
            "--tripinfo-output", "tripinfo" + str(isim) + ".xml",
            "--no-step-log", "--time-to-teleport", "-1"
        ])