Oscilador Armónico Cuántico Unidimensional en Python

Antes de crear el código fuente es necesario que se importan algunas librerías correspondientes para compilar este código.

import numpy as np

import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import sympy as sp
from sympy import Derivative, diff, simplify
import matplotlib.patches

Iniciando el código, primero se definen algunas funciones necesarias para el calculo de la onda normalizada tales como el factorial, los polinomios físicos de Hermite, etc, 

def factorial(n):

        

    """ Imprime en pantalla el factorial de un número entero positivo n 

        por el método de recursividad """

        

    if n == 0:

        return 1

    elif n == 1:

        return 1

    else:

        return n*factorial(n-1)

def hermite(n, t):

        

    """ Imprime en pantalla los polinomios físicos de Hermite en 

        función de la variable t """

        

    if n == 0:

        return 1

    

    hermite_p = [1, 2 * t]

    

    for m in range(2, n + 1):

        hermite_p.append( 2 *t* hermite_p[m - 1] - 2 * (m - 1) * hermite_p[m- 2] )              

    return hermite_p[n]        

def potencia(n):

        

    """ Imprime en pantalla la potencia enésima de 2 """

        

    z = 2**n

    return z

def psi(n):

        

    """ Imprime en pantalla la función de onda del oscilador 

        cuántico unidimandional en el estado n """

        

    y = hermite(n,t)*(np.exp(-(t**2)/2))

    z = np.sqrt(potencia(n)*factorial(n)*np.sqrt(np.pi))

    w = y/z

    return w

Ahora se define una función para el calculo de la onda normalizada en función de las funciones anteriormente definidas respectivas.

def oscilador(n):

    

    """ Código Matemático del Oscilador Cuántico Unidimensional para n """

    

    fig, (ax1, ax2) = plt.subplots(1,2)

    fig.set_size_inches(14,6)

    

    ax1.plot(t, psi(n))

    ax1.set_title("Amplitud de la Onda", size=20)

    ax1.grid()

    ax1.set_xlabel("Eje X", size=15)

    ax1.set_ylabel("Eje Y", size=15)

    ax1.set(xlim =(-2*np.pi, 2*np.pi), ylim = (min(psi(n)), max(psi(n))), 

            autoscale_on = False) 

    red_patch = mpatches.Patch(color='blue', label='Amplitud')

    ax1.legend(handles=[red_patch], loc='best')

    

    ax2.plot(t, psi(n))

    ax2.set_title("Densidad de Probabilidad", size=20)

    ax2.grid()

    ax2.set_xlabel("Eje X", size=15)

    ax2.set(xlim =(-2*np.pi, 2*np.pi), ylim = (min(psi(n)), max(psi(n))), 

            autoscale_on = False)

    ax2.fill_between(t, psi(n) , color="blue")

    red_patch = mpatches.Patch(color='blue', label='P($\Psi(x)$)')

    ax2.legend(handles=[red_patch], loc='best')

    

    plt.suptitle('Oscilador Armonico Cuántico Unidimensional n = {} '.format(n)

                 , fontsize=25, size=20)

    plt.tight_layout()

    

    return oscilador 

Aplicación del código fuente

• Para n = 0

• Para n =1

• Para n = 2

• Para n = 3

Por último una animación del oscilador armónico cuántico unidimensional.

Oscilador Armónico Cuántico Unidimensional para una frecuencia angular de w = 0.5 Hz