def failImpact(analyzer, landingPoint):
# Se obtiene el id del landing point a partir de su nombre
vertexId = me.getValue(mp.get(analyzer['landingPointNames'], landingPoint))
# Se obtiene la entrada del mapa para el landing point
lp = me.getValue(mp.get(analyzer['landingPoints'], vertexId))
# Se obtiene el nombre del país del landing point que falla
countryName = lp['country']
# Se obtienen los datos del país del landing point que falla
country = me.getValue(mp.get(analyzer['countries'], countryName))
# Se crea un mapa para almacenar los nombres de los países que estan conectados al landing point que falla
countries = mp.newMap(numelements=300, maptype='PROBING')
# Se obtienen los vértices adyacentes para cada uno de los vertices del landing point
for vertex in lt.iterator(lp['vertices']):
# Los vertices adyacentes se almacenan en una lista
adjVertices = gr.adjacents(analyzer['connections'], vertex)
# Para cada vertice adyacente, se obtiene el país
for adjVertex in lt.iterator(adjVertices):
# Si el vertice adyacente corresponde al vertice de la ciudad capital, se intenta agregar el país actual
if adjVertex == country['vertex']:
# Se verifica que el país no exista en el listado de resultado
if not mp.contains(countries, countryName):
# Se obtiene el arco para poder saber la distancia y se agrega el pais al listado de resultado
ctryEdge = gr.getEdge(analyzer['connections'], vertex,
country['vertex'])
mp.put(countries, countryName, ctryEdge['weight'])
else:
# Si el vertice no corresponde a un vertice de capital, se obtiene su id y luego su entrada en el mapa de landing points
adjVertexId = adjVertex.split('-')[0]
adjLP = me.getValue(
mp.get(analyzer['landingPoints'], adjVertexId))
# Se verifica si el país del landing point adyacente ya existe en el listado, y si no, se agrega
if not mp.contains(countries, adjLP['country']):
adjEdge = gr.getEdge(analyzer['connections'], vertex,
adjVertex)
mp.put(countries, adjLP['country'], adjEdge['weight'])
countriesList = mp.keySet(countries)
# Se crea un mapa ordenado para el resultado
result = om.newMap('BST')
for ctry in lt.iterator(countriesList):
distance = me.getValue(mp.get(countries, ctry))
if om.contains(result, distance):
ctryList = me.getValue(om.get(result, distance))
lt.addLast(ctryList, ctry)
else:
newList = lt.newList('SINGLE_LINKED', compareCountries)
lt.addLast(newList, ctry)
om.put(result, distance, newList)
return mp.size(countries), result
def getRoute(self, area1, area2) -> Route:
if not self.containsArea(area1):
graph.insertVertex(self.Routes, area1)
if not self.containsArea(area2):
graph.insertVertex(self.Routes, area2)
route = graph.getEdge(self.Routes, area1, area2)
if route is None:
route = Route()
graph.addEdge(self.Routes, area1, area2, route)
route = graph.getEdge(self.Routes, area1, area2)
return route['weight']
def addTrip(chicagoAnalyzer, origin, destiny, tripTime, idTrip):
"""
Crea el arco(camino) entre los dos vertices(el de origen y el de destino)
"""
edge = gr.getEdge(chicagoAnalyzer['communityTrip'], origin, destiny)
if edge is None:
gr.addEdge(chicagoAnalyzer['communityTrip'], origin, destiny, tripTime)
edge = gr.getEdge(chicagoAnalyzer['communityTrip'], origin, destiny)
m.put(chicagoAnalyzer['tripID_edge'], idTrip, edge)
return chicagoAnalyzer
def addConnection(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer['graph'], origin, destination)
if edge is not None:
edge['pesos'] += duration
edge['size'] += 1
edge['weight'] = round((edge['pesos'] / edge['size']), 2)
else:
gr.addEdge(analyzer['graph'], origin, destination, duration)
edge = gr.getEdge(analyzer['graph'], origin, destination)
edge['pesos'] += duration
edge['size'] += 1
edge['weight'] = round((edge['pesos'] / edge['size']), 2)
def updateRoute(trip: dict, DataBase: dict) -> None:
startId = int(trip["start station id"])
endId = int(trip["end station id"])
tripTime = int(trip["tripduration"])
edgeRoute = graph.getEdge(DataBase['graph'], startId, endId)
if edgeRoute is None:
weight = Structure.newWeight()
graph.addEdge(DataBase['graph'], startId, endId, weight)
edgeRoute = graph.getEdge(DataBase['graph'], startId, endId)
weight = edge.weight(edgeRoute)
weight['time'] = aveTime(weight, tripTime)
weight['users'] += 1
def addEdge(analyzer, originPoint, destinationPoint, distance):
edge = gr.getEdge(analyzer['connections'], originPoint, destinationPoint)
# Se intenta crear un arco. Primero se verifica si existe
if edge is None:
gr.addEdge(analyzer['connections'], originPoint, destinationPoint,
distance)
return analyzer
def dfsVertex(search, graph, vertex):
"""
Funcion auxiliar para calcular un recorrido DFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
result = False
adjlst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjlst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
if w == vertex:
result = True
visited = map.get(search['visited'], w)
if visited is None:
map.put(
search['visited'], w, {
'marked': True,
'edgeTo': vertex,
'peso': edge.weight(gr.getEdge(graph, vertex, w))
})
dfsVertex(search, graph, w)
return (search, result)
except Exception as exp:
error.reraise(exp, 'dfs:dfsVertex')
def pathTowithLimiter(search, vertex, grafo, limit):
"""
Retorna el camino entre el vertices source y el
vertice vertex
Args:
search: La estructura con el recorrido
vertex: Vertice de destingo
Returns:
Una pila con el camino entre el vertices source y el
vertice vertex
Raises:
Exception
"""
try:
if hasPathTo(search, vertex) is False:
return None
path = stk.newStack()
TIEMPO = 0
limit=limit*60
while vertex != search['source']:
stk.push(path, vertex)
papu=vertex
vertex = map.get(search['visited'], vertex)['value']['edgeTo']
edge=graph.getEdge(grafo,vertex,papu)
t=int(edge['weight'])+1200
TIEMPO+=t
if TIEMPO>limit:
return None
stk.push(path, search['source'])
return path,TIEMPO
except Exception as exp:
error.reraise(exp, 'dfs:pathtotuniao')
def bfsVertex(search, graph, source, time, camino):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not (queue.isEmpty(adjsqueue)):
lista = []
tiempo = time
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited_w = map.get(search['visited'], w)
if ed.weight(g.getEdge(graph, vertex, w)) <= tiempo:
lista.append(w)
tiempo = tiempo - ed.weight(g.getEdge(graph, vertex, w))
else:
camino.append(lista)
if visited_w is None:
dist_to_w = visited_v['distTo'] + 1
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def addConnection(analyzer, origin, destination, weight):
"""
Adiciona un arco entre dos vértices del grafo
"""
graph = analyzer['connections']
edge = gr.getEdge(graph, origin, destination)
if edge is None:
gr.addEdge(graph, origin, destination, weight)
return analyzer
def addConnection(catalog, graph, origin, destination, weight):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(catalog[graph], origin, destination)
if edge is None:
gr.addEdge(catalog[graph], origin, destination, weight)
#gr.addEdge(catalog[graph], destination, origin, weight)
return catalog
def bfsVertex(search, graph, source, maxtime):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not queue.isEmpty(adjsqueue):
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
if not (it.hasNext(adjslstiter)):
visited_v["final"] = True
c = 0
while (it.hasNext(adjslstiter)):
if c == 1 and vertex != source:
break
total_time = 0
w = it.next(adjslstiter)
if not (it.hasNext(adjslstiter)) and c == 0:
visited_v["final"] = True
edge = g.getEdge(graph, vertex, w)
time = edge['weight'] / 60
visited_w = map.get(search['visited'], w)
if visited_w is None:
if visited_v["final"] == False:
dist_to_w = visited_v['distTo'] + time
total_time = dist_to_w
if total_time <= maxtime:
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w,
"final": False
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
c = 1
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def getTargetEdge(trip: dict, DataBase: dict) -> edge:
startId = int(trip["start station id"])
endId = int(trip["end station id"])
target = selectTarget(trip)
if not (map.contains(DataBase['target'], target)):
targetGraph = Structure.newTargetGraph()
map.put(DataBase['target'], target, targetGraph)
targetGraph = mapentry.getValue(map.get(DataBase['target'], target))
if not (graph.containsVertex(targetGraph, startId)):
graph.insertVertex(targetGraph, startId)
if not (graph.containsVertex(targetGraph, endId)):
graph.insertVertex(targetGraph, endId)
edgeRoute = graph.getEdge(targetGraph, startId, endId)
if edgeRoute is None:
graph.addEdge(targetGraph, startId, endId, 0)
edgeRoute = graph.getEdge(targetGraph, startId, endId)
return edgeRoute
def AddSameLanding_pointEdge(catalog):
"""
Unen los mismo landing_point
"""
# Obtener la lista de landing_point
landing_point_list = mp.keySet(catalog['map_landing_points'])
# Iterar sobre la lista de landing_point
landing_point_iterator = it.newIterator(landing_point_list)
while it.hasNext(landing_point_iterator):
landing_point = it.next(landing_point_iterator)
# Obtener el map de landing_point
landing_point_mapEntry = mp.get(catalog['map_landing_points'],
landing_point)
landing_point_map = me.getValue(landing_point_mapEntry)
# Obtener la lista de ciudades
ciudades_list = mp.keySet(landing_point_map)
# Iterar sobre ciudades
i = 0
ciudades_iterator = it.newIterator(ciudades_list)
while i < int(lt.size(ciudades_list)):
ciudad = it.next(ciudades_iterator)
# Crear la lista de vertex A
vertexA_list = lt.newList('ARRAY_LIST')
# Obtener la lista de vertex
vertex_list = gr.vertices(catalog['graph_landing_points'])
# iterar sobre la lista de vertices
vertex_iterator = it.newIterator(vertex_list)
while it.hasNext(vertex_iterator):
vertex = it.next(vertex_iterator)
# Separar el vertice
vertex_separado = vertex.split("*")
# Obtener la lista filtrada de vertices
if vertex_separado[0] == landing_point and vertex_separado[
1] == ciudad and not mp.contains(
catalog['capitals'], vertex_separado[1]):
lt.addLast(vertexA_list, vertex)
# Iterar sobre vertexA_list
vertexA_iterator = it.newIterator(vertexA_list)
while it.hasNext(vertexA_iterator):
vertexA = it.next(vertexA_iterator)
# Iterar sobre vertexA_list
vertexB_iterator = it.newIterator(vertexA_list)
while it.hasNext(vertexB_iterator):
vertexB = it.next(vertexB_iterator)
if gr.getEdge(catalog['graph_landing_points'], vertexA,
vertexB) == None:
gr.addEdge(catalog['graph_landing_points'], vertexA,
vertexB, float(0.1))
i += 1
def add_capital_edges(self, country):
if country == "Colombia":
country = country
capital = self.get_capital_id_safe(country)
cities = mp.get(self.point_country, country)
if cities:
city_it = ll_it.newIterator(cities['value'])
while ll_it.hasNext(city_it):
city = ll_it.next(city_it)
if capital != city:
if not gp.getEdge(self.connections_map, capital, city):
gp.addEdge(self.connections_map, capital, city,
self.haversine(capital, city))
gp.addEdge(self.connections_map, city, capital,
self.haversine(capital, city))
def test_getEdgesGraph(graph):
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Yopal')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.insertVertex(graph, 'Pasto')
g.insertVertex(graph, 'Barranquilla')
g.insertVertex(graph, 'Manizales')
g.addEdge(graph, 'Bogota', 'Yopal', 2)
g.addEdge(graph, 'Bogota', 'Medellin', 3)
g.addEdge(graph, 'Bogota', 'Pasto', 1)
g.addEdge(graph, 'Bogota', 'Cali', 10)
g.addEdge(graph, 'Yopal', 'Medellin', 20)
g.addEdge(graph, 'Medellin', 'Pasto', 4)
g.addEdge(graph, 'Cali', 'Pasto', 6)
g.addEdge(graph, 'Cali', 'Barranquilla', 3)
g.addEdge(graph, 'Barranquilla', 'Manizales', 10)
g.addEdge(graph, 'Pasto', 'Manizales', 8)
assert g.numVertices(graph) == 7
assert g.numEdges(graph) == 10
edge = g.getEdge(graph, 'Pasto', 'Medellin')
assert edge['weight'] == 4
def addConnection(catalog, origin, destination, distance):
edge = gr.getEdge(catalog['connections'], origin, destination)
if edge is None:
gr.addEdge(catalog['connections'], origin, destination, distance)
def addEdges(grafo, origin, destination, weight):
edge = gr.getEdge(grafo, origin, destination)
if edge is None:
gr.addEdge(grafo, origin, destination, weight)
def addEdge(catalog, origin, destination, weight):
edge = gr.getEdge(catalog['connections'], origin, destination)
if edge is None:
gr.addEdge(catalog['connections'], origin, destination, weight)
