def init_state_util(): util.state_util = {} for comm in enum_commodity(): util.state_util[comm] = {} for timeslice in xrange(min2slice(conf.DAY) + 1): util.state_util[comm][timeslice] = {} for state in enum_state(comm, timeslice): # flag the states that has not been visited by # setting the state utilities to negative infinity util.state_util[comm][timeslice][state] = float('-inf') # initialize the value of terminal state to zeros # and the backward recursive process starts here util.state_util[comm][min2slice(conf.DAY)][comm.term_state] = 0.0
def init_state_util(): util.state_util = {} for comm in enum_commodity(): util.state_util[comm] = {} for timeslice in xrange(min2slice(conf.DAY)+1): util.state_util[comm][timeslice] = {} for state in enum_state(comm, timeslice): # flag the states that has not been visited by # setting the state utilities to negative infinity util.state_util[comm][timeslice][state] = float('-inf') # initialize the value of terminal state to zeros # and the backward recursive process starts here util.state_util[comm][min2slice(conf.DAY)][comm.term_state] = 0.0
def get_movements(self, timeslice): ''' Return the list of movements at timeslice or generate the list if neccessary. The travel time and travel cost is calculated at the same time. ''' if timeslice in self.moves_on_path: return self.moves_on_path[timeslice] # first calculate transfer cost total_travel_cost = self.num_transfer * conf.ALPHA_tran # then generate memoization for movements on path, and calculate other travel costs self.moves_on_path[timeslice] = [] self.path_travel_time[timeslice] = 0.0 timeline = timeslice for each_edge in self.edges_on_path: if isinstance(each_edge.related_vector, TransitLine): # if the edge is a transit line line = each_edge.related_vector (arrival_time, wait_time) = line.calc_arrival_time(slice2min(timeline), each_edge.head_node, each_edge.tail_node) # when there is no public transport service at timeslice, return infinite travel time/cost if arrival_time == float('inf') or wait_time == float('inf'): self.path_travel_timeslice[timeslice] = float('inf') self.path_travel_cost[timeslice] = float('inf') return [] in_vehicle_time = arrival_time - slice2min( timeline) - wait_time # create transit line move line_move = Move(timeline + min2slice(wait_time), each_edge) self.moves_on_path[timeslice].append(line_move) timeline = min2slice(arrival_time) # calculate travel cost wait_cost = wait_time * conf.ALPHA_wait move_flow = get_move_flow(line_move) in_vehicle_cost = line.calc_travel_cost( in_vehicle_time, move_flow) total_travel_cost = total_travel_cost + in_vehicle_cost + wait_cost else: # if the edge is NOT a transit line each_vector = each_edge.related_vector next_move = Move(timeline, each_edge) self.moves_on_path[timeslice].append(next_move) move_flow = get_move_flow(next_move) travel_time = each_vector.calc_travel_time(move_flow) travel_cost = each_vector.calc_travel_cost(travel_time) timeline = timeline + min2slice(travel_time) total_travel_cost = total_travel_cost + travel_cost self.path_travel_time[timeslice] += travel_time self.path_travel_timeslice[timeslice] = timeline - timeslice self.path_travel_cost[timeslice] = total_travel_cost return self.moves_on_path[timeslice]
def export_activity_choice_prob(export): print >> export, '\n---------- activity choice prob ----------\n' for person in elem.person_list: print >> export, "%s" % person # print titles print >> export, "\t travel", for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print >> export, "\t%8s" % (each_actv), print >> export print >> export, "\t road", for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print >> export, "\t%8s" % (each_zone), print >> export # print probability for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, "[%3d]\t" % timeslice, static_percent = sum( prob.activity_choice_prob[person][timeslice].values()) print >> export, "%8.2f\t" % (1.0 - static_percent), for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print >> export, "%8.2f\t" % prob.activity_choice_prob[ person][timeslice][(each_actv, each_zone)], print >> export print >> export
def calc_activity_choice_prob(): # activity/zone choice probability for comm in enum_commodity(): for timeslice in xrange(min2slice(conf.DAY) + 1): for state in enum_state(comm, timeslice): prob.activity_choice_prob[comm.person][timeslice][(state.activity,state.zone)] += \ flow.state_flows[comm][timeslice][state] / elem.person_flows[comm.person]
def calc_state_util(): math.exp = math.exp math.log = math.log # find the optimal uitility for comm in enum_commodity(): # print " %s" % comm # backtrack from the ending to the beginning for timeslice in xrange(min2slice(conf.DAY) - 1, -1, -1): for state in enum_state(comm, timeslice): these_util = {} for transition, starting_time, travel_cost, schedule_delay in \ enum_transition(comm, timeslice, state): these_util[transition] = conf.THETA_tour * ( conf.discount * \ util.state_util[comm][starting_time][transition.state] + \ util.solo_util[timeslice][state.activity] + \ util.socio_util[comm.person][timeslice][(state.activity,state.zone)] - \ (travel_cost + schedule_delay) ) # if these_util == [], the decision space is empty and then continue to next if these_util == {}: continue # scale the utility of each decision min_util = min(these_util.values()) max_util = max(these_util.values()) sum_exp_util = sum([math.exp(utility-(max_util+min_util)/2.0) \ for utility in these_util.values()]) # calculate the expected optimal utility util.state_util[comm][timeslice][state] = \ ((max_util+min_util)/2.0 + math.log(sum_exp_util)) / conf.THETA_tour # calculate the transition choice probability for trans, utility in these_util.items(): prob.transition_choice_prob[comm][timeslice][state][trans] = \ math.exp(utility - (max_util+min_util)/2.0) / sum_exp_util util.commodity_util[comm] = util.state_util[comm][0][comm.init_state]
def export_activity_choice_prob(export): print>>export, '\n---------- activity choice prob ----------\n' for person in elem.person_list: print>>export, "%s" % person # print titles print>>export, "\t travel", for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "\t%8s" % (each_actv), print>>export print>>export, "\t road", for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "\t%8s" % (each_zone), print>>export # print probability for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, "[%3d]\t" % timeslice, static_percent = sum(prob.activity_choice_prob[person][timeslice].values()) print>>export, "%8.2f\t" % (1.0 - static_percent), for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "%8.2f\t" % prob.activity_choice_prob[person][timeslice][(each_actv,each_zone)], print>>export print>>export
def calc_state_util(): math.exp = math.exp math.log = math.log # find the optimal uitility for comm in enum_commodity(): # print " %s" % comm # backtrack from the ending to the beginning for timeslice in xrange(min2slice(conf.DAY)-1,-1,-1): for state in enum_state(comm, timeslice): these_util = {} for transition, starting_time, travel_cost, schedule_delay in \ enum_transition(comm, timeslice, state): these_util[transition] = conf.THETA_tour * ( conf.discount * \ util.state_util[comm][starting_time][transition.state] + \ util.solo_util[timeslice][state.activity] + \ util.socio_util[comm.person][timeslice][(state.activity,state.zone)] - \ (travel_cost + schedule_delay) ) # if these_util == [], the decision space is empty and then continue to next if these_util == {}: continue # scale the utility of each decision min_util = min(these_util.values()) max_util = max(these_util.values()) sum_exp_util = sum([math.exp(utility-(max_util+min_util)/2.0) \ for utility in these_util.values()]) # calculate the expected optimal utility util.state_util[comm][timeslice][state] = \ ((max_util+min_util)/2.0 + math.log(sum_exp_util)) / conf.THETA_tour # calculate the transition choice probability for trans, utility in these_util.items(): prob.transition_choice_prob[comm][timeslice][state][trans] = \ math.exp(utility - (max_util+min_util)/2.0) / sum_exp_util util.commodity_util[comm] = util.state_util[comm][0][comm.init_state]
def calc_activity_choice_prob(): # activity/zone choice probability for comm in enum_commodity(): for timeslice in xrange(min2slice(conf.DAY)+1): for state in enum_state(comm, timeslice): prob.activity_choice_prob[comm.person][timeslice][(state.activity,state.zone)] += \ flow.state_flows[comm][timeslice][state] / elem.person_flows[comm.person]
def get_movements(self, timeslice): ''' Return the list of movements at timeslice or generate the list if neccessary. The travel time and travel cost is calculated at the same time. ''' if timeslice in self.moves_on_path: return self.moves_on_path[timeslice] # first calculate transfer cost total_travel_cost = self.num_transfer * conf.ALPHA_tran # then generate memoization for movements on path, and calculate other travel costs self.moves_on_path[timeslice] = [] self.path_travel_time[timeslice] = 0.0 timeline = timeslice for each_edge in self.edges_on_path: if isinstance(each_edge.related_vector, TransitLine): # if the edge is a transit line line = each_edge.related_vector (arrival_time, wait_time) = line.calc_arrival_time( slice2min(timeline), each_edge.head_node, each_edge.tail_node) # when there is no public transport service at timeslice, return infinite travel time/cost if arrival_time == float('inf') or wait_time == float('inf'): self.path_travel_timeslice[timeslice] = float('inf') self.path_travel_cost[timeslice] = float('inf') return [] in_vehicle_time = arrival_time - slice2min(timeline) - wait_time # create transit line move line_move = Move(timeline + min2slice(wait_time), each_edge) self.moves_on_path[timeslice].append(line_move) timeline = min2slice(arrival_time) # calculate travel cost wait_cost = wait_time * conf.ALPHA_wait move_flow = get_move_flow(line_move) in_vehicle_cost = line.calc_travel_cost(in_vehicle_time, move_flow) total_travel_cost = total_travel_cost + in_vehicle_cost + wait_cost else: # if the edge is NOT a transit line each_vector = each_edge.related_vector next_move = Move(timeline, each_edge) self.moves_on_path[timeslice].append(next_move) move_flow = get_move_flow(next_move) travel_time = each_vector.calc_travel_time(move_flow) travel_cost = each_vector.calc_travel_cost(travel_time) timeline = timeline + min2slice(travel_time) total_travel_cost = total_travel_cost + travel_cost self.path_travel_time[timeslice] += travel_time self.path_travel_timeslice[timeslice] = timeline - timeslice self.path_travel_cost[timeslice] = total_travel_cost return self.moves_on_path[timeslice]
def export_OD_trips(export): print >> export, '\n-------- O-D trips ---------\n' for timeslice in xrange(min2slice(conf.DAY)): for O in elem.zone_list: print >> export, "[%3d] " % timeslice, for D in elem.zone_list: print >> export, "%08.1f\t" % (flow.OD_trips[timeslice][O][D]), print >> export
def init_OD_trips(init_value): flow.OD_trips = {} for timeslice in xrange(min2slice(conf.DAY) + 1): flow.OD_trips[timeslice] = {} for zone_a in elem.zone_list: flow.OD_trips[timeslice][zone_a] = {} for zone_b in elem.zone_list: flow.OD_trips[timeslice][zone_a][zone_b] = init_value
def init_OD_trips(init_value): flow.OD_trips = {} for timeslice in xrange(min2slice(conf.DAY)+1): flow.OD_trips[timeslice] = {} for zone_a in elem.zone_list: flow.OD_trips[timeslice][zone_a] = {} for zone_b in elem.zone_list: flow.OD_trips[timeslice][zone_a][zone_b] = init_value
def enum_path(timeslice, this_zone, next_zone): shortest_path = elem.shortest_path[this_zone][next_zone] travel_timeslice, travel_cost = shortest_path.calc_travel_impedences(timeslice) arrival_timeslice = timeslice + travel_timeslice starting_time = arrival_timeslice + 1 if starting_time > min2slice(conf.DAY): return yield shortest_path, starting_time, travel_cost
def export_OD_trips(export): print>>export, '\n-------- O-D trips ---------\n' for timeslice in xrange(min2slice(conf.DAY)): for O in elem.zone_list: print>>export, "[%3d] " % timeslice, for D in elem.zone_list: print>>export, "%08.1f\t" % (flow.OD_trips[timeslice][O][D]), print>>export
def calc_average_temporal_util(commodity): average_temporal_utility = {} average_travel_disutil = {} for timeslice in xrange(min2slice(conf.DAY) + 1): # initialize temporal utility average_temporal_utility[timeslice] = 0.0 for state in enum_state(commodity, timeslice): # average temporal utility average_temporal_utility[timeslice] += (util.solo_util[timeslice][state.activity] + \ util.socio_util[commodity.person][timeslice][(state.activity,state.zone)])* \ flow.state_flows[commodity][timeslice][state] / flow.commodity_steps[commodity] # travel disutility for timeslice in xrange(min2slice(conf.DAY) + 1): average_travel_disutil[timeslice] = (flow.commodity_steps[commodity] - \ flow.static_population[commodity][timeslice]) * \ conf.ALPHA_car / flow.commodity_steps[commodity] return average_temporal_utility, average_travel_disutil
def draw_zone_population(bar_width): # average number of passengers in each aggregate time interval avg_zone_population = [None] * len(elem.zone_list) for i, each_zone in enumerate(elem.zone_list): avg_zone_population[i] = [] for lower in range(0, min2slice(conf.DAY), bar_width): upper = min(lower + bar_width, min2slice(conf.DAY)) sum_zone_population = sum([flow.zone_population[timeslice][each_zone] \ for timeslice in xrange(lower, upper)]) avg_zone_population[i].append(sum_zone_population / (upper - lower)) # plot figure fig = plt.figure() ax = fig.add_subplot(111, projection='3d') colors = ['r', 'g', 'b', 'y'] cc = colors[0:len(elem.zone_list)] ordered_zone_population = sorted(avg_zone_population, key=sum) for c, z in zip(cc, xrange(len(elem.zone_list))): xs = range(int(math.ceil(min2slice(conf.DAY) / float(bar_width)))) ys = ordered_zone_population[z] ## print xs ## print ys ax.bar(xs, ys, zs=z * 10, zdir='y', color=c, linewidth=None, alpha=0.8) ## day_len = int(math.ceil(min2slice(DAY)/float(slice_width)))+1 ## xtick_location = range(0, day_len, day_len/4) ## ax.set_xticks([5, 10]) ## ax.set_xticklabels(['5', '10']) ## ax.set_yticks(range(len(zone_list) )) ## ax.set_yticklabels(['5', '10']) ## ax.set_zticks([10000, 20000, 30000]) ## ax.set_zticklabels(['10,000', '20,000', '30,000']) ax.w_yaxis.set_major_locator( ticker.FixedLocator(range(0, 10 * len(elem.zone_list), 10))) ax.w_yaxis.set_major_formatter( ticker.FuncFormatter(lambda i, j: elem.zone_list[i / 10].name)) for tl in ax.w_xaxis.get_ticklabels(): tl.set_ha('right') tl.set_rotation(30) ax.set_xlabel('Time') # ax.set_ylabel('Activity locations') ax.set_zlabel('Population') plt.show()
def calc_average_temporal_util(commodity): average_temporal_utility = {} average_travel_disutil = {} for timeslice in xrange(min2slice(conf.DAY)+1): # initialize temporal utility average_temporal_utility[timeslice] = 0.0 for state in enum_state(commodity, timeslice): # average temporal utility average_temporal_utility[timeslice] += (util.solo_util[timeslice][state.activity] + \ util.socio_util[commodity.person][timeslice][(state.activity,state.zone)])* \ flow.state_flows[commodity][timeslice][state] / flow.commodity_steps[commodity] # travel disutility for timeslice in xrange(min2slice(conf.DAY)+1): average_travel_disutil[timeslice] = (flow.commodity_steps[commodity] - \ flow.static_population[commodity][timeslice]) * \ conf.ALPHA_car / flow.commodity_steps[commodity] return average_temporal_utility, average_travel_disutil
def enum_path(timeslice, this_zone, next_zone): shortest_path = elem.shortest_path[this_zone][next_zone] travel_timeslice, travel_cost = shortest_path.calc_travel_impedences( timeslice) arrival_timeslice = timeslice + travel_timeslice starting_time = arrival_timeslice + 1 if starting_time > min2slice(conf.DAY): return yield shortest_path, starting_time, travel_cost
def init_activity_choice_prob(): prob.activity_choice_prob = {} for person in elem.person_list: prob.activity_choice_prob[person] = {} for timeslice in xrange(min2slice(conf.DAY)+1): prob.activity_choice_prob[person][timeslice] = {} for each_actv in elem.activities.values(): for each_zone in each_actv.locations: prob.activity_choice_prob[person][timeslice][(each_actv,each_zone)] = 0.0
def init_socio_activity_util(): util.socio_util = {} for person in elem.person_list: util.socio_util[person] = {} for timeslice in xrange(min2slice(conf.DAY)+1): util.socio_util[person][timeslice] = {} for each_actv in elem.activities.values(): for each_zone in each_actv.locations: util.socio_util[person][timeslice][(each_actv,each_zone)] = 0.0
def export_state_flows(export): print>>export, '\n-------- state flows ---------\n' for comm in enum_commodity(): print>>export, " %s " % comm for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, " [%03d]\t" % timeslice, for state in enum_state(comm, timeslice): print>>export, " %s: %8.2f\t" % (state, flow.state_flows[comm][timeslice][state]), print>>export
def export_zone_population(export): print >> export, '\n-------- zone passengers ---------\n' for zone in sorted(elem.zone_list): print >> export, "\t %s" % (zone), print >> export for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, "[%3d]\t" % timeslice, for zone in sorted(elem.zone_list): print >> export, "%08.1f\t" % flow.zone_population[timeslice][zone], print >> export
def draw_zone_population(bar_width): # average number of passengers in each aggregate time interval avg_zone_population = [None] * len(elem.zone_list) for i, each_zone in enumerate(elem.zone_list): avg_zone_population[i] = [] for lower in range(0, min2slice(conf.DAY), bar_width): upper = min(lower+bar_width, min2slice(conf.DAY)) sum_zone_population = sum([flow.zone_population[timeslice][each_zone] \ for timeslice in xrange(lower, upper)]) avg_zone_population[i].append(sum_zone_population/(upper-lower) ) # plot figure fig = plt.figure() ax = fig.add_subplot(111, projection='3d') colors = ['r', 'g', 'b', 'y'] cc = colors[0:len(elem.zone_list)] ordered_zone_population = sorted(avg_zone_population, key=sum) for c, z in zip(cc, xrange(len(elem.zone_list))): xs = range(int(math.ceil(min2slice(conf.DAY)/float(bar_width)))) ys = ordered_zone_population[z] ## print xs ## print ys ax.bar(xs, ys, zs=z*10, zdir='y', color=c, linewidth=None, alpha=0.8) ## day_len = int(math.ceil(min2slice(DAY)/float(slice_width)))+1 ## xtick_location = range(0, day_len, day_len/4) ## ax.set_xticks([5, 10]) ## ax.set_xticklabels(['5', '10']) ## ax.set_yticks(range(len(zone_list) )) ## ax.set_yticklabels(['5', '10']) ## ax.set_zticks([10000, 20000, 30000]) ## ax.set_zticklabels(['10,000', '20,000', '30,000']) ax.w_yaxis.set_major_locator(ticker.FixedLocator(range(0, 10*len(elem.zone_list), 10))) ax.w_yaxis.set_major_formatter(ticker.FuncFormatter(lambda i, j: elem.zone_list[i/10].name)) for tl in ax.w_xaxis.get_ticklabels(): tl.set_ha('right') tl.set_rotation(30) ax.set_xlabel('Time') # ax.set_ylabel('Activity locations') ax.set_zlabel('Population') plt.show()
def init_activity_choice_prob(): prob.activity_choice_prob = {} for person in elem.person_list: prob.activity_choice_prob[person] = {} for timeslice in xrange(min2slice(conf.DAY) + 1): prob.activity_choice_prob[person][timeslice] = {} for each_actv in elem.activities.values(): for each_zone in each_actv.locations: prob.activity_choice_prob[person][timeslice][( each_actv, each_zone)] = 0.0
def export_activity_population(export): print>>export, '\n-------- activity passengers ---------\n' for each_actv in sorted_dict_values(elem.activities): print>>export, "\t %s" % (each_actv), print>>export for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, "[%3d]\t" % timeslice, for each_actv in sorted_dict_values(elem.activities): print>>export, "%08.1f\t" % flow.activity_population[timeslice][each_actv], print>>export
def export_zone_population(export): print>>export, '\n-------- zone passengers ---------\n' for zone in sorted(elem.zone_list): print>>export, "\t %s" % (zone), print>>export for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, "[%3d]\t" % timeslice, for zone in sorted(elem.zone_list): print>>export, "%08.1f\t" % flow.zone_population[timeslice][zone], print>>export
def export_solo_activity_util(export): print>>export, '\n---------- solo activity utility ----------\n' for actv_name in sorted(elem.activities.keys()): print>>export, "%s\t" % actv_name, print>>export for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, "[%3d]\t" % timeslice, for each_actv in sorted_dict_values(elem.activities): print>>export, "%8.2f\t" % util.solo_util[timeslice][each_actv], print>>export
def export_state_util(export): print>>export, '\n------ state utility ------\n' for comm in enum_commodity(): print>>export, " %s " % comm for timeslice in xrange(min2slice(conf.DAY)): print>>export, "[%3d] " % timeslice, for state in enum_state(comm, timeslice): print>>export, ("\t %s: %4.2f" % (state, util.state_util[comm][timeslice][state])), print>>export print>>export
def export_static_population(export): print>>export, '\n-------- temporal flows ---------\n' for comm in enum_commodity(): print>>export, " %s " % comm print>>export, "\t static\t traveling" for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, " [%03d]\t" % timeslice, print>>export, "%8.2f\t" % flow.static_population[comm][timeslice], print>>export, "%8.2f\t" % (flow.commodity_steps[comm] - flow.static_population[comm][timeslice]) print>>export
def init_socio_activity_util(): util.socio_util = {} for person in elem.person_list: util.socio_util[person] = {} for timeslice in xrange(min2slice(conf.DAY) + 1): util.socio_util[person][timeslice] = {} for each_actv in elem.activities.values(): for each_zone in each_actv.locations: util.socio_util[person][timeslice][(each_actv, each_zone)] = 0.0
def export_state_flows(export): print >> export, '\n-------- state flows ---------\n' for comm in enum_commodity(): print >> export, " %s " % comm for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, " [%03d]\t" % timeslice, for state in enum_state(comm, timeslice): print >> export, " %s: %8.2f\t" % ( state, flow.state_flows[comm][timeslice][state]), print >> export
def export_solo_activity_util(export): print >> export, '\n---------- solo activity utility ----------\n' for actv_name in sorted(elem.activities.keys()): print >> export, "%s\t" % actv_name, print >> export for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, "[%3d]\t" % timeslice, for each_actv in sorted_dict_values(elem.activities): print >> export, "%8.2f\t" % util.solo_util[timeslice][each_actv], print >> export
def export_average_temporal_util(export): print>>export, '\n------- average temporal utility -------\n' for comm in enum_commodity(): print>>export, " %s " % comm print>>export, "\t utility\t disutility" average_utility, average_travel_disutil = calc_average_temporal_util(comm) for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, " [%d]\t" % timeslice, print>>export, "%8.1f\t%8.1f\t" % (average_utility[timeslice], average_travel_disutil[timeslice]), print>>export print>>export
def export_activity_population(export): print >> export, '\n-------- activity passengers ---------\n' for each_actv in sorted_dict_values(elem.activities): print >> export, "\t %s" % (each_actv), print >> export for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, "[%3d]\t" % timeslice, for each_actv in sorted_dict_values(elem.activities): print >> export, "%08.1f\t" % flow.activity_population[timeslice][ each_actv], print >> export
def init_state_flows(init_value): flow.state_flows = {} for comm in enum_commodity(): flow.state_flows[comm] = {} for timeslice in xrange(min2slice(conf.DAY)+1): flow.state_flows[comm][timeslice] = {} for state in enum_state(comm, timeslice): flow.state_flows[comm][timeslice][state] = init_value # initialize the population at timeslice 0 for each zone for comm in enum_commodity(): flow.state_flows[comm][0][comm.init_state] = flow.commodity_steps[comm]
def __init__(self, name, U0, Um, Sigma, Lambda, Xi, \ time_win, min_duration, \ is_joint=0, is_madatory=0, pref_timing=0): ''' U0 is the baseline utility level of acivity. Um is the maximum utility of activity. Sigma determines the slope or steepness of the curve. Lambda determines the relative position of the inflection point. Xi determines the time of day at which the marginal utility reaches the maximum. time_win is the interval of starting time for this activity (a tuple). min_duration is the minimum duration for this activity. ''' # activity type self.name, self.is_joint, self.is_madatory, self.pref_timing = name, is_joint, is_madatory, pref_timing # utility function parameters self.U0, self.Um, self.Ur = U0, Um, Um self.Sigma, self.Lambda, self.Xi = Sigma, Lambda, Xi # spatial and temproal constraints self.locations = [] self.time_win = (min2slice(time_win[0]), min2slice(time_win[1])) self.min_duration = min2slice(min_duration)
def init_state_flows(init_value): flow.state_flows = {} for comm in enum_commodity(): flow.state_flows[comm] = {} for timeslice in xrange(min2slice(conf.DAY) + 1): flow.state_flows[comm][timeslice] = {} for state in enum_state(comm, timeslice): flow.state_flows[comm][timeslice][state] = init_value # initialize the population at timeslice 0 for each zone for comm in enum_commodity(): flow.state_flows[comm][0][comm.init_state] = flow.commodity_steps[comm]
def init_transition_flows(init_value): flow.transition_flows = {} for comm in enum_commodity(): flow.transition_flows[comm] = {} for timeslice in xrange(min2slice(conf.DAY)): flow.transition_flows[comm][timeslice] = {} for state in enum_state(comm, timeslice): flow.transition_flows[comm][timeslice][state] = {} for transition_info in enum_transition(comm, timeslice, state): transition = transition_info[0] flow.transition_flows[comm][timeslice][state][transition] = init_value
def init_transition_choice_prob(): prob.transition_choice_prob = {} for comm in enum_commodity(): prob.transition_choice_prob[comm] = {} for timeslice in xrange(min2slice(conf.DAY)): prob.transition_choice_prob[comm][timeslice] = {} for state in enum_state(comm, timeslice): prob.transition_choice_prob[comm][timeslice][state] = {} for transition_info in enum_transition(comm, timeslice, state): transition = transition_info[0] prob.transition_choice_prob[comm][timeslice][state][transition] = 0.0
def init_transition_flows(init_value): flow.transition_flows = {} for comm in enum_commodity(): flow.transition_flows[comm] = {} for timeslice in xrange(min2slice(conf.DAY)): flow.transition_flows[comm][timeslice] = {} for state in enum_state(comm, timeslice): flow.transition_flows[comm][timeslice][state] = {} for transition_info in enum_transition(comm, timeslice, state): transition = transition_info[0] flow.transition_flows[comm][timeslice][state][ transition] = init_value
def __init__(self, name, head_node, tail_node, drive_time, capacity, length, toll=0.0): super(Road, self).__init__(name) self.head_node, self.tail_node, self.drive_time, self.capacity, self.length, self.toll = \ head_node, tail_node, drive_time, capacity/min2slice(60.0), length, toll self.head_node.add_adjacent_vector(self)
def init_transition_choice_prob(): prob.transition_choice_prob = {} for comm in enum_commodity(): prob.transition_choice_prob[comm] = {} for timeslice in xrange(min2slice(conf.DAY)): prob.transition_choice_prob[comm][timeslice] = {} for state in enum_state(comm, timeslice): prob.transition_choice_prob[comm][timeslice][state] = {} for transition_info in enum_transition(comm, timeslice, state): transition = transition_info[0] prob.transition_choice_prob[comm][timeslice][state][ transition] = 0.0
def export_depart_flows(export): print>>export, '\n-------- departure flows ---------\n' for O in elem.zone_list: for D in elem.zone_list: print>>export, "\t %s->%s" % (O, D), print>>export for timeslice in xrange(min2slice(conf.DAY)): print>>export, "[%3d] " % timeslice, for O in elem.zone_list: for D in elem.zone_list: print>>export, "\t %08.1f" % (flow.OD_trips[timeslice][O][D]), print>>export
def export_state_util(export): print >> export, '\n------ state utility ------\n' for comm in enum_commodity(): print >> export, " %s " % comm for timeslice in xrange(min2slice(conf.DAY)): print >> export, "[%3d] " % timeslice, for state in enum_state(comm, timeslice): print >> export, ( "\t %s: %4.2f" % (state, util.state_util[comm][timeslice][state])), print >> export print >> export
def export_average_temporal_util(export): print >> export, '\n------- average temporal utility -------\n' for comm in enum_commodity(): print >> export, " %s " % comm print >> export, "\t utility\t disutility" average_utility, average_travel_disutil = calc_average_temporal_util( comm) for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, " [%d]\t" % timeslice, print >> export, "%8.1f\t%8.1f\t" % ( average_utility[timeslice], average_travel_disutil[timeslice]), print >> export print >> export
def export_depart_flows(export): print >> export, '\n-------- departure flows ---------\n' for O in elem.zone_list: for D in elem.zone_list: print >> export, "\t %s->%s" % (O, D), print >> export for timeslice in xrange(min2slice(conf.DAY)): print >> export, "[%3d] " % timeslice, for O in elem.zone_list: for D in elem.zone_list: print >> export, "\t %08.1f" % ( flow.OD_trips[timeslice][O][D]), print >> export
def calc_average_activity_duration(commodity): average_activity_duration = {} # initialize average duration for activity in commodity.bundle.activity_set: average_activity_duration[activity] = 0.0 # average duration for timeslice in xrange(min2slice(conf.DAY)): for state in enum_state(commodity, timeslice): average_activity_duration[state.activity] += conf.TICK * \ flow.state_flows[commodity][timeslice][state] / flow.commodity_steps[commodity] # average travel time average_travel_time = 1440 - sum(average_activity_duration.values()) return average_activity_duration, average_travel_time
def calc_joint_time_use(): calc_joint_time_use = {} for person in elem.person_list: calc_joint_time_use[person] = 0.0 for other in elem.person_list: if (person, other) in conf.corr: for timeslice in xrange(min2slice(conf.DAY)): for each_actv in elem.activities.values(): for each_zone in each_actv.locations: if each_actv.is_joint: calc_joint_time_use[person] += conf.TICK * \ prob.activity_choice_prob[other][timeslice][(each_actv,each_zone)] return calc_joint_time_use
def export_static_population(export): print >> export, '\n-------- temporal flows ---------\n' for comm in enum_commodity(): print >> export, " %s " % comm print >> export, "\t static\t traveling" for timeslice in xrange(min2slice(conf.DAY) + 1): print >> export, " [%03d]\t" % timeslice, print >> export, "%8.2f\t" % flow.static_population[comm][ timeslice], print >> export, "%8.2f\t" % ( flow.commodity_steps[comm] - flow.static_population[comm][timeslice]) print >> export
def calc_socio_activity_util(): # social utility for person in elem.person_list: for other in elem.person_list: if (person, other) in conf.corr: corr = conf.corr[(person, other)] for timeslice in xrange(min2slice(conf.DAY)+1): for each_actv in elem.activities.values(): for each_zone in each_actv.locations: if each_actv.is_joint: util.socio_util[person][timeslice][(each_actv,each_zone)] = \ prob.activity_choice_prob[other][timeslice][(each_actv,each_zone)] * \ 3.0 * corr * util.solo_util[timeslice][each_actv] else: util.socio_util[person][timeslice][(each_actv,each_zone)] = 0.0
def calc_socio_activity_util(): # social utility for person in elem.person_list: for other in elem.person_list: if (person, other) in conf.corr: corr = conf.corr[(person, other)] for timeslice in xrange(min2slice(conf.DAY) + 1): for each_actv in elem.activities.values(): for each_zone in each_actv.locations: if each_actv.is_joint: util.socio_util[person][timeslice][(each_actv,each_zone)] = \ prob.activity_choice_prob[other][timeslice][(each_actv,each_zone)] * \ 3.0 * corr * util.solo_util[timeslice][each_actv] else: util.socio_util[person][timeslice][( each_actv, each_zone)] = 0.0
def export_movement_flows(export): print >> export, '\n------ movement flows ------\n' sorted_moves = sorted(flow.movement_flows.keys(), key=repr) max_bus_flow, max_sub_flow,max_hwy_flow, max_ped_flow = \ float('-inf'), float('-inf'), float('-inf'), float('-inf') for each_move in sorted_moves: # print>>export, " %s\t%6.1f" % (each_move, flow.movement_flows[each_move]) if each_move.related_edge.related_vector.capacity == conf.CAPACITY_bus: if max_bus_flow < flow.movement_flows[each_move]: max_bus_flow = flow.movement_flows[each_move] elif each_move.related_edge.related_vector.capacity == conf.CAPACITY_sub: if max_sub_flow < flow.movement_flows[each_move]: max_sub_flow = flow.movement_flows[each_move] elif each_move.related_edge.related_vector.capacity == conf.CAPACITY_ped: if max_ped_flow < flow.movement_flows[each_move]: max_ped_flow = flow.movement_flows[each_move] else: if max_hwy_flow < flow.movement_flows[each_move]: max_hwy_flow = flow.movement_flows[each_move] print >> export, " maximum transit line flows %6.1f png" % (max_bus_flow) print >> export, " maximum subway line flows %6.1f png" % (max_sub_flow) print >> export, " maximum highway flows %6.1f png" % (max_hwy_flow) print >> export, " maximum pedestrian flows %6.1f png" % (max_ped_flow) print >> export, '\n movement flow variables (exceeding capacity) \n' for origin in elem.zone_list: for dest in elem.zone_list: # print>>export, [origin, dest] path = elem.shortest_path[origin][dest] print >> export, "\n%s" % path for timeslice in xrange(min2slice(conf.DAY)): path_travel_timeslice, path_travel_cost = path.calc_travel_impedences( timeslice) print >> export, "[%3d] " % timeslice, print >> export, "%8.2f\t%8.2f\t" % ( path.get_travel_time(timeslice), path_travel_cost) for each_move in path.moves_on_path[timeslice]: get_move_flow(each_move) print >> export, " %s:\t" % each_move, print >> export, "%8.2f / %8.2f" % ( flow.movement_flows[each_move], each_move.related_edge.related_vector.capacity), if flow.movement_flows[ each_move] > each_move.related_edge.related_vector.capacity: print >> export, " !!", print >> export
def calc_population_flows(): # initialize the population flows init_zone_population(0.0) init_activity_population(0.0) init_static_population(0.0) # calculate population flow variables based on state flows for comm in enum_commodity(): for timeslice in xrange(min2slice(conf.DAY) + 1): for state in enum_state(comm, timeslice): # calculate static population flow.static_population[comm][timeslice] += \ flow.state_flows[comm][timeslice][state] # calculate zone population flow.zone_population[timeslice][state.zone] += \ flow.state_flows[comm][timeslice][state] # calculate activity population flow.activity_population[timeslice][state.activity] += \ flow.state_flows[comm][timeslice][state]
def calc_population_flows(): # initialize the population flows init_zone_population(0.0) init_activity_population(0.0) init_static_population(0.0) # calculate population flow variables based on state flows for comm in enum_commodity(): for timeslice in xrange(min2slice(conf.DAY)+1): for state in enum_state(comm, timeslice): # calculate static population flow.static_population[comm][timeslice] += \ flow.state_flows[comm][timeslice][state] # calculate zone population flow.zone_population[timeslice][state.zone] += \ flow.state_flows[comm][timeslice][state] # calculate activity population flow.activity_population[timeslice][state.activity] += \ flow.state_flows[comm][timeslice][state]
def export_movement_flows(export): print>>export, '\n------ movement flows ------\n' sorted_moves = sorted(flow.movement_flows.keys(), key = repr) max_bus_flow, max_sub_flow,max_hwy_flow, max_ped_flow = \ float('-inf'), float('-inf'), float('-inf'), float('-inf') for each_move in sorted_moves: # print>>export, " %s\t%6.1f" % (each_move, flow.movement_flows[each_move]) if each_move.related_edge.related_vector.capacity == conf.CAPACITY_bus: if max_bus_flow < flow.movement_flows[each_move]: max_bus_flow = flow.movement_flows[each_move] elif each_move.related_edge.related_vector.capacity == conf.CAPACITY_sub: if max_sub_flow < flow.movement_flows[each_move]: max_sub_flow = flow.movement_flows[each_move] elif each_move.related_edge.related_vector.capacity == conf.CAPACITY_ped: if max_ped_flow < flow.movement_flows[each_move]: max_ped_flow = flow.movement_flows[each_move] else: if max_hwy_flow < flow.movement_flows[each_move]: max_hwy_flow = flow.movement_flows[each_move] print>>export, " maximum transit line flows %6.1f png" % (max_bus_flow) print>>export, " maximum subway line flows %6.1f png" % (max_sub_flow) print>>export, " maximum highway flows %6.1f png" % (max_hwy_flow) print>>export, " maximum pedestrian flows %6.1f png" % (max_ped_flow) print>>export, '\n movement flow variables (exceeding capacity) \n' for origin in elem.zone_list: for dest in elem.zone_list: # print>>export, [origin, dest] path = elem.shortest_path[origin][dest] print>>export, "\n%s" % path for timeslice in xrange(min2slice(conf.DAY)): path_travel_timeslice, path_travel_cost = path.calc_travel_impedences(timeslice) print>>export, "[%3d] " % timeslice, print>>export, "%8.2f\t%8.2f\t" % (path.get_travel_time(timeslice), path_travel_cost) for each_move in path.moves_on_path[timeslice]: get_move_flow(each_move) print>>export, " %s:\t" % each_move, print>>export, "%8.2f / %8.2f" % (flow.movement_flows[each_move], each_move.related_edge.related_vector.capacity), if flow.movement_flows[each_move] > each_move.related_edge.related_vector.capacity: print>>export, " !!", print>>export
def export_socio_activity_util(export): print>>export, '\n---------- socio activity utility ----------\n' for person in elem.person_list: print>>export, "%s" % person # print titles for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "\t%8s" % (each_actv), print>>export for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "\t%8s" % (each_zone), print>>export # print utility for timeslice in xrange(min2slice(conf.DAY)+1): print>>export, "[%3d]\t" % timeslice, for each_actv in sorted_dict_values(elem.activities): for each_zone in each_actv.locations: print>>export, "%8.2f\t" % util.socio_util[person][timeslice][(each_actv,each_zone)], print>>export print>>export