Potencial de Lennard-Jones
Nome: André Bracht Burmeister
Fluidos estão em todos os lugares e, portanto, estudá-los é muito importante. Como são objetos de estudo extremamente complicados, se fazem necessários modelos e simplificações. Uma simplificação muito usada é a análise do sistema em duas dimensões apenas, excluindo a terceira dimensão espacial.
O Modelo
Um fluido bidimensional pode ser modelado como partículas em um plano com densidade (partículas por ). O plano é um quadrado de lado . Para escolher a posição inicial de uma partícula, são escolhidas coordenadas e aleatórias entre e .
O Método de Monte Carlo
Para evoluir o sistema, usaremos caminhadas aletórias, escolhendo as partículas com o método de Monte Carlo[[1]]. O método de Monte Carlo consiste em escolher uma partícula aleatoriamente entre as . Então escolhemos aleatoriamente um deslocamento proposto para a partícula , onde e estão entre e . A partícula só é realmente deslocada em de acordo com o Algoritmo de Metropolis-Hasting.
Algoritmo de Metropolis-Hasting
O Algoritmo de Metropolis-Hasting consiste em escolher se o movimento será ou não aceito usando a diferença de energia potencial entre o estado após o movimento e anterior ao movimento . A probabilidade de aceitar o movimento é dada por:
Onde , é a temperatura e é a constante de Boltzmann.
O Potencial de Lennard Jones
Para que o algoritmo funcione, precisamos então encontrar uma maneira de calcular a energia potencial de cada partícula. O potencial que uma partícula causa na outra, pode ser aproximado a uma distribuição em termos da distância entre elas:
Esse potencial é conhecido como o potencial de Lennard-Jones, primeiro apresentado por ele em seu artigo [1].
Unidades Reduzidas
Ao realizar a simulação computacionalmente, usar unidades do sistema internacional faria com que os números ficassem muito grandes ou muito pequenos, fazendo com que perdêssemos em precisão. Portanto, faz sentido que usemos unidades reduzidas em termos de , e a constante de Boltzmann . As unidades utilizadas foram:
Grandeza | Comprimento | Temperatura | Energia | Densidade |
---|---|---|---|---|
Unidade |
Usando as novas unidades o potencial de Lennard-Jones fica:
O formato do potencial faz com que para distâncias grandes, a interação entre partículas seja muito pequena e, para distâncias muito pequenas, haja uma força de repulsão que tende ao infinito. Além disso, a região de potencial mínimo se encontra a do centro da partícula. Ou seja, as partículas tendem a se organizar em uma configuração similar a da figura à direita, onde o raio dos círculos é
Potencial de Lennard-Jones com unidades reduzidas |
---|
Escolha de
Foi escolhido um deslocamento máximo , pois isso faz com que o deslocamento não seja maior que metade da distância ao mínimo do potencial.
Deslocamento máximo e aceitação ao longo da simulação | ||
---|---|---|
LEGENDA CARALEO |
Resultados
A simulação foi rodada com 32 partículas, para temperaturas de 0.1, 0.3, 0.5 e 1.5 e densidades de 0.1, 0.5 e 0.9 e com 1000 MCS. Onde 1 MCS (monte carlo step) é o número de passos correspondente ao número de partículas (nesse caso, 1 MCS = 32 passos).
Energia
Medidas de energia a cada para diferentes densidades e temperaturas | ||
---|---|---|
LEGENDA CARALEO |
Olhando para os gráficos de energia podemos notar uma grande diferença entre temperaturas e densidades. Claramente quanto maior a temperatura, maior a energia, o que é esperado. Além disso, quando maior a temperatura, aparentemente há uma maior variabilidade na energia, o que também é esperado, pois a temperatura maior, faz com que mais movimentos desfavoráveis (dU >0) sejam aceitos.
Olhando para a densidade, fica claro, que quanto maior a densidade, menor a energia. Para densidade 0.1 e temperaturas baixas (0.5 e 1.5), a energia chega até a ficar positiva em alguns pontos, logo voltando a ficar zero ou menor. Isso provavelmente acontece, pois com menos densidade, os movimentos tendem a não cair pŕoximos do mínimo do potencial de uma partícula. Na verdade, como há muito espaço livre, tendem a ficar mais afastados, o que faz com que as vezes possam ficar a uma distância de de uma partícula (e não 0.56 como esperado). Assim é mais provável que possam dar saltos próximos do centro (para 0.4, por exemplo) e aumentar muito a energia do sistema.
Posição final das Partículas
Posição das partículas ao fim da simulação com diferentes densidades e temperaturas | ||
---|---|---|
Transição de Fase
Olhando para a posição das partículas, podemos ver claramente uma transição de fase. Com temperatura 0.1, para todas as densidades as partículas se encontram juntas, na configuração de menor energia, ou seja, numa fase líquida. Já para as temperaturas 0.5 e 1.5, e densidades baixas as partículas se encontram mais afastadas umas das outras. Para temperaturas de 0.3 podemos ver que para as densidades 0.1 e 0.5, algumas partículas se encontram juntas, na configuração de menor energia, e outras se encontram mais afastadas, o que indica que estamos perto da temperatura de transição de fase para essa densidade. Com densidade 0.9, isso não ocorre, pois as partículas são forçadas a continuarem juntas, por não terem espaço para se afastar. Esse caso seria o de maior pressão.
A transição de fase também aparece no gráfico da energia. Se observarmos a temperatura 0.3, notamos que a energia média é instável fazendo movimentos no sentido de maior e menor energia.
Código
Simulação
# -*- coding: utf-8 -*-
"""lennard_jones.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1jSPjBz0RXXWLEAzf3zcHgdlQpzjyO_ni
# Potencial de Lennard-Jones
# Monte Carlo no contínuo
#### Delete variables and import packages
"""
"""import sys
this = sys.modules[__name__]
for n in dir():
if n[0]!='_': delattr(this, n)"""
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
import random
from scipy.optimize import bisect as find_root
"""## Simulação:
### Definições Numéricas:
"""
densidade = 0.1 #(2 ** (2/3)) * (3 ** (-1/2)) # partícula(s) por sigma^2 (partículas por area)
densidade_round = round(densidade, 2)
n_particles = 64
L = np.sqrt(n_particles / densidade) # unidade de sigma
print(L)
dLmax = 0.1
MCS = 10000
eps = 1
T = .1
k = 1
beta = 1/(k*T)
raio = 2**(1/6)
"""### Funcões:"""
def lennard_jones(r1, r2, L): # r1 e r2 em unidades de sigma (na vdd seria r1/sig e r2/sig)
dr = np.absolute(np.subtract(r2, r1))
for i in np.arange(2):
if dr[i] > 0.5:
dr[i] = L - dr[i]
r2 = (dr[0] ** 2) + (dr[1] ** 2)
sr2 = 1/r2
return 4 * (((sr2) ** 6) - ((sr2) ** 3))
def initial_energy(pos_particles, n_particles, L):
U0 = 0
for xxx in range(n_particles - 1):
for yyy in range(xxx+1, n_particles):
U0 += lennard_jones(pos_particles[:, xxx], pos_particles[:, yyy], L=L)
return U0
def energy_var(p, pos_particles, n_particles, L, new_pos=np.zeros(2)):
U1 = 0
U2 = 0
for i in range(n_particles - 1):
j = (i + p + 1) % n_particles # j vai ser todas as partículas
# exceto a partícula p (porque p interage com todas, menos com ela mesma)
U1 += lennard_jones(pos_particles[:, j], pos_particles[:, p], L=L)
U2 += lennard_jones(pos_particles[:, j], new_pos, L=L)
return U2 - U1
def main_loop(dLmax, beta, n_particles, MCS, L, acceptance_array=False,
last_acceptance=False):
pos_particles = L * np.random.random([2, n_particles])
# Random positions:
pos_MCS = np.zeros([MCS+1, 2, n_particles])
pos_particles = pos_particles
pos_MCS[0] = pos_particles
# Energy:
energy_arr = np.zeros(MCS+1)
energy = initial_energy(pos_particles, n_particles, L=L)
energy_arr[0] = energy
# Acceptance:
accepted = 0
if acceptance_array:
acceptance_arr = np.zeros(MCS)
# Main Loop:
for m in range(MCS):
for _ in range(n_particles):
p = random.randint(0, n_particles - 1)
# change position:
displacement = dLmax * ((2 * np.random.random([2])) - 1)
new_pos = pos_particles[:, p] + displacement
for i in range(2):
if new_pos[i] < 0:
new_pos[i] += L
elif new_pos[i] > L:
new_pos[i] -= L
dU = energy_var(p, pos_particles, n_particles, L, new_pos)
if dU <= 0:
pos_particles[0][p] = new_pos[0]
pos_particles[1][p] = new_pos[1]
energy += dU
accepted += 1
else:
if random.random() < np.exp(-beta * dU):
pos_particles[0][p] = new_pos[0]
pos_particles[1][p] = new_pos[1]
energy += dU
accepted += 1
if not (acceptance_array):
pos_MCS[m+1] = pos_particles
energy_arr[m+1] = energy
if acceptance_array:
acceptance_arr[m] = accepted / (n_particles*(m + 1))
if acceptance_array:
return acceptance_arr
elif last_acceptance:
return accepted / (n_particles*MCS)
else:
return pos_MCS, energy_arr, (accepted / (n_particles*(m + 1)))
def save_data(dLmax=dLmax, n_particles=n_particles, MCS=MCS, T=T, densidade=densidade):
beta = 1 / (k*T)
L = np.sqrt(n_particles / densidade) # unidade de sigma
print(L)
pos, energy, acceptance = main_loop(dLmax=dLmax, beta=beta, n_particles=n_particles,
MCS=MCS, L=L)
densidade_round = round(densidade, 3)
# save positions:
pos_reshaped = pos.reshape(pos.shape[0], -1)
np.savetxt(f"positions_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}.txt",
pos_reshaped)
# save energy:
np.savetxt(f"energy_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}.txt",
energy)
return pos, energy, acceptance
def open_pos(file, n_particles):
loaded_pos = np.loadtxt(file)
load_original_pos = loaded_pos.reshape(loaded_pos.shape[0], loaded_pos.shape[1] // n_particles, n_particles)
return load_original_pos
"""### Rodar e salvar dados:
#### Rodar uma vez:
"""
dLmax = round(0.5*raio, 3)
pos, energy, acceptance = save_data(dLmax=dLmax)
print(f'dLmax={dLmax} \n beta={beta} \n n_particles={n_particles} \n MCS={MCS} \n\n pos[0]: \n {pos[0]}')
print(acceptance)
"""#### Rodar para vários T e rô:"""
dLmax = round(0.5*raio, 3)
n_particles = 32
T_arr = np.array([0.1, 0.3, 0.5, 1.5])
dens_arr = np.array([0.1, 0.5, 0.9])
for T in T_arr:
print()
print(f'T = {T}')
for densidade in dens_arr:
print(f'd = {densidade}')
pos, energy, acceptance = save_data(dLmax=dLmax, n_particles=n_particles, MCS=MCS, T=T, densidade=densidade)
#print(f'dLmax={dLmax} \n beta={beta} \n n_particles={n_particles} \n MCS={MCS} \n\n pos[0]: \n {pos[0]}')
print(f'acceptance = {acceptance}')
Gráficos
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
import random
from scipy.optimize import bisect as find_root
raio = 2 ** (1/6)
path = '/home/a_burmeister/AA_CADEIRAS_UFRGS/7-semestre/Monte Carlo/lennard_jones/colab/N32/'
save_path = '/home/a_burmeister/AA_CADEIRAS_UFRGS/7-semestre/Monte Carlo/lennard_jones/colab/N32/figures/'
dLmax = round(0.5*raio, 3)
def open_pos(file, n_particles=32):
loaded_pos = np.loadtxt(file)
load_original_pos = loaded_pos.reshape(loaded_pos.shape[0], loaded_pos.shape[1] // n_particles, n_particles)
return load_original_pos
"""
## Figuras
### Intial and final positions:
"""
def scatter_pos(pos, indices, T, L, circles=True, n_particles=32):
graphs = len(indices)
fig, axes = plt.subplots(1, graphs)
fig.suptitle(f'T = {T} N = {n_particles} d = {densidade_round} dLmax = {round(dLmax, 2)}', fontsize=14)
for j in range(graphs):
k = indices[j]
if circles:
# draw the circles where they are
for i in range(n_particles):
c = plt.Circle([pos[k][0][i], pos[k][1][i]], raio/2, fill=False, edgecolor='black', alpha=0.5)
axes.add_patch(c)
# draw the circle's projections:
for a in range(-1, 2):
for b in range(-1, 2):
for i in range(n_particles):
c = plt.Circle([pos[k][0][i] + a*L, pos[k][1][i] + b*L], raio/2, fill=False, edgecolor='black', alpha=0.25)
axes.add_patch(c)
points = axes.scatter(pos[k][0], pos[k][1])
margem = raio/2
axes.plot([0, L, L, 0, 0], [0, 0, L, L, 0], color='black')
axes.axis([-margem, L + margem, -margem, L + margem], 'equal')
axes.grid(visible=False)
axes.set_aspect("equal")
axes.set_title(f'passo {k}')
return fig, axes, points
T_arr = np.array([0.1, 0.3, 0.5, 1.5])
dens_arr = np.array([0.1, 0.5, 0.9])
n_particles = 32
MCS = 10000
for T in T_arr:
print()
print(f'T = {T}')
for densidade in dens_arr:
print(f'd = {densidade}')
densidade_round = round(densidade, 3)
file_end = f"_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}"
file_name = f"{path}positions{file_end}.txt"
pos = open_pos(file_name, n_particles=32)
L = np.sqrt(n_particles / densidade) # unidade de sigma
plot = scatter_pos(pos=pos, indices=[pos.shape[0] - 1], T=T, L=L, circles=True)
# plt.show()
plt.savefig(f"{save_path}first_last_positions{file_end}.png")
plt.close()
"""### Energy:"""
def y_limits(energy, limites):
energy_hist_range = energy[int(round(0.2*len(energy), 0)):]
max_energy_range = max(energy_hist_range)
if max_energy_range > 100:
max_energy_range = 0
return [min([min(energy_hist_range)-1, limites[0]]), max([0, max_energy_range + 1, limites[1]])]
"""#### Energy graph:"""
for densidade in dens_arr:
print()
print(f'd = {densidade}')
densidade_round = round(densidade, 3)
fig, ax = plt.subplots(1, 1)
titulo = f'densidade = {densidade_round} N = {n_particles} L = {round(L, 2)} dLmax = {round(dLmax, 2)}'
fig.suptitle(titulo, fontsize=14)
limites = [0, 0]
for T in T_arr:
print(f'T = {T}')
file_end = f"_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}"
energy = np.loadtxt(f"{path}energy{file_end}.txt")
# Histogram:
fig2, ax2 = plt.subplots(1, 1)
fig2.suptitle(titulo, fontsize=14)
ax2.hist(energy[100:], density=True)
ax2.set_xlabel('energy')
# plt.show()
fig2.savefig(f"{save_path}energy_histogram{file_end}.png")
plt.close(fig2)
# Plot:
energy_range = energy
ax.plot(np.arange(len(energy_range)), energy_range, label=f'T = {T}')
limites = y_limits(energy, limites)
ax.set_ylim(limites)
ax.set_ylabel('U')
ax.set_xlabel('tempo em MCS')
ax.legend()
# plt.show()
file_end2 = f"N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}"
fig.savefig(f"{save_path}energy_graph{file_end}.png")
plt.close(fig)
## Animação
for T in T_arr:
print()
print(f'T = {T}')
for densidade in dens_arr:
print(f'd = {densidade}')
densidade_round = round(densidade, 3)
file_end = f"_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}"
file_name = f"{path}positions{file_end}.txt"
pos = open_pos(file_name, n_particles=32)
fig, ax = plt.subplots(1,1, figsize=(5, 6))
fig.suptitle(f'T = {T} N = {n_particles} d = {densidade_round} \n L = {round(L, 2)} dLmax = {round(dLmax, 2)}',
fontsize=14)
margem = raio
ax.axis([-margem, L + margem, -margem, L + margem], 'equal')
ax.grid()
ax.set_aspect("equal")
c = []
for i in range(n_particles):
c.append(plt.Circle([pos[0][0][i], pos[0][1][i]], raio, fill=False, color='lightgrey'))
ax.add_patch(c[i])
scatter_points = ax.scatter(pos[0][0], pos[0][1], s=1000)
def animate(i):
for k in range(n_particles):
c[k].center = (pos[i][0][k], pos[i][1][k])
scatter_points.set_offsets(pos[i].T)
return scatter_points
anim = FuncAnimation(fig, animate, interval = 10, frames = MCS)
anim_file = f'animacao_T{T}_N{n_particles}_d{densidade_round}_MCS{MCS}_dL_{dLmax}.mp4'
print(anim_file)
anim.save(anim_file, writer = 'ffmpeg', fps = 20)
"""### Potencial Lennard Jones:"""
def lennard_jones1d(r):
sr6 = 1/(r ** 6)
return 4 * (((sr6) ** 2) - (sr6))
xx = np.linspace(0, 4, 100)
yy = lennard_jones1d(xx)
fig, ax = plt.subplots(1, 1, figsize=(10, 4))
ax.plot([-10, 10], [0, 0], color='black')
ax.plot(xx, yy)
ax.set_ylabel('U(r)')
ax.set_xlabel('r')
ax.set_ylim([-1.5, 5])
ax.set_xlim([0, 3])
plt.show()
fig.savefig('lennard_jones_potential.png')
plt.close()
- ↑ J E Lennard-Jones 1931 Proc. Phys. Soc. 43 461