def get_constrains(self, fopt: List[float]) -> List[float]:
"""
to get all constrains as a List[float]
:param fopt: variable to optimize
:return: all constrains as a List[float]
"""
f = self.fopt_to_f(fopt)
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(self.Vij, self.hyperpaths, self.successors,
self.assignment, f)
most_loaded_section = Assignment.most_loaded_section(loaded_section_route)
constrain_obj = Constrains()
ineq_k = constrain_obj.most_loaded_section_constrains(self.network_obj.get_routes(), most_loaded_section)
ineq_f = constrain_obj.fmax_constrains(self.graph_obj, self.network_obj.get_routes(),
self.network_obj.get_modes(), f)
con = []
for c in ineq_k:
con.append(c)
for c in ineq_f:
con.append(c)
return con
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_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 get_k(loaded_section_route: defaultdict3_float) -> defaultdict_float:
"""
:param loaded_section_route: dic[route_id][direction][stop: StopNode] = pax [pax/veh]
:return: k: dic[route_id] = vehicle capacity [pax/veh]
"""
most_loaded_section = Assignment.most_loaded_section(loaded_section_route)
k = defaultdict(float)
for route_id in most_loaded_section:
k[route_id] = most_loaded_section[route_id]
return k
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 last_iteration(self, res: Tuple):
"""
return last network optimized with optimization result
:param res: res: Tuple, (fopt, success, status, message, constr_violation, vrc)
:return: Optimizer object, boarding dictionary, alighting dictionary, k dictionary, loaded_section_route
"""
fopt, success, status, message, constr_violation, vrc = res
f = self.fopt_to_f(fopt)
final_optimizer = Optimizer(self.graph_obj, self.demand_obj, self.passenger_obj, self.network_obj, f)
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(final_optimizer.Vij,
final_optimizer.hyperpaths,
final_optimizer.successors,
final_optimizer.assignment, f)
k = self.get_k(loaded_section_route)
return final_optimizer, z, v, k, loaded_section_route
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 constrains(self, loaded_section_route: defaultdict3_float, f: defaultdict_float) -> (
List[float], List[float]):
"""
to get k constrains and f constrains
:param loaded_section_route: dic[route_id][direction][stop: StopNode] = pax [pax/veh]
:param f: dict with frequency [veh/hr] for each route_id
:return: (k_ineq_constrains, f_ineq_constrains)
"""
most_loaded_section = Assignment.most_loaded_section(loaded_section_route)
constrains_obj = Constrains()
ineq_k = constrains_obj.most_loaded_section_constrains(self.network_obj.get_routes(), most_loaded_section)
ineq_f = constrains_obj.fmax_constrains(self.graph_obj, self.network_obj.get_routes(),
self.network_obj.get_modes(), f)
return ineq_k, ineq_f
def VRC(self, fopt: List[float]) -> float:
"""
to get VRC objective function to minime in optimizer
:param fopt: variable to optimize
:return: float, VRC value function
"""
f = self.fopt_to_f(fopt)
z, v, loaded_section_route = Assignment.get_alighting_and_boarding(self.Vij, self.hyperpaths, self.successors,
self.assignment, f)
k = self.get_k(loaded_section_route)
CO = self.operators_cost(z, v, f, k)
CI = self.infrastructure_cost(f)
CU = self.user_cost(self.hyperpaths, self.Vij, self.assignment, self.successors, self.extended_graph_obj, f, z,
v)
return CO + CI + CU
def __init__(self, graph_obj: Graph, demand_obj: Demand, passenger_obj: Passenger, network_obj: TransportNetwork,
f: defaultdict_float = None):
# definimos ciudad
self.graph_obj = graph_obj
_, _, _, self.p, _, _, _, _, _ = self.graph_obj.get_parameters()
# definimos demanda
self.demand_obj = demand_obj
self.total_trips = demand_obj.get_total_trips()
# definimos pasajeros
self.passenger_obj = passenger_obj
self.vp = self.passenger_obj.va
self.pa = self.passenger_obj.pa
self.pv = self.passenger_obj.pv
self.TP = self.passenger_obj.pt
# definimos red de transporte
self.network_obj = network_obj
# definimos frecuencia
self.f, self.f_opt, self.lines_position = self.f0(f)
self.extended_graph_obj = ExtendedGraph(self.graph_obj, self.network_obj.get_routes(), self.TP, self.f)
self.hyperpath_obj = Hyperpath(self.extended_graph_obj, self.passenger_obj)
# en este punto se debería levantar exception de que la red tiene mas de dos modos defnidos
# o que existe un par OD con viaje y sin conexion
self.hyperpaths, self.labels, self.successors, self.frequency, self.Vij = self.hyperpath_obj.get_all_hyperpaths(
self.demand_obj.get_matrix())
self.assignment = Assignment.get_assignment(self.hyperpaths, self.labels, self.p, self.vp, self.pa,
self.pv)
self.len_constrains = len(self.get_constrains(self.f_opt))
self.len_var = len(self.f_opt)
self.better_res = None # (fopt, success, status, message, constr_violation, vrc)
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)