Carlos Alberto Nunes da S. Jr.

PROJETO E OTIMIZAÇÃO MULTIDISCIPLINAR

TRABALHO 01

Prof. Bento Silva de Matos

São José dos Campos

17 de Agosto de 2018
 Sumário

1 ESTRUTURAÇÃO DO PROBLEMA ........................................................................... 3

1.1 Objetivos .................................................................................................................... 4
1.2 Variáveis de Projeto ................................................................................................. 5
1.3 Restrições ................................................................................................................... 5
1.4 Parâmetros dos Sensores.......................................................................................... 5

2 DESCRIÇÃO DA METODOLOGIA ............................................................................. 5

2.1 Cálculo da Área Coberta ......................................................................................... 6
2.2 Cálculo da Autonomia da Rede ............................................................................... 9
2.3 Otimização Multiobjetivo ...................................................................................... 10

3 GRÁFICOS DE CONVERGÊNCIA E FRENTE DE PARETO ............................... 10

4 ANÁLISE DOS RESULTADOS ................................................................................... 13

5 CONCLUSÃO................................................................................................................. 13

6 CÓDIGO DE OTIMIZAÇÃO ....................................................................................... 14

 3

1 Estruturação do Problema

Neste trabalho é determinado o posicionamento ótimo de um conjunto de sensores para o

funcionamento de uma rede de comunicação sem fio. Eles são lançados por um veículo aéreo
não tripulado e são ser capazes de enviar as informações coletadas para um sensor central de
longo alcance (LRCN – Long Range Communication Node), que, em seguida, transmite a
informação para um satélite ou aeronave.
Existe um raio de comunicação limitado e um número máximo de transmissões antes
que a bateria do sistema acabe e pare de funcionar. Além disso, caso a distância entre um sensor
e o vizinho seja menor que o raio de comunicação, a informação poderá ser transferida entre
eles até chegar ao LRCN.
A Figura 1.1 a seguir mostra dois tipos básicos de configuração dos sensores. No
primeiro posicionamento toda as informações dos sensores 2,3 e 4 chegam ao LRCN por meio
sensor 1. Quando este atingir o número máximo de transmissões toda a rede irá deixar de
funcionar. Já no segundo posicionamento os sensores 1,2,3 e 4 se conectam diretamente ao nó
central, dessa forma, se um sensor atingir o limite de transmissões o funcionamento dos demais
não será afetado.

Figura 1.1 – Grupos de configurações de posicionamento dos sensores

 4

1.1 Objetivos

Os dois objetivos deste trabalho são: maximizar a cobertura e autonomia da rede de sensores.
A cobertura da rede é dada por:

Área Coberta Pela Rede

Cobertura  (1.1)
Área Total

A interseção entre as áreas cobertas por dois sensores ou mais deverá ser contabilizada apenas
uma vez (área azul mostrada na Figura 1.2); caso parte da cobertura do sensor esteja fora da
área total (área em vermelho), esta será desconsiderada no cálculo da área coberta pela rede.

Figura 1.2 – Representação da área de cobertura

Já a autonomia é definida pela seguinte relação:

Número de Ciclos
Autonomia  (1.2)
Número de Ciclos Total

O ciclo é definido como o evento onde todos os sensores ativos enviam as informações para o
NRCN. O número de ciclos é a quantidade de ciclos necessários para que a área total coberta
pelos sensores fique abaixo de 90% da área inicial. O número de ciclos total é a máxima
 5

quantidade de ciclos até que todos os sensores fiquem impossibilitados de enviar suas
informações para o NRCN, por falta de conexão ou por falta de carga.

1.2 Variáveis de Projeto

As variáveis utilizadas como entrada na otimização serão as coordenadas x e y dos pontos de

posicionamento dos sensores no plano xy.

X   x1 y5 
T
x5 y1
(1.3)

1.3 Restrições

Os sensores que estiverem desconectados do LRCN não contribuem para a cobertura e

funcionamento da rede, portanto são desprezíveis.

1.4 Parâmetros dos Sensores

Serão utilizados 5 sensores, cada um com raio de comunicação constante igual a 2, e

posicionados em uma região quadrada com lado igual a 10. O número máximo de transmissões
que cada sensor pode fazer é igual a 100, e, para cada transmissão efetuada, esse valor é
reduzido ém 1 unidade, até chegar a 0 e inutilizar o sensor.

2 Descrição da Metodologia

O algoritmo de otimização será composto por três rotinas principais que tem as seguintes
funções:
i. Calcular a área coberta pela rede.
ii. Calcular a autonomia da rede.
iii. Executar a otimização multiobjetivo usando algoritmo genético.
 6

2.1 Cálculo da Área Coberta

Para determinar a área coberta é necessário inicialmente avaliar quais sensores podem enviar
informação para o LRCN. Deve-se então, para um conjunto de sensores, determinar quais são
os sensores vizinhos (possuem distâncias entre si menor que o raio) e qual o caminho mais
rápido para levar a informação até o sensor central. O método adotado nesse trabalho consiste
em transformar a região quadrada onde os sensores são posicionados em uma matriz com
dimensão n x n conforme mostrado na Figura 2.1.

Figura 2.1 – Matriz que representa o posicionamento dos sensores

A matriz é inicializada com todos seus elementos iguais a 0, em seguida determinam-se

os índices correspondentes ao posicionamento do sensor pela seguinte equação, sendo que ceil
é a função que arredonda para cima o valor encontrado dentro dos parênteses:

x 
ic  ceil   n 
L 
y 
jc  ceil   n 
L  (2.1)

Os índices 𝑖𝑐 e 𝑗𝑐 representam, respectivamente, as linhas e colunas da matriz onde

estará localizado o sensor e receberá valor 2.
Em seguida são calculadas as posições da matriz correspondentes à área de cobertura do sensor.
Deve-se então fazer uma varredura, começando pelos índices iniciais e indo até os índices
finais, os quais estão mostrados na Equação 2.2 abaixo:
 7

R 
nsweep  ceil  sensor  n 
 L 
 ic  nsweep 
Indexinitial   
 jc  nsweep 
 ic  nsweep 
Index final   
 jc  nsweep  (2.2)

Em cada iteração é calculada a distância euclidiana do ponto analisado até o sensor, se

essa distância for menor ou igual ao raio de comunicação então a posição analisada na matriz
receberá valor 1. Caso algum desses índices possuam valor menor do que 1 ou maior do que n,
os índices serão modificados para valores iguais a 1 ou n, respectivamente.
Para determinar se um sensor está conectado a um outro sensor qualquer basta somar as
matrizes que representam o posicionamento desses sensores e calcular o máximo elemento da
matriz resultante, de forma que serão possíveis os seguintes resultados:

 Máximo > 2, os dois sensores podem comunicar entre si.

 Máximo ≤ 2, os dois sensores não podem comunicar entre si.

Repetindo esse processo para todos os sensores determina-se a matriz que contém as
relações entre os sensores conforme mostrado abaixo:

0 1 3 4 5 1
1 0 2 1 1 1

2 1 1 1 1 1
R 
3 0 5 1 1 1
4 0 5 1 1 1
 
5 0 3 4 1 1 (2.3)

Essa matriz representa as relações de conexões entre os sensores mostrados na Figura

2.2. A primeira coluna corresponde ao índice do sensor, onde 0 foi utilizado para identificar o
LRCN. As colunas subsequentes contêm os índices dos sensores que estão conectados ao sensor
representado na primeira coluna. Ex: a linha do LRCN contém os valores 1, 3, 4 e 5, indicando
 8

que esses sensores estão conectados ao LRCN; quando não existe mais sensores conectados
então a posição é preenchida com o valor -1.

Figura 2.2 – Exemplo de posicionamento de sensores

Uma vez determinada as conexões dos sensores deve-se procurar pelo caminho mais
curto entre o um determinado sensor e o LRCN, o qual pode ser obtido pelo método BFS
(Breadth First Search). Essa função foi implementada, tendo como entrada a matriz R da
equação 2.3 e retorna como saída a seguinte matriz:

0 0 0 0 0
1 1 3 4 5 

 1 2 1 1 1
BFS   
 1 1 1 1 1
 1 1 1 1 1
 
 1 1 1 1 1 (2.4)

Cada coluna da matriz mostrada na Equação 2.4 representa o caminho mais curto entre
um sensor e o LRCN. Caso não haja nenhum caminho a coluna será toda igual a -1, o sensor
não irá contribuir para o funcionamento da rede e deverá ser excluído do cálculo.
 9

Por fim, o cálculo da área de cobertura será obtido por meio da definição de uma nova
matriz 𝑀𝑡𝑜𝑡𝑎𝑙 que contém a soma das matrizes correspondentes aos nós que são capazes de
enviar informação para o LRCN. Os valores de 𝑀𝑡𝑜𝑡𝑎𝑙 são normalizados de tal forma que serão
iguais a 1 onde existir um sensor e sua área de cobertura e 0 caso contrário. Sendo assim a área
coberta pela rede poderá ser calculada como:

2
 10 
  i 1  j 1 M total (i, j)
n n
Área Coberta Pela Rede   (2.5)
 n 1 

2.2 Cálculo da Autonomia da Rede

Na Figura 2.3 abaixo está ilustrado o processo iterativo utilizado para calcular a autonomia da
rede. O algoritmo é composto por um ciclo global, que será executado no máximo 100 vezes.
Cada vez que esse ciclo é executado realiza-se o envio de informação de todos os sensores,
atualiza-se a carga e as conexões até o LRCN.
Durante esse processo a área coberta pela rede é constantemente avaliada e, no momento que
seu valor fica abaixo de 90% da área inicial, grava-se o número de ciclos já executados.

Figura 2.3 – Fluxo de processo para calcular a autonomia da rede

 10

2.3 Otimização Multiobjetivo

Para executar a otimização multiobjetivo, onde-se deseja maximizar área coberta e a autonomia
da rede é utilizada a função gamultiobj do software Matlab. Essa função recebe como entradas
as funções que se deseja otimizar (funções para cálculo da área e autonomia), o número de
variáveis de entrada e os limites inferior e superior que podem ser atribuidos às mesmas.
O resultado da otimização será uma solução de Pareto ótima, ou seja, o conjunto de
coordenadas de sensores tal que não é possível obter uma melhora em um dos objetivos sem
que haja uma diminuição do outro objetivo.

3 Gráficos de Convergência e Frente de Pareto

A Figura 3.1 mostra o espalhamento médio de cada geração até obter a Frente de Pareto

Figura 3.1 – Espalhamento médio

Na Figura 3.2 está traçado o gráfico da frente de Pareto:

 11

4
3 1

5
2

Figura 3.2 – Frente de Pareto

Onde os objetivos 1 e 2 são definidos conforme mostrado na Equação 3.1. Como o

algoritmo utilizado minimiza as funções objetivos, então, obter o máximo das funções que
calculam a autonomia e a área coberta, é equivalente a minimizar o valor negativo de autonomia
e área coberta.

Objetivo 1  - Autonomia
(3.1)
Objetivo 2  - Cobertura

Utilizando a Equação 3.1 e os valores obtidos da otimização é possível determinar a

autonomia e cobertura dos pontos ótimos. Os resultados estão mostrados na Tabela 1 abaixo:

Tabela 1 – Pontos da frente de Pareto

Ponto Objetivo 1 Objetivo 2 Autonomia Cobertura

1 -0,67 -0,45 0,67 0,45
2 -0,50 -0,50 0,50 0,50
3 -0,74 -0,45 0,74 0,45
4 -1,00 -0,42 1,00 0,42
5 -0,67 -0,47 0,67 0,47

Os layouts correspondentes a cada ponto da Tabela 1 estão representados na Figura 3.3.

É possível notar que existem vários outros pontos ótimos que podem ser obtidos apenas pela
rotação do posicionamento dos sensores em 90° em relação ao eixo perpendicular à página e
que passa pelo LRCN.
 12

Figura 3.3 – Posicionamento dos sensores nos pontos da solução de Pareto Ótima
 13

4 Análise dos Resultados

Para a situação onde o LRCN está localizado no centro do espaço de projeto a otimização
mostrou que os pontos ótimos da Frente Pareto representam layouts de posicionamento que
estão entre dois extremos, o primeiro onde todos os sensores estão conectados ao LRCN
(favorece a autonomia mas prejudica a cobertura), e o segundo onde todos os sensores se
conectam ao LRCN por meio de um único sensor (posicionamento que possui a pior autonomia
mas a área de cobertura é maior que no primeiro caso).
A solução ótima utilizando a otimização multiobjetivo por meio de um algoritmo
genético resulta em um posicionamento onde pelo menos um dos sensores transmite os dados
de um sensor vizinho, além de seu próprio envio de informação para o LRCN. Além disso, a
distância entre os centros dos sensores e LRCN é a máxima possível, evitando assim a
sobreposição de cobertura com sensores vizinhos e aumentando a área de atuação.

5 Conclusão

A elaboração deste trabalho mostrou que a compreensão e correta modelagem do problema é

uma etapa extremamente importante do processo de otimização de um projeto. O caso analisado
é uma simplificação de um problema real, onde a determinação do ponto ótimo de apenas um
objetivo não significa que o sistema como um todo terá a melhor performance.
Além disso, a aplicação do conceito de Frente de Pareto é facilmente entendida a partir
da análise dos resultados, o que facilita a aplicação desse método para problemas mais
complexos e com mais objetivos. Por fim, percebe-se também que é possível saber a priori qual
o perfil da solução a ser encontrada. Neste caso em específico eram conhecidos dois extremos
de layout, um onde a autonomia era máxima, e outro que possuia uma maior cobertura mas
eficiência mínima, portanto a solução ótima deveria ter um perfil entre esses dois extremos, o
que de fato aconteceu.
 14

6 Código de Otimização

function [x,fval] = optimize

FitnessFunction = @main;
numberOfVariables = 10;

A = []; b = [];
Aeq = []; beq = [];
lb = 0*ones(numberOfVariables,1);
ub = 10*ones(numberOfVariables,1);

options =
gaoptimset('Display','iter','PlotFcns',{@gaplotpareto,@gaplotscoredivers
ity,@gaplotspread});

[x,fval] =
gamultiobj(FitnessFunction,numberOfVariables,[],[],[],[],lb,ub,options);

end

function y = main(x)

R = 2;
L = 10;
n = 150;

n_coord = length(x)/2;

coord_sensor = zeros(n_coord+1,2);
coord_sensor(1,1) = 5;
coord_sensor(1,2) = 5;

coord_sensor(2:end,1) = x(1:n_coord);
coord_sensor(2:end,2) = x(n_coord+1:end);

% plot_chart(coord_sensor,R,title_chart);

[endurance,covered_area_ratio] = get_max_cycles(coord_sensor,R,L,n);

y(1) = endurance;
y(2) = covered_area_ratio;

end
 15

function [endurance,covered_area_ratio] = get_max_cycles(coord_sensor,R,L,n)

[fastest_path,coord_sensor,nodes_to_delete,covered_area_initial] =
updated_fastest_path(coord_sensor,R,L,n);

covered_area_ratio = covered_area_initial/L^2;

max_packs = 100;
max_iter = max_packs*2;
number_of_nodes = size(coord_sensor,1);

covered_area_criteria = 0.90;
number_of_trans_before_reach_cov_area = 0;

packs_count = zeros(number_of_nodes,2);
packs_count(:,1) = find(nodes_to_delete==0)-1;
packs_count(:,2) = max_packs;

number_of_transmission = 0;

all_nodes_died = 0;

%transmission_checker >> when all colluns is equal to 1, means that info

%has bee sent

if size(fastest_path,2)== 0
% fprintf('\n Max. Number of Transmission: %d\n',0);

else

for kk = 1:max_iter
number_of_cols_to_sweep = size(fastest_path,2);
j = 1;

while j<=number_of_cols_to_sweep
for i=1:size(packs_count,1)%varrendo ao longo das linhas
if fastest_path(i,j)>-1%otimizar isso depois
line_being_checked = find((packs_count(:,1)==fastest_path(i,j))==1);%linha
correspondente ao no que zerou o contador
if line_being_checked>1 %se esta analisando o no apos o NRCN
%reduzindo o numero de transmissoes do contador
packs_count(line_being_checked,2) = packs_count(line_being_checked,2)-1;
end
end
end % iteracao nos packs

%deletando so nos que estao sem carga

line_to_be_deleted = find(packs_count(:,2)==0);

if size(line_to_be_deleted,1)>0
 16

coord_sensor(line_to_be_deleted,:) = [];
packs_count(line_to_be_deleted,:) = [];

packs_count(line_to_be_deleted:end,1) =
packs_count(line_to_be_deleted:end,1)-1;%cuidado aqui

coord_sensor_old = coord_sensor;

[fastest_path,coord_sensor,nodes_to_delete,covered_area]
= updated_fastest_path(coord_sensor,R,L,n);
nodes_remaining = get_nodes_remaining(fastest_path);

if
(covered_area/covered_area_initial)<covered_area_criteria &&
number_of_trans_before_reach_cov_area == 0
number_of_trans_before_reach_cov_area = kk;
end

%deletar as linhas nao uteis

%copiar os valores do fastest path

packs_count_temp = zeros(size(coord_sensor,1),2);

for qq = 1:size(packs_count_temp,1)
index_row =
find(ismember(coord_sensor_old,coord_sensor(qq,:),'rows')==1);
packs_count_temp(qq,2) = packs_count(index_row,2);
packs_count_temp(qq,1) = nodes_remaining(qq);
end

packs_count = packs_count_temp;

number_of_cols_to_sweep = size(fastest_path,2);
end

if size(fastest_path,2)== 0 | fastest_path==-1
all_nodes_died = 1;
break;
end

j=j+1;

end

if all_nodes_died
% fprintf('\n All nodes died!');
break;
end

end
 17

number_of_transmission = kk;
end

if number_of_transmission==0
endurance = 0;
covered_area_initial = 0;
else
endurance =
number_of_trans_before_reach_cov_area/number_of_transmission;
end

endurance = -endurance;
covered_area_ratio = -covered_area_ratio;

%% fprintf('\n Max. Number of Transmission: %d',number_of_transmission);

% fprintf('\n Initial Covered Area: %4.2f',covered_area_initial);
% fprintf('\n Max Cycles Endurance:
%4.2f',number_of_trans_before_reach_cov_area);
%% fprintf('\n Max. Endurance: %4.2f%%\n',endurance*100);
% fprintf('\n');
end
 18

function nodes_remaining = get_nodes_remaining(fastest_path)

num_nodes = size(fastest_path,2);
nodes_remaining = zeros(num_nodes,1);

for jj = 1:num_nodes
for ii = 1:num_nodes+1
if fastest_path(ii,jj)==-1
break
end
nodes_remaining(jj,1) = fastest_path(ii,jj);
end
end

nodes_remaining = [0;nodes_remaining];
end

function
[fastest_path_new,coord_sensor_new,nodes_to_delete,covered_area] =
updated_fastest_path(coord_sensor,R,L,n)

[m] = get_sensor_coord(coord_sensor,R,L,n);

%finding nodes that are neighbors

[nodes_sensor] = get_sensor_neighbor_nodes(m);

%getting the fastest path

fastest_path = get_fastest_path(coord_sensor,nodes_sensor);

%deleting nodes that aren't connected to node NRCN

[coord_sensor_new,fastest_path_new,nodes_to_delete] =
delete_unlinked_nodes(coord_sensor,fastest_path);

[m_new] = get_sensor_coord(coord_sensor_new,R,L,n);

m_total = zeros(size(m_new,1),size(m_new,2));

for j = 2:size(m_new,3);
m_total = m_total+m_new(:,:,j);

end

max_element = max(max(m_total));

m_total = ceil(m_total/max(max(m_total)));

d_area = (L/(n-1))^2;

covered_area = sum(sum(m_total))*d_area;

if (max_element==0)
covered_area=0;
end

end
 19

function fastest_path = get_fastest_path(coord_sensor,nodes_sensor)

number_of_nodes = size(coord_sensor,1);

%finding the fastes path between node i and node NRCN

fastest_path = zeros(number_of_nodes,number_of_nodes-1);
for j = 1:number_of_nodes-1
fastest_path(:,j) = bfs (nodes_sensor,j,0);
end
end

function [nodes_sensor] = get_sensor_neighbor_nodes(m)

number_of_nodes = size(m,3);

nodes_sensor = -ones(number_of_nodes,number_of_nodes+1);

nodes_sensor(:,1) = 0:number_of_nodes-1;

for kk = 1:number_of_nodes %varrendo as matrizes com coordenadas dos

sensores
current_matrix = m(:,:,kk);
col_count = 2;

for qq = 1:number_of_nodes
matrix_of_node_being_checked = m(:,:,qq);

%checking if nodes is neighboor

if max(max(abs(current_matrix+matrix_of_node_being_checked)))>2
nodes_sensor(kk,col_count) = nodes_sensor(qq,1);
end
col_count = col_count+1;
end

end

%apenas ajustando a matriz

nodes_sensor_temp = -ones(number_of_nodes);

for i=1:number_of_nodes
col_count = 1;
for j=1:number_of_nodes
if i~=j
if nodes_sensor(i,j+1)~=-1
nodes_sensor_temp(i,col_count) = nodes_sensor(i,j+1);
col_count = col_count+1;
end
end
end

end
nodes_sensor (:,2:end) = nodes_sensor_temp;

end
 20

function [fastest_path] = bfs (nodes,node_1,node_2)

num_nodes = size(nodes,1);
num_cols = size(nodes,2);

max_iter = num_nodes+1;

q = -ones(num_nodes,1);
q(1,1) = nodes(nodes(:,1)==node_1,1);

q_last_filled_index = 1;

visit_table = zeros(num_nodes,2);
visit_table(:,1) = nodes(:,1);

prev = zeros(num_nodes,2);
prev(:,1) = nodes(:,1);

count = 0;
while q(1,1)>-1

visit_table(visit_table(:,1)==q(1,1),2) = 1; %equivalent to
find(visit_table==q(1,1))

line_being_checked = nodes(:,1)==q(1,1);

node_come_from = q(1,1);

%shifting line
q = [q(2:end);-1];

for j = 2:num_cols
node_being_checked = nodes(line_being_checked,j);

if node_being_checked > -1 &&

visit_table(visit_table(:,1)==node_being_checked,2) == 0 %vistiting node

q(q_last_filled_index,1) = node_being_checked;
visit_table(visit_table(:,1)==node_being_checked,2) = 1;

prev(visit_table(:,1)==node_being_checked,2) =
node_come_from;

q_last_filled_index = q_last_filled_index + 1;
end

end

q_last_filled_index = q_last_filled_index-1;

count = count+1;
if count==max_iter
disp('stopped');
break
end
end
 21

count = 0;

prev(visit_table(:,1)==node_1,2) = -1;

fastest_path = -ones(num_nodes,1);

fastest_path(1,1) = node_2;
id_count = 2;

current_node = node_2;

while current_node~=node_1

fastest_path(id_count,1) = prev(visit_table(:,1)==current_node,2);
current_node = prev(visit_table(:,1)==current_node,2);

id_count = id_count+1;

count = count+1;
if count==max_iter
break
end

end

if (fastest_path)==0
fastest_path = -ones(num_nodes,1);
end
end
 22

function [m] = get_sensor_coord(coord_sensor,R,L,n)

number_of_sensors = size(coord_sensor,1);

m = zeros(n,n,number_of_sensors);
m_total = zeros(n,n);

for j = 1:number_of_sensors
[m(:,:,j)] = get_matrix_filled(coord_sensor(j,:),L,n,R);
% m_total = m_total+m(:,:,j);
end

% m_total = m_total/max(max(m_total));

% clf
% spy(m_total);
% pause
end

function [m] = get_matrix_filled(coord_sensor,L,n,R)

m = zeros(n);

center = ceil(coord_sensor/L*n);

n_sweep = ceil(R/L*n);

index_initial_sweep = center - n_sweep; %coord x and y initial

index_final_sweep = center + n_sweep; %coord x and y final

for i=1:length(index_initial_sweep)
if index_initial_sweep(i)<1
index_initial_sweep(i) = 1;
end
end

for i=1:length(index_initial_sweep)
if index_final_sweep(i)>n
index_final_sweep(i) = n;
end
end

for i = index_initial_sweep(1):index_final_sweep(1)
for j = index_initial_sweep(2):index_final_sweep(2)
dx = (abs(i-center(1))/n*L);
dy = (abs(j-center(2))/n*L);

if (dx^2+dy^2)^.5<R % if distance is lower than radius..

m(i,j) = 1;
end

end
end
 23

for i=1:2
if center(i)>n
center(i) = n;
elseif center(i)<=0
center(i) = 1;
end

end

m(center(1),center(2)) = 2;

m = m';

end
 24

function [coord_sensor_new,fastest_path_new,nodes_to_delete] =
delete_unlinked_nodes(coord_sensor,fastest_path)

number_nodes_to_keep = size(coord_sensor,1);
nodes_to_delete = zeros(number_nodes_to_keep,1);

fastest_path_columns_to_delete = zeros(1,size(fastest_path,2));

for j = 1:size(fastest_path,2)
if fastest_path(:,j)==-1
fastest_path_columns_to_delete(1,j) = 1;

nodes_to_delete(j+1) = 1;
number_nodes_to_keep = number_nodes_to_keep-1;
end
end

if max(nodes_to_delete)>0
coord_sensor(nodes_to_delete==1,:) = [];
fastest_path(:,fastest_path_columns_to_delete==1) = [];

end

coord_sensor_new = coord_sensor;
fastest_path_new = fastest_path;

end