def _compute_fastest_path_labels(self, labels):
fp_labels = [
label for label in labels
if (self.start_time_dep < label.departure_time <= self.end_time_dep
)
]
if len(fp_labels
) is 0 or fp_labels[-1].departure_time < self.end_time_dep:
# add an after label
smallest_arr_time_after_end_time = float('inf')
smallest_arr_time_label = None
for label in labels:
if self.end_time_dep < label.departure_time and (
label.arrival_time_target <
smallest_arr_time_after_end_time):
smallest_arr_time_after_end_time = label.arrival_time_target
smallest_arr_time_label = label
if smallest_arr_time_label is not None:
fp_labels.append(smallest_arr_time_label)
fp_labels = list(
reversed(compute_pareto_front(fp_labels, ignore_n_boardings=True)))
# assert ordered:
for i in range(len(fp_labels) - 1):
assert (fp_labels[i].departure_time <
fp_labels[i + 1].departure_time)
return fp_labels
def get_time_profile_analyzer(self, max_n_boardings=None):
"""
Parameters
----------
max_n_boardings: int
The maximum number of boardings allowed for the labels used to construct the "temporal distance profile"
Returns
-------
analyzer: NodeProfileAnalyzerTime
"""
if max_n_boardings is None:
max_n_boardings = self.max_trip_n_boardings()
# compute only if not yet computed
if not max_n_boardings in self._n_boardings_to_simple_time_analyzers:
if max_n_boardings == 0:
valids = []
else:
candidate_labels = [
LabelTimeSimple(label.departure_time,
label.arrival_time_target)
for label in self._node_profile_final_labels
if ((self.start_time_dep <= label.departure_time)
and label.n_boardings <= max_n_boardings)
]
valids = compute_pareto_front(candidate_labels)
valids.sort(key=lambda label: -label.departure_time)
profile = NodeProfileSimple(self._walk_to_target_duration)
for valid in valids:
profile.update_pareto_optimal_tuples(valid)
npat = NodeProfileAnalyzerTime.from_profile(
profile, self.start_time_dep, self.end_time_dep)
self._n_boardings_to_simple_time_analyzers[max_n_boardings] = npat
return self._n_boardings_to_simple_time_analyzers[max_n_boardings]
def _compute_final_pareto_optimal_labels(self, neighbor_label_bags, walk_durations, departure_arrival_stops):
labels_from_neighbors = []
for i, (label_bag, walk_duration)in enumerate(zip(neighbor_label_bags, walk_durations)):
for label in label_bag:
if self.label_class == LabelTimeBoardingsAndRoute or self.label_class == LabelTimeAndRoute:
departure_arrival_tuple = departure_arrival_stops[i]
departure_time = label.departure_time - walk_duration
arrival_time = label.departure_time
connection = Connection(departure_arrival_tuple[0],
departure_arrival_tuple[1],
departure_time,
arrival_time,
Connection.WALK_TRIP_ID,
Connection.WALK_SEQ,
is_walk=True)
labels_from_neighbors.append(label.get_copy_with_walk_added(walk_duration, connection))
else:
labels_from_neighbors.append(label.get_copy_with_walk_added(walk_duration))
pareto_front = compute_pareto_front(self._real_connection_labels +
labels_from_neighbors,
finalization=True)
if pareto_front and hasattr(pareto_front[0], "duration"):
self._final_pareto_optimal_labels = list(filter(lambda label: label.duration() < self._walk_to_target_duration, pareto_front))
else:
self._final_pareto_optimal_labels = pareto_front
def add_fastest_path_column(self):
print("adding fastest path column")
cur = self.conn.cursor()
for target in self.get_targets():
fastest_path_journey_ids = []
for origin in self.get_origins():
cur.execute(
'SELECT departure_time, arrival_time_target, journey_id FROM journeys '
'WHERE from_stop_I = ? AND to_stop_I = ? '
'ORDER BY departure_time ASC', (origin, target))
all_trips = cur.fetchall()
all_labels = [
LabelTimeAndRoute(x[0], x[1], x[2], False)
for x in all_trips
] #putting journey_id as movement_duration
all_fp_labels = compute_pareto_front(all_labels,
finalization=False,
ignore_n_boardings=True)
fastest_path_journey_ids.append(all_fp_labels)
fastest_path_journey_ids = [(1, x.movement_duration)
for sublist in fastest_path_journey_ids
for x in sublist]
cur.executemany(
"UPDATE journeys SET fastest_path = ? WHERE journey_id = ?",
fastest_path_journey_ids)
self.conn.commit()
def test_some_are_optimal_some_are_not(self):
label_a = LabelTimeWithBoardingsCount(
departure_time=1,
arrival_time_target=2,
n_boardings=1,
first_leg_is_walk=False) # optimal
label_b = LabelTimeWithBoardingsCount(
departure_time=1,
arrival_time_target=5,
n_boardings=0,
first_leg_is_walk=False) # label_d dominates
label_c = LabelTimeWithBoardingsCount(
departure_time=3,
arrival_time_target=4,
n_boardings=1,
first_leg_is_walk=False) # optimal
label_d = LabelTimeWithBoardingsCount(
departure_time=4,
arrival_time_target=5,
n_boardings=0,
first_leg_is_walk=False) # optimal
labels = [label_a, label_b, label_c, label_d]
pareto_front = compute_pareto_front(labels)
self.assertEqual(3, len(pareto_front))
self.assertNotIn(label_b, pareto_front)
def test_compute_pareto_front_all_include(self):
label_a = LabelTimeWithBoardingsCount(departure_time=1, arrival_time_target=2, n_boardings=0, first_leg_is_walk=False)
label_b = LabelTimeWithBoardingsCount(departure_time=2, arrival_time_target=3, n_boardings=0, first_leg_is_walk=False)
label_c = LabelTimeWithBoardingsCount(departure_time=3, arrival_time_target=4, n_boardings=0, first_leg_is_walk=False)
label_d = LabelTimeWithBoardingsCount(departure_time=4, arrival_time_target=5, n_boardings=0, first_leg_is_walk=False)
labels = [label_a, label_b, label_c, label_d]
self.assertEqual(4, len(compute_pareto_front(labels)))
def test_compute_pareto_front_smart_randomized(self):
import random
for i in range(10):
labels = [LabelTimeWithBoardingsCount(random.randint(0, 1000), random.randint(0, 1000), random.randint(0, 10), 0)
for _ in range(1000)]
pareto_optimal_labels_old = compute_pareto_front_naive(labels)
pareto_optimal_labels_smart = compute_pareto_front(labels)
self.assertEqual(len(pareto_optimal_labels_old), len(pareto_optimal_labels_smart))
def test_one_dominates_all(self):
label_a = LabelTimeWithBoardingsCount(departure_time=1, arrival_time_target=12, n_boardings=0, first_leg_is_walk=False)
label_b = LabelTimeWithBoardingsCount(departure_time=2, arrival_time_target=13, n_boardings=0, first_leg_is_walk=False)
label_c = LabelTimeWithBoardingsCount(departure_time=3, arrival_time_target=14, n_boardings=0, first_leg_is_walk=False)
label_d = LabelTimeWithBoardingsCount(departure_time=4, arrival_time_target=5, n_boardings=0, first_leg_is_walk=False)
labels = [label_a, label_b, label_c, label_d]
pareto_front = compute_pareto_front(labels)
self.assertEqual(1, len(pareto_front))
self.assertEqual(label_d, pareto_front[0])
def _compute_real_connection_labels(self):
pareto_optimal_labels = []
# do not take those bags with first event is a pseudo-connection
for dep_time in self._connection_dep_times:
index = self.dep_times_to_index[dep_time]
pareto_optimal_labels.extend([label for label in self._label_bags[index] if not label.first_leg_is_walk])
if self.label_class == LabelTimeWithBoardingsCount or self.label_class == LabelTime \
or self.label_class == LabelTimeBoardingsAndRoute:
pareto_optimal_labels = [label for label in pareto_optimal_labels
if label.duration() < self._walk_to_target_duration]
if self.label_class == LabelVehLegCount and self._walk_to_target_duration < float('inf'):
pareto_optimal_labels.append(LabelVehLegCount(0))
self._real_connection_labels = [label.get_copy() for label in compute_pareto_front(pareto_optimal_labels,
finalization=True)]
def test_compute_pareto_front_smart(self):
labels = []
for n in [1, 2, 10]: #, 500]:
for dep_time in range(0, n):
for n_veh_legs in range(2):
for arr_time in range(dep_time, dep_time + 10):
label = LabelTimeWithBoardingsCount(dep_time, arr_time - n_veh_legs, n_veh_legs, False)
labels.append(label)
import random
random.shuffle(labels)
labels_copy = copy.deepcopy(labels)
pareto_optimal_labels = compute_pareto_front_naive(labels)
self.assertEqual(len(pareto_optimal_labels), n * 2)
pareto_optimal_labels = compute_pareto_front(labels_copy)
self.assertEqual(len(pareto_optimal_labels), n * 2)
def _compute_fastest_path_labels(self, labels):
relevant_labels = [
label.get_copy() for label in labels
if (self.start_time_dep < label.departure_time <= self.end_time_dep
)
]
if len(relevant_labels) is 0 or relevant_labels[
-1].departure_time < self.end_time_dep:
# add an after label
smallest_arr_time_after_end_time = float('inf')
smallest_arr_time_label = None
for label in labels:
if self.end_time_dep < label.departure_time and (
label.arrival_time_target <
smallest_arr_time_after_end_time):
smallest_arr_time_after_end_time = label.arrival_time_target
smallest_arr_time_label = label
if smallest_arr_time_label is not None:
relevant_labels.append(smallest_arr_time_label.get_copy())
for label in relevant_labels:
if hasattr(label, "first_leg_is_walk"):
label.first_leg_is_walk = False
fp_labels = list(
reversed(
compute_pareto_front(relevant_labels,
ignore_n_boardings=True)))
# assert ordered:
for i in range(len(fp_labels) - 1):
try:
assert (fp_labels[i].arrival_time_target <=
fp_labels[i + 1].arrival_time_target)
assert (fp_labels[i].departure_time <
fp_labels[i + 1].departure_time)
except AssertionError as e:
for fp_label in fp_labels:
print(fp_label)
print(fp_labels[i].arrival_time_target,
fp_labels[i + 1].arrival_time_target)
print(fp_labels[i].departure_time,
fp_labels[i + 1].departure_time)
raise e
return fp_labels
def _get_modified_arrival_node_labels(self, connection):
# get all different "accessible" / arrival times (Pareto-optimal sets)
arrival_profile = self._stop_profiles[connection.arrival_stop] # NodeProfileMultiObjective
assert (isinstance(arrival_profile, NodeProfileMultiObjective))
arrival_node_labels_orig = arrival_profile.evaluate(connection.arrival_stop_next_departure_time,
first_leg_can_be_walk=not connection.is_walk,
connection_arrival_time=connection.arrival_time)
increment_vehicle_count = (self._count_vehicle_legs and not connection.is_walk)
# TODO: (?) this copying / modification logic should be moved to the Label / ForwardJourney class ?
arrival_node_labels_modified = self._copy_and_modify_labels(
arrival_node_labels_orig,
connection,
increment_vehicle_count=increment_vehicle_count,
first_leg_is_walk=connection.is_walk
)
if connection.is_walk:
connection.is_walk = True
arrival_node_labels_modified = compute_pareto_front(arrival_node_labels_modified)
return arrival_node_labels_modified
def test_empty(self):
labels = []
self.assertEqual(0, len(compute_pareto_front(labels)))
def test_pareto_frontier(self):
pt3 = LabelVehLegCount(departure_time=5, n_boardings=0)
pt2 = LabelVehLegCount(departure_time=6, n_boardings=1)
pt1 = LabelVehLegCount(departure_time=7, n_boardings=2)
labels = [pt1, pt2, pt3]
self.assertEqual(1, len(compute_pareto_front(labels)))