def test_get_operators_cost(self):
"""
to test operators cost method
:return:
"""
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
[bus_obj, metro_obj] = TransportMode.get_default_modes()
network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
network_obj.add_route(route)
for route in radial_routes_bus:
network_obj.add_route(route)
f = defaultdict(float)
k = defaultdict(float)
line_cycle_time = defaultdict(float)
for route in network_obj.get_routes():
f[route.id] = 28
k[route.id] = 100
line_cycle_time[route.id] = 10
cost = OperatorsCost.get_operators_cost(network_obj.get_routes(),
line_cycle_time, f, k)
self.assertEqual(cost, 75331.2)
def setUp(self) -> None:
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
demand_obj = Demand.build_from_parameters(graph_obj=graph_obj, y=100, a=0.5, alpha=1 / 3, beta=1 / 3)
passenger_obj = Passenger.get_default_passenger()
[bus_obj, metro_obj] = TransportMode.get_default_modes()
self.network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = self.network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = self.network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
self.network_obj.add_route(route_obj=route)
for route in radial_routes_bus:
self.network_obj.add_route(route_obj=route)
self.extended_graph_obj = ExtendedGraph(graph_obj=graph_obj, routes=self.network_obj.get_routes(),
TP=passenger_obj.pt, frequency_routes=None)
hyperpath_obj = Hyperpath(extended_graph_obj=self.extended_graph_obj, passenger_obj=passenger_obj)
self.hyperpaths, self.labels, self.successors, self.frequency, self.Vij = hyperpath_obj.get_all_hyperpaths(
OD_matrix=demand_obj.get_matrix())
self.OD_assignment = Assignment.get_assignment(hyperpaths=self.hyperpaths, labels=self.labels, p=2,
vp=passenger_obj.va, spa=passenger_obj.spa,
spv=passenger_obj.spv)
def test_raises_get_route_exceptions(self):
"""
raises get_route exceptions from transport network class
:return:
"""
with self.assertRaises(exceptions.RouteIdNotFoundException):
graph_obj = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
network = TransportNetwork(graph_obj)
network.get_route("r1")
def test_resources_consumer(self):
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
demand_obj = Demand.build_from_parameters(graph_obj=graph_obj,
y=100,
a=0.5,
alpha=1 / 3,
beta=1 / 3)
passenger_obj = Passenger.get_default_passenger()
[bus_obj, metro_obj] = TransportMode.get_default_modes()
network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
network_obj.add_route(route_obj=route)
for route in radial_routes_bus:
network_obj.add_route(route_obj=route)
extended_graph_obj = ExtendedGraph(graph_obj=graph_obj,
routes=network_obj.get_routes(),
TP=passenger_obj.pt,
frequency_routes=None)
hyperpath_obj = Hyperpath(extended_graph_obj=extended_graph_obj,
passenger_obj=passenger_obj)
hyperpaths, labels, successors, frequency, Vij = hyperpath_obj.get_all_hyperpaths(
OD_matrix=demand_obj.get_matrix())
OD_assignment = Assignment.get_assignment(hyperpaths=hyperpaths,
labels=labels,
p=2,
vp=passenger_obj.va,
spa=passenger_obj.spa,
spv=passenger_obj.spv)
f = defaultdict(float)
z = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
v = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
for route in network_obj.get_routes():
f[route.id] = 28
CU_obj = UsersCost()
ta, te, tv, t = CU_obj.resources_consumer(hyperpaths, Vij,
OD_assignment, successors,
extended_graph_obj,
passenger_obj.va, f, z, v)
self.assertEqual(round(ta, 4), 3.069)
self.assertEqual(round(te, 4), 13.9597)
self.assertEqual(round(tv, 4), 74.685)
self.assertEqual(round(t, 4), 41.6667)
def test_get_mode_network_distance(self):
graph_obj = Graph.build_from_parameters(2, 10, 1, 2)
network_obj = TransportNetwork(graph_obj)
[bus_obj, metro_obj] = TransportMode.get_default_modes()
CI_obj = InfrastructureCost()
circular = network_obj.get_circular_routes(mode_obj=metro_obj)
radial = network_obj.get_radial_routes(mode_obj=bus_obj)
for route in circular:
network_obj.add_route(route)
for route in radial:
network_obj.add_route(route)
f = defaultdict(float)
for route in network_obj.get_routes():
f[route.id] = 28
mode_distance = CI_obj.get_mode_network_distance(graph_obj,
network_obj,
f=f)
self.assertEqual(mode_distance[bus_obj], 160)
self.assertEqual(mode_distance[metro_obj], 20)
def test_lines_travel_time(self):
"""
test lines_travel_time method of class operators_cost
:return:
"""
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
[bus_obj, metro_obj] = TransportMode.get_default_modes()
network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
network_obj.add_route(route_obj=route)
for route in radial_routes_bus:
network_obj.add_route(route_obj=route)
lines_travel_time = OperatorsCost.lines_travel_time(
routes=network_obj.get_routes(),
edge_distance=graph_obj.get_edges_distance())
self.assertEqual(lines_travel_time["R_bus_1"], 1.5)
self.assertEqual(lines_travel_time["F_metro_1"], 0.25)
def test_remove_route_transport_network(self):
"""
to test delete_route method of class transport_network class
:return:
"""
graph_obj = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
network = TransportNetwork(graph_obj)
route = Route("r1", bus_obj, "1,2,0,4,3", "3,4,0,2,1", "1,0,3", "3,0,1")
network.add_route(route)
network.remove_route("r1")
self.assertEqual(len(network.get_routes()), 0)
with self.assertRaises(exceptions.RouteIdNotFoundException):
network.remove_route("r1")
def test_network_to_file(self):
"""
to test method to write a file with network information
:return:
"""
graph_obj = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
metro = mode_manager.get_mode("metro")
network = TransportNetwork(graph_obj)
route1 = Route("r1", bus_obj, "1,2,0,4,3", "3,4,0,2,1", "1,0,3", "3,0,1")
route2 = Route("r2", metro, "1,2,0,4,3", "3,4,0,2,1", "1,0,3", "3,0,1")
network.add_route(route1)
network.add_route(route2)
# write file
network.routes_to_file(os.path.join(self.data_path, 'write_test.csv'))
file_obj = Path(os.path.join(self.data_path, 'write_test.csv'))
# test
self.assertTrue(file_obj.is_file())
# to compare file with a test file
self.assertTrue(
filecmp.cmp(os.path.join(self.data_path, 'write1_test.csv'),
os.path.join(self.data_path, "write_test.csv")))
# remove file
os.remove(os.path.join(self.data_path, 'write_test.csv'))
def test_get_feeder_routes(self):
"""
to test add feeder routes
:return:
"""
graph_obj = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
network = TransportNetwork(graph_obj)
routes = network.get_feeder_routes(bus_obj)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [1, 2])
self.assertEqual(routes[0].nodes_sequence_r, [2, 1])
self.assertEqual(routes[0].stops_sequence_i, [1, 2])
self.assertEqual(routes[0].stops_sequence_r, [2, 1])
self.assertEqual(routes[1].nodes_sequence_i, [3, 4])
self.assertEqual(routes[1].nodes_sequence_r, [4, 3])
self.assertEqual(routes[1].stops_sequence_i, [3, 4])
self.assertEqual(routes[1].stops_sequence_r, [4, 3])
with self.assertRaises(exceptions.ModeIsNotValidException):
network.get_feeder_routes("bus_obj")
def get_mode_network_distance(graph_obj: Graph,
network_obj: TransportNetwork,
f: defaultdict_float) -> defaultdict_float:
"""
to get total distance builded in each transport mode
:param network_obj: TransportNetwork object
:param graph_obj: Graph object
:param f: dict with frequency for each route_id
:return: ddict with total distance for each mode in transport network
"""
edges = graph_obj.get_edges()
edges_distance = graph_obj.get_edges_distance()
routes = network_obj.get_routes()
list_modes = network_obj.get_modes()
mode_distance = defaultdict(float)
for mode in list_modes:
edge_list = []
for edge in edges:
d_e = edges_distance[edge.node1.id][edge.node2.id]
for route in routes:
if route.mode == mode:
if f[route.id] != 0:
node_sequence_i = route.nodes_sequence_i
node_sequence_r = route.nodes_sequence_r
ver_sum = False
for i in range(len(node_sequence_i) - 1):
j = i + 1
if node_sequence_i[
i] == edge.node1.id and node_sequence_i[
j] == edge.node2.id and (
edge.node1.id, edge.node2.id
) not in edge_list:
mode_distance[mode] += d_e * mode.d
edge_list.append(
(edge.node1.id, edge.node2.id))
edge_list.append(
(edge.node2.id, edge.node1.id))
ver_sum = True
break
if ver_sum is True:
break
for i in range(len(node_sequence_r) - 1):
j = i + 1
if node_sequence_r[
i] == edge.node1.id and node_sequence_r[
j] == edge.node2.id and (
edge.node1.id, edge.node2.id
) not in edge_list:
mode_distance[mode] += d_e * mode.d
edge_list.append(
(edge.node1.id, edge.node2.id))
edge_list.append(
(edge.node2.id, edge.node1.id))
ver_sum = True
break
if ver_sum is True:
break
return mode_distance
def test_get_cycle_time(self):
"""
test get_cycle_time method of class operators_cost
:return:
"""
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
demand_obj = Demand.build_from_parameters(graph_obj=graph_obj,
y=100,
a=0.5,
alpha=1 / 3,
beta=1 / 3)
passenger_obj = Passenger.get_default_passenger()
[bus_obj, metro_obj] = TransportMode.get_default_modes()
network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
network_obj.add_route(route_obj=route)
for route in radial_routes_bus:
network_obj.add_route(route_obj=route)
extended_graph_obj = ExtendedGraph(graph_obj=graph_obj,
routes=network_obj.get_routes(),
TP=passenger_obj.pt,
frequency_routes=None)
hyperpath_obj = Hyperpath(extended_graph_obj=extended_graph_obj,
passenger_obj=passenger_obj)
hyperpaths, labels, successors, frequency, Vij = hyperpath_obj.get_all_hyperpaths(
OD_matrix=demand_obj.get_matrix())
OD_assignment = Assignment.get_assignment(hyperpaths=hyperpaths,
labels=labels,
p=2,
vp=passenger_obj.va,
spa=passenger_obj.spa,
spv=passenger_obj.spv)
f = defaultdict(float)
for route in network_obj.get_routes():
f[route.id] = 28
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(
Vij=Vij,
hyperpaths=hyperpaths,
successors=successors,
assignment=OD_assignment,
f=f)
lines_travel_time = OperatorsCost.lines_travel_time(
routes=network_obj.get_routes(),
edge_distance=graph_obj.get_edges_distance())
line_cycle_time = OperatorsCost.get_cycle_time(
z, v, network_obj.get_routes(), lines_travel_time)
self.assertEqual(round(line_cycle_time["F_metro_1"], 7), 0.2500082)
self.assertEqual(round(line_cycle_time["R_bus_1"], 7), 1.5032756)
self.assertEqual(line_cycle_time["l1"], 0)
def test_add_route_transport_network(self):
"""
to test add_route method of transport_network class
:return:
"""
graph_obj = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
network = TransportNetwork(graph_obj)
route = Route("r1", bus_obj, "1,2,0,4,3", "3,4,0,2,1", "1,0,3", "3,0,1")
network.add_route(route)
self.assertTrue(isinstance(network.get_route("r1"), Route))
self.assertEqual(len(network.get_routes()), 1)
with self.assertRaises(exceptions.RouteIsNotvalidException):
network.add_route("route")
with self.assertRaises(exceptions.NodeSequencesIsNotValidException):
route = Route("r2", bus_obj, "1,3,0,4,3", "3,4,0,2,1", "1,0,3",
"3,0,1")
network.add_route(route)
with self.assertRaises(exceptions.RouteIdDuplicatedException):
route = Route("r1", bus_obj, "1,2,0,4,3", "3,4,0,2,1", "1,0,3",
"3,0,1")
network.add_route(route)
def test_get_tangencial_routes(self):
"""
to test add tangencial routes
:return:
"""
g = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
m = TransportModeManager()
bus = m.get_mode("bus")
t = TransportNetwork(g)
routes = t.get_tangencial_routes(mode_obj=bus, jump=2, short=False, express=False)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [1, 2, 4, 6, 5])
self.assertEqual(routes[0].nodes_sequence_r, [5, 6, 4, 2, 1])
self.assertEqual(routes[0].stops_sequence_i, [1, 2, 4, 6, 5])
self.assertEqual(routes[0].stops_sequence_r, [5, 6, 4, 2, 1])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_i, [9, 10, 2, 4, 3])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_r, [3, 4, 2, 10, 9])
self.assertEqual(routes[len(routes) - 1].stops_sequence_i, [9, 10, 2, 4, 3])
self.assertEqual(routes[len(routes) - 1].stops_sequence_r, [3, 4, 2, 10, 9])
routes = t.get_tangencial_routes(mode_obj=bus, jump=2, short=True, express=False)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [2, 4, 6])
self.assertEqual(routes[0].nodes_sequence_r, [6, 4, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 4, 6])
self.assertEqual(routes[0].stops_sequence_r, [6, 4, 2])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_i, [10, 2, 4])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_r, [4, 2, 10])
self.assertEqual(routes[len(routes) - 1].stops_sequence_i, [10, 2, 4])
self.assertEqual(routes[len(routes) - 1].stops_sequence_r, [4, 2, 10])
routes = t.get_tangencial_routes(mode_obj=bus, jump=2, short=False, express=True)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [1, 2, 4, 6, 5])
self.assertEqual(routes[0].nodes_sequence_r, [5, 6, 4, 2, 1])
self.assertEqual(routes[0].stops_sequence_i, [1, 5])
self.assertEqual(routes[0].stops_sequence_r, [5, 1])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_i, [9, 10, 2, 4, 3])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_r, [3, 4, 2, 10, 9])
self.assertEqual(routes[len(routes) - 1].stops_sequence_i, [9, 3])
self.assertEqual(routes[len(routes) - 1].stops_sequence_r, [3, 9])
routes = t.get_tangencial_routes(mode_obj=bus, jump=2, short=True, express=True)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [2, 4, 6])
self.assertEqual(routes[0].nodes_sequence_r, [6, 4, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 6])
self.assertEqual(routes[0].stops_sequence_r, [6, 2])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_i, [10, 2, 4])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_r, [4, 2, 10])
self.assertEqual(routes[len(routes) - 1].stops_sequence_i, [10, 4])
self.assertEqual(routes[len(routes) - 1].stops_sequence_r, [4, 10])
routes = t.get_tangencial_routes(mode_obj=bus, jump=1, short=True, express=True)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [2, 4])
self.assertEqual(routes[0].nodes_sequence_r, [4, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 4])
self.assertEqual(routes[0].stops_sequence_r, [4, 2])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_i, [10, 2])
self.assertEqual(routes[len(routes) - 1].nodes_sequence_r, [2, 10])
self.assertEqual(routes[len(routes) - 1].stops_sequence_i, [10, 2])
self.assertEqual(routes[len(routes) - 1].stops_sequence_r, [2, 10])
with self.assertRaises(exceptions.JumpIsNotValidException):
t.get_tangencial_routes(mode_obj=bus, jump=6, short=True, express=True)
with self.assertRaises(exceptions.ModeIsNotValidException):
t.get_tangencial_routes(mode_obj="bus", jump=6, short=True, express=True)
def test_get_radial_routes(self):
"""
to test add radial routes
:return:
"""
g = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
metro_obj = mode_manager.get_mode("metro")
network = TransportNetwork(g)
routes = network.get_radial_routes(mode_obj=bus_obj, short=False, express=False)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [1, 2, 0])
self.assertEqual(routes[0].nodes_sequence_r, [0, 2, 1])
self.assertEqual(routes[0].stops_sequence_i, [1, 2, 0])
self.assertEqual(routes[0].stops_sequence_r, [0, 2, 1])
self.assertEqual(routes[1].nodes_sequence_i, [3, 4, 0])
self.assertEqual(routes[1].nodes_sequence_r, [0, 4, 3])
self.assertEqual(routes[1].stops_sequence_i, [3, 4, 0])
self.assertEqual(routes[1].stops_sequence_r, [0, 4, 3])
routes = network.get_radial_routes(mode_obj=bus_obj, short=True, express=False)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [2, 0])
self.assertEqual(routes[0].nodes_sequence_r, [0, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 0])
self.assertEqual(routes[0].stops_sequence_r, [0, 2])
self.assertEqual(routes[1].nodes_sequence_i, [4, 0])
self.assertEqual(routes[1].nodes_sequence_r, [0, 4])
self.assertEqual(routes[1].stops_sequence_i, [4, 0])
self.assertEqual(routes[1].stops_sequence_r, [0, 4])
routes = network.get_radial_routes(mode_obj=bus_obj, short=False, express=True)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [1, 2, 0])
self.assertEqual(routes[0].nodes_sequence_r, [0, 2, 1])
self.assertEqual(routes[0].stops_sequence_i, [1, 0])
self.assertEqual(routes[0].stops_sequence_r, [0, 1])
self.assertEqual(routes[1].nodes_sequence_i, [3, 4, 0])
self.assertEqual(routes[1].nodes_sequence_r, [0, 4, 3])
self.assertEqual(routes[1].stops_sequence_i, [3, 0])
self.assertEqual(routes[1].stops_sequence_r, [0, 3])
routes = network.get_radial_routes(mode_obj=metro_obj, short=True, express=True)
self.assertEqual(len(routes), 5)
self.assertEqual(routes[0].nodes_sequence_i, [2, 0])
self.assertEqual(routes[0].nodes_sequence_r, [0, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 0])
self.assertEqual(routes[0].stops_sequence_r, [0, 2])
self.assertEqual(routes[1].nodes_sequence_i, [4, 0])
self.assertEqual(routes[1].nodes_sequence_r, [0, 4])
self.assertEqual(routes[1].stops_sequence_i, [4, 0])
self.assertEqual(routes[1].stops_sequence_r, [0, 4])
with self.assertRaises(exceptions.ModeIsNotValidException):
network.get_radial_routes("bus_obj")
def test_get_circular_routes(self):
"""
to test add circular routes
:return:
"""
g = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
network = TransportNetwork(g)
routes = network.get_circular_routes(bus_obj)
self.assertEqual(len(routes), 2)
self.assertEqual(routes[0].nodes_sequence_i, [2, 4, 6, 8, 10, 2])
self.assertEqual(routes[0].stops_sequence_i, [2, 4, 6, 8, 10, 2])
self.assertEqual(routes[0].nodes_sequence_r, [])
self.assertEqual(routes[0].stops_sequence_r, [])
self.assertEqual(routes[1].nodes_sequence_i, [])
self.assertEqual(routes[1].stops_sequence_i, [])
self.assertEqual(routes[1].nodes_sequence_r, [10, 8, 6, 4, 2, 10])
self.assertEqual(routes[1].stops_sequence_r, [10, 8, 6, 4, 2, 10])
with self.assertRaises(exceptions.ModeIsNotValidException):
g = graph.Graph.build_from_parameters(5, 1000, 0.5, 2)
network = TransportNetwork(g)
network.get_circular_routes("bus_obj")
with self.assertRaises(exceptions.CircularRouteIsNotValidException):
g = graph.Graph.build_from_parameters(1, 1000, 0.5, 2)
mode_manager = TransportModeManager()
bus_obj = mode_manager.get_mode("bus")
network = TransportNetwork(g)
network.get_circular_routes(bus_obj)
# print(tiempo_viaje)
# print(tiempo_ciclo)
# print(CO_obj.get_operators_cost(network_obj.get_routes(), tiempo_ciclo, f, k))
from sidermit.city import Graph, Demand
from sidermit.optimization.optimizer import Optimizer
from sidermit.publictransportsystem import TransportMode, TransportNetwork, Passenger
n, l, g, p = 4, 10, 0.85, 2
graph_obj = Graph.build_from_parameters(n, l, g, p)
graph_obj.graph_to_pajek_file("graph.pajek")
graph_obj = Graph.build_from_file("graph.pajek")
print(graph_obj.get_parameters())
demand_obj = Demand.build_from_parameters(graph_obj, 300000, 0.78, 0.25, 0.22)
network_obj = TransportNetwork(graph_obj)
va = 4
pv = 2.74
pw = 2 * 2.74
pa = 3 * 2.74
pt = 16
spv = 2.74
spw = 2 * 2.74
spa = 3 * 2.74
spt = 16
passenger_obj = Passenger(va=va,
pv=pv,
pw=pw,
pa=pa,
def test_fmax_constrains(self):
graph_obj = Graph.build_from_parameters(2, 10, 1, 2)
network_obj = TransportNetwork(graph_obj)
[bus_obj, metro_obj] = TransportMode.get_default_modes()
radial_bus = network_obj.get_radial_routes(bus_obj)
feeder_bus = network_obj.get_feeder_routes(bus_obj)
radial_metro = network_obj.get_radial_routes(metro_obj, short=True)
for route in radial_bus:
network_obj.add_route(route)
for route in feeder_bus:
network_obj.add_route(route)
for route in radial_metro:
network_obj.add_route(route)
f = defaultdict(float)
for route in network_obj.get_routes():
f[route.id] = 28
ineq_f = Constrains.fmax_constrains(graph_obj,
network_obj.get_routes(),
network_obj.get_modes(), f)
self.assertEqual(ineq_f, [
-136.0, -40.0, -136.0, -40.0, -143.0, -12.0, -143.0, -12.0, -150.0,
-40.0, -150.0, -40.0, -136.0, -40.0, -136.0, -40.0, -143.0, -12.0,
-143.0, -12.0
])
def test_most_loaded_section_constrains(self):
graph_obj = Graph.build_from_parameters(2, 10, 1, 2)
network_obj = TransportNetwork(graph_obj)
[bus_obj, metro_obj] = TransportMode.get_default_modes()
radial_bus = network_obj.get_radial_routes(bus_obj)
feeder_bus = network_obj.get_feeder_routes(bus_obj)
radial_metro = network_obj.get_radial_routes(metro_obj, short=True)
for route in radial_bus:
network_obj.add_route(route)
for route in feeder_bus:
network_obj.add_route(route)
for route in radial_metro:
network_obj.add_route(route)
most_loaded_section = defaultdict(float)
for route in network_obj.get_routes():
most_loaded_section[route.id] = 10
ineq_k = Constrains.most_loaded_section_constrains(
network_obj.get_routes(), most_loaded_section)
self.assertEqual(len(ineq_k), 6)
self.assertEqual(ineq_k, [-150, -150, -150, -150, -1430, -1430])
class test_graph(unittest.TestCase):
def setUp(self) -> None:
graph_obj = Graph.build_from_parameters(n=2, l=10, g=0.5, p=2)
demand_obj = Demand.build_from_parameters(graph_obj=graph_obj, y=100, a=0.5, alpha=1 / 3, beta=1 / 3)
passenger_obj = Passenger.get_default_passenger()
[bus_obj, metro_obj] = TransportMode.get_default_modes()
self.network_obj = TransportNetwork(graph_obj=graph_obj)
feeder_routes_metro = self.network_obj.get_feeder_routes(mode_obj=metro_obj)
radial_routes_bus = self.network_obj.get_radial_routes(mode_obj=bus_obj)
for route in feeder_routes_metro:
self.network_obj.add_route(route_obj=route)
for route in radial_routes_bus:
self.network_obj.add_route(route_obj=route)
self.extended_graph_obj = ExtendedGraph(graph_obj=graph_obj, routes=self.network_obj.get_routes(),
TP=passenger_obj.pt, frequency_routes=None)
hyperpath_obj = Hyperpath(extended_graph_obj=self.extended_graph_obj, passenger_obj=passenger_obj)
self.hyperpaths, self.labels, self.successors, self.frequency, self.Vij = hyperpath_obj.get_all_hyperpaths(
OD_matrix=demand_obj.get_matrix())
self.OD_assignment = Assignment.get_assignment(hyperpaths=self.hyperpaths, labels=self.labels, p=2,
vp=passenger_obj.va, spa=passenger_obj.spa,
spv=passenger_obj.spv)
def test_assignment(self):
"""
test assignment method of class Assignment
:return:
"""
nodes = self.extended_graph_obj.get_extended_graph_nodes()
P1 = None
SC1 = None
CBD = None
stop_bus_p1 = None
stop_metro_p1 = None
for city_node in nodes:
if city_node.graph_node.name == "P_1":
P1 = city_node
if city_node.graph_node.name == "SC_1":
SC1 = city_node
if city_node.graph_node.name == "CBD":
CBD = city_node
for stop_node in nodes[city_node]:
if stop_node.mode.name == "bus":
if city_node.graph_node.name == "P_1":
stop_bus_p1 = stop_node
if stop_node.mode.name == "metro":
if city_node.graph_node.name == "P_1":
stop_metro_p1 = stop_node
self.assertEqual(round(self.OD_assignment[P1][CBD][stop_bus_p1], 2), 100)
self.assertEqual(round(self.OD_assignment[P1][SC1][stop_bus_p1], 2), 84.88)
self.assertEqual(round(self.OD_assignment[P1][SC1][stop_metro_p1], 2), 15.12)
def test_get_alighting_and_boarding(self):
"""
to test get_alighting_and_boarding of class get_alighting_and_boarding
:return:
"""
f = defaultdict(float)
for route in self.network_obj.get_routes():
f[route.id] = 28
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(Vij=self.Vij, hyperpaths=self.hyperpaths,
successors=self.successors,
assignment=self.OD_assignment, f=f)
nodes = self.extended_graph_obj.get_extended_graph_nodes()
stop_bus_p1 = None
stop_bus_sc1 = None
stop_bus_cbd = None
stop_metro_p1 = None
stop_metro_sc1 = None
for city_node in nodes:
for stop_node in nodes[city_node]:
if stop_node.mode.name == "bus":
if city_node.graph_node.name == "P_1":
stop_bus_p1 = stop_node
if city_node.graph_node.name == "SC_1":
stop_bus_sc1 = stop_node
if city_node.graph_node.name == "CBD":
stop_bus_cbd = stop_node
if stop_node.mode.name == "metro":
if city_node.graph_node.name == "P_1":
stop_metro_p1 = stop_node
if city_node.graph_node.name == "SC_1":
stop_metro_sc1 = stop_node
self.assertEqual(round(z["R_bus_1"]["I"][stop_bus_p1], 2), 0.85)
self.assertEqual(round(z["R_bus_1"]["I"][stop_bus_sc1], 2), 0.89)
self.assertEqual(round(z["R_bus_1"]["R"][stop_bus_cbd], 2), 0.74)
self.assertEqual(round(v["R_bus_1"]["I"][stop_bus_cbd], 2), 1.49)
self.assertEqual(round(v["R_bus_1"]["I"][stop_bus_sc1], 2), 0.25)
self.assertEqual(round(v["R_bus_1"]["R"][stop_bus_sc1], 2), 0.74)
self.assertEqual(round(z["F_metro_1"]["I"][stop_metro_p1], 2), 0.04)
self.assertEqual(round(v["F_metro_1"]["I"][stop_metro_sc1], 2), 0.04)
self.assertEqual(round(z["F_metro_1"]["R"][stop_metro_sc1], 2), 0)
def test_most_loaded_section(self):
"""
to test most_loaded_section class assignment
:return:
"""
f = defaultdict(float)
for route in self.network_obj.get_routes():
f[route.id] = 28
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(Vij=self.Vij, hyperpaths=self.hyperpaths,
successors=self.successors,
assignment=self.OD_assignment, f=f)
loaded_section = Assignment.most_loaded_section(loaded_section_route)
self.assertEqual(len(loaded_section), 4)
self.assertEqual(loaded_section['F_metro_1'], loaded_section['F_metro_2'])
self.assertEqual(loaded_section['F_metro_1'], 0.044997165532879815)
self.assertEqual(loaded_section['R_bus_1'], loaded_section['R_bus_2'])
self.assertEqual(loaded_section['R_bus_1'], 1.4880952380952384)
def create_default_routes(self, request):
""" create defaults routes """
default_routes = request.data.get('default_routes', [])
scene_public_id = request.data.get('scene_public_id')
scene_obj = Scene.objects.select_related('city').get(
public_id=scene_public_id)
graph_obj = scene_obj.city.get_sidermit_graph()
network_obj = SidermitTransportNetwork(graph_obj)
transport_mode_dict = dict()
try:
route_tuple = []
all_routes = []
for default_route in default_routes:
transport_mode_public_id = default_route['transportMode']
if transport_mode_public_id not in transport_mode_dict:
transport_mode_obj = TransportMode.objects.get(
public_id=transport_mode_public_id)
transport_mode_dict[
transport_mode_public_id] = transport_mode_obj.get_sidermit_transport_mode(
)
if default_route['type'] == 'Feeder':
route_tuple.append((network_obj.get_feeder_routes(
transport_mode_dict[transport_mode_public_id]),
transport_mode_public_id))
elif default_route['type'] == 'Circular':
route_tuple.append((network_obj.get_circular_routes(
transport_mode_dict[transport_mode_public_id]),
transport_mode_public_id))
elif default_route['type'] == 'Radial':
route_tuple.append((network_obj.get_radial_routes(
transport_mode_dict[transport_mode_public_id],
short=default_route['extension'],
express=default_route['odExclusive']),
transport_mode_public_id))
elif default_route['type'] == 'Diametral':
route_tuple.append((network_obj.get_diametral_routes(
transport_mode_dict[transport_mode_public_id],
jump=default_route['zoneJumps'],
short=default_route['extension'],
express=default_route['odExclusive']),
transport_mode_public_id))
elif default_route['type'] == 'Tangential':
route_tuple.append((network_obj.get_tangencial_routes(
transport_mode_dict[transport_mode_public_id],
jump=default_route['zoneJumps'],
short=default_route['extension'],
express=default_route['odExclusive']),
transport_mode_public_id))
else:
raise ParseError('type "{0}" is not valid.'.format(
default_route['type']))
for (routes, transport_mode_public_id) in route_tuple:
for route in routes:
all_routes.append(
dict(name=route.id,
transport_mode_public_id=transport_mode_public_id,
nodes_sequence_i=','.join(
str(x) for x in route.nodes_sequence_i),
nodes_sequence_r=','.join(
str(x) for x in route.nodes_sequence_r),
stops_sequence_i=','.join(
str(x) for x in route.stops_sequence_i),
stops_sequence_r=','.join(
str(x) for x in route.stops_sequence_r),
type=3 if route._type.value == 3 else 1))
except SIDERMITException as e:
raise ParseError(e)
except TransportMode.DoesNotExist:
raise ParseError('Transport mode does not exist')
return Response(all_routes, status.HTTP_200_OK)
