Física Computacional - Contribuições do usuário [pt-br]

Grupo - BOIDS

2018-01-25T09:31:23Z

Pedrow7: /* Resultados e Discussão */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição do k-ésimo predador.

No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas em áreas quadradas de lados <math>L = 1000</math> e <math>L = 100</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:30:37Z

Pedrow7: /* Resultados e Discussão */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição do k-ésimo predador.

No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 100</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:30:01Z

Pedrow7: /* Predador */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição do k-ésimo predador.

No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:28:43Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:28:31Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-\(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:27:53Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp\(-\(\frac{x_{j} - L}{E}\)^2\) </math>, para quando o boid se aproxima da extremidade superior do dominio, idem para componente x,

<math> v_{j} = a exp\(-\(\frac{x_{j}}{E}\)^2\) </math>, para quando o boid se aproxima da parte inferior do dominio. Idem para componente x,

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:26:51Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio,

<math> v_{j} = a exp(-(\frac{x_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio.

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:26:34Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, sendo a constante de proporcionalidade e E o raio de interação da barreira, da seguinte forma:

<math> v_{j} = a exp(-(\frac{x_{i}_{j} - L}{E})^2) </math>, para quando o boid se aproxima da extremidade superior do dominio,

<math> v_{j} = a exp(-(\frac{x_{i}_{j}}{E})^2) </math>, para quando o boid se aproxima da parte inferior do dominio.

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:24:18Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas. Porém também serão acrescentadas uma barreira repulsiva que dificulte a chegada dos boids na fronteira, da forma

<math> v_{j} = a exp(-(\frac{x_{j} - L}{E})^2) </math>, sendo a constante de proporcionalidade e E o raio de interação da barreira

para todos os programas se L = 100, então E = 10 e para L = 1000 então E = 50.

Também é feito que, para todos os boids que possuem mais de <math>0.2N</math> vizinhos, sejam freiados, pois foi observado que peixes quando na presença de vizinhos (semelhantes) diminuem suas velocidades.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:14:10Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boid no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:13:54Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade dos boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:13:14Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:12:59Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x
e
<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:12:19Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x
e
<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y.

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:12:05Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>, na componente x
e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>, na componente y

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:11:32Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>,
e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>,

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:11:16Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>,
e,
<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>,

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:11:03Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>,
e
<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>,

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:10:46Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>
e
<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:10:31Z

Pedrow7: /* Ruído */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,

<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math>

e

<math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:10:12Z

Pedrow7: /* Coesão */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, com <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, e <math>C</math> sendo o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:09:31Z

Pedrow7: /* Coesão */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^N_{i=1} \vec{r}_i</math>, <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, <math>C</math> é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:08:59Z

Pedrow7: /* Coesão */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, <math>N</math> sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, <math>C</math> é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:08:01Z

Pedrow7: /* Alinhamento (vetor velocidade) */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:07:35Z

Pedrow7: /* Separação */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Uma força central, dependente apenas da distância entre o boid e a origem da força:

<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T09:01:37Z

Pedrow7: /* Contexto Histórico */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras básicas, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T08:20:57Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

Alunos: Álvaro Essinger, Pedro Widniczck.
=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade está dependo da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

Para melhorar o comportamento do cardume, fora implementada uma barreira fraca nas bordas da região. Isso fará muita diferença na visualização da situação com predadores.

Na situação abaixo foram usados os seguintes parâmetros:
<math>C = 0.05; S =0.3; M=0.15 e B = 0.6</math>

[[Arquivo:Barreiranaborda.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume e barreira fraca nas bordas. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_barreira_fronteira]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS/codigo BOIDS cardume

2018-01-25T08:20:11Z

Pedrow7:

<source lang="c">
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>

// programa particulas boids para CC periodica.

#define N 500 // numero de particulas
#define T 3200 // numero de passos
#define C 0.2 // constante de coesao
#define S 0.3 // constante de separaçao
#define ini 2 // valor maximo das componentes da velocidade
// valor maximo da velocidade (sqrt(2)*ini)
#define PI 3.1415926538979 //aprox de pi
#define I 15 // numero de passos entre as plotagens
#define E 8 // distancia maxima que a barreira afeta os BOIDS
#define EE 0.01 // barreira dificulta a chegada nas fronteiras

double norm(double x, double y){ //funçao norma
return sqrt(x*x + y*y);
}

main(){

double r[N][2], v[N][2], epsilon=0.00001, R=8, rmin=2, erre=7, dt = 0.1;
double randomi=0;
double x=0., y=0., vel[N], L=100, vmx=0, vmy=0, vmed=0, vmedl =0;
int i=0, j=0, k=0, l=0, m=0, t=0;
int cont=0, kont=0; //conta o numero de vizinhos proximos da particula
int vizinhos[N][2]; //nao deixa a velocidade explodir nem tender a 0

//**********inicializar particulas (posicao e velocidade)**********//
printf("set terminal gif animate delay 1.0E-5\n");// Produz arquivo .gif
printf("set output 'boidcvel.gif'\n"); //
printf("set title 'Tempo t = 0'\n"); //
printf("set xrange [0:%lf]\n", L); // caso rode com |gnuplot aparecem
printf("set yrange [0:%lf]\n", L); // os graficos.
printf("plot '-' w p pt 10\n"); //

for(i=0;i<N;i++){
r[i][0] = L*rand()/RAND_MAX; //
r[i][1] = L*rand()/RAND_MAX; // Inicializa as pos e vel
v[i][0] = ini*(2.*rand()/RAND_MAX - 1); // das particulas aleatoriamente
v[i][1] = ini*(2.*rand()/RAND_MAX - 1); //
printf("%lf %lf \n", r[i][0], r[i][1]); //
}

printf("e \n");

//**********Dinamica das Particulas**********//

do{ //inicio do passo de tempo

if(t%I == 0){
printf("set title 'Tempo t = %.1lf'\n", t*dt); //
printf("set xrange [0:%lf]\n",L); // Caso rode com |gnuplot
printf("set yrange [0:%lf]\n",L); // sao gerados os graficos
printf("plot '-' w p pt 10\n"); //
}

vmed = 0; // velocidade media das particulas

for(j=0;j<N;j++){ // dinamica de cada particula

cont=0; // contador para coesao das particulass
x = 0; // media das particulas vizinhas para coesao
y = 0; // media das particulas vizinhas para coesao

kont = 0; // contador para media das velocidades
vmx = 0; // media das veloc. das particulas
vmy = 0; // media das veloc. das particulas

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas ass particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = vmx/kont; // media com peso M para a vel.
v[j][1] = vmy/kont; // dos vizinhos e a propria
}

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem
// a uma distancia menor q
// "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c pote-
// ncial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c pote-
} // ncial de mola na componente y

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2)/L; // Atualiza velocidade c potencial analogo ao gravitacional
// na componente x
v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2)/L; // Atualiza velocidade c potencial analogo ao gravitacional
// na componente y
}
}
}

//**********Velocidade Pela Densidade de Vizinhos**********//

if(cont + kont < 0.1*N){ // se o numero de vizinhos for menor que 0.1*N
vizinhos[j][0] = 1; // chave 1 fecha
vizinhos[j][1] = 0; // chave 2 abre
}else{
vizinhos[j][0] = 0; // chave 1 abre
}

if(norm(v[j][0],v[j][1]) > 0.5*ini){ // se a velocidade media do passo anterior for maior
// que 0.7*ini
vizinhos[j][1] = 0; // chave 2 "abre"
}

if(vizinhos[j][0] == 0){ // se chave 1 aberta
if(vizinhos[j][1] == 1){ // se chave 2 fechada entao nao faz nada

}else if(cont +kont >0.5*N){ // se vizinhos > 0.5*N entao
v[j][0] = 0.85*v[j][0]; // velocidade reduz 20%
v[j][1] = 0.85*v[j][1]; // velocidade reduz 20%

}else if(cont + kont > 0.4*N){ // se vizinhos 0.5> e >0.4 entao
v[j][0] = 0.9*v[j][0]; // velocidade reduz 15%
v[j][1] = 0.9*v[j][1]; // velocidade reduz 15%

}else if(cont + kont > 0.3*N){ // se vizinhos 0.4> e >0.3 entao
v[j][0] = 0.93*v[j][0]; // velocidade reduz 10%
v[j][1] = 0.93*v[j][1]; // velocidade reduz 10%

}else if(cont + kont > 0.2*N){ // se vizinhos 0.3> e >0.2 entao
v[j][0] = 0.97*v[j][0]; // velocidade reduz 5%
v[j][1] = 0.97*v[j][1]; // velocidade reduz 5%
}
vizinhos[j][1] = 1; // chave 2 fecha
}

//**********Ruido**********//

if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(PI*randomi)*v[j][0] - sin(PI*randomi)*v[j][1]; // rotaçao
v[j][1] = sin(PI*randomi)*v[j][0] + cos(PI*randomi)*v[j][1]; // rotaçao

//**********Passo das particulas com CC periodica**********//

if(L-r[j][0] < epsilon){ // final do dominio na componente x
r[j][0] = L - r[j][0]; // recomeça no inicio do dominio em x
}else if(r[j][0] < 0){ // inicio do dominio na coomponente x
r[j][0] = L + r[j][0]; // recomeça no finaldo dominio em x
}

r[j][0] = r[j][0] + v[j][0]*dt; // atualiza a posiçao da particula em x

if(L-r[j][1] < epsilon){ // final do dominio em y
r[j][1] = L - r[j][1]; // recomeça no inicio do dominio em y
}else if(r[j][1] < 0){ // inicio do dominio em y
r[j][1] = L + r[j][1]; // recomeça no final do dominio em y
}

r[j][1] = r[j][1] + v[j][1]*dt; // atualiza a posiçao da particula em y

if(t%I == 0){
printf("%lf %lf \n", r[j][0], r[j][1]); // imprime a posiçao da particula
}
vmed = vmed + norm(v[j][0],v[j][1]); // contador para velocidade media
}

if(t%I == 0){
printf("e\n"); // final do grafico para |gnuplot
}

vmedl = vmed/N; // velocidade media no tempo t
//printf("%lf %lf\n", t*dt, vmed);
t++; // contador para o tempo (numero de passos)
}while(t<T);

printf("\n\n");
}
</source>

Grupo - BOIDS

2018-01-25T08:04:29Z

Pedrow7: /* Separação */

=Contexto Histórico=
Desenvolvido por Craig Reynolds, engenheiro de software, em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

Posteriormente, em 1995, Tamás Vicsek, cientista húngaro, apresentou um modelo simplificado de BOID para o estudo de transições de fase de um sistema desordenado para um estado ordenado de larga escala. Esse tipo de transição espontânea é um exemplo de movimento coletivo. Esse modelo é bastante popular atualmente na área da física. Um exemplo do uso desse modelo é o modelo de Ising[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_Ising_2D].

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{r}_j - \vec{r}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discussão=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um comportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

A animação abaixo busca ilustrar a dependência do parâmetro <math>S</math> no sistema, aumentando-o progressivamente.

[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento 1.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

A animação abaixo ilustra a influência da regra mostrando o sistema inicialmente com o alinhamento desligado e ligando-o logo após.

[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Animação da regra de alinhamento entre BOIDS. ]]

== BOIDS (3 regras ligadas) ==
Aqui temos a implementação das 3 regras básicas ligadas.

Os parâmetros usados nessa simulação foram:
<math>C = 0,1 ; S = 0,4</math>, nesse caso não temos o parâmetro <math>M</math> pois só é utilizada a media aritmética das componentes.

[[Arquivo:BOIDS.gif |thumb|none|500px| Animação BOIDS sem adaptação de cardume. Código:[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS] ]]

== BOIDS Adaptados Para Cardume de Peixes ==
Implementação das 2 regras básicas de coesão e separação com a modificação da regra de alinhamento buscando um comportamento de grupo mais real. Note que aqui, ao se juntarem, a velocidade diminui. Pois a velocidade depende da quantidade de vizinhos.

Os parâmetros utilizados foram:
<math>C = 0,2; S = 0,3</math>

[[Arquivo:BoidsMOD.gif |thumb|none|500px| Simulação BOIDS com otimização de velocidade do cardume. Código: [https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_cardume]]]

== Predador ==
Resultado obtido com as regras de coesão, separação e alinhamento adaptado para cardume de peixes implementadas. Aqui buscamos colocar os predadores em cena depois de algum tempo dos objetos criados para que o cardume se organize.

Os parâmetros melhores ajustados que encontramos para essa situação foram:

<math>C = 0,05; S= 0,3; M = 0,15; B = 0,6</math>

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

[[Arquivo:PREDADOR.gif |thumb|none|500px| Animação dos BOIDs na presença de dois predadores. Código[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo_BOIDS_predador]]]

= Conclusão =
O comportamento coletivo sincronizado de animais é muito complexo. O estudo do cardume de peixes num sistema 2D é uma simplificação mas que nos dá ideias boas das regras básicas de comportamento e otimizações posteriores sobre o objeto de estudo. A regra modificada de alinhamento nos trás um comportamento mais real do cardume de peixes. Outras otimizações poderiam inserir diversas outras regras, como por exemplo um sentimento de nervosismo no bando pela presença de muitos predadores pode fazer o grupo se mover mais rápido e etc. Além disso o algoritmo BOID se torna muito intuitivo de ser trabalhado, podendo ser tratado com regras distintas, ligando e desligando como quisermos.

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o código completo[https://fiscomp.if.ufrgs.br/index.php/Grupo_-_BOIDS/codigo].

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T03:43:11Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

=== Predador ===
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>C</math> crescente. Note que, de fato, a medida que <math>C</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T03:37:55Z

Pedrow7: /* BOIDS Adaptados Para Cardume de Peixes */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, M sendo o termo da média.

as outras relaçoes, separação e coesão continuam idênticas.

=== Predador ===
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS.]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T03:33:45Z

Pedrow7:

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

Para a realização da adaptação, utiliza-se outra regra de alinhamento, fazendo uma média ponderada entre a velocidade do boids no tempo t com a velocidade dos vizinhos, da forma:

<math>\vec{V}^{n+1}_{j} = (1-M) v_{j} + \frac{M}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>

=== Predador ===
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS.]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T03:30:25Z

Pedrow7:

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

= O Algoritmo Para BOIDS =
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade) ==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão ==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

==BOIDS Adaptados Para Cardume de Peixes==

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS.]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:51:00Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhamento.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS.]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:50:24Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:46:22Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]
[[Arquivo:alinhamento.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Arquivo:Alinhamento.gif

2018-01-25T02:45:56Z

Pedrow7: Pedrow7 enviou uma nova versão de "Arquivo:Alinhamento.gif"

Grupo - BOIDS

2018-01-25T02:44:34Z

Pedrow7: /* Coesão */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:|thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:38:52Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:38:08Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com k sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:37:40Z

Pedrow7: /* Predador */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math>, onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:37:27Z

Pedrow7: /* Predador */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como uma barreira repulsiva. Obedecendo a

<math> F_{b} = B \frac{r_{j} - b_{k}}{ ||r_{j} - b_{k}||^{1.5} } </math> onde B é o coeficiente da barreira e b é a posição da barreira

. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:32:10Z

Pedrow7: /* Ruído */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x - \sin{(\zeta)} V_y</math> e <math>V_y = \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:31:26Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x + \sin{(\zeta)} V_y</math> e <math>V_y = - \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:31:12Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos (<math>k</math>) influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>, com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x + \sin{(\zeta)} V_y</math> e <math>V_y = - \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:30:56Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos (<math>k</math>) influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math> com <math>k</math> sendo o número de vizinhos dentro do raio de interação.

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x + \sin{(\zeta)} V_y</math> e <math>V_y = - \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:29:43Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos (<math>k</math>) influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{i=1} \vec{V}_{i}</math>

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x + \sin{(\zeta)} V_y</math> e <math>V_y = - \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo - BOIDS

2018-01-25T02:29:03Z

Pedrow7: /* Alinhamento (vetor velocidade) */

=Contexto Histórico=
Desenvolvido por Craig Reynolds em 1986, é um algoritmo que busca, por meio de regras de comportamento, reproduzir o comportamento sincronizado de grupos de animais. Por exemplo manadas de animais terrestres, cardumes de peixes, bando de pássaros e etc. O nome BOID corresponde ao encurtamento da expressão em inglês ''“bird-oid object”'', que se refere a um objeto “tipo pássaro”. Seu trabalho foi publicado em 87 sob o título original, em inglês, ''"Flocks, herds and schools: A distributed behavioral model"''.
O modelo base de Craig já fora utilizado para diversas implementações e estudos. Como estudo comportamental de medo, interação entre animais via olfato modelando feromônios, mudança de liderança de um bando, dentre muitas outras aplicações interessantes.

=Motivação=
O movimento de animais em sincronia é extremamente complexo e é chave para sua sobrevivência em bando. Peixes, pássaros e mamíferos terrestres tem esse tipo de comportamento principalmente no que diz respeito a defesa em momentos em que sentem em perigo. A concentração intimida e o movimento confunde seus predadores. Além de ser extremamente prazeroso assistir um bando de pássaros ou um cardume de peixes em sua dança sincronizada.

Este trabalho busca, em suas etapas, reproduzir um cardume de peixes em seu padrão síncrono de movimento e, posteriormente, na presença de um ou mais predadores.

=O Algoritmo=
Inicialmente são sorteadas posições e velocidades aleatórias para os objetos. As regras são então calculadas a cada de passo temporal. Embora cada boid tenha liberdade sobre todo o espaço descrito, o seu comportamento é influenciado apenas por outros dentro de uma região circular centrada no objeto dita ''raio de interação'' (R). Após o cálculo das novas posições e velocidades é somado um incremento de tempo e o algoritmo recomeça.

== Separação ==
Interação de repulsão entre os indivíduos para evitar superconcentração local (ou no caso extremo uma superposição). Um potencial análogo à Lei de Coulomb para cargas de mesmo sinal:
<math>\vec{V}_j = \frac{S (\vec{p}_j - \vec{p}_k)}{||\vec{r}||^2}</math>, onde <math>\vec{r} = (x_j-x_k)\hat{i} + (y_j-y_k)\hat{j}</math> e <math>S</math> é o coeficiente de separação.

[[Arquivo:Rule_separation.gif|thumb|none|300px|Fig1. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_separation.gif]]

== Alinhamento (vetor velocidade)==
A velocidade média dos parceiros próximos (<math>k</math>) influencia o vetor velocidade do objeto, fazendo-o ter um comportamento parecido com sua vizinhança.

<math>\vec{V}^{n+1}_{j} = (1-M)\vec{V}^{n}_{j} + M \frac{1}{k} \Sigma^{k}_{k=1} \vec{V}_{k}</math>

[[Arquivo:Rule_alignment.gif|thumb|none|300px|Fig2. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_alignment.gif]]

== Coesão==
Os BOIDs interagentes tem um potencial de mola entre si, fazendo com que tenham a tendência de mover-se em direção ao centro de massa do grupo. Calculando primeiramente o centro de massa (CM) das partículas vizinhas utiliza-se da força elástica para simular uma mola entre o objeto e o CM da vizinhança.

<math>\vec{r}_{CM} = \frac{1}{N}\Sigma^n_{i=1} \vec{r}_i</math>, N sendo o número de partículas dentro do raio de interação.

<math>\vec{V}_j = C (\vec{r}_j - \vec{r}_{CM})</math>, C é o coeficiente elástico.

[[Arquivo:Rule_cohesion.gif|thumb|none|300px|Fig3. link:https://en.wikipedia.org/wiki/Boids#/media/File:Rule_cohesion.gif]]

== Ruído ==
Para reproduzir melhor um ser vivo, um pequeno ruído compõe a velocidade. Isso faz com que tenhamos uma maior flutuação no caminho que os boids traçam.

sendo <math>\zeta</math> um número real aleatório,
<math>V_x = \cos{(\zeta)} V_x + \sin{(\zeta)} V_y</math> e <math>V_y = - \sin{(\zeta)} V_x + \cos{(\zeta)} V_y</math>

== Predador ==
A partícula que representa o predador é como se fosse uma barreira repulsiva. Obedecendo, também, a Lei de Coulomb. No presente trabalho o predador não persegue os BOIDs, apenas se desloca em linha reta no plano com velocidade constante.

Aqui[https://youtu.be/mgg6HhKRwY0?t=41] é possível ver o comportamento de um cardume de peixes na presença de algumas arraias.

=Resultados e Discução=
Nosso modelo foi simulado com condições de contorno periódicas numa área quadrada de lado <math>L = 1000</math>. Abaixo apresentamos os resultados para cada regra isoladamente e ao final todas funcionando simultaneamente com e sem a presença do predador.

== Separação ==
Aqui temos, como esperado, um corportamento semelhante ao de um gás ideal. Que busca um estado de menor energia ocupando todo o espaço disponível. Note que poucas regiões tem mais de 3 objetos próximos.

[[Arquivo:Separacao.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]
[[Arquivo:Repelentes.gif‎ |thumb|none|500px| Simulação apenas da regra de separação entre BOIDS. ]]

== Coesão ==
Para a coesão temos um comportamento semelhante ao condensamento de um gás em gotas ou gotículas. As regiões mais concentradas (círculo verde) perdem um pouco de sua capacidade de mobilidade e se tornam atrativas para partículas vizinhas (círculos azuis). Ao passo que objetos isolados (círculos roxos) se comportam independentemente até encontrarem um, ou mais, vizinhos ou regiões de alta concentração.

[[Arquivo:Coesao edit.gif |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS.]]

Na animação abaixo temos o comportamento dinâmico do sistema para o parâmetro <math>S</math> crescente. Note que, de fato, a medida que <math>S</math> aumenta, também ocorre o aumento da concentração dos BOIDs.

[[Arquivo:Coesas.gif‎ |thumb|none|500px| Simulação apenas da regra de coesão entre BOIDS. ]]

== Alinhamento (vetor velocidade) ==
Na regra de alinhamento temos o comportamento do vetor velocidade do objeto sendo influenciado pela velocidade das partículas na vizinhança. Na imagem estática fica difícil de diferenciar da regra de separação, porém, note como aqui há mais regiões com 3 ou mais BOIDs bem próximos. Em alguns casos pode-se notar que quase ocorre uma superposição.

[[Arquivo:Alinhamento.gif |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]
[[Arquivo:Alinhadas.gif‎ |thumb|none|500px| Simulação apenas da regra de alinhamento entre BOIDS. ]]

[[Arquivo:BOIDS.gif‎ |thumb|none|500px| BOIDS. ]]

== Predador ==

[[Arquivo:Predador.jpg |thumb|none|500px| BOIDs na presença de dois predadores.]]

= Conclusão =

=Desenvolvimento em C=
Abaixo verá trechos do código em linguagem de programação C utilizados no trabalho para as regras e etapas.

Link para o [[/codigo]] completo.

== Coesão ==
 

<source lang="c">

//**********Coesao Entre Particulas e CM**********//

for(m=0;m<N;m++){ // laço das particulas
if(norm(r[j][1]-r[m][1],r[j][0]-r[m][0])<R){// se as particulas tiverem a uma distancia menor q "R"
cont++; // acrescenta no contador
x = x + r[m][0]; // acrescenta na posicao das particulas na comp. x
y = y + r[m][1]; // acrescenta na posicao das particulas na comp. y
}
}

if(cont>1){ // se contador for cont > 1
x = x/cont; // media aritmetica na componente x
y = y/cont; // media aritmetica a componente y

v[j][0] = v[j][0] - C*(r[j][0] - x)/L; // atualiza velocidade c potencial de mola na componente x
v[j][1] = v[j][1] - C*(r[j][1] - y)/L; // atualiza velocidade c potencial de mola na componente y
}

</source> 

== Separação ==
 

<source lang="c">

//**********Separacao Entre Particulas**********//

for(l=0;l<N;l++){ //laço para particulas
if(l==j){ // se a particula for ela mesma nao faz nada

}else{ // se nao é ela entao

if(norm(r[j][0]-r[l][0],r[j][1]-r[l][1])<rmin){ // se as particulas estao a uma distancia menor que "rmin"
v[j][0] = v[j][0] + S*(r[j][0] - r[l][0])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente x

v[j][1] = v[j][1] + S*(r[j][1] - r[l][1])/pow(norm(r[l][0]-r[j][0],r[l][1]-r[j][1]),2); // Atualiza velocidade c potencial analogo a lei de Coulomb na componente y

}
}
}

</source> 

== Alinhamento (vetor Velocidade) ==
 

<source lang="c">

//**********Media da Velocidade dos Vizinhos**********//

for(k=0;k<N;k++){ // laço para todas as particulas
if(k == j){ // se eh a mesma particula nao faz nada
}else if(norm(r[j][1]-r[k][1],r[j][0]-r[k][0])<erre){
kont++; // se eh outra particula acrescenta no contador
vmx = vmx + v[k][0]; // acrescenta a velocidade na componente x
vmy = vmy + v[k][1]; // acrescenta a velocidade na componente y
}
}

if(kont > 1){
v[j][0] = (1-M)*v[j][0] + M*(vmx/kont); // media com peso M para a vel.
v[j][1] = (1-M)*v[j][1] + M*(vmy/kont); // dos vizinhos e a propria
}

</source> 

== Ruído ==

 

<source lang="c">

//**********Ruido**********//
if(rand()%2 == 0){ // criterio para decidir a fase
randomi = - rand()/RAND_MAX; // fase
}else{
randomi = rand()/RAND_MAX; // fase
}
v[j][0] = cos(randomi)*v[j][0] + sin(randomi)*v[j][1]; // rotaçao
v[j][1] = - sin(randomi)*v[j][0] + cos(randomi)*v[j][1]; // rotaçao

</source> 

== Predador ==

 

<source lang="c">

//Barreira puntual no centro
if(norm(r[j][0] -bx, r[j][1] - by) < ERRE){ // se a particula ta a menos
// de "ERRE" entao

if(r[j][0] < bx && r[j][1] < by){ // se estiver atras e abaixo
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] < by){ // se estiver a frente e abaixo
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] - B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] < bx && r[j][1] > by){ // se estiver abaixo e acima
v[j][0] = v[j][0] - B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5);// atualiza velocidade com potencial analogo "gravitac"

}else if(r[j][0] > bx && r[j][1] > by){// se estiver a frente e acima
v[j][0] = v[j][0] + B*norm(r[j][0] - bx, r[j][0] - bx)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
v[j][1] = v[j][1] + B*norm(r[j][1] - by, r[j][1] - by)/pow(norm(r[j][0] - bx, r[j][1]- by),1.5); // atualiza velocidade com potencial analogo "gravitac"
}

}

</source> 

=Referências=
*https://en.wikipedia.org/wiki/Boids
*Reynolds, C. W. (1987) Flocks, Herds, and Schools: A Distributed Behavioral Model, in Computer Graphics, 21(4) (SIGGRAPH '87 Conference Proceedings) pages 25-34.
*Vicsek, T.; Czirok, A.; Ben-Jacob, E.;; Cohen, I.; Shochet, O. (1995). "Novel type of phase transition in a system of self-driven particles". Physical Review Letters. 75: 1226–1229. [https://arxiv.org/abs/cond-mat/0611743 arXiv:cond-mat/0611743]

Grupo1 - Dif em 2D

2017-12-02T16:18:45Z

Pedrow7: /* Método da Super Relaxação */

A equação de Poisson:

<math>\Delta u = \frac{\partial ^{2} u }{\partial x^2} + \frac{\partial ^{2} u }{\partial y^2} = -g(x,y)</math>

é uma equação do tipo Elíptica que representa fenômenos físicos estácionarios relacionados a Eletrostatica, Dinâmica de Fluídos e Transferência de Calor. Se <math> g(x,y) \equiv 0 </math> a equação passa a ser chamada de Equação de Laplace. Os problemas relacionados a equação de Laplace são estudados pela "Teoria do Potencial".

As soluções <math> u = u(x,y) </math> da Equação de Laplace são denominadas funções Harmônicas. Os problemas mais habituais na vida de um físico, engenheiro ou matemático ao se depararem com uma EDP, são os problemas com Condições de Contorno em um dominío <math> \Omega \in \mathbb{R}^2</math>, essencialmente será trabalhada a Condição de Dirichlet, que possui fronteiras (<math> \partial \Omega </math>) conhecidas, tendo o seguinte formato:

<math> \begin{cases}
\Delta u = 0 & \text{para } (x,y) \in \Omega, \\
u = f(x,y) & \text{para } (x,y) \in \partial \Omega.
\end{cases}
</math>

A equação de Poisson possui forma parecida para o Problema de Dirichlet, que fica:

<math> \begin{cases}
\Delta u = - g(x) & \text{para } (x,y) \in \Omega, \\
u = f(x,y) & \text{para } (x,y) \in \partial \Omega.
\end{cases}
</math>

Para tais problemas, estudaremos os métodos de Relaxação e Super-Relaxação para encontrar as soluções da Equação de Laplace na região de Quadrado de Lado <math>L </math> <math> ( \{ \Omega = (0,L)\times (0,L) \} ) </math>.
== Dominio Quadrado de Lado <math> L </math> ==

=== Solução Analítica da Equação de Laplace ===

Seja o problema em <math>\Omega = (0, L) \times (0, L)</math>, temos:

<math>
\begin{cases}
\Delta u(x,y) = 0 \text{ em } \Omega \\
u(x, y) = f(x) \text{ em } \partial \Omega
\end{cases}
</math>

sendo

<math>
f(x) =
\begin{cases}
f(0,y) = f_{1}(y); \\
f(L,y) = f_{2}(y); \\
f(x,0) = f_{3}(x); \\
f(x,L) = f_{4}(x).
\end{cases}
</math>

Separamos o problema geral de Dirchlet em 4 problemas "menores", com condições de contorno diferentes de zero em apenas um trecho da fronteira, de modo que obtemos desde:

<math>
\begin{cases}
\Delta u_{1}(x,y) = 0 \text{ em } \Omega; \\
u_{1}(0,y) = f_{1}(y) \text{ para } y \in (0, L); \\
u_{1}(L,y) = u_{1}(x,0) = u_{1}(x,L) =0,
\end{cases}
</math>

...

até:

<math>
\begin{cases}
\Delta u_{4}(x,y) = 0 \text{ em } \Omega; \\
u_{4}(x,L) = f_{4}(x) \text{ para } x \in (0, L); \\
u_{4}(0,y) = u_{4}(L,y) = u_{4}(x,0) =0.
\end{cases}
</math>

Podemos então utilizar o Método da Separação de Variáveis para resolver os 4 problemas e, como a Equação de Laplace é linear, sua soma será a solução completa do Problema de Dirichlet. O método consiste em supor <math> u(x, y) = \phi(x)\theta(y)</math>, para então, ao substituirmos na equação obtermos a seguinte expressão:

<math> \Delta u_{i} = \ddot{\phi_{i}}(x)\theta_{i}(y) + \phi_{i}(x) \ddot{\theta_{i}}(y) = 0 </math>

Podemos isolar as funções <math>\phi_{i}</math> e <math>\theta_{i}</math>, de fato ficamos com com duas relações que dependem ou apenas de <math> x </math> e <math> y </math> portanto para elas serem sempre iguais, é necessário que sejam constantes (<math> = \lambda</math>):

<math> \frac{\ddot{\phi_{i}}}{\phi_{i}} = -\frac{\ddot{\theta_{i}}}{\theta_{i}} = \lambda </math>

Assim obtemos 2 EDOs de segunda ordem, que podem ser resolvidas pelo Método dos Coeficientes a Determinar. Como não é objetivo aqui realizar cálculos analíticos (especialmente "na mão") apenas será resolvido o primeiro problema (<math>u_{1}(x, y)</math>):

As condições de contorno mostram que <math> \phi(L)\theta(y) = 0 \Rightarrow \phi(L) = 0 </math>, <math> \phi(x)\theta(0) = 0 \Rightarrow \theta(0) = 0 </math> e <math> \phi(x)\theta(L) = 0 \Rightarrow \theta(L) = 0 </math>.

Dividindo o problema, temos a parte de <math>\phi</math>

<math>
\begin{cases}
\ddot{\phi_{1}}(y) - \lambda \phi_{1} =0; \\
\phi_{1} (L) = 0; \\
\end{cases}
</math>

Supondo uma solução da forma <math> \phi_{1}(x) = Ae^{sx}</math>:

<math> \ddot{\phi_{1}} - \lambda \phi_{1} = s^{2}Ae^{sx} - \lambda Ae^{sx} = 0 \Longrightarrow</math>
<math> s = \pm \sqrt{\lambda} </math>

Ou seja, temos a solução de <math>\phi_{1}</math> sendo

<math> \phi_{1}(x) = A_{1}e^{\sqrt{\lambda} x} + A_{2}e^{- \sqrt{\lambda} x} </math>

Partindo para a segunda equação <math> \theta_{1}(y) </math>,

<math>
\begin{cases}
\ddot{\theta_{1}}(x) + \lambda \theta_{1} =0; \\
\theta_{1} (0) = 0 \\
\theta_{1} (L) = 0;
\end{cases}
</math>

supondo solução do tipo <math> \theta_{1} (y) = Be^{i\omega y} </math> temos:

<math> \ddot{\theta_{1}} + \theta_{1} = -\omega^2 Be^{i\omega y} + \lambda Be^{i\omega y} = 0 \Longrightarrow </math>
<math> \omega = \pm \sqrt{\lambda} </math>

Ou seja, temos solução <math> \theta_{1}(y) = B_{1}e^{i\sqrt{\lambda} y} + B_{2}e^{-i\sqrt{\lambda} y} </math>

Utilizando a primeira C.C. obtemos <math>B_{1} = - B_{2} = B</math>

ou seja, temos que

<math>\theta_{1}(y) = B sen(\sqrt{\lambda} y ). </math> Utilizando a segunda C.C. temos <math> 0 = sen(\sqrt{\lambda} y) \Rightarrow \lambda = \frac{n^2 \pi^2}{L^2}, </math>

ou seja, existem infinitos <math>n</math> tal que <math>\theta_{1}</math> é solução.

Voltando a <math>\phi_{1}</math>, temos <math> \phi_{1}(x) = senh(\frac{n\pi (L-x)}{L}). </math>

Finalmente unindo as respostas, temos

<math> u_{1}(x, y) = \phi_{1}(x) \theta_{1}(y) = \sum C_{1n} \frac{senh(\frac{n \pi(L- x)}{L})}{senh(n\pi)}sen(\frac{n \pi y}{L})</math>

sendo <math>C_{1n} = \frac{2}{L}\int_{0}^{L} f_{1}(y) sen(\frac{n \pi y}{L}) dy</math>

Para os outros problemas, temos soluções parecidas:

<math> u_{2}(x, y) = \phi_{2}(x) \theta_{2}(y) = \sum C_{2n} \frac{senh(\frac{n \pi x}{L})}{senh(n\pi)}sen(\frac{n \pi y}{L});</math> sendo <math> C_{2n} = \frac{2}{L}\int_{0}^{L} f_{2}(x) sen(\frac{n \pi y}{L}) dy,</math>

<math> u_{3}(x, y) = \phi_{3}(x) \theta_{3}(y) = \sum C_{3n} \frac{senh(\frac{n \pi(L- y)}{L})}{senh(n\pi)}sen(\frac{n \pi x}{L});</math> sendo <math>C_{3n} = \frac{2}{L}\int_{0}^{L} f_{3}(y) sen(\frac{n \pi x}{L}) dx,</math>

<math> u_{4}(x, y) = \phi_{4}(x) \theta_{4}(y) = \sum C_{4n} \frac{senh(\frac{n \pi y}{L})}{senh(n\pi)}sen(\frac{n \pi x}{L});</math> sendo <math>C_{4n} = \frac{2}{L}\int_{0}^{L} f_{4}(x) sen(\frac{n \pi x}{L}) dx.</math>

A solução completa do problema de Dirichlet no quadrado de Lado <math>L</math> é a soma das quatro soluções parciais: <math> u(x, y) = u_{1}(x, y) + u_{2}(x, y) + u_{3}(x, y) + u_{4}(x, y) </math>.

=== Método da Relaxação ===

O Método da Relaxação é um método iterativo utilizado para obter a solução numérica para a equação de Laplace e Poisson. A ideia do método é de, utilizando a vizinhança iterar os pontos da malha até que convirjam para uma solução.

Discretizando a equação temos <math>x\mapsto x_{i}</math> e <math>y\mapsto y_{j}</math> para <math>i</math>, <math>j = 1, ..., N</math> e <math> h = \Delta x = \Delta y = N/L</math> a função <math> g(x, y) = g_{ij}</math>, nos deparamos com uma matriz <math>\mathcal{M}_{i j} = u(x_{i},y_{j}) = u_{i j}</math> quadrada sendo as bordas <math>\mathcal{M}_{1 j} = f(0, y) = u_{1 j}</math>, <math>\mathcal{M}_{N j} = f(L, y) = u_{N j}</math>, <math>\mathcal{M}_{i 1} = f(x, 0) = u_{i 1}</math> e <math>\mathcal{M}_{i N} = f(x, L) = u_{i N}</math>.

Realizando-se a discretização, podemos tomar as derivadas:

<math> \frac{\partial^2 u}{\partial x^2} = \frac{u_{(i+1) j} + u_{(i-1) j} -2u_{i j}}{h^2} </math>
e
<math> \frac{\partial^2 u}{\partial y^2} = \frac{u_{i (j+1)} + u_{i (j-1)} -2u_{i j}}{h^2} </math>

Substituindo na Equação, temos

<math> \frac{u_{(i+1) j} + u_{(i-1) j} -2u_{i j}}{h^2} + \frac{u_{i (j+1)} + u_{i (j-1)} -2u_{i j}}{h^2} = - g_{ij} </math>,
ou seja:

<math> u_{i j} = \frac{u_{(i-1) j} + u_{(i+1) j} + u_{i (j-1)} + u_{i (j+1)} + h^{2}g_{ij}}{4}</math>,

ou mais geralmente (supondo <math>\Delta x \neq \Delta y</math>):

<math> u_{i j} = \frac{(\Delta y)^{2}(u_{(i-1) j} + u_{(i+1) j}) + (\Delta x)^2(u_{i (j-1)} + u_{i (j+1)}) + (\Delta y \Delta x)^2 g_{ij}}{2((\Delta x)^2 + (\Delta y)^2)}, </math>

para <math> i, j = 2, ..., N+1 </math>

Para condição de parada, foi convencionado tomar o erro relativo entre as iterações <math> k </math> e <math> k+1 </math>, para estimar o erro, se optou por tomar como valores, o ponto médio da malha (já que é o ultimo ponto a ser alcançado nas iterações, portanto, quando sua variação diminuir é sinal de que a solução já está convergindo), para observarmos a evolução em relação a outros pontos que variam desde o inicio, foram utilizados as diagonais interiores, tal que o erro relativo é:

<math> \epsilon = \Big|\frac{v^{k} - v^{k+1}}{v^{k}}\Big|</math>

fazendo a média ponderada com peso 4 para o ponto médio:

<math> v^{k} = \frac{1}{8} (u_{2 2} + u_{2 (N+1)} + u_{(N+1) 2} + 4u_{\frac{(N+2)}{2} \frac{(N+2)}{2}}+u_{(N+1) (N+1)}) </math>

=== Método da Super Relaxação (SOR) ===

Podemos também realizar uma média entre os valores já calculados e os ainda não calculados na iteração, o método da Super Relaxação ou Sobrerrelaxação (SOR) é da seguinte forma:

<math> u_{ij}^{k+1} = u_{i j}^{k}(1 - \omega) + \omega u_{ij}^{R} </math>

tal que <math> u_{ij}^{R} </math> é o valor calculado através do método da Relaxação e <math> \omega \in [0:2]</math> é o fator de relaxamento, se <math> \omega = 1 </math> temos a Relaxação normal.

=== Estabilidade ===

==== Relaxação ====
[[Arquivo:erro2.png|thumb|400px| Erro relativo (método da Relaxação) em função da quantidade de iterações]]

A relaxação é um método Iterativo sobre os pontos vizinhos que pode ser feita de 2 modos, pelo Algoritmo de Jacobi, e pelo de Gauss-Seidel.

O algoritmo de Jacobi pega valores "antigos" para a iteração e possui convergencia muito lenta, por isso não é muito utilizado. Já o algoritmo de Gauss-Seidel pega os valores "novos" (que ja foram calculados na iteração) e os "antigos" (que não foram calculados na iteração <math> k </math>), possui convergência mais rapida, porém ainda é lenta.

Como a média definida anteriormente foi feita utilizando o ponto médio do domínio, o erro cresce após decair, pois é quando efetivamente ocorrem variações maiores no ponto médio.

Para a relaxação, o algoritmo de Jacobi faz o seguinte cálculo:

<math> u_{i j}^{k+1} = \frac{u_{(i-1) j}^{k} + u_{(i+1) j}^{k} + u_{i (j-1)}^{k} + u_{i (j+1)}^{k} + h^{2}g_{ij}}{4}</math>,

já o algoritmo de Gauss-Seidel faz:

<math> u_{i j}^{k+1} = \frac{u_{(i-1) j}^{k+1} + u_{(i+1) j}^{k} + u_{i (j-1)}^{k+1} + u_{i (j+1)}^{k} + h^{2}g_{ij}}{4}</math>,

Algoritmos iterativos tendem a convergir para solução unica, se a matriz que as representa for Diagonal Dominante, ou seja:

<math> |a_{ii}| \ge \sum_{j=1 (i\neq j)}^{N} |a_{ij}| </math>

Sendo <math> a_{ii} = u_{ii} </math> e <math> a_{ij} = u_{ij} </math>, então <math> |u_{ii}| = 4 </math> e <math> |u_{ij}| = 1 </math> e

<math> \sum_{j=1 (i\neq j)}^{N+2} |a_{ij}| = 4 </math>

Como <math> 4 = 4 </math>, a desigualdade vale e o método converge.

De fato, podemos ver que a equação de Laplace respeita tal desigualdade.

Caso façamos um retangulo <math> L_{x} \neq L_{y} </math> com <math> \Delta x \neq \Delta y </math>, obtemos os erros da imagem a seguir, feito utilizando <math> L_{x} =1 </math> e <math> L_{y} = 5 </math>, <math> L_{x} =2 </math> e <math> L_{y} = 4 </math> e <math> L_{x} =1.5 </math> e <math> L_{y} = 4.5 </math>:

[[Arquivo:erro.png|frameless|400px|Erro obtido para diferentes comprimentos do retangulo]]

==== Super Relaxação ====

[[Arquivo:errooverr.png|thumb|400px|Grafico mostra a quantidades de Iterações para convergência do exemplo 1 em função de omega]]

Como o método depende de <math> \omega </math>, e se <math> \omega = 1 </math> temos a Relaxação normal, então podemos já observar que a convergência será mais demorada se <math> \omega < 1 </math>, já quando maior que 1, a solução sempre converge mais rápido até um <math> \omega_{otimo} </math> após o valor ótimo o valor cresce até 2, valor que diverge para o SOR.

Usaremos <math> \omega = \frac{2}{1+sen(\pi \Delta x)} </math> que é o valor ótimo.

=== Exemplos ===

Foram realizados 5 exemplos, 2 sobre a equação de Laplace e 3 sobre a equação de Poisson.

==== Exemplo 1 ====

O primeiro problema,que pode ser descrito como a temperatura <math> T = T(x, y)</math> de uma chapa que está em equilíbrio térmico com um dos lados a temperatura <math>T(x, 0) = L</math>, todos os outros lados iguais com temperatura 0 e sem geração. Para o domínio <math> \Omega = (0;L) \times (0;L) </math>, tal problema é descrito pela seguinte expressão:

<math>
\begin{cases}
\Delta u = 0 \forall x,y \in \Omega \\
u(x,0) = L \big( \forall x \in [0;L] \big) \\
u(x, L) = 0 \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

A solução analítica para o problema é:

<math> u(x, y) = \frac{4L}{\pi}\sum_{n=0}^{\infty} \frac{sen(\frac{(2n+1) \pi x}{L})}{2n+1} \frac{senh\Big(\frac{(2n+1) \pi (L-y)}{L}\Big)}{ senh((2n+1)\pi)} </math>

Foi possível obter o gráfico da função analítica aproximada com os 110 primeiros termos parciais e estimar o erro entre a solução numérica e a solução analítica, que foi alto devido ao truncamento da série que forma a solução analítica.

[[Arquivo:solucaoanalitica1.png|450px|thumb|Solução analítica do Problema de Contorno 1]]

[[Arquivo:erroanalitico1.png|450px|thumb|Erro entre solução numérica e solução analítica em função do número de iterações]]

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel, no caso da relaxação foram necessárias 1471 iterações para a solução convergir, já SOR levou 1000.

[[Arquivo:relaxacao1k1471.png|450px|Solução do Problema de Contorno através do Método de Relaxação (utilizando o algoritmo de Gauss-Seidel)]]
[[Arquivo:sol1k1001.png|450px|Solução do Problema de Contorno através do Método de Super Relaxação (utilizando o algoritmo de Gauss-Seidel)]]

==== Exemplo 2 ====

O segundo problema é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = 0 \forall x,y \in \Omega \\
u(x,0) = Lsin(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(x, L) = Lcos(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(0, y) = \frac{x^{2}}{L} \big( \forall y \in [0;L] \big) \\
u(L, y) = \frac{(L-x)^{2}}{L} \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as seguintes soluções mostradas nos gráficos, através do algoritmo de Gauss-Seidel.

[[Arquivo:relaxacao2k2122.png|300px|Solução do Problema de Contorno através do Método de Relaxação (utilizando o algoritmo de Gauss-Seidel)]]
[[Arquivo:relaxacao2k1001.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação (utilizando o algoritmo de Gauss-Seidel)]]

==== Exemplo 3 ====

O primeiro problema sobre a equação de Poisson , possui contornos fixos e uma gaussiana, pode ser considerado um problema de eletrostática com distribuição de carga <math> \frac{\rho}{\epsilon_{0}} = xy e^{-(x^2+ y^2)} </math> . Tal problema é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = 0 \big( \forall x \in [0;L] \big) \\
u(x, L) = 0 \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson0.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:overrP0.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

==== Exemplo 4 ====

O segundo problema sobre a equação de Poisson, que é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = 0 \big( \forall x \in [0;L] \big) \\
u(x, L) = L \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson1r.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:poisson1sor.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

==== Exemplo 5 ====

O segundo problema sobre a equação de Poisson, que é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = Lsin(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(x, L) = Lcos(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(0, y) = \frac{x^{2}}{L} \big( \forall y \in [0;L] \big) \\
u(L, y) = \frac{(L-x)^{2}}{L} \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson2r.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:poisson2sor.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

O programa utilizado para gerar as soluçoes e erros foi o seguir (ou com pequenas alteraçoes):

==== Programa ====
Trechos do programa realizado para os exemplos acima.

Programa para o método de Relaxação (Equação de Laplace):

<source lang="c">
#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529
void gaussseidelL(){
double u[M+2][M+2];
double dx=0, dy=0;
double L=5., parada=0, erro=0.00001, up=0;
int i=0, j=0, k=1, a=0;
dx = L/(M+1);
dy = L/(M+1);
for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = 1.;
}
}
/* Primeira Solução, GaussSeidel1 */
for(i=0;i<M+1;i++){
u[0][i] = L;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
/* Segunda Solução, GaussSeidel2
for(i=0;i<M+1;i++){
u[0][i] = L*pow(cos(i*dx*PI/L),2);
u[M+1][i] = L*pow(sin(i*dx*PI/L),2);
u[i][0] = L - pow(i*dx,2)/L;
u[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/
do{
up = (u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3;
for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = (u[i+1][j] + u[i-1][j] + u[i][j+1] + u[i][j-1])/4;
}
}
k++;
parada = fabs((up-(u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3)/up);
if(parada < erro && k>N/5){
a = 1;
}else{
a = 0;
}
}while(a == 0);
for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, u[i][j]);
}
}
printf("\n\n");
return;
}
</source>

Segundo trecho para método de Relaxação, Equação de Poisson

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void gaussseidelP(){

double u[M+2][M+2], F[M+2][M+2];
double dx=0, dy=0;
double L=5., parada=0, erro=0.00001, up=0;
int i=0, j=0, k=1, a=0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = 0.;
F[i][j] = i*dx*j*dy*exp(-(pow(i*dx,2) + pow(j*dy,2))/L);
}
}

/* Solução Zero, Poisson0 */
for(i=0;i<M+1;i++){
u[0][i] = 0;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = 0;
u[M+1][M+1] = 0.0;

/* Primeira Solução, PoissonGS1
for(i=0;i<M+1;i++){
u[0][i] = L;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/

/* Segunda Solução, PoissonGS2
for(i=0;i<M+1;i++){
u[0][i] = L*pow(cos(i*dx*PI/L),2);
u[M+1][i] = L*pow(sin(i*dx*PI/L),2);
u[i][0] = L - pow(i*dx,2)/L;
u[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/

do{
up = (u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = (u[i+1][j] + u[i-1][j] + u[i][j+1] + u[i][j-1] + 4*dx*dx*F[i][j])/4;
}
}

k++;
parada = fabs((up-(u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3)/up);
if(parada < erro && k>N/5){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, u[i][j]);
}
}

printf("\n\n");
return;
}

</source>

Trecho de programa que utiliza o método de Super Relaxação para Equação de Laplace:

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void overrelaxationL(){

double u[M+2][M+2], un[M+2][M+2];
double dx=0, dy=0, omega=1.;
double L=5., parada=0, erro=0.00005, up=0;
int i=0, j=0, k=1, a=0;

omega = 2/(1+PI*dx);

k = 0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = 1.;
u[i][j] = un[i][j];
}
}
/*
for(i=0;i<M+1;i++){
un[0][i] = 0.0;
un[M+1][i] = L;
un[i][0] = 0.0;
un[i][M+1] = 0.0;
}
un[0][M+1] = 0.0;
un[M+1][M+1] = L;
*/

for(i=0;i<M+1;i++){
un[0][i] = L*pow(cos(i*dx*PI/L),2);
un[M+1][i] = L*pow(sin(i*dx*PI/L),2);
un[i][0] = L - pow(i*dx,2)/L;
un[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
un[0][M+1] = L;
un[M+1][M+1] = 0.0;

do{

up = (un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = (un[i+1][j] + un[i-1][j] + un[i][j+1] + un[i][j-1])/4;
u[i][j] = u[i][j]*(1 - omega) + omega*un[i][j];
un[i][j] = u[i][j];
}
}
k++;
parada = fabs((up-(un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8)/up);
if(parada < erro && k>N){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, un[i][j]);
}
}

printf("\n\n");
}

</source>

Trecho de programa do algoritmo de Super Relaxação para Equação de Poisson:

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void overrelaxationP(){

double u[M+2][M+2], un[M+2][M+2], F[M+2][M+2];
double dx=0, dy=0, omega=1.;
double L=5., parada=0, erro=0.00005, up=0;
int i=0, j=0, k=1, a=0;

omega = 2/(1+PI*dx);

k = 0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = 1.;
u[i][j] = un[i][j];
F[i][j] = i*dx*j*dy*exp(-(pow(i*dx,2) + pow(j*dy,2))/L);
}
}

for(i=0;i<M+1;i++){
un[0][i] = 0.0;
un[M+1][i] = 0.0;
un[i][0] = 0.0;
un[i][M+1] = 0.0;
}
un[0][M+1] = 0.0;
un[M+1][M+1] = 0.0;

/*
for(i=0;i<M+1;i++){
un[0][i] = L*pow(cos(i*dx*PI/L),2);
un[M+1][i] = L*pow(sin(i*dx*PI/L),2);
un[i][0] = L - pow(i*dx,2)/L;
un[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
un[0][M+1] = L;
un[M+1][M+1] = 0.0;
*/

do{

up = (un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = (un[i+1][j] + un[i-1][j] + un[i][j+1] + un[i][j-1] + 4*dx*dx*F[i][j])/4;
u[i][j] = u[i][j]*(1 - omega) + omega*un[i][j];
un[i][j] = u[i][j];
}
}
k++;
parada = fabs((up-(un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8)/up);
if(parada < erro && k>N){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, un[i][j]);
}
}

printf("\n\n");
}

</source>

== Referências ==

#[[http://www.mat.ufmg.br/~rodney/notas_de_aula/metodos_numericos_EDPs_elipticas.pdf]] Biezuner, Rodney Josué,''Notas de Aula Métodos Numéricos para Equações Diferenciais Parciais Elípticas'' (UFMG, 2007)
#[[http://www.mat.ufmg.br/~rodney/notas_de_aula/iedp.pdf]] Biezuner, Rodney Josué,''Introdução às Equações Diferenciais Parciais'' (UFMG, 2007)
#Jianping Zhu, ''Solving Partial Differential Equations on Parallel Computers'' (World Scientific, 1994)

Grupo: Pedro Barbisan Widniczck

Grupo1 - Dif em 2D

2017-10-31T01:22:10Z

Pedrow7:

A equação de Poisson:

<math>\Delta u = \frac{\partial ^{2} u }{\partial x^2} + \frac{\partial ^{2} u }{\partial y^2} = -g(x,y)</math>

é uma equação do tipo Elíptica que representa fenômenos físicos estácionarios relacionados a Eletrostatica, Dinâmica de Fluídos e Transferência de Calor. Se <math> g(x,y) \equiv 0 </math> a equação passa a ser chamada de Equação de Laplace. Os problemas relacionados a equação de Laplace são estudados pela "Teoria do Potencial".

As soluções <math> u = u(x,y) </math> da Equação de Laplace são denominadas funções Harmônicas. Os problemas mais habituais na vida de um físico, engenheiro ou matemático ao se depararem com uma EDP, são os problemas com Condições de Contorno em um dominío <math> \Omega \in \mathbb{R}^2</math>, essencialmente será trabalhada a Condição de Dirichlet, que possui fronteiras (<math> \partial \Omega </math>) conhecidas, tendo o seguinte formato:

<math> \begin{cases}
\Delta u = 0 & \text{para } (x,y) \in \Omega, \\
u = f(x,y) & \text{para } (x,y) \in \partial \Omega.
\end{cases}
</math>

A equação de Poisson possui forma parecida para o Problema de Dirichlet, que fica:

<math> \begin{cases}
\Delta u = - g(x) & \text{para } (x,y) \in \Omega, \\
u = f(x,y) & \text{para } (x,y) \in \partial \Omega.
\end{cases}
</math>

Para tais problemas, estudaremos os métodos de Relaxação e Super-Relaxação para encontrar as soluções da Equação de Laplace na região de Quadrado de Lado <math>L </math> <math> ( \{ \Omega = (0,L)\times (0,L) \} ) </math>.
== Dominio Quadrado de Lado <math> L </math> ==

=== Solução Analítica da Equação de Laplace ===

Seja o problema em <math>\Omega = (0, L) \times (0, L)</math>, temos:

<math>
\begin{cases}
\Delta u(x,y) = 0 \text{ em } \Omega \\
u(x, y) = f(x) \text{ em } \partial \Omega
\end{cases}
</math>

sendo

<math>
f(x) =
\begin{cases}
f(0,y) = f_{1}(y); \\
f(L,y) = f_{2}(y); \\
f(x,0) = f_{3}(x); \\
f(x,L) = f_{4}(x).
\end{cases}
</math>

Separamos o problema geral de Dirchlet em 4 problemas "menores", com condições de contorno diferentes de zero em apenas um trecho da fronteira, de modo que obtemos desde:

<math>
\begin{cases}
\Delta u_{1}(x,y) = 0 \text{ em } \Omega; \\
u_{1}(0,y) = f_{1}(y) \text{ para } y \in (0, L); \\
u_{1}(L,y) = u_{1}(x,0) = u_{1}(x,L) =0,
\end{cases}
</math>

...

até:

<math>
\begin{cases}
\Delta u_{4}(x,y) = 0 \text{ em } \Omega; \\
u_{4}(x,L) = f_{4}(x) \text{ para } x \in (0, L); \\
u_{4}(0,y) = u_{4}(L,y) = u_{4}(x,0) =0.
\end{cases}
</math>

Podemos então utilizar o Método da Separação de Variáveis para resolver os 4 problemas e, como a Equação de Laplace é linear, sua soma será a solução completa do Problema de Dirichlet. O método consiste em supor <math> u(x, y) = \phi(x)\theta(y)</math>, para então, ao substituirmos na equação obtermos a seguinte expressão:

<math> \Delta u_{i} = \ddot{\phi_{i}}(x)\theta_{i}(y) + \phi_{i}(x) \ddot{\theta_{i}}(y) = 0 </math>

Podemos isolar as funções <math>\phi_{i}</math> e <math>\theta_{i}</math>, de fato ficamos com com duas relações que dependem ou apenas de <math> x </math> e <math> y </math> portanto para elas serem sempre iguais, é necessário que sejam constantes (<math> = \lambda</math>):

<math> \frac{\ddot{\phi_{i}}}{\phi_{i}} = -\frac{\ddot{\theta_{i}}}{\theta_{i}} = \lambda </math>

Assim obtemos 2 EDOs de segunda ordem, que podem ser resolvidas pelo Método dos Coeficientes a Determinar. Como não é objetivo aqui realizar cálculos analíticos (especialmente "na mão") apenas será resolvido o primeiro problema (<math>u_{1}(x, y)</math>):

As condições de contorno mostram que <math> \phi(L)\theta(y) = 0 \Rightarrow \phi(L) = 0 </math>, <math> \phi(x)\theta(0) = 0 \Rightarrow \theta(0) = 0 </math> e <math> \phi(x)\theta(L) = 0 \Rightarrow \theta(L) = 0 </math>.

Dividindo o problema, temos a parte de <math>\phi</math>

<math>
\begin{cases}
\ddot{\phi_{1}}(y) - \lambda \phi_{1} =0; \\
\phi_{1} (L) = 0; \\
\end{cases}
</math>

Supondo uma solução da forma <math> \phi_{1}(x) = Ae^{sx}</math>:

<math> \ddot{\phi_{1}} - \lambda \phi_{1} = s^{2}Ae^{sx} - \lambda Ae^{sx} = 0 \Longrightarrow</math>
<math> s = \pm \sqrt{\lambda} </math>

Ou seja, temos a solução de <math>\phi_{1}</math> sendo

<math> \phi_{1}(x) = A_{1}e^{\sqrt{\lambda} x} + A_{2}e^{- \sqrt{\lambda} x} </math>

Partindo para a segunda equação <math> \theta_{1}(y) </math>,

<math>
\begin{cases}
\ddot{\theta_{1}}(x) + \lambda \theta_{1} =0; \\
\theta_{1} (0) = 0 \\
\theta_{1} (L) = 0;
\end{cases}
</math>

supondo solução do tipo <math> \theta_{1} (y) = Be^{i\omega y} </math> temos:

<math> \ddot{\theta_{1}} + \theta_{1} = -\omega^2 Be^{i\omega y} + \lambda Be^{i\omega y} = 0 \Longrightarrow </math>
<math> \omega = \pm \sqrt{\lambda} </math>

Ou seja, temos solução <math> \theta_{1}(y) = B_{1}e^{i\sqrt{\lambda} y} + B_{2}e^{-i\sqrt{\lambda} y} </math>

Utilizando a primeira C.C. obtemos <math>B_{1} = - B_{2} = B</math>

ou seja, temos que

<math>\theta_{1}(y) = B sen(\sqrt{\lambda} y ). </math> Utilizando a segunda C.C. temos <math> 0 = sen(\sqrt{\lambda} y) \Rightarrow \lambda = \frac{n^2 \pi^2}{L^2}, </math>

ou seja, existem infinitos <math>n</math> tal que <math>\theta_{1}</math> é solução.

Voltando a <math>\phi_{1}</math>, temos <math> \phi_{1}(x) = senh(\frac{n\pi (L-x)}{L}). </math>

Finalmente unindo as respostas, temos

<math> u_{1}(x, y) = \phi_{1}(x) \theta_{1}(y) = \sum C_{1n} \frac{senh(\frac{n \pi(L- x)}{L})}{senh(n\pi)}sen(\frac{n \pi y}{L})</math>

sendo <math>C_{1n} = \frac{2}{L}\int_{0}^{L} f_{1}(y) sen(\frac{n \pi y}{L}) dy</math>

Para os outros problemas, temos soluções parecidas:

<math> u_{2}(x, y) = \phi_{2}(x) \theta_{2}(y) = \sum C_{2n} \frac{senh(\frac{n \pi x}{L})}{senh(n\pi)}sen(\frac{n \pi y}{L});</math> sendo <math> C_{2n} = \frac{2}{L}\int_{0}^{L} f_{2}(x) sen(\frac{n \pi y}{L}) dy,</math>

<math> u_{3}(x, y) = \phi_{3}(x) \theta_{3}(y) = \sum C_{3n} \frac{senh(\frac{n \pi(L- y)}{L})}{senh(n\pi)}sen(\frac{n \pi x}{L});</math> sendo <math>C_{3n} = \frac{2}{L}\int_{0}^{L} f_{3}(y) sen(\frac{n \pi x}{L}) dx,</math>

<math> u_{4}(x, y) = \phi_{4}(x) \theta_{4}(y) = \sum C_{4n} \frac{senh(\frac{n \pi y}{L})}{senh(n\pi)}sen(\frac{n \pi x}{L});</math> sendo <math>C_{4n} = \frac{2}{L}\int_{0}^{L} f_{4}(x) sen(\frac{n \pi x}{L}) dx.</math>

A solução completa do problema de Dirichlet no quadrado de Lado <math>L</math> é a soma das quatro soluções parciais: <math> u(x, y) = u_{1}(x, y) + u_{2}(x, y) + u_{3}(x, y) + u_{4}(x, y) </math>.

=== Método da Relaxação ===

O Método da Relaxação é um método iterativo utilizado para obter a solução numérica para a equação de Laplace e Poisson. A ideia do método é de, utilizando a vizinhança iterar os pontos da malha até que convirjam para uma solução.

Discretizando a equação temos <math>x\mapsto x_{i}</math> e <math>y\mapsto y_{j}</math> para <math>i</math>, <math>j = 1, ..., N</math> e <math> h = \Delta x = \Delta y = N/L</math> a função <math> g(x, y) = g_{ij}</math>, nos deparamos com uma matriz <math>\mathcal{M}_{i j} = u(x_{i},y_{j}) = u_{i j}</math> quadrada sendo as bordas <math>\mathcal{M}_{1 j} = f(0, y) = u_{1 j}</math>, <math>\mathcal{M}_{N j} = f(L, y) = u_{N j}</math>, <math>\mathcal{M}_{i 1} = f(x, 0) = u_{i 1}</math> e <math>\mathcal{M}_{i N} = f(x, L) = u_{i N}</math>.

Realizando-se a discretização, podemos tomar as derivadas:

<math> \frac{\partial^2 u}{\partial x^2} = \frac{u_{(i+1) j} + u_{(i-1) j} -2u_{i j}}{h^2} </math>
e
<math> \frac{\partial^2 u}{\partial y^2} = \frac{u_{i (j+1)} + u_{i (j-1)} -2u_{i j}}{h^2} </math>

Substituindo na Equação, temos

<math> \frac{u_{(i+1) j} + u_{(i-1) j} -2u_{i j}}{h^2} + \frac{u_{i (j+1)} + u_{i (j-1)} -2u_{i j}}{h^2} = - g_{ij} </math>,
ou seja:

<math> u_{i j} = \frac{u_{(i-1) j} + u_{(i+1) j} + u_{i (j-1)} + u_{i (j+1)} + h^{2}g_{ij}}{4}</math>,

ou mais geralmente (supondo <math>\Delta x \neq \Delta y</math>):

<math> u_{i j} = \frac{(\Delta y)^{2}(u_{(i-1) j} + u_{(i+1) j}) + (\Delta x)^2(u_{i (j-1)} + u_{i (j+1)}) + (\Delta y \Delta x)^2 g_{ij}}{2((\Delta x)^2 + (\Delta y)^2)}, </math>

para <math> i, j = 2, ..., N+1 </math>

Para condição de parada, foi convencionado tomar o erro relativo entre as iterações <math> k </math> e <math> k+1 </math>, para estimar o erro, se optou por tomar como valores, o ponto médio da malha (já que é o ultimo ponto a ser alcançado nas iterações, portanto, quando sua variação diminuir é sinal de que a solução já está convergindo), para observarmos a evolução em relação a outros pontos que variam desde o inicio, foram utilizados as diagonais interiores, tal que o erro relativo é:

<math> \epsilon = \Big|\frac{v^{k} - v^{k+1}}{v^{k}}\Big|</math>

fazendo a média ponderada com peso 4 para o ponto médio:

<math> v^{k} = \frac{1}{8} (u_{2 2} + u_{2 (N+1)} + u_{(N+1) 2} + 4u_{\frac{(N+2)}{2} \frac{(N+2)}{2}}+u_{(N+1) (N+1)}) </math>

=== Método da Super Relaxação ===

Podemos também realizar uma média entre os valores já calculados e os ainda não calculados na iteração, o método da Super Relaxação ou Sobrerrelaxação (SOR) é da seguinte forma:

<math> u_{ij}^{k+1} = u_{i j}^{k}(1 - \omega) + \omega u_{ij}^{R} </math>

tal que <math> u_{ij}^{R} </math> é o valor calculado através do método da Relaxação e <math> \omega \in [0:2]</math> é o fator de relaxamento, se <math> \omega = 1 </math> temos a Relaxação normal.

=== Estabilidade ===

==== Relaxação ====
[[Arquivo:erro2.png|thumb|400px| Erro relativo (método da Relaxação) em função da quantidade de iterações]]

A relaxação é um método Iterativo sobre os pontos vizinhos que pode ser feita de 2 modos, pelo Algoritmo de Jacobi, e pelo de Gauss-Seidel.

O algoritmo de Jacobi pega valores "antigos" para a iteração e possui convergencia muito lenta, por isso não é muito utilizado. Já o algoritmo de Gauss-Seidel pega os valores "novos" (que ja foram calculados na iteração) e os "antigos" (que não foram calculados na iteração <math> k </math>), possui convergência mais rapida, porém ainda é lenta.

Como a média definida anteriormente foi feita utilizando o ponto médio do domínio, o erro cresce após decair, pois é quando efetivamente ocorrem variações maiores no ponto médio.

Para a relaxação, o algoritmo de Jacobi faz o seguinte cálculo:

<math> u_{i j}^{k+1} = \frac{u_{(i-1) j}^{k} + u_{(i+1) j}^{k} + u_{i (j-1)}^{k} + u_{i (j+1)}^{k} + h^{2}g_{ij}}{4}</math>,

já o algoritmo de Gauss-Seidel faz:

<math> u_{i j}^{k+1} = \frac{u_{(i-1) j}^{k+1} + u_{(i+1) j}^{k} + u_{i (j-1)}^{k+1} + u_{i (j+1)}^{k} + h^{2}g_{ij}}{4}</math>,

Algoritmos iterativos tendem a convergir para solução unica, se a matriz que as representa for Diagonal Dominante, ou seja:

<math> |a_{ii}| \ge \sum_{j=1 (i\neq j)}^{N} |a_{ij}| </math>

Sendo <math> a_{ii} = u_{ii} </math> e <math> a_{ij} = u_{ij} </math>, então <math> |u_{ii}| = 4 </math> e <math> |u_{ij}| = 1 </math> e

<math> \sum_{j=1 (i\neq j)}^{N+2} |a_{ij}| = 4 </math>

Como <math> 4 = 4 </math>, a desigualdade vale e o método converge.

De fato, podemos ver que a equação de Laplace respeita tal desigualdade.

Caso façamos um retangulo <math> L_{x} \neq L_{y} </math> com <math> \Delta x \neq \Delta y </math>, obtemos os erros da imagem a seguir, feito utilizando <math> L_{x} =1 </math> e <math> L_{y} = 5 </math>, <math> L_{x} =2 </math> e <math> L_{y} = 4 </math> e <math> L_{x} =1.5 </math> e <math> L_{y} = 4.5 </math>:

[[Arquivo:erro.png|frameless|400px|Erro obtido para diferentes comprimentos do retangulo]]

==== Super Relaxação ====

[[Arquivo:errooverr.png|thumb|400px|Grafico mostra a quantidades de Iterações para convergência do exemplo 1 em função de omega]]

Como o método depende de <math> \omega </math>, e se <math> \omega = 1 </math> temos a Relaxação normal, então podemos já observar que a convergência será mais demorada se <math> \omega < 1 </math>, já quando maior que 1, a solução sempre converge mais rápido até um <math> \omega_{otimo} </math> após o valor ótimo o valor cresce até 2, valor que diverge para o SOR.

Usaremos <math> \omega = \frac{2}{1+sen(\pi \Delta x)} </math> que é o valor ótimo.

=== Exemplos ===

Foram realizados 5 exemplos, 2 sobre a equação de Laplace e 3 sobre a equação de Poisson.

==== Exemplo 1 ====

O primeiro problema,que pode ser descrito como a temperatura <math> T = T(x, y)</math> de uma chapa que está em equilíbrio térmico com um dos lados a temperatura <math>T(x, 0) = L</math>, todos os outros lados iguais com temperatura 0 e sem geração. Para o domínio <math> \Omega = (0;L) \times (0;L) </math>, tal problema é descrito pela seguinte expressão:

<math>
\begin{cases}
\Delta u = 0 \forall x,y \in \Omega \\
u(x,0) = L \big( \forall x \in [0;L] \big) \\
u(x, L) = 0 \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

A solução analítica para o problema é:

<math> u(x, y) = \frac{4L}{\pi}\sum_{n=0}^{\infty} \frac{sen(\frac{(2n+1) \pi x}{L})}{2n+1} \frac{senh\Big(\frac{(2n+1) \pi (L-y)}{L}\Big)}{ senh((2n+1)\pi)} </math>

Foi possível obter o gráfico da função analítica aproximada com os 110 primeiros termos parciais e estimar o erro entre a solução numérica e a solução analítica, que foi alto devido ao truncamento da série que forma a solução analítica.

[[Arquivo:solucaoanalitica1.png|450px|thumb|Solução analítica do Problema de Contorno 1]]

[[Arquivo:erroanalitico1.png|450px|thumb|Erro entre solução numérica e solução analítica em função do número de iterações]]

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel, no caso da relaxação foram necessárias 1471 iterações para a solução convergir, já SOR levou 1000.

[[Arquivo:relaxacao1k1471.png|450px|Solução do Problema de Contorno através do Método de Relaxação (utilizando o algoritmo de Gauss-Seidel)]]
[[Arquivo:sol1k1001.png|450px|Solução do Problema de Contorno através do Método de Super Relaxação (utilizando o algoritmo de Gauss-Seidel)]]

==== Exemplo 2 ====

O segundo problema é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = 0 \forall x,y \in \Omega \\
u(x,0) = Lsin(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(x, L) = Lcos(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(0, y) = \frac{x^{2}}{L} \big( \forall y \in [0;L] \big) \\
u(L, y) = \frac{(L-x)^{2}}{L} \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as seguintes soluções mostradas nos gráficos, através do algoritmo de Gauss-Seidel.

[[Arquivo:relaxacao2k2122.png|300px|Solução do Problema de Contorno através do Método de Relaxação (utilizando o algoritmo de Gauss-Seidel)]]
[[Arquivo:relaxacao2k1001.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação (utilizando o algoritmo de Gauss-Seidel)]]

==== Exemplo 3 ====

O primeiro problema sobre a equação de Poisson , possui contornos fixos e uma gaussiana, pode ser considerado um problema de eletrostática com distribuição de carga <math> \frac{\rho}{\epsilon_{0}} = xy e^{-(x^2+ y^2)} </math> . Tal problema é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = 0 \big( \forall x \in [0;L] \big) \\
u(x, L) = 0 \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson0.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:overrP0.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

==== Exemplo 4 ====

O segundo problema sobre a equação de Poisson, que é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = 0 \big( \forall x \in [0;L] \big) \\
u(x, L) = L \big( \forall x \in [0;L] \big) \\
u(0, y) = 0 \big( \forall y \in [0;L] \big) \\
u(L, y) = 0 \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson1r.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:poisson1sor.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

==== Exemplo 5 ====

O segundo problema sobre a equação de Poisson, que é descrito pela seguinte expressão, para o domínio <math> \Omega = (0;L) \times (0;L) </math>:

<math>
\begin{cases}
\Delta u = -g(x, y) = -xye^{-(x^2 + y^2)} \forall x,y \in \Omega \\
u(x,0) = Lsin(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(x, L) = Lcos(\frac{\pi x}{L}) \big( \forall x \in [0;L] \big) \\
u(0, y) = \frac{x^{2}}{L} \big( \forall y \in [0;L] \big) \\
u(L, y) = \frac{(L-x)^{2}}{L} \big( \forall y \in [0;L] \big) .
\end{cases}
</math>

Foram obtidas as soluções mostradas nos gráficos a seguir, através do algoritmo de Gauss-Seidel.

[[Arquivo:poisson2r.png|300px|Solução do Problema de Contorno através do Método de Relaxação]]
[[Arquivo:poisson2sor.png|300px|Solução do Problema de Contorno através do Método de Super Relaxação]]

O programa utilizado para gerar as soluçoes e erros foi o seguir (ou com pequenas alteraçoes):

==== Programa ====
Trechos do programa realizado para os exemplos acima.

Programa para o método de Relaxação (Equação de Laplace):

<source lang="c">
#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529
void gaussseidelL(){
double u[M+2][M+2];
double dx=0, dy=0;
double L=5., parada=0, erro=0.00001, up=0;
int i=0, j=0, k=1, a=0;
dx = L/(M+1);
dy = L/(M+1);
for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = 1.;
}
}
/* Primeira Solução, GaussSeidel1 */
for(i=0;i<M+1;i++){
u[0][i] = L;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
/* Segunda Solução, GaussSeidel2
for(i=0;i<M+1;i++){
u[0][i] = L*pow(cos(i*dx*PI/L),2);
u[M+1][i] = L*pow(sin(i*dx*PI/L),2);
u[i][0] = L - pow(i*dx,2)/L;
u[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/
do{
up = (u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3;
for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = (u[i+1][j] + u[i-1][j] + u[i][j+1] + u[i][j-1])/4;
}
}
k++;
parada = fabs((up-(u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3)/up);
if(parada < erro && k>N/5){
a = 1;
}else{
a = 0;
}
}while(a == 0);
for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, u[i][j]);
}
}
printf("\n\n");
return;
}
</source>

Segundo trecho para método de Relaxação, Equação de Poisson

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void gaussseidelP(){

double u[M+2][M+2], F[M+2][M+2];
double dx=0, dy=0;
double L=5., parada=0, erro=0.00001, up=0;
int i=0, j=0, k=1, a=0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = 0.;
F[i][j] = i*dx*j*dy*exp(-(pow(i*dx,2) + pow(j*dy,2))/L);
}
}

/* Solução Zero, Poisson0 */
for(i=0;i<M+1;i++){
u[0][i] = 0;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = 0;
u[M+1][M+1] = 0.0;

/* Primeira Solução, PoissonGS1
for(i=0;i<M+1;i++){
u[0][i] = L;
u[M+1][i] = 0.0;
u[i][0] = 0.0;
u[i][M+1] = 0.0;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/

/* Segunda Solução, PoissonGS2
for(i=0;i<M+1;i++){
u[0][i] = L*pow(cos(i*dx*PI/L),2);
u[M+1][i] = L*pow(sin(i*dx*PI/L),2);
u[i][0] = L - pow(i*dx,2)/L;
u[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
u[0][M+1] = L;
u[M+1][M+1] = 0.0;
*/

do{
up = (u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
u[i][j] = (u[i+1][j] + u[i-1][j] + u[i][j+1] + u[i][j-1] + 4*dx*dx*F[i][j])/4;
}
}

k++;
parada = fabs((up-(u[1][1] + u[M/2+1][M/2+1] + u[M][M])/3)/up);
if(parada < erro && k>N/5){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, u[i][j]);
}
}

printf("\n\n");
return;
}

</source>

Trecho de programa que utiliza o método de Super Relaxação para Equação de Laplace:

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void overrelaxationL(){

double u[M+2][M+2], un[M+2][M+2];
double dx=0, dy=0, omega=1.;
double L=5., parada=0, erro=0.00005, up=0;
int i=0, j=0, k=1, a=0;

omega = 2/(1+PI*dx);

k = 0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = 1.;
u[i][j] = un[i][j];
}
}
/*
for(i=0;i<M+1;i++){
un[0][i] = 0.0;
un[M+1][i] = L;
un[i][0] = 0.0;
un[i][M+1] = 0.0;
}
un[0][M+1] = 0.0;
un[M+1][M+1] = L;
*/

for(i=0;i<M+1;i++){
un[0][i] = L*pow(cos(i*dx*PI/L),2);
un[M+1][i] = L*pow(sin(i*dx*PI/L),2);
un[i][0] = L - pow(i*dx,2)/L;
un[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
un[0][M+1] = L;
un[M+1][M+1] = 0.0;

do{

up = (un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = (un[i+1][j] + un[i-1][j] + un[i][j+1] + un[i][j-1])/4;
u[i][j] = u[i][j]*(1 - omega) + omega*un[i][j];
un[i][j] = u[i][j];
}
}
k++;
parada = fabs((up-(un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8)/up);
if(parada < erro && k>N){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, un[i][j]);
}
}

printf("\n\n");
}

</source>

Trecho de programa do algoritmo de Super Relaxação para Equação de Poisson:

<source lang="c">

#include<stdio.h>
#include<math.h>
#define N 1000
#define M 70
#define P 1
#define PI 3.141529

void overrelaxationP(){

double u[M+2][M+2], un[M+2][M+2], F[M+2][M+2];
double dx=0, dy=0, omega=1.;
double L=5., parada=0, erro=0.00005, up=0;
int i=0, j=0, k=1, a=0;

omega = 2/(1+PI*dx);

k = 0;

dx = L/(M+1);
dy = L/(M+1);

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = 1.;
u[i][j] = un[i][j];
F[i][j] = i*dx*j*dy*exp(-(pow(i*dx,2) + pow(j*dy,2))/L);
}
}

for(i=0;i<M+1;i++){
un[0][i] = 0.0;
un[M+1][i] = 0.0;
un[i][0] = 0.0;
un[i][M+1] = 0.0;
}
un[0][M+1] = 0.0;
un[M+1][M+1] = 0.0;

/*
for(i=0;i<M+1;i++){
un[0][i] = L*pow(cos(i*dx*PI/L),2);
un[M+1][i] = L*pow(sin(i*dx*PI/L),2);
un[i][0] = L - pow(i*dx,2)/L;
un[i][M+1] = pow(((M+1)-i)*dx,2)/L;
}
un[0][M+1] = L;
un[M+1][M+1] = 0.0;
*/

do{

up = (un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8;

for(i=1;i<M+1;i++){
for(j=1;j<M+1;j++){
un[i][j] = (un[i+1][j] + un[i-1][j] + un[i][j+1] + un[i][j-1] + 4*dx*dx*F[i][j])/4;
u[i][j] = u[i][j]*(1 - omega) + omega*un[i][j];
un[i][j] = u[i][j];
}
}
k++;
parada = fabs((up-(un[1][1] + 4*un[M/2+1][M/2+1] + un[M][M] + un[1][M] + un[M][1])/8)/up);
if(parada < erro && k>N){
a = 1;
}else{
a = 0;
}
}while(a == 0);

for(i=0;i<M+2;i++){
for(j=0;j<M+2;j++){
printf("%lf %lf %lf \n",i*dx, j*dy, un[i][j]);
}
}

printf("\n\n");
}

</source>

== Referências ==

#[[http://www.mat.ufmg.br/~rodney/notas_de_aula/metodos_numericos_EDPs_elipticas.pdf]] Biezuner, Rodney Josué,''Notas de Aula Métodos Numéricos para Equações Diferenciais Parciais Elípticas'' (UFMG, 2007)
#[[http://www.mat.ufmg.br/~rodney/notas_de_aula/iedp.pdf]] Biezuner, Rodney Josué,''Introdução às Equações Diferenciais Parciais'' (UFMG, 2007)
#Jianping Zhu, ''Solving Partial Differential Equations on Parallel Computers'' (World Scientific, 1994)

Grupo: Pedro Barbisan Widniczck