Modelo de Potts 2D

Modelo de Potts

O Modelo

O "modelo de Potts de Q-estados" trata de um sistema de rede com N spins interagentes $s=\{s_{1},s_{2},..s_{i},...s_{N}\}$, onde um spin $s_{i}$ pode assumir valores discretos $q\in {\{0,1,2,...,Q-2,Q,Q-1\}}$. Cada spin do sistema está limitado a interagir com outros spins em sua vizinhança e a energia da interação entre dois spins $s_{i}$ e $s_{j}$ é dada pelo potencial

$V(s_{i},s_{j})=-J\delta {(s_{i},s_{j})}$

onde $\delta {(s_{i},s_{j})}$ é a função delta de Kronecker e $J$ é a constante de interação entre os spins. Dessa maneira, a interação entre dois spins vizinhos contabiliza um valor $-J$ de energia ao sistema apenas se $s_{i}=s_{j}$. A hamiltoniana do sistema é dada pela soma entre todas as interações entre spins vizinhos:

${\mathcal {H}}=-J\sum _{\langle i,j\rangle }{\delta {(s_{i},s_{j})}}$

Este modelo é tido como uma generalização natural do Modelo de Ising e para o caso $Q=2$ ambos modelos são equivalentes a menos de uma constante:

${\mathcal {H}}_{ising}={\mathcal {H}}_{potts}+\sum _{\langle i,j\rangle }{\frac {J}{2}}=-{\frac {J}{2}}\sum _{\langle i,j\rangle }[2\delta (s_{i},s_{j})-1]$

Nesse caso, a interação entre dois spins $s_{i}$ e $s_{j}$ assume a mesma dinâmica do modelo de Ising a contribuição para a energia do sistema será

$V(s_{i},s_{j})={\begin{cases}-{\frac {J}{2}},\quad {\text{se }}s_{i}=s_{j}\\{\frac {J}{2}},\quad {\text{se }}s_{i}\neq s_{j}\end{cases}}$

Método de Monte Carlo

O método de Monte Carlo é aplicado ao modelo de Potts com o objetivo de gerar estados de equilíbrio para medir os observáveis do sistema. Os $N$ spins são iniciados com valores aleatórios de Q na rede e o método de Monte Carlo escolhe arbitrariamente um spin $s_{i}$ e gera um novo valor de $q\in Q|q\neq s_{i}$ para o spin. A partir disso, através de algum algoritmo específico, se escolhe como os estados serão gerados e quais serão aceitos ou não para o sistema transicionar, respeitando as condições de balanço detalhado e ergodicidade das cadeias markovianas. Para este trabalho, foram estudados os algoritmos de Metropolis-Hasting e o algoritmo de banho térmico.

Algorítmo de Metropolis-Hasting

O primeiro algoritmo utilizado para gerar as configurações do sistema foi o algoritmo de Metropolis-Hasting. O algoritmo escolhe repetidamente um novo estado para o sistema $\nu$ e aceitando ou rejeitando ele de acordo com uma probabilidade de aceitação $A(\mu \rightarrow \nu )$ de transitar de um estado antigo $\mu$ para o novo estado $\nu$. O algoritmo que iremos descrever utiliza a dinâmica de inversão única de spins.

Temos que a condição de balanceamento detalhado é dada por :

${\frac {A(\mu \rightarrow \nu )}{A(\nu \rightarrow \mu )}}=e^{-\beta \Delta E},\qquad (3)$

onde $\Delta E=E_{\nu }-E_{\mu }$ é a diferença de energia entre o novo e o antigo estado.

Vamos supor que tenhamos os estados $\mu$ e $\nu$ e que temos a relação de energias: $E_{\mu }<E_{\nu }$. Então, a maior das duas chances de aceitação é $A(\nu \rightarrow \mu )$, portanto iremos igualar essa probabilidade a 1. Para que $(3)$ seja respeitada, iremos definir o valor de $A(\mu \rightarrow \nu )$ como $e^{-\beta \Delta E}$. Temos, assim, o algoritmo de Metropolis-Hasting:

$A(\mu \rightarrow \nu )={\begin{cases}e^{-\beta \Delta E},\qquad {\text{se }}\Delta E>0\\\\1,\qquad \qquad {\text{caso contrario}}.\end{cases}}$

Dessa forma, sempre que tivermos um estado cuja energia seja menor do que a do estado atual, iremos aceitar a transição, mas se a energia for maior, teremos uma pequena probabilidade de trocarmos de estado.

Algoritmo de Banho Térmico

O algoritmo de Metropolis-Hasting para inversão única de spins é eficaz para o modelo de Potts em baixos valores de $Q$ ou temperaturas acima da temperatura crítica, entretanto para valores altos de $Q$ ou baixas temperaturas o algoritmo falha em convergir o sistema rapidamente para o estado estacionário.

Considerando um caso onde $Q=100$ e um spin que possui 4 vizinhos, se todos os vizinhos do spin possuem valores diferentes uns do outro e do próprio spin, poderá levar em média $100/4=25$ passos de Monte Carlo para sortear um novo valor de $q$ que tem a transição aceita, e dessa forma o algoritmo irá demorar mais tempo para alcançar a configuração de equilíbrio do sistema. A dificuldade de aceitar transições é maior ainda para baixas temperaturas, onde a probabilidade de transicionar para um novo estado tem um peso maior para qualquer $q$ diferente dos spins da vizinhança, dessa maneira poderá demorar 96 passos para gerar um spin que seja igual a algum spin da vizinhança e realizar a transição. Para contornar este problema podemos utilizar o algoritmo de banho térmico.

O algoritmo de banho térmico, assim como o metropolis, é um algoritmo em que mudamos um spin por vez. O algoritmo segue as seguintes etapas: primeiro escolhemos um spin na rede ($i$), e independente do seu valor atual, escolhemos um novo valor para $s_{i}$. Esse novo valor será aceito, ou não, de acordo com os pesos de Boltzmann. Temos que no algoritmo de Banho Térmico nós atribuímos um valor $n$, entre 1 e $q$, ao spin com uma probabilidade

$A(\mu \rightarrow \nu )={\frac {e^{-\beta E_{\nu }}}{\sum _{m=1}^{q}e^{-\beta E_{m}}}},$

onde $E_{n}$ é a energia do sistema quando $s_{i}=n$ e o somatório é dado em todas energias possíveis. Pelo fato desse algoritmo permitir que o spin assuma qualquer valor ele satisfaz a condição de ergodicidade. Temos que $A(\mu \rightarrow \nu )=a_{\nu }$ e $A(\nu \rightarrow \mu )=a_{\mu }$, assim, pela descrição do algoritmo temos

${\frac {A(\mu \rightarrow \nu )}{A(\nu \rightarrow \mu )}}={\frac {a_{\nu }}{a_{\mu }}}={\frac {e^{-\beta E_{\nu }}}{\sum _{m=1}^{q}e^{-\beta E_{m}}}}\times {\frac {\sum _{m=1}^{q}e^{-\beta E_{m}}}{e^{-\beta E_{\mu }}}}=e^{-\beta \Delta E}.$

Ou seja, o algoritmo de banho térmico respeita a condição de balanço detalhado.

Veremos que para valores pequenos de $q$ (como $q=2$, que é o modelo de Ising), o algoritmo de Metropolis é mais eficiente. Porém, para valores altos de $q$ ou altas temperaturas o algoritmo de banho térmico é mais eficiente.

Aplicação

Neste trabalho, o modelo de Potts foi estudado em uma rede quadrada 2D com vizinhança de von Neumann para primeiros vizinhos e condições de contorno periódicas. A quantidade de spins no modelo é $N=L\times L$ com interações ferromagnéticas e $J=1$, favorecendo vizinhanças de spins que compartilham o mesmo valor de $q$ para minimizar a energia do sistema. Em cada passo temporal, são realizadas $L^{2}$ iterações do algoritmo de aceitação do Metropolis ou Banho Térmico. Definimos Passo de Monte Carlo (MCS) como cada um desses passos temporais. Em cada passo de Monte Carlo, todos os sítios tem a probabilidade de tentar realizar uma troca.

Otimizações Computacionais

Essa seção é focada em algumas otimizações computacionais que podemos fazer ao simular sistemas de rede. Os "snippets" de códigos estão em C, mas a ideia pode ser adaptada para qualquer linguagem de programação.

Redes

Uma boa sugestão ao criar a topologia do sistema é utilizar um "array" unidimensional ao invés de bidimensional. Como estamos falando de uma rede quadrada de tamanho $L\times L=L^{2}$ podemos fazer

int sitio[L*L];

no lugar de

int sitio[L][L];

Uma praticidade que ganhamos com isso é que diminuímos as componentes que precisamos utilizar para diferenciar cada sítio na rede, sendo necessário apenas um número aleatório para identificar o sítio. Outra sugestão é criar uma matriz de vizinhos, pois nas simulações desses sistemas geralmente precisamos saber a configuração deles. Nos vizinhos criaremos um "array" bidimensional, uma coordenada indicará o sitio que queremos e a outra indicará qual dos quatro vizinhos estamos lidando:

int viz[L*L][4];

Então por lidarmos com os nossos sítios em um "array" unidimensional e condições periódicas utilizamos as seguintes relações que determinam a posição de cada vizinho nessa matriz.

for(i=0; i<L*L; i++)
{
        viz[i][0] = (i-L+(L*L))%(L*L);
        viz[i][1] = (i+1)%L + (i/L)*L;
        viz[i][2] = (i+L)%(L*L);
        viz[i][3] = (i-1+L)%L + (i/L)*L;
}

Assim, se necessitarmos comparar com apenas um vizinho utilizamos o numero correspondente a ele, e se precisarmos comparar com todos podemos fazer um "loop". Lembrando que esse "array" guarda a posição dos vizinhos, se quisermos, por exemplo, associar um valor $q$ ao vizinho 3 do sítio $i$ fazemos da forma

sitio[viz[i][3]] = q;

Redução de "if"s

No Modelo de Potts nós possuímos uma delta de Kronecker. Iremos subtrair $J$ da nossa energia se o valor do sítio for igual ao de um vizinho. A maneira mais direta de se pensar em simular essa parte do sistema é utilizando condicionais "if/else", da forma

for(int j=0; j<_Q; j++)
{
        for(int k=0; k<4; k++)
        {
                E1 = 0;
                if(j==spin[neigh[site][k]])
                {
                        E1-=J;
                }
        }
                 E2 += exp(-E1/(KB*_TEMP));
}

Entretanto, Para valores grandes de $q$ esses condicionais "if"s resultarão em um alto custo computacional. Como temos uma delta de Kronecker no sistema podemos utilizar dela dentro do programa. Primeiro definimos o array bidimensional como a delta de kronecker da forma

for(i=0; i<_Q; i++)
{
        for(j=0; j<_Q; j++)
        {
                if(i==j)
                {
                        kronecker[i][j] = 1;
                }
                else
                {
                        kronecker[i][j] = 0;
                }
        }
}

Note que utilizamos "if/else", porém essa parte do código executa apenas uma vez. E então usamos esse "array" para otimizar as comparações:

for(j=0; j<_Q; j++)
{
        E1 = 0;

        for(k=0; k<4; k++)
        {
                E1-=J*kronecker[j][spin[neigh[site][k]]];
        }

        E2 += exp(-E1/(KB*_TEMP));
}

Assim obtemos um melhor desempenho computacional, já que não temos uma grande quantidade de "if"" no código. Também utilizamos de forma mais clara a delta de kronecker do nosso hamiltoniano.

Função de Visualização

Podemos estar interessados em ver a evolução do nosso sistema. Podemos plotar diretamente do programa sem gerar os dados e plotar depois. Definimos essa função da forma

void visualize(int *spin)
{
        int i;
        printf("unset xtics\nunset ytics\n");
        printf("set size square\n");
        printf("set xrange [0:%d]\nset yrange [0:%d]\n",L-1,L-1);
        printf("pl '-' matrix w image\n");
        for(i=L2-1; i>=0; i--)
        {
                printf("%d ", spin[i]);
                if(i%L == 0)
                {
                        printf("\n");
                }
        }

        printf("e\n\n");
}

onde a função recebe o sitio. Utilizando um "pipe" redirecionamos a saida diretamente para a o gnuplot. Podemos também não querer plotar sempre, assim definimos uma diretiva que responde a compilação do programa

#ifdef VIEW     
        if(mcs % 10 == 0)
        {
                printf("set title 'T = %d MCS'\n", mcs);
                visualize(spin);
        }
#endif

Assim, se na linha de compilação tiver a opção

 -DVIEW

o programa irá, a cada $10mcs$, plotar a configuração do sistema. Essa opção as vezes se torna importante para visualizar se nosso sistema esta evoluindo da forma que estamos esperando.

Programas Utilizados

Programas na linguagem C. Para utilizar os programas, abra o terminal e compile da forma

$ gcc prog.c -lm

Onde prog.c é o programa que deseja utilizar. É necessário que o programa e a biblioteca com funções para simulações de Monte Carlo estejam no mesmo diretório no momento da compilação. Execute da seguinte maneira

$ ./a.out Q TEMP

onde o segundo termo é o estado Q do sistema e o terceiro é a temperatura do sistema. Os programas possuem uma diretiva de compilação para visualização do sistema ao decorrer da execução. Para utilizar é necessário ter o gnuplot instalado e compilar da forma

$ gcc -DVIEW prog.c -lm

e então executar da maneira

$ ./a.out Q TEMP | gnuplot

Entretanto com a visualização no gnuplot o programa demora mais para executar, então é recomendado diminuir os tempos de transiente (TRAN) e medidas (TMAX) caso se queira observar a simulação inteira.

O script possui alguns exemplos de execução através de diferentes estados e temperaturas do sistema. Copie o conteudo em um arquivo e então o deixar executável:

$ chmod +x script.sh

e então com o programa compilado pode executar da forma

$ ./script.sh

Potts Metropolis

Potts Banho Térmico

Biblioteca com funções em C para simulações de Monte Carlo

Script em bash para gerar os dados