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}},\qquad {\text{se }}s_{i}=s_{j}\\{\frac {J}{2}},\qquad {\text{se }}s_{i}\neq s_{j}\end{cases}}$

Motivações

Por muitos anos o modelo de Potts foi considerado um sistema que exibe transição de ordem e desordem de interesse apenas teórico, mas atualmente se sabe que as propriedades do modelo de Potts podem ser encontradas em sistemas reais e podem ser medidos através da realização de experimentos. O princípio básico na experimentação de sistemas de spin é o princípio da universalidade, onde busca-se identificar sistemas reais que pertencem a mesma classe de universalidade do modelo de spin em questão. Ou seja, medindo os expoentes críticos do experimento, encontramos sua classe.

Para $Q=2$ sabemos que o modelo de Potts possui as propriedades do modelo de Ising. Em duas dimensões, foi provado que um sistema absorvido de átomos de $He^{4}$ cobrindo ${\frac {1}{2}}$ de uma rede honeycomb de grafite exibe o mesmo expoente crítico do calor específico que o modelo de Ising. Esse mesmo sistema, mas agora cobrindo ${\frac {1}{3}}$ da rede exibe o comportamento do modelo de Potts para $Q=3$. Outros estudos de sistemas absorvidos, como $N_{2}$ em uma rede 2D de grafite, mostram mostram comportamento da classe $Q=4$. Também foi provado que polímeros que interagem em soluções, como processos de vulcanização de polímeros ramificados tem a classe de universalidade para o modelo de Potts com $0\leq Q\leq 1$. Uma breve observação: o modelo de Potts de $q$-estados generalizado não exige que $q$ seja um valor inteiro, mas neste trabalho só tratamos desse caso.

Modelo celular de Potts

Além da física de materiais, o modelo de Potts também é aplicado em biologia computacional para a simulação de células através do modelo celular de Potts. Esse modelo trata células como objetos deformáveis que podem mover, crescer ou até se dividir e pode simular o comportamento coletivo de células, estudando o surgimento de células cancerígenas e morfogênese.

A energia do sistema é descrita por

${\mathcal {H}}=-\sum _{\langle i,j\rangle }J_{\sigma _{i},\sigma _{j}}\left(1-\delta _{\sigma _{i},\sigma _{j}}\right)+\lambda \sum _{\sigma _{i}}\left(v(\sigma _{i})-V(\sigma _{i})\right)^{2}$

onde $i$, $j$ são posições da rede, $\sigma _{i}$ é a célula na posição $i$, $J$ é o coeficiente determinando a adesão de dois tipos diferentes de células, $v(\sigma )$ é o volume da célula $\sigma$, $V(\sigma )$ é o volume padrão de $\sigma$ e $\lambda$ determina a força da elasticidade volumétrica da célula. O modelo pode considerar ainda elasticidade de área e perímetro de cada célula.

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.

Implementaçã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 e $\beta =T$. Em cada passo temporal, são realizadas $L^{2}$ iterações do algoritmo de aceitação do Metropolis ou do 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 realizar uma troca.

Resultados

Foram executadas simulações do modelo de Potts com $L=64$ e com $Q\in [2,10]|Q\in \mathbb {Z}$. Foram feitas medidas das "magnetizações" do sistema e da energia total. A ideia de magnetização só tem sentido direto quando $Q=2$ (mesmo caso do modelo de Ising), mas para $Q>2$ a magnetização indica apenas para qual direção o sistema está mais alinhado. Contudo, a medida de relevância para os casos em que $Q>2$ é na verdade a susceptibilidade magnética, que ainda indica com qual facilidade o sistema muda seu alinhamento e também pode indicar a transição de fase. Abaixo seguem gráficos das energias totais do sistema com o algoritmo de banho térmico e o algoritmo de Metropolis.

Casos para Q < 5

Correspondência com o modelo de Ising

Medidas de energia, calor específico e susceptibilidade magnética para Q = 2 e L = 64 utilizando algoritmo de Metropolis
Energia média em função da temperatura para Q = 2 e L = 64.	Calor específico em função da temperatura para Q = 2 e L = 64
Média do valor absoluto da magnetização em função da temperatura para Q = 2 e L = 64	Susceptibilidade magnética em função da temperatura para Q = 2 e L = 64

Aqui é importante ressaltar que tivemos que mudar a quantidade de passos de Monte Carlo para algumas das simulações para que o sistema alcançasse o estado estcionário com o algoritmo de banho térmico. Isso porque o algoritmo de banho térmico favorece a formação de faixas dominadas por dois ou mais $q$, o que faz com que o sistema demore muito até que uma dessas faixas consiga alinhar a(s) outra(s) e então levar o sistema para o estado estacionário. Quando as simulações passam por esses casos, observamos uma distribuição de energia com duas curvas normais: uma para o estado transiente do sistema em que as faixas causam um equilíbrio instável para o sistema e outra de menor energia que representa o estado de equilíbrio do sistema após uma das faixas alinhar a outra. Veja:

Histograma para $Q=5$ e $T=0.7$ executado com o algoritmo de banho térmico mostrando a formação de duas curvas normais.

Podemos ver que os dados resultantes das simulações para o modelo de Potts com $Q=2$ de fato recriam o comportamento esperado pelo modelo de Ising. Observamos que tanto o calor específico como a susceptibilidade magnética aumentam drásticamente conforme se aproximam de $T=1,1$. Como foi elaborado acima, o modelo de Ising tem a hamiltoniana igual a hamiltoniana do modelo de Potts a menos de uma constante, que é equivalente a $\sum _{\langle i,j\rangle }{\frac {J}{2}}$, o que corrobora que a temperatura crítica para o modelo de Potts, com $Q=2$ seja aproximadamente $T_{c}\approx 1,1$.

Demais casos

Medidas de energia e magnetização para Q = {2,3,4} e L = 64 utilizando o algoritmo de Metropolis
Energia média em função da temperatura para Q = {2,3,4} e L = 64.	Calor específico em função da temperatura para Q = {2,3,4} e L = 64
Média do valor absoluto da magnetização em função da temperatura para Q = {2,3,4} e L = 64	Susceptibilidade magnética em função da temperatura para Q = {2,3,4} e L = 64

Medidas de energia e magnetização para Q = {2,3,4} e L = 64 utilizando o algoritmo de banho térmico
Energia média em função da temperatura para Q = {2,3,4} e L = 64.	Calor específico em função da temperatura para Q = {2,3,4} e L = 64
Média do valor absoluto da magnetização em função da temperatura para Q = {2,3,4} e L = 64	Susceptibilidade magnética em função da temperatura para Q = {2,3,4} e L = 64

Agrupamos aqui os resultados obtidos para $Q\leq 4$ porque se descobriu que para o caso bidimensional o modelo de Potts muda de tipo de transição de fase para $Q>4$, passando a apresentar uma transição de primeira ordem. Como mostrado por Barkema , a transição de fase ocorre em temperaturas críticas que variam para cada $Q$, e aqui encontramos que são aproximadamente $1,0$ para $Q=3$, $0,9$ para $Q=4$, e $1,1$ para $Q=2$ como dito acima.

Casos para Q > 4

Medidas de energia e magnetização para Q = {5,6,7,8,9,10} e L = 64 utilizando o algoritmo de Metropolis
Energia média em função da temperatura para Q = {5,6,7,8,9,10} e L = 64.	Calor específico em função da temperatura para Q = {5,6,7,8,9,10} e L = 64
Susceptibilidade magnética em função da temperatura para Q = {5,6,7,8,9,10} e L = 64

Medidas de energia e magnetização para Q = {5,6,7,8,9,10} e L = 64 utilizando o algoritmo de banho térmico
Energia média em função da temperatura para Q = {5,6,7,8,9,10} e L = 64.	Calor específico em função da temperatura para Q = {5,6,7,8,9,10} e L = 64
Susceptibilidade magnética em função da temperatura para Q = {5,6,7,8,9,10} e L = 64

Comparação entre algoritmo de Metropolis-Hasting e banho térmico para baixas temperaturas

Algoritmo de Metropolis (azul) X Algoritmo de banho térmico para Q = 2 e T = 0.25 e T = 0.3
Energia função dos passos de Monte Carlo para Q = 2, L = 64 e T = 0.25	Energia função dos passos de Monte Carlo para Q = 2, L = 64 e T = 0.3

Algoritmo de Metropolis (azul) X Algoritmo de banho térmico para Q = 3 e T = 0.25 e T = 0.3
Energia função dos passos de Monte Carlo para Q = 3, L = 64 e T = 0.25	Energia função dos passos de Monte Carlo para Q = 3, L = 64 e T = 0.3

Algoritmo de Metropolis (azul) X Algoritmo de banho térmico para Q = 4 e T = 0.3 e T = 0.4
Energia função dos passos de Monte Carlo para Q = 4, L = 64 e T = 0.3	Energia função dos passos de Monte Carlo para Q = 4, L = 64 e T = 0.4

Animações comparando a evolução do sistema usando o algoritmo de Metropolis (esquerda) e o algoritmo de banho térmico (direita).
Evolução do sistema com o algoritmo de Metropolis com $Q=10$ e $T=0.25$.	Evolução do sistema com o algoritmo de banho térmico com $Q=10$ e $T=0.25$.

Note que o sistema com o algoritmo de Metropolis fica "preso" em um estado com uma faixa de $q=2$ no meio de um mar de spins $q=1$, mas não consegue se alinhar até o final da animação. Isso representa um estado de equilíbrio instável para o modelo, mas o sistema fica preso nessa condição por limitação do algoritmo de Metropolis, que tem baixíssima eficiência para baixas temperaturas. O sistema com o algoritmo de banho térmico por outro lado consegue "dissolver" os aglomerados de spins diferentes que mostra haviam no começo da animação e no fim da animação todos os spins estão alinhados, demonstrando a melhor eficiência desse algoritmo nessas condições.

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