def balanceamento_por_demanda(regioes, qtd_casas, qtd_centros):
# distribuição por demanda
centros = list(regioes.keys())
demanda_ideal = (qtd_casas - qtd_centros) / qtd_centros
for centro in regioes.keys():
grafo = regioes[centro]
if (len(list(grafo.neighbors(centro))) <= demanda_ideal):
continue
for cliente in list(grafo.neighbors(centro)):
centros.sort(reverse=True, key=lambda centro : distancia(centro, cliente))
if (len(list(regioes[centros[1]].neighbors(centros[1]))) < demanda_ideal):
if (centros[1].maior_distancia * 1.2) >= distancia(cliente, centros[1]):
grafo.remove_node(cliente)
regioes[centros[1]].add_node(cliente)
regioes[centros[1]].add_edge(cliente, centros[1], distancia=distancia(centros[1], cliente))
elif (len(list(regioes[centros[2]].neighbors(centros[2]))) <= demanda_ideal):
if (centros[2].maior_distancia * 1.2) >= distancia(cliente, centros[2]):
grafo.remove_node(cliente)
regioes[centros[2]].add_node(cliente)
regioes[centros[2]].add_edge(cliente, centros[2], distancia=distancia(centros[2], cliente))
if (len(list(grafo.neighbors(centro))) <= demanda_ideal):
break
def heuristica(v):
if h[v] == inf:
h[v] = (distancia(
G.llegir_atributs(v)["coords"],
G.llegir_atributs(f)["coords"]) - distancia(
G.llegir_atributs(v)["coords"],
G.llegir_atributs(i)["coords"])) / 2
return h[v]
def balanceamento_por_volume(regioes, volume_total, qtd_centros):
volume_ideal = volume_total / qtd_centros
for centro in regioes.keys():
if (centro.volume <= volume_ideal):
continue
# ordena a partir dos clientes mais distantes
clientes = list(regioes[centro].neighbors(centro))
clientes.sort(reverse=True, key=lambda cliente : distancia(centro, cliente))
# quantidade de clientes que serão deslocados, garantidos pela taxa de 87%
# de melhoria das distribuições de serviços
qtd_melhoria = math.floor(len(clientes) * 0.90)
while qtd_melhoria > 0 and centro.volume > volume_ideal:
# pega o cliente
cliente = clientes.pop(0)
# remove esse cliente para entrega deste centro de distribuição
regioes[centro].remove_node(cliente)
# atualiza o volume
centro.volume -= cliente.volume
possiveis_centros = list(regioes.keys())
possiveis_centros.remove(centro)
possiveis_centros.sort(reverse=True, key=lambda c: distancia(c, cliente))
definiu = False
contador = 0
while not definiu and len(possiveis_centros) > 0 and contador < 2:
contador += 1
possivel_centro = possiveis_centros.pop(0)
if (possivel_centro.volume + cliente.volume) <= volume_ideal:
if (possivel_centro.maior_distancia * 1.2) >= distancia(cliente, possivel_centro):
definiu = True
regioes[possivel_centro].add_node(cliente)
regioes[possivel_centro].add_edge(cliente, possivel_centro, distancia=distancia(possivel_centro, cliente))
possivel_centro.volume += cliente.volume
# caso não seja encontrado um outro centro de distribuição que
# consiga atender este cliente, ele deverá ainda ser atendido pelo
# centro em que já se encontrava
if not definiu:
regioes[centro].add_node(cliente)
regioes[centro].add_edge(cliente, centro, distancia=distancia(centro, cliente))
centro.volume += cliente.volume
# atualiza a quantidade de clientes que podem ser melhorados
qtd_melhoria -= 1
def a_star(G, i, f, nom_atribut_pes):
distancies = [inf] * G.ordre()
distancies[i] = 0
predecessors = [None] * G.ordre()
PQ = PriorityQueue()
PQ.put((distancies[i], i))
while not PQ.empty():
u = PQ.get()[1]
if u == f:
return reconstruir_cami(predecessors, f)
for v in G.llista_adjacencia[u]:
g = distancies[u] + G.llegir_atributs((u, v))[nom_atribut_pes]
if g < distancies[v]:
predecessors[v] = u
distancies[v] = g
PQ.put((distancies[v] + distancia(
G.llegir_atributs(v)["coords"],
G.llegir_atributs(f)["coords"]), v))
return None
def getFitnessCromosoma(self, cromosoma):
'''
El tiempo que tardan en recorrer todos los nodos del grafo es el maximo de los tiempos que tardan los drones en hacer su ruta.
Asumiendo que todos los drones van a la misma velocidad, se calcula el fitness como el maximo de las distancias recorridas por cada UAV.
Para este problema: Mayor fitness -> Peor cromosoma.
'''
ciudades_dron = []
last_index = 0
for n_ciudades_dron in cromosoma[-len(self.drones):]:
ciudades_dron.append(cromosoma[last_index:last_index +
n_ciudades_dron])
last_index += n_ciudades_dron
distancias_recorridas_drones = []
if self.contar_pos_inicial_en_fitness:
for i, posicion_actual_dron in enumerate(
[dron.posicion_actual for dron in self.drones]):
distancia_recorrida_dron = 0
for ciudad in ciudades_dron[i]:
distancia_recorrida_dron += utils.distancia(
posicion_actual_dron, self.nodos[ciudad])
posicion_actual_dron = self.nodos[ciudad]
distancias_recorridas_drones.append(distancia_recorrida_dron)
else:
for i in range(len(self.drones)):
posicion_actual_dron = self.nodos[ciudades_dron[i][
0]] # Posicion inicial primer nodo del grafo
distancia_recorrida_dron = 0
for ciudad in ciudades_dron[i]:
distancia_recorrida_dron += utils.distancia(
posicion_actual_dron, self.nodos[ciudad])
posicion_actual_dron = self.nodos[ciudad]
distancias_recorridas_drones.append(distancia_recorrida_dron)
return np.max(distancias_recorridas_drones) + np.sum(
distancias_recorridas_drones)
def unifica_nomes_parecidos(nome):
if not nome:
return nome
if not isinstance(nome, str):
return nome
global registro
try:
if not nome.lower() in registro:
for key in registro.keys():
if len(nome) > 20 and distancia(nome, key) < 5:
logging.info("Renomeando: {} => {}".format(nome, key))
registro[nome.lower()] = key
break
if not nome.lower() in registro:
registro[nome.lower()] = nome
return registro[nome.lower()]
except TypeError:
return nome
def visual(G, i, f, nom_atribut_pes, heuristiques):
distancies = [inf] * G.ordre()
distancies[i] = 0
predecessors = [None] * G.ordre()
PQ = PriorityQueue()
PQ.put((distancies[i], i))
visualitzacio = []
while not PQ.empty():
u = PQ.get()[1]
if predecessors[u] is not None:
visualitzacio.append([[
G.llegir_atributs(predecessors[u])["coords"],
G.llegir_atributs(u)["coords"]
], "Lime"])
if u == f:
return reconstruir_cami(predecessors, f), visualitzacio
for v in G.llista_adjacencia[u]:
g = distancies[u] + G.llegir_atributs((u, v))[nom_atribut_pes]
if g < distancies[v]:
predecessors[v] = u
distancies[v] = g
if heuristiques:
PQ.put((distancies[v] + distancia(
G.llegir_atributs(v)["coords"],
G.llegir_atributs(f)["coords"]), v))
else:
PQ.put((distancies[v], v))
visualitzacio.append([[
G.llegir_atributs(u)["coords"],
G.llegir_atributs(v)["coords"]
], "ForestGreen"])
return None, visualitzacio
def processar_osm():
'''Processa el fitxer OSM XML i en crea un graf.
Un cop s'ha obtingut el graf, es guarda en pickle (un format per guardar
objectes de Python) per no haver-lo de processar cada cop.'''
element_tree = xml.parse("mapa.osm").getroot()
dicc_vertexs = {}
vies = []
tipus_via = [
"motorway", "motorway_link", "trunk", "trunk_link", "primary",
"primary_link", "secondary", "secondary_link", "tertiary",
"tertiary_link", "unclassified", "residential", "service",
"living_street", "track"
]
for i in element_tree:
if i.tag == "node":
dicc_vertexs[int(i.attrib["id"])] = [
float(i.attrib["lat"]),
float(i.attrib["lon"])
]
elif i.tag == "way":
via = []
unidireccional = False
insertar = False
for j in i:
if j.tag == "nd":
via.append(int(j.attrib["ref"]))
elif j.tag == "tag":
if (j.attrib["k"] == "oneway" and j.attrib["v"] == "yes"
) or (j.attrib["k"] == "junction" and
(j.attrib["v"] in ["roundabout", "circular"])):
unidireccional = True
elif j.attrib["k"] == "highway" and j.attrib[
"v"] in tipus_via:
insertar = True
if insertar:
vies.append(via)
if not unidireccional:
vies.append(list(reversed(via)))
G = GrafDirigit()
for id, coordenades in dicc_vertexs.items():
for via in vies:
if id in via:
dicc_vertexs[id] = G.ordre()
G.afegir_vertex(coords=coordenades)
break
for via in vies:
for i, id in enumerate(via):
via[i] = dicc_vertexs[id]
for i in range(len(via) - 1):
G.afegir_aresta((via[i], via[i + 1]))
for e in G.arestes():
G.assignar_atributs(e,
llargada=distancia(
G.llegir_atributs(e[0])["coords"],
G.llegir_atributs(e[1])["coords"]))
fitxer = open("graf.pickle", "wb")
pickle.dump(G, fitxer)
fitxer.close()
qtdNodes = 100 kmin = 5 kmax = 20 kopt = kmin timeslot = 0.1 # tempo de slot (segundo) round_length = 500 # tamanho do round (timeslots) round_time = round_length * timeslot # tempo do round (segundos) horizon = 10 # horizonte de predição (rounds) payload = 2000 area = 100 qtd_setores = 2 BS = [0, area+25.0, area/2, 0.0, 0] distMax = distancia(0,0, area,area) cluster_len = qtdNodes/kopt pwr_max_tx = 0.0801 # W pwr_rx = 0.0222 # W pwr_ch_tx = 0.0267 # W (valor aproximado para a primeira vez, já que não tem como calcular) packet_rate = 0.5 # pacotes/s energy = 0.5*0.000154*0.22*400 ener_max_tx = pwr_max_tx * timeslot ener_rx = pwr_rx * timeslot ener_nch_tx = pwr_ch_tx * timeslot ener_agg = 0.00001*(cluster_len-1) ener_setup = ener_max_tx + (cluster_len-1)*ener_rx + ener_nch_tx
for i in range(qtd_casas - qtd_centros):
leitura = arquivo.readline().split()
clientes.append(ler_cliente(float(leitura[0]), float(leitura[1]), float(leitura[2]), float(leitura[3]), float(leitura[4]), False))
for i in range(qtd_veiculos):
leitura = arquivo.readline().split()
veiculos.append(ler_veiculo(float(leitura[0]), float(leitura[1]), float(leitura[2]), float(leitura[3]),
float(leitura[4]), float(leitura[5]), float(leitura[6]), float(leitura[7]), float(leitura[8]), float(leitura[9])))
volume_total = 0
distancia_total = 0
# definição a partir de proximidade
for cliente in clientes:
menor_centro = list(regioes.keys())[0]
menor_distancia = distancia(cliente, menor_centro)
for centro in regioes.keys():
if (distancia(cliente, centro) < distancia(cliente, menor_centro)):
menor_centro = centro
menor_distancia = distancia(cliente, centro)
regioes[menor_centro].add_node(cliente)
regioes[menor_centro].add_edge(cliente, menor_centro, distancia=menor_distancia)
menor_centro.volume += cliente.volume
menor_centro.pacotes += cliente.pacotes
menor_centro.soma_distancias += distancia(cliente, menor_centro)
# encontra a maior distancia de cliente e centro
if menor_centro.maior_distancia < menor_distancia:
# RECEPÇÃO CH: Chs recebem o broadcast dos outros CHs
for ch in CH:
for pkt in pacotesBroadcast:
if (pkt[0] != ch[0]):
ch[10].append(pkt)
ch[1] = gastoRx(ch[1], tamPacoteConfig)
if (nodes != []):
# RECEPÇÃO NCH: Recepção dos Pacotes de Bradcast
for n in nodes:
menorDistancia = n[4]
nodeMenorDistancia = []
# Escolha do CH (o mais próximo)
for pack in pacotesBroadcast:
dist = distancia(n[2], n[3], pack[1], pack[2])
if (dist < menorDistancia):
menorDistancia = dist
nodeMenorDistancia = pack
# Atualização dos valores
n[10] = [nodeMenorDistancia]
n[4] = menorDistancia
n[1] = gastoRx(
n[1], tamPacoteConfig
) # !!!! esse gasto não deveria ser no for acima??
print("NCHs se associam")
# TRANSMISSÃO NCH: Envio de Pacotes Resposta
for n in nodes:
node = [n[0], n[2], n[3], n[4], 0]
# localiza o CH escolhido na lista de CH e coloca seu node em ListCL do CH
list_area = [100]
arquivo = open('novo-arquivo.txt', 'w')
arquivo_bat = open('bateria.csv', 'a')
############################### Main ################################
# Realiza a variação de um dos cenários (Quem usar a variável: cenario)
qtdNodes = list_qtdNodes[0]
qtdFrames = list_qtdFrames[0]
tamPacoteTransmissao = list_tamPacoteTransmissao[0]
percentualCH = list_percentualCH[0]
qtdSetores = list_qtdSetores[0]
area = list_area[0]
distMax = distancia(0, 0, area, area)
BS = [0, area + 25.0, area / 2, 0.0, 0]
print("\n\nCENÁRIO: " + str(qtdNodes) + ' nodes, ' + str(qtdFrames) +
' frames, ' + str(tamPacoteTransmissao) + ' bits, ' +
str(int(percentualCH * 100)) + '%, ' + str(int(qtdSetores)) +
' setores, ' + str(int(area)) + ' m2')
col = "Round"
for i in range(1, qtdNodes + 1):
col += " id bat"
arquivo_bat.write(col + "\n")
# Altera entre os modos de operação do multi-hop
for modoOp in modosHop:
intraCluster = modoOp[0]