http://fiscomp.if.ufrgs.br/api.php?action=feedcontributions&feedformat=atom&user=GabrielcanovaFísica Computacional - Contribuições do usuário [pt-br]2026-04-15T21:39:58ZContribuições do usuárioMediaWiki 1.39.4http://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=337DM: um primeiro programa2015-07-16T21:33:45Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em uma dada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa. No próximo passo, a função rint(dx/Lx) arredondará o valor da divisão para o inteiro mais próximo, assim, se <math> dx/L_x > 0.5 </math> descontaremos <math> L_x </math> de <math> dx </math> e se <math> dx/L_x \le 0.5 </math> já teremos o <math> dx </math> correto. O mesmo procedimento também é aplicado sobre a componente <math> y </math>. No ''if'' testamos se a distância ao quadrado entre um par de partículas é menor que o raio crítico de interação, ou seja, a distância máxima acima da qual desconsideramos a força entre duas partículas, lembrando que isso é feito devido ao fato do potencial Lennard-Jones ser de curto alcance. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=336DM: um primeiro programa2015-07-16T20:40:10Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em uma dada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa. No próximo passo, a função rint(dx/Lx) arredondará o valor da divisão para o inteiro mais próximo, assim, se <math> dx/L_x >0.5 </math> descontaremos <math> L_x </math> de <math> dx </math> e se <math> dx/L_x \le 0.5 </math> já teremos o <math> dx </math> correto. O mesmo procedimento também é aplicado sobre a componente <math> y </math>. No {\it if} testamos se a distância ao quadrado entre um par de partículas é menor que o raio crítico de interação, ou seja, a distância máxima acima da qual desconsideramos a força entre duas partículas, lembrando que isso é feito devido ao fato do potencial Lennard-Jones ser de curto alcance. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=335DM: um primeiro programa2015-07-16T20:28:32Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em uma dada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa. No próximo passo, a função rint(dx/Lx) arredondará o valor da divisão para o inteiro mais próximo, assim, se <math> dx/L_x >0.5 </math> descontaremos <math> L_x </math> de <math> dx </math> e se <math> dx/L_x \le 0.5 </math> já teremos o <math> dx </math> correto. O mesmo procedimento é aplicado sobre a componente <math> y </math>. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=334DM: um primeiro programa2015-07-16T20:27:19Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em uma dada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa. No próximo passo, a função rint(dx/Lx) arredondará o valor da divisão para o inteiro mais próximo, assim, se <math> dx/L_x >0.5 </math> descontaremos <math> L_x </math> de <math> dx </math> e se <math> dx/L_x < 0.5 </math> já teremos o <math> dx </math> correto. O mesmo procedimento é aplicado sobre a componente <math> y </math>. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=333DM: um primeiro programa2015-07-16T20:26:31Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em uma dada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa. No próximo passo, a função rint(dx/Lx) arredondará o valor da divisão para o inteiro mais próximo, assim, se <math> dx/L_x >0.5 </math> descontaremos <math> L_x </math> de <math> dx </math> e se <math> dx/L_x \l.e 0.5 </math> já teremos o <math> dx </math> correto. O mesmo procedimento é aplicado sobre a componente <math> y </math>. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=332DM: um primeiro programa2015-07-16T19:57:06Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada uma delas teríamos que fazer um loop sobre todas as outras, porém, pela Terceira Lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em cada direção, além disso, elas não precisam necessariamente estar limitadas aos contornos da caixa as quais foram inseridas, mas o cálculo da força sim. Desse modo, a função resto fmod(dx,Lx) nos assegura que nenhuma distância estará fora da caixa e ao...<br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=331DM: um primeiro programa2015-07-16T19:41:30Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada partícula do sistema teríamos que fazer um loop sobre todas as outras, porém, pela terceira lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <math> x_1 </math> e <math> x_2 </math> são, respectivamente, as posições das partículas <math> i </math> e <math> j </math>, enquanto <math> dx </math> e <math> dy </math> as distâncias entre elas. Porém, como nosso sistema possui condições periódicas de contorno, nenhum par de partículas poderá ter um distância maior que <math> L/2 </math> em cada direção. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=330DM: um primeiro programa2015-07-15T22:26:54Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada partícula do sistema teríamos que fazer um loop sobre todas as outras, porém, pela terceira lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo varremos <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Desse modo, asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=329DM: um primeiro programa2015-07-15T22:20:25Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
Como a aceleração resultante sobre uma partícula é a soma de todas as forças que agem sobre ela, para cada partícula do sistema teríamos que fazer um loop sobre todas as outras, porém, pela terceira lei de Newton <math> F_{ij}=-F_{ji} </math>, ou seja, apenas temos que somar sobre todas as combinações de pares de partículas. No primeiro loop abaixo estamos varrendo <math> i </math> para todas partículas, no segundo, a varredura começa em <math> i+1 </math> e segue até <math> N-1 </math>. Assim asseguramos que todos os pares de partículas entrem no cálculo, no caso, temos <math> N(N-1)/2 </math> pares. <br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=328DM: um primeiro programa2015-07-15T22:03:24Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
O cálculo da força é a parte mais crucial do programa, pois é a que mais consome recursos e pode ser drasticamente melhorada com otimizações. Abaixo introduzimos a rotina mais simples possível para o cálculo da força. Ela recebe os ponteiros das forças nas direções <math> x </math> e <math> y </math>, as coordenadas (o potencial Lennard-Jones só depende da posição) e a energia potencial. No primeiro loop zeramos as duas componentes da força para todas as partículas. <br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
</pre><br />
<br />
<br />
<br />
<pre><br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=327DM: um primeiro programa2015-07-15T21:45:45Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<pre><br />
void compute_forces(double *fx,double *fy,double *x,double *y,double *Ep)<br />
{<br />
unsigned i,j;<br />
double x1,y1,x2,y2,dx,dy,r2,r2i,r6,ff,Energy=0.;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
fx[i] = 0.;<br />
fy[i] = 0.;<br />
}<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x1=x[i]; y1=y[i];<br />
<br />
for(j=i+1;j<N;j++)<br />
{<br />
x2=x[j];<br />
<br />
dx=x1 - x2;<br />
dx=fmod(dx,Lx);<br />
dx=dx-rint(dx/Lx)*Lx;<br />
<br />
y2=y[j];<br />
<br />
dy=y1 - y2;<br />
dy=fmod(dy,Ly);<br />
dy=dy-rint(dy/Ly)*Ly;<br />
<br />
r2=dx*dx + dy*dy;<br />
<br />
if(r2<Rc2)<br />
{<br />
r2i=1/r2 ;<br />
r6=r2i*r2i*r2i;<br />
ff=48*r2i*r6*(r6-0.5);<br />
fx[i] += ff*dx; fy[i] += ff*dy;<br />
fx[j] -= ff*dx; fy[j] -= ff*dy;<br />
Energy += 4*r6*(r6-1);<br />
}<br />
}<br />
}<br />
*Ep=Energy;<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=326DM: um primeiro programa2015-07-15T21:37:10Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. Como <math> i </math> é o índice global das partículas, o resto (%) da divisão inteira entre <math> L_x </math> e <math> Nx </math> nos dará a coordenada <math> x </math>, enquanto o resultado da divisão inteira entre <math> L_y </math> e <math> Ny </math> definirá a coordenada <math> y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=325DM: um primeiro programa2015-07-07T21:37:01Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada representada na Figura 2, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>. <br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=324DM: um primeiro programa2015-07-07T21:34:32Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>.<br />
<br />
[[Arquivo:initialcondition.jpg|thumb|300px|Figura 2 - Condição inicial.]]<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Initialcondition.jpg&diff=323Arquivo:Initialcondition.jpg2015-07-07T21:29:00Z<p>Gabrielcanova: </p>
<hr />
<div></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=322DM: um primeiro programa2015-07-07T21:26:30Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
[[Arquivo:initialcondition.jpg]]<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>.<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=321DM: um primeiro programa2015-07-07T21:24:12Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
[[Arquivo:initialcondition.eps]]<br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>.<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=320DM: um primeiro programa2015-07-07T20:49:50Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. Podemos imaginar a disposição inicial das partículas como uma rede quadrada, onde em cada vértice se encontra uma partícula, a distância entre elas é dada por <math> dx=L_x/N_x </math> e <math> dy=L_y/N_y </math>.<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=319DM: um primeiro programa2015-07-07T20:37:45Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
A rotina da inicialização das posições recebe os ponteiros das coordenadas <math> x </math> e <math> y </math> das partículas, as coordenadas no tempo anterior <math> x_0 </math> e <math> y_0 </math>, além das velocidades inicias <math> v_x </math> e <math> v_y </math>. <br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=318DM: um primeiro programa2015-07-07T20:29:31Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre><br />
<br />
<br />
<br />
<pre><br />
void initialize_positions(double *x,double *y,double *xo,double *yo,double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double dx,dy;<br />
<br />
dx=(double)Lx/Nx;<br />
dy=(double)Ly/Ny;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
x[i]=(i%Nx)*dx;<br />
y[i]=(i/Ny)*dy;<br />
<br />
xo[i]=x[i]-vx[i]*dt;<br />
yo[i]=y[i]-vy[i]*dt;<br />
}<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=317DM: um primeiro programa2015-07-07T20:09:25Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso, as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=316DM: um primeiro programa2015-07-07T20:07:18Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descrevemos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das velocidades, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. Como condição inicial, todas as partículas recebem uma velocidade aleatória dada por rand()/RAND_MAX que gera um número entre zero e um. Vcx e Vcy são, respectivamente, as componentes da velocidade do centro de massa do sistema nas direções <math> x </math> e <math> y </math>, enquanto V2 é a energia cinética. Para o caso em que as partículas estejam transladando em uma direção preferencial, descontamos suas velocidades pela do centro de massa, além disso as renormalizamos por um fator de escala que depende da temperatura inicial dada, lembrando que a mesma pode variar no ensamble microcanônico. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=315DM: um primeiro programa2015-07-07T05:25:02Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a energia total. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
Agora descremos detalhadamente todas as rotinas que aparecem na parte principal. Começamos com a inicialização das posições, a rotina recebe os ponteiros das velocidades nas direções <math> x </math> e <math> y </math>. <br />
<pre><br />
<br />
void initialize_velocities(double *vx,double *vy)<br />
{<br />
unsigned i;<br />
double Vcx=0.,Vcy=0.,V2=0.,fs;<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=1.*rand()/RAND_MAX;<br />
vy[i]=1.*rand()/RAND_MAX;<br />
<br />
Vcx+=vx[i];<br />
Vcy+=vy[i];<br />
V2 +=vx[i]*vx[i] + vy[i]*vy[i];<br />
}<br />
<br />
Vcx/=N;<br />
Vcy/=N;<br />
V2 /=N;<br />
fs=sqrt(2.*T/V2);<br />
<br />
for(i=0;i<N;i++)<br />
{<br />
vx[i]=(vx[i]-Vcx)*fs;<br />
vy[i]=(vy[i]-Vcy)*fs;<br />
}<br />
<br />
}<br />
</pre></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=314DM: um primeiro programa2015-07-03T19:39:03Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total\_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute\_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate\_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a soma das duas últimas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=313DM: um primeiro programa2015-07-03T19:36:05Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total/_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a soma das duas últimas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=312DM: um primeiro programa2015-07-03T19:32:13Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
<br />
FILE *file1,*file2;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate_EqMotion </math> atualiza as posições das partículas. O <math> for </math> em <math> i </math> imprime no arquivo "trajectories.dat" as posições e velocidades de todas as partículas no instante <math> t </math>. No <math> if </math> testamos se o tempo total é maior que o tempo de equilíbrio e se a medida deve ser feita, caso seja, no arquivo "energy.dat" imprimiremos, respectivamente, o tempo, energia cinética, energia potencial e a soma das duas últimas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=311DM: um primeiro programa2015-07-03T19:17:51Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)malloc(size);<br />
y= (double*)malloc(size);<br />
xo=(double*)malloc(size);<br />
yo=(double*)malloc(size);<br />
vx=(double*)malloc(size);<br />
vy=(double*)malloc(size);<br />
Fx=(double*)malloc(size);<br />
Fy=(double*)malloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate_EqMotion </math> atualiza as posições das partículas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=310DM: um primeiro programa2015-07-03T19:10:42Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
<br />
#define dt 0.01<br />
#define transient 5.<br />
#define total_time 10.<br />
#define measure 0.1<br />
#define samples ((total_time-transient)/measure)<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transient </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> measure </math> define o intervalo de tempo entre as medições. <br />
<br />
<math> samples </math> nos dá o número total de medidas que serão realizadas<br />
<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)jmalloc(size);<br />
y= (double*)jmalloc(size);<br />
xo=(double*)jmalloc(size);<br />
yo=(double*)jmalloc(size);<br />
vx=(double*)jmalloc(size);<br />
vy=(double*)jmalloc(size);<br />
Fx=(double*)jmalloc(size);<br />
Fy=(double*)jmalloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate_EqMotion </math> atualiza as posições das partículas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=309DM: um primeiro programa2015-07-03T19:02:41Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define total_time 5000<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> total_time </math> é o tempo absoluto da simulação. <br />
<br />
<math> transiente </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> medir </math> define o intervalo de tempo entre as medições. <br />
<br />
<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)jmalloc(size);<br />
y= (double*)jmalloc(size);<br />
xo=(double*)jmalloc(size);<br />
yo=(double*)jmalloc(size);<br />
vx=(double*)jmalloc(size);<br />
vy=(double*)jmalloc(size);<br />
Fx=(double*)jmalloc(size);<br />
Fy=(double*)jmalloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
Abaixo é mostrada a parte principal do programa, o loop sobre o tempo. A cada passo de tempo, a rotina <math> compute_forces </math> calcula a força e a energia potencial das partículas a partir de suas posições, na sequência, a rotina <math> integrate_EqMotion </math> atualiza as posições das partículas. <br />
<br />
<pre><br />
for(t=0.;t<total_time;t+=dt)<br />
{<br />
compute_forces(Fx,Fy,x,y,&Ep);<br />
integrate_EqMotion(Fx,Fy,x,y,xo,yo,&Ec,&Vxm);<br />
<br />
if( t>transient && (1.-fmod(t/measure,1.) )<0.00001 )<br />
{<br />
for(i=0;i<N;i++)fprintf(file2,"%lf %lf %lf %lf\n",x[i],y[i],vx[i],vy[i]);<br />
fflush(file2);<br />
rewind(file2);<br />
<br />
fprintf(file1,"%lf %lf %lf %lf\n",t,Ec,Ep,Ec+Ep);<br />
fflush(file1);<br />
}<br />
}<br />
<br />
fclose(file1);<br />
fclose(file2);<br />
<br />
free(x);<br />
free(y);<br />
free(xo);<br />
free(yo);<br />
free(vx);<br />
free(vy);<br />
free(Fx);<br />
free(Fy);<br />
}<br />
</pre><br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=308DM: um primeiro programa2015-07-02T21:15:18Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<math> transiente </math> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<math> medir </math> define o intervalo de tempo entre as medições. <br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)jmalloc(size);<br />
y= (double*)jmalloc(size);<br />
xo=(double*)jmalloc(size);<br />
yo=(double*)jmalloc(size);<br />
vx=(double*)jmalloc(size);<br />
vy=(double*)jmalloc(size);<br />
Fx=(double*)jmalloc(size);<br />
Fy=(double*)jmalloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=307DM: um primeiro programa2015-07-02T21:09:35Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
<pre> transiente </pre> é o tempo que esperamos até o sistema supostamente equilibrar e, então, começarmos a fazer medidas. <br />
<br />
<pre> medir </pre> define o intervalo de tempo entre as medições. <br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)jmalloc(size);<br />
y= (double*)jmalloc(size);<br />
xo=(double*)jmalloc(size);<br />
yo=(double*)jmalloc(size);<br />
vx=(double*)jmalloc(size);<br />
vy=(double*)jmalloc(size);<br />
Fx=(double*)jmalloc(size);<br />
Fy=(double*)jmalloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
Com o os vetores alocados, podemos agora inicializar as velocidades e posições das partículas na rede<br />
<br />
<pre><br />
initialize_velocities(vx,vy);<br />
initialize_positions(x,y,xo,yo,vx,vy);<br />
</pre> <br />
<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=306DM: um primeiro programa2015-07-02T20:50:49Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio de corte acima do qual o cálculo da força é desconsiderado. <br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
unsigned i;<br />
double *x,*y,*xo,*yo,*vx,*vy,*Fx,*Fy,Ep,Ec,Vxm=0.,t;<br />
<br />
size_t size=N*sizeof(double);<br />
<br />
x= (double*)jmalloc(size);<br />
y= (double*)jmalloc(size);<br />
xo=(double*)jmalloc(size);<br />
yo=(double*)jmalloc(size);<br />
vx=(double*)jmalloc(size);<br />
vy=(double*)jmalloc(size);<br />
Fx=(double*)jmalloc(size);<br />
Fy=(double*)jmalloc(size);<br />
<br />
</pre><br />
<br />
Acima são declaradas todas as variáveis essenciais ao programa, assim como a alocação de memória para os vetores como posição, velocidade, força, etc. <br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=305DM: um primeiro programa2015-04-23T00:29:30Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio acima do qual o cálculo da força é desconsiderado. <br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *fx, double *fy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main(void)<br />
{<br />
FILE *file1,*file2,*file3,*file4;<br />
file1=fopen("energy.dat","w");<br />
file2=fopen("trajectories.dat","w");<br />
<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=304DM: um primeiro programa2015-04-23T00:09:56Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
#define Rc 4<br />
#define Rc2 (Rc*Rc)<br />
#define T 1.<br />
#define transiente 1000<br />
#define medir 10<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
<math> R_c </math> é o raio acima do qual o cálculo da força é desconsiderado. <br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=303DM: um primeiro programa2015-04-23T00:01:12Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np (Nx*Ny)<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> Np=N_xN_y </math> número total de partículas<br />
<br />
<math> dt </math> define o intervalo de tempo de integração na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=302DM: um primeiro programa2015-04-22T23:57:05Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente, introduziremos partes do código comentando cada etapa. Para o leitor mais familiarizado com DM, ao final da página há o programa completo sem comentários. <br />
<br />
<br />
A ideia básica da simulação pode ser entendida como: Leitura dos parâmetros da simulação, inicialização das posições das partículas, inicialização das velocidades das partículas, laço temporal onde se calcula a força, integra-se as equações de movimento e, de tempos em tempos, medidas são realizadas.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
Abaixo introduzimos partes do código onde começamos declarando as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros da simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=301DM: um primeiro programa2015-04-21T18:19:55Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] Aqui mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, o programa pode ser organizado como mostra o fluxograma abaixo. Posteriormente introduziremos partes do programa comentando cada etapa. <br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Fluxograma.jpg&diff=300Arquivo:Fluxograma.jpg2015-04-21T18:04:45Z<p>Gabrielcanova: foi enviada uma nova versão de &quot;Arquivo:Fluxograma.jpg&quot;</p>
<hr />
<div></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=299DM: um primeiro programa2015-04-21T18:02:08Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Fluxograma(1).jpg&diff=298Arquivo:Fluxograma(1).jpg2015-04-21T03:18:11Z<p>Gabrielcanova: </p>
<hr />
<div></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=297DM: um primeiro programa2015-04-21T02:55:51Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
[[Arquivo:fluxograma(1).jpg]]<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=296DM: um primeiro programa2015-04-21T02:54:54Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=295DM: um primeiro programa2015-04-21T02:54:07Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Fluxograma.jpg&diff=294Arquivo:Fluxograma.jpg2015-04-21T02:52:19Z<p>Gabrielcanova: </p>
<hr />
<div></div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=293DM: um primeiro programa2015-04-21T02:51:32Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
[[Arquivo:fluxograma.jpg]]<br />
<br />
<br />
<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=292DM: um primeiro programa2015-04-19T01:32:06Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Np Nx*Ny<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
A seguir introduzimos a função principal<br />
<br />
<pre><br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
</pre><br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=291DM: um primeiro programa2015-04-19T01:25:20Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem eventualmente aparecer à medida que novas funções são implementadas. Abaixo declaramos as funções essenciais ao programa, onde cada uma delas será detalhadamente explicada no decorrer da implementação. <br />
<br />
<pre><br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
</pre> <br />
<br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=290DM: um primeiro programa2015-04-19T01:18:01Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem, eventualmente, aparecer à medida <br />
/*********** declaring functions ************/<br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
<br />
<br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=289DM: um primeiro programa2015-04-19T01:16:44Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<math> dt </math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem, eventualmente, aparecer à medida <br />
/*********** declaring functions ************/<br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
<br />
<br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanovahttp://fiscomp.if.ufrgs.br/index.php?title=DM:_um_primeiro_programa&diff=288DM: um primeiro programa2015-04-19T01:13:41Z<p>Gabrielcanova: </p>
<hr />
<div>[EM CONSTRUÇÃO] A seguir mostraremos o passo a passo de como montar o primeiro programa para simulação de dinâmica molecular. A linguagem de programação utilizada será o C. Como um primeiro esboço, podemos organizar o programa da seguinte maneira, onde cada etapa será explicada detalhadamente.<br />
<br />
Aqui declaramos quais são as bibliotecas ''standard'' utilizadas do C<br />
<br />
<pre><br />
#include<stdio.h><br />
#include<stdlib.h><br />
#include<math.h><br />
</pre><br />
<br />
Está parte é reservada para declarações de constantes que definem os parâmetros e condições iniciais utilizadas na simulação. As constantes podem ser definidas utilizando-se das diretivas de compilação do C através do comando "#define" ou podem ser lidas a partir de um arquivo externo chamado pelo programa. A vantagem do segundo método é que o programa só precisará ser compilado uma única vez para diferentes condições iniciais. Porém, por simplicidade e clareza, optaremos pelo primeiro caso. <br />
<br />
<pre><br />
#define Nx 16<br />
#define Ny 16<br />
#define Lx 16<br />
#define Ly 16<br />
#define dt 0.01<br />
</pre><br />
<br />
<math> N_x \; \mbox{e} \; N_y </math> representam, respectivamente, o número de partículas nas direções <math> x \; \mbox{e} \; y </math>. <br />
<math> L_x \; \mbox{e} \; L_y </math> representam, respectivamente, o tamanho da rede nas direções <math> x \; \mbox{e} \; y </math>.<br />
<math>dt</math> define o intervalo de tempo na simulação.<br />
<br />
Conforme o programa é construído, novas constantes podem, eventualmente, aparecer à medida <br />
/*********** declaring functions ************/<br />
void initialize_positions(double *xx, double *yy ) ;<br />
void initialize_velocities(double *vx, double *vy ) ;<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) ;<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) ;<br />
<br />
<br />
void main()<br />
{<br />
/*********** declaring variables ************/<br />
// declara as variaveis necessarias<br />
// ex: double *fx ;<br />
<br />
/********** allocating memory ************/<br />
// aloca a memoria<br />
// ex. de alocacao DINAMICA de memoria:<br />
// fx = (double *)malloc( NP * sizeof(double) ); <br />
<br />
initialize_positions( px, py); <br />
initialize_velocities( vx, vy);<br />
for(i = 0; i < NP; i++)<br />
{ ppx[i] = px[i] - vx[i]*deltat; ppy[i] = py[i] - vy[i]*deltat; } // positions in the initial time <br />
<br />
tt=0; iframe=0;<br />
// faz um loop no tempo <br />
// chama a funcao que calcula forcas<br />
// chama a funcao que integra as Eqs de movimento<br />
// incrementa o tempo de simulacao<br />
// a cada intervalo de tempo definido, fazer medidas<br />
<br />
<br />
}<br />
<br />
<br />
void initialize_positions( double *xx, double *yy )<br />
{<br />
int i ;<br />
double deltax, deltay; <br />
<br />
deltax = (double)Lx/Nx; deltay = (double)Ly/Ny;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xx[i] = (i%Nx)*deltax ; <br />
yy[i] = (i/Ny)*deltay ;<br />
// printf("%lf %lf %d \n", xx[i], yy[i], i);<br />
}<br />
}<br />
<br />
void initialize_velocities(double *vx, double *vy )<br />
{ <br />
int i ;<br />
double vcmx, vcmy, v2, fs;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
vx[i] = (double)rand()/RAND_MAX ;<br />
vy[i] = (double)rand()/RAND_MAX ;<br />
vcmx += vx[i]; vcmy += vy[i];<br />
v2 += vx[i]*vx[i] + vy[i]*vy[i] ; // kinetic energy<br />
}<br />
vcmx /= NP ; vcmy /= NP ; v2 /= NP;<br />
fs=sqrt(2*TEMP/v2) ; // fator de escala -- escolhe uma dada temp T e computa isto : SE escolher uma dist maxwelliana, isto nao eh necessario (me parece)<br />
<br />
// set the velocity center of mass to zero (linear momentum of the system is zero)<br />
// and set its value in such a way that \sum m_i v^2 = Kb T for each degree of freedom<br />
for(i = 0; i < NP; i++)<br />
{ vx[i] = (vx[i] - vcmx)*fs ; vy[i] = (vy[i]-vcmy)*fs ; } <br />
}<br />
<br />
// fx = -dV/dx = -(x/r) (dV/dr)<br />
// fx= 48x/r² (1/r^12 - 1/r^6) -- LJ in reduced Units<br />
void compute_forces( double *ffx, double *ffy, double *xx, double *yy, double *eenergia ) <br />
{<br />
int i, j;<br />
double x1, y1, x2, y2,dxx, dyy, r2, r2i, r6, ff, energia=0.0 ;<br />
<br />
for( i=0; i < NP; i++ )<br />
{ ffx[i] = 0.0; ffy[i] = 0.0; }<br />
<br />
for( i=0; i < NP; i++ )<br />
{<br />
x1 = xx[i]; y1 = yy[i]; <br />
for( j=i+1; j < NP; j++ )<br />
{<br />
x2 = xx[j]; y2 = yy[j];<br />
<br />
dxx = x1 - x2; // compute the distance between particles taking into account the periodic boundary conditions <br />
dxx = fmod(dxx, Lx); <br />
dxx=dxx-rint(dxx/Lx)*Lx ; //note: rint(arg) : rounds its argument to the nearest whole number<br />
<br />
dyy = y1 - y2; <br />
dyy = fmod(dyy, Ly);<br />
dyy=dyy-rint(dyy/Ly)*Ly ;<br />
<br />
r2 = dxx*dxx + dyy*dyy ;<br />
if(r2<RC2) // rc2: critical value or r<br />
{<br />
r2i = 1/r2 ; <br />
r6 = r2i*r2i*r2i;<br />
ff = 48*r2i*r6*(r6-0.5); // LJ potential integrated <br />
ffx[i] += ff* dxx ; ffy[i] += ff* dyy ; // update forces<br />
ffx[j] -= ff* dxx ; ffy[j] -= ff* dyy ;<br />
energia += 4*r6*(r6-1) ; // compute energy<br />
}<br />
}<br />
}<br />
*eenergia=energia;<br />
}<br />
<br />
<br />
void integrate_EqMotion( double *ffx, double *ffy, double *xx, double *yy, double *xxp, double *yyp, double eenergia, double *energy_pp, double *vxm ) <br />
{<br />
int i; <br />
double xp, yp, vxi, vyi, vcmx, vcmy, v2, temp ;<br />
<br />
vcmx=0.0; vcmy=0.0; v2=0.0;<br />
for(i = 0; i < NP; i++)<br />
{<br />
xp = 2*xx[i] - xxp[i] + deltat2 * ffx[i] ;<br />
yp = 2*yy[i] - yyp[i] + deltat2 * ffy[i] ;<br />
vxi = (xp - xx[i]) / (2*deltat);<br />
vyi = (yp - yy[i]) / (2*deltat);<br />
<br />
vcmx += vxi; vcmy += vyi; // to monitor the average velocity<br />
v2 += vxi*vxi + vyi*vyi ; // kinetic energy<br />
xxp[i] = xx[i] ; yyp[i] = yy[i] ; // update the "previous position"<br />
yyp[i] = yy[i] ; <br />
xx[i] = xp; // update the positions in a current time<br />
yy[i] = yp;<br />
} <br />
temp=v2/(2*NP) ; // kbT = < m*v^2 > per degree of freedom<br />
*energy_pp=(eenergia + 0.5*v2)/NP; // energia total = ( U + K ) -- energy per particle =energia/NP<br />
*vxm = vcmx /NP ;<br />
}</div>Gabrielcanova