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__(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_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 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 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 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
