Grupo5 - Eq. Schroedinger: mudanças entre as edições

De Física Computacional
Ir para navegação Ir para pesquisar
Sem resumo de edição
Linha 66: Linha 66:
==Implementação em C==
==Implementação em C==


===Condição de contorno limitada===
<br><code>
void CN(double complex *u, double complex *u_aux, double complex *u_next, double complex a)
{
//Nomeia-se E a matriz da equação matricial que multiplica o estado evoluído no tempo.
//Tem-se L, dx e dt definidos
//u -- vetor de estado atual
//u_aux -- conj(E) * u
//u_next -- o novo estado
//Esta função resolve resolve E * u_next = conj(E) * u
int i;
//atualização do vetor u_aux
for(i = 1; i < L; i++) u_aux[i] = conj(a) * (u[i-1+] + u[i+1]) + conj(b(i)) * u[i];
//para resolver E * u_next = u_aux, utiliza-se do Método de Thomas:
double complex c_new[L+1], d_new[L+1];
c_new[1] = a / b(1);
for(i = 2; i < L; i++) c_new[i] = a / (b(i) - c_new[i-1] * a);
d_new[1] = u_aux[1] / b(1);
for(i = 2; i < L; i++) d_new[i] = (u_aux[i] - d_new[i-1] * a) / (b(i) - c_new[i-1] * a);
u_next[0] = u_next[L] = 0;
u_next[L-1] = d_new[L-1];
for(i = L-2; i > 0; i --) u_next[i] = d_new[i] - c_new[i] * u_next[i+1];
//atualiza-se o valor do estado: u = u_next
for(i = 0; i <= L; i++) u[i] = u_next[i];
}
</code><br>


==Referências==
==Referências==

Edição das 22h50min de 23 de outubro de 2017

A evolução temporal do estado quântico é dada pela equação de Schrödinger, a qual é postulada como:

Posto em unidades atômicas (onde e são unitários), o caso unidimensional de um elétron num potencial independente do tempo reduz-se a:


Método numérico

Buscando resolver a equação numericamente, tem-se a discretização de  :

e as discretizações de (explícita e implícita, respectivamente):

Tanto no método explícito quanto no método implícito não é conservada a norma do estado (o que é estritamente necessário, já que o estado pode ser interpretado como uma onda de probabilidade). Por esse motivo, utiliza-se o método de Crank-Nicolson, o qual tem essa propriedade \cite{enswork}.

O método de Crank-Nicolson consiste em uma média aritmética dos métodos explícito e implícito. Excetuando manipulações algébricas triviais, verifica-se que a relação de recorrência do método é dada por:

onde

e .

A integração numérica depende, portanto, do potencial em que o elétron está sujeito, bem como da sua condição inicial e suas das condições de contorno.

Que condições podemos impor para a fronteira? Quando se trata do problema analiticamente, costuma-se considerar que a função de onda tende a zero no infinito. Numericamente, pode-se fazer uma transposição disso, criando uma condição para bordas em pontos suficientemente distantes do centro da distribuição da função de onda, igualando-as a zero. Outra forma de tratar o problema numericamente é criando condições de contorno periódicas, em que para as bordas vale para todo (ou, para as bordas e há a relação para todo ).

Condições de contorno iguais a zero

Para as condições de contorno , a iteração reduz-se à equação matricial:


Condições de contorno periódicas

De maneira semelhante, a iteração do caso das condições de contorno periódicas - - reduz-se à equação matricial:


Condição inicial

Já a condição inicial é arbitrária, pois define o estado inicial do sistema que queremos tratar. Fazendo uma referência ao tratamento de sistemas clássicos, seria como definir posição e momento iniciais. É claro que, para ter o sentido físico de uma função de onda, deve-se ter o cuidado de criar uma condição inicial normalizada, satisfazendo

bastando, então, inseri-la no programa.

Implementação em C

Condição de contorno limitada


void CN(double complex *u, double complex *u_aux, double complex *u_next, double complex a) { //Nomeia-se E a matriz da equação matricial que multiplica o estado evoluído no tempo. //Tem-se L, dx e dt definidos

//u -- vetor de estado atual //u_aux -- conj(E) * u //u_next -- o novo estado

//Esta função resolve resolve E * u_next = conj(E) * u

int i;

//atualização do vetor u_aux

for(i = 1; i < L; i++) u_aux[i] = conj(a) * (u[i-1+] + u[i+1]) + conj(b(i)) * u[i];

//para resolver E * u_next = u_aux, utiliza-se do Método de Thomas:

double complex c_new[L+1], d_new[L+1];

c_new[1] = a / b(1); for(i = 2; i < L; i++) c_new[i] = a / (b(i) - c_new[i-1] * a);

d_new[1] = u_aux[1] / b(1); for(i = 2; i < L; i++) d_new[i] = (u_aux[i] - d_new[i-1] * a) / (b(i) - c_new[i-1] * a);

u_next[0] = u_next[L] = 0; u_next[L-1] = d_new[L-1]; for(i = L-2; i > 0; i --) u_next[i] = d_new[i] - c_new[i] * u_next[i+1];

//atualiza-se o valor do estado: u = u_next

for(i = 0; i <= L; i++) u[i] = u_next[i]; }


Referências