FSICA COMPUTACIONAL II

Deber Segundo Bimestre

Diego Santana A.

Escuela Politcnica Nacional, Facultad de Ciencias, Departamento de Fsica

Quito, Ecuador

dsantana2804 @gmail.com

31 de enero de 2017

Mtodo de Elementos Finitos

1. Encontrar la solucin de la ecuacin de Poisson para una densidad de carga lineal distribuida
en un lazo ubicado en el centro de la regin circular.

La ecuacin de Poisson en 2 dimensiones viene dada por

2 u(x, y) 2 u(x, y)
+ = (x, y)/0 (1)
x2 y 2

La densidad de carga lineal que utilizaremos sera distribuida en una region rectangular.
Para resolver la ecuacin de Poisson numricamente se utiliza el Mtodo de Elementos Finitos que consiste
en dividir el dominio donde esta denida la ecuacin diferencial. Ademas se debe replantear el problema en
forma variacional. El dominio es dividido en un nmero elevado de subdominios denominados elementos
nitos. El conjunto de elementos nitos forma una particin del dominio y se le conoce como discretizacin.
Dentro de cada elemento se distinguen una serie de puntos representativos llamados nodos.
Despues de la discretizacion, se construye un espacio vectorial de dimensin nita, llamado espacio de ele-
mentos nitos, donde la solucin numrica aproximada obtenida por elementos nitos es una combinacin
lineal en dicho espacio.
Entonces del problema variacional que tenamos inicialmente al realizar la discretizacion nos conlleva a
un sistema de ecuaciones lineales, que se puede resolver en forma matricial por descomposicin LU.
El codigo en C++ implementado [1] en este trabajo utiliza este mtodo para la resolucin de la ecuacin
de Poisson. Los resultados se presentan a continuacin.

1
 Figura 1: Grca de la solucin de la ecuacin de Poisson (potencial).

Figura 2: Campo elctrico de la distribucin de Carga.

2. Analizar la consistencia de la solucin encontrada

Se ha encontrado el potencial con una distribucin de carga lineal. comprobando que en las frontera se
cumple que u(x, y) = 0. El potencial es propio de una carga constante denida en intervalos, en este caso
rectangular Ademas que para una carga lineal el campo elctrico diverge en las fronteras.

2
 Simulaciones Monte Carlo
Considerar un sistema de 100 partculas en una caja tridimensional en contacto con un reservorio de calor a
temperatura T. La interaccion de las particulas se describe adecuadamente con el potencial de Lennard-Jones:
   r 6 
r 12
V (r) = 
0
2
0
(2)
r r

1. Utilizar el algoritmo Monte Carlo Metropolis para calcular el valor medio de la energia
potencial del sistema para 10 valores diferentes de temperatura.

Mediante el algorimo Monte Carlo Metropoli nos permite hacer una seleccion inteligente al tomar el
promedio en el ensamble de la Energia Potencial, es decir, las energias que tendran un peso mayor en el
calculo del promedio termico son las conguraciones mas probables para un sistema, este peso viene dado
por el ensamble canonico en donde el sistema esta en equilibrio a una temperatura T. La energia de cada
copia del sistema esta asociada a una probabilidad que estara dada por

Epi

P (Epi ) = e kB T (3)
De esta manera, el mtodo Monte Carlo Metropoli nos permite hacer una mejor seleccion para obtener
el promedio trmico de una variable, al asociarla a la probabilidad de que cierta conguracin sea mas o
menos probable.

Figura 3: Grca de la energa promediop

en el ensamble < Ep > vs T . La graca tambien muestra la desvicion
estandar del calculo computacional = < Ep2 > < Ep >2 representado con las barras de errores.

2. Analizar la consistencia de los resultados encontrados

Se ha encontrado que el promedio de la Energa potencial < Ep > en el ensamble permanece constante
conforme aumenta la Temperatura, este resultado es consistente con la teora debido a que en la interaccin
de las partculas mediante el potencial de Lennard Jones solo se involucran distancias relativas entre los
tomos, en el presente trabajo se ha simulado tomos de Argn. Es decir, debido a que no hay dependencia
explicita de las velocidades de las partculas se esperara que la Temperatura no afecte al promedio trmico,
a diferencia de la Energa cintica que es proporcional a la Temperatura.

3
 Referencias
[1]Bukardt, John. Florida State University , Department of Scientic Computing GNU LGPL license. (2012)
Disponible en https : //people.sc.f su.edu/ jburkardt/cpps rc/f em2dp oissonr ectangle/f em2dp oissonr ectangle.html

[2]Pang, Tao An Introduction to Computational Physics Cambridge Second Edition Chap 9 .

4
 Anexos
Codigo utilizado problema 2
#include <iostream>
#include <fstream>
#include <cmath>
#include <time.h>
#include <cstdlib>
#include <vector>

using namespace std;

double Enp(vector<vector<double> >, int);

int ale(int, int);
double aleatorio();
vector<double> pared(vector<double>);
// condiciones=================================

double kb=0.00836; //kb unidades sistema

int n = 100; // numero de particulas

double N=100002;

//caja
double sep = 0.7 ;
int ancho = 50;
int salto = 100;

double fce=0.0103125;//ev
double fct=0.46;//picosegundos
double fcpos=0.34;//nm
double temperatura=380;
double delta=0.05;
// ===========================

double l1 = sep*ancho; //ancho x

double l2 = sep*ancho; //alto y
double l3 = sep*ancho; //alto y

ofstream fs("gasPosicion.dat");
ofstream fs1("gasE7.dat");
ofstream fsp("parametros7.txt");

int main()
{
// srand(time(NULL));
vector<vector<double> > particula; //(x=0, y=1 , z=2,vx=3 ,vy=4 ,vz=5)
vector<vector<double> > particula0;
double Ep = 0;
double prob=1e-100;
double probA=1e-100;
double modulo;
double r=0;
double Em=0;
double Em2=0;
double desviacion=0;

vector <double> totalE;

fsp<<"numero de iteraciones = "<<N<<" "<<"Temp="<<temperatura<<endl;

cout <<"inicialn "<<N<<" iteraciones"<<" "<<"Temp="<<temperatura<< endl;

5
 particula.resize(n);
for (int i = 0; i < n; i++)
particula[i].resize(3);

// posicion inicial

//genero aleatorio
int aux;
fsp << "Separacion " << sep << endl;
for (int i = 0; i < n; i++) {
do {
aux = 0;

particula[i][0] = sep *ale(0, ancho);

particula[i][1] = sep *ale(0, ancho);
particula[i][2] = sep *ale(0, ancho);

if (i > 0) {
for (int k = 0; k < i; k++) {
if (k != i) {
if (particula[i][0] == particula[k][0] && particula[i][1] ==
particula[k][1] && particula[i][2] == particula[k][2]) {
aux++;
}
}
}
}
} while (aux >= 1);
}

// itero
for (int k = 0; k < N; k++) {

for(int i =0 ; i<n ; i++){

particula[i][0] = particula[i][0] + 2*delta*aleatorio()-delta;
particula[i][1] = particula[i][1] + 2*delta*aleatorio()-delta;
particula[i][2] = particula[i][2] + 2*delta*aleatorio()-delta;
particula[i] = pared(particula[i]);
}
//termino aleatorio

Ep = 0;

for (int i = 0; i < n; i++) {

Ep=Ep+Enp(particula, i);

// modulo = k % salto;
// if (modulo == 1) {
// fs << particula0[i][0] *fcpos<< " " << particula0[i][1] *fcpos
<< " " << particula0[i][2]*fcpos;
// fs << endl;
// }
}
// if (modulo == 1){
// fs << endl;
// fs << endl;
// }

6
 //Calculo y escritura de la energia
//Seleccion montecarlo
probA=prob;
prob=exp(-Ep/(kb*temperatura));
r=prob/probA;

if(k==0)
r=2;

double randomico=aleatorio();
if(r>randomico)
{
particula0=particula;
totalE.push_back(Ep);
}
else
{

totalE.push_back(totalE[k-1]);
// cout<<"descartado "<<k<<endl;
// fsp <<"descartado "<<k<<endl;
particula=particula0;

//fin seleccion montecarlo

fs1 << k <<" " << Ep *fce<< " " << totalE[k] *fce <<" " << r<<" " << randomico<<endl;

Em=Em+(totalE[k]/N);
Em2=Em2+((totalE[k]*totalE[k])/N);

//fin escritura

}
fs.close();

desviacion=sqrt(Em2-Em*Em);

cout << "Energia potencial promedio " << Em *fce<<endl;

cout << "desviacion " << desviacion*fce<<endl;

fsp << "Energia potencial promedio " << Em *fce<<endl;

fsp << "desviacion " << desviacion*fce<<endl;

return 0;
}

vector<double> pared(vector<double> a)
{
if (a[0] <= 0)
a[0] = l1 + a[0];

if (a[0] >= l1)

a[0] = a[0] - l1;

if (a[1] <= 0)

7
 a[1] = l2 + a[1];

if (a[1] >= l2)

a[1] = a[1] - l2;

if (a[2] <= 0)
a[2] = l3 + a[2];

if (a[2] >= l3)

a[2] = a[2] - l3;

return a;
}

double Enp (vector<vector<double> > particula0, int i)

{
double ePi=0;

double diky, dikx, dikz, rik;

for (int ik = 0; ik < n; ik++) {
if (i < ik) {

dikx = particula0[i][0] - particula0[ik][0];

diky = particula0[i][1] - particula0[ik][1];
dikz = particula0[i][2] - particula0[ik][2];
rik = dikx * dikx + diky * diky + dikz * dikz;

ePi = ePi + (1 / pow(rik, 6) - 2/ pow(rik, 3));

}
}

return ePi;
}

int ale(int x1, int x2)

{
int ale = rand();
int dif = x2 - x1 + 1;
if (x2 <= x1)
cout << "error x1 <= x2";
ale = x1 + ale % dif;

return ale;
}
double aleatorio()
{
double estesi=(double) rand()/RAND_MAX;
return estesi ;