Exemple #1
0
 def find_shortest_path(cls, net, depart_time, start, end=None):
     if end != None and start == end:
         return {end.id: (None, 0.0, depart_time)}
     # creater a FIFO queue for searching
     queue = deque()
     # create containers with default values
     cost = defaultdict(constant_factory(float('+inf')))
     time = defaultdict(constant_factory(float('+inf')))
     prev = defaultdict(None)
     # set values for the start node
     cost[start.id] = 0.0
     time[start.id] = depart_time
     queue.appendleft(start.id)
     # continue until the queue is empty
     while len(queue) > 0:
         # pop out the first object in the queue
         qtop = queue.pop()
         node = net.nodes[qtop]
         # relax each adjacent edges
         for edge in node.adj_edges:
             # get the traffic flow on the edge
             if Time.lessthan_maxtick(time[node.id]):
                 edge_flow = net.flows[edge.id][time[node.id]]
             else:
                 edge_flow = 0.0
             # if the relaxation makes a shorter path
             travel_time = edge.calc_travel_time(edge_flow)
             travel_cost = edge.calc_travel_cost(travel_time)
             if cost[edge.tail.id] > cost[node.id] + travel_cost:
                 # then update cost and time labels
                 cost[edge.tail.id] = cost[node.id] + travel_cost
                 time[edge.tail.id] = time[node.id] + travel_time
                 # and save the edge on the shortest path
                 prev[edge.tail.id] = edge
                 # and append the expanded node to the queue
                 queue.appendleft(edge.tail.id)
     # if end node is given, extract the shortest path to end node recursively
     if end != None:
         # if the end node is reached, there is at least one path
         # if the end node is not reached, the start and end nodes are not connected
         path = cls.create_shortest_path(start, end, prev, time) if end.id in prev else None
         return {end.id: (path, cost[end.id], time[end.id])}
     else:
         # if end node is not given, extract the shortest paths from start to all the other nodes
         paths = cls.create_all_shortest_paths(start, prev, time)
         # no path is defined for a ring and the travel time/cost is zero
         tuples = {start.id: (None, 0.0, depart_time)}
         for id_ in paths:
             # wrap the path, cost and time in a tuple
             # note that time[id_] is the arrival time at node[id_]
             # that is, time[id_] = depart_time + travel_time
             tuples[id_] = (paths[id_], cost[id_], time[id_])
         return tuples
Exemple #2
0
 def individual_schedule(cls, demand, network, land, router, population):
     # save in-home activity into a local variable
     home = demand.activities["home"]
     for hh in population.households[:2]:
         if hh.id % 100 == 0:
             print " %d." % hh.id
         logger.info((hh, hh.program))
         for person in itertools.chain(hh.adults, hh.children):
             logger.info((person, person.program, person.get_residence()))
             # save the person's residence into a local variable
             residence = person.get_residence()
             # a dict with default value +inf
             state_utils = defaultdict(constant_factory(float('-inf')))
             # initialize the absorbing states
             for elapsed in xrange(Time.MAXTICK + 1):
                 if home.within_time_window(Time.MAXTICK - elapsed):
                     # absorbing states consists of maximum tick and in-home activity
                     absorbing_state = (Time.MAXTICK, home, residence,
                                        elapsed, None, None)
                     state_utils[absorbing_state] = 0.0
             for state in cls.individual_states(person, land):
                 tick, activity, position, elapsed, joint, todo = state
                 # logger.debug(("state:", state))
                 for trans in cls.individual_transitions(
                         person, network, land, router, *state):
                     next_activity, destination, path, travel_cost, arrival_time = trans
                     # logger.debug(("trans:", trans))
                     # elapsed time depends on the activity transition
                     if next_activity == activity and position == destination:
                         next_elapsed = elapsed + 1
                     else:
                         next_elapsed = 0
                     # transition to the next state
                     next_state = (arrival_time, next_activity, destination,
                                   next_elapsed, None, None)
                     # logger.debug(("next state:", next_state))
                     # skip, if the arrival time is too late or the state is not feasible
                     if arrival_time > Time.MAXTICK or next_state not in state_utils:
                         continue
                     # get activity utility
                     activity_util = demand.get_activity_util(
                         activity, tick, elapsed)
                     # calculate state utility
                     state_util = activity_util - travel_cost + Config.discount * state_utils[
                         next_state]
                     # the maximum state utility and the associated choice
                     if state_utils[state] < state_util:
                         state_utils[state] = state_util
                         person.transitions[state] = next_state
             # logger.debug(pformat(person.transitions))
             # the initial state starts at the mid night and in home
             current_state = (0, home, residence, 0, None, None)
             person.states.append(current_state)
             while current_state[0] < Time.MAXTICK:
                 current_state = person.transitions[current_state]
                 person.states.append(current_state)
             logger.info(pformat(person.states))
Exemple #3
0
 def individual_schedule(cls, demand, network, land, router, population):
     # save in-home activity into a local variable
     home = demand.activities["home"]
     for hh in population.households[:2]:
         if hh.id % 100 == 0:
             print " %d." % hh.id
         logger.info((hh, hh.program))
         for person in itertools.chain(hh.adults, hh.children):
             logger.info((person, person.program, person.get_residence()))
             # save the person's residence into a local variable
             residence = person.get_residence()
             # a dict with default value +inf
             state_utils = defaultdict(constant_factory(float('-inf')))
             # initialize the absorbing states
             for elapsed in xrange(Time.MAXTICK + 1):
                 if home.within_time_window(Time.MAXTICK - elapsed):
                     # absorbing states consists of maximum tick and in-home activity
                     absorbing_state = (Time.MAXTICK, home, residence, elapsed, 
                                        None, None)
                     state_utils[absorbing_state] = 0.0
             for state in cls.individual_states(person, land):
                 tick, activity, position, elapsed, joint, todo = state
                 # logger.debug(("state:", state))
                 for trans in cls.individual_transitions(person, network, land, router, *state):
                     next_activity, destination, path, travel_cost, arrival_time = trans
                     # logger.debug(("trans:", trans))
                     # elapsed time depends on the activity transition
                     if next_activity == activity and position == destination:
                         next_elapsed = elapsed + 1
                     else:
                         next_elapsed = 0
                     # transition to the next state
                     next_state = (arrival_time, next_activity, destination, next_elapsed, None, None)
                     # logger.debug(("next state:", next_state))
                     # skip, if the arrival time is too late or the state is not feasible
                     if arrival_time > Time.MAXTICK or next_state not in state_utils:
                         continue
                     # get activity utility
                     activity_util = demand.get_activity_util(activity, tick, elapsed)
                     # calculate state utility
                     state_util = activity_util - travel_cost + Config.discount * state_utils[next_state]
                     # the maximum state utility and the associated choice
                     if state_utils[state] < state_util:
                         state_utils[state] = state_util
                         person.transitions[state] = next_state
             # logger.debug(pformat(person.transitions))
             # the initial state starts at the mid night and in home
             current_state = (0, home, residence, 0, None, None)
             person.states.append(current_state)
             while current_state[0] < Time.MAXTICK:
                 current_state = person.transitions[current_state]
                 person.states.append(current_state)
             logger.info(pformat(person.states))