PUNTO PARA PARCIAL OSCILADOR ARMÓNICO

Juan David Hernández Flórez

10/05/2023

Método de Runge-Kutta
Para hallar la densidad de probabilidad del el oscilador armónico clásico se necesita encontrar primero
una función dtT para poder definir el la relación tiempo que pasa por un dx y tiempo total (T ) por lo
que inicialmente se define la ecuación de un oscilador clásico

x(t) = Asen(wt − ϕ) (1)

Y el tiempo que se demora en recorre de un extremo a otro corresponde a medio periodo, por lo que:
T ω
Tr = = (2)
2 π
Derivando la ecuación de la posición y despejando dt
dx
dt = (3)
Aωcos(ωt − ϕ)
Dividiendo a ambos lados por T
dt ωdx
= (4)
T r πωAcos(ωt − ϕ)
Pero de la ecuación de la velocidad se puede deducir

v2 = A2 ω2 cos2 (ωt − ϕ) = ω2 (A2 − A2 sin2 (ωt − ϕ)) (5)

Y el segundo termino del marentes de la derecha se sabe que es x(t), por lo que:
√
v = ω A2 − x 2 (6)

Reemplazando este resultado en la ec (3) se obtiene finalmente:

dt dx
= √ (7)
T π A2 − x2
Y el resultado para la densidad de probabilidad ρ(x) es:
1
ρ(x) = √ (8)
π A2 − x 2
que graficando la ecuación anterior queda:
El código para esta grafica es:

1
import numpy as np
import math
import matplotlib . pyplot as plt

def f(x, y, z, B, E):

return (pow(B*x,2)*y)-(2*B*E*y)

def g(x, y, z):

return z

def Runge_Kutta (x0 , y0 , z0 , h, Paso , B, E):

x_0 = [x0]
y_0 = [y0]
z_0 = [z0]

for _ in range(int(Paso)):
x = x_0[-1]
y = y_0[-1]
z = z_0[-1]

l1 = h * g(x, y, z)
k1 = h * f(x, y, z, B, E)
l2 = h * g(x + h/2, y + l1/2, z + k1/2)
k2 = h * f(x + h/2, y + l1/2, z + k1/2, B, E)
l3 = h * g(x + h/2, y + l2/2, z + k2/2)
k3 = h * f(x + h/2, y + l2/2, z + k2/2, B, E)
l4 = h * g(x + h, y + l3 , z + k3)
k4 = h * f(x + h, y + l3 , z + k3 , B, E)

y_n = y + (l1 + 2*l2 + 2*l3 + l4) / 6

z_n = z + (k1 + 2*k2 + 2*k3 + k4) / 6
x_n = x + h

x_0. append (x_n)

y_0. append (y_n)
z_0. append (z_n)

return x_0 , y_0 , z_0

def psi(x, N):

return np.sum([(Nn*pow(-1,i)*math. factorial (n)*pow(2*a*x,n-2*i)*pow(math.e ,(-1)
*pow(2,-1)*pow(a*x,2))) / (math.
factorial (i)*math. factorial (n-2*i)) for
i in range(int(N)+1)])

Oscilador cuántico
La resolución de este oscilador fue la realizada en clase, partiendo desde la ecuación de Schrödinger,
se llega a una solución de la forma:
α2 x 2
φ(x) = h(x)e− 2 (9)

2
Donde la función h(x) es el producto de una serie que genera polinomios de Hermite (hn (x)) y otro
termino Nn . Donde cada una de estas funciones está representada por:
N
X (−1) s n!(2ξ)n−2s
hn (x) = (10)
s=0
s!(n − 2s)!
 n

 2
si n es par
Nn = 

(11)


 n−1

2
si n es impar
Llegando a que para diferentes valores de N, n, s cambia la función del oscilador. Se realiza el código
en phyton en la plataforma de Colab de google y para verificar su veracidad se realiza la graficación
con los primeros 5 estados. Como por ejemplo n = 2 y n = 3
El siguente es el código que se encarga de realizar las gráficas usando las mismas librerı́as: numpy
y matplotlib.pyplot.

# Par metros
#Datos para el Runge - Kutta
xm = 0.5 # Matching
xR0 = 20 # Rango simetrico
h = 0.01 # Delta x para crecimiento
y0 = 0 # Funcion de onda inicial evaluada en el punto inicial para ambos lados
B = 1
##
x0 = -(xR0)
hR = -h # Delta x para decrecimiento
IterL = (xm-x0)/h
IterR = (xR0-xm)/h
# Parametros para hallar la energia de matching
Eo=0.0
dE=0.001
tol=0.01
# Condiciones para aplicar condiciones iniciales
n_0=int(Eo)
n_1=Eo-n_0

# tratamiento previo para las condiciones iniciales

if n_0 % 2 == 0 and n_1 > 0.5:
z0 = -0.01
zR0 = -0.01
else:
if n_0 % 2 == 0 and n_1 < 0.5:
z0 = 0.01
zR0 = -0.01
else:
if n_1 > 0.5:
z0 = 0.01
zR0 = -0.01
else:
z0 = -0.01
zR0 = -0.01

3
# Definicion Variables vacias
xL = [0]
yL = [0]
zL = [0]
xR = [0]
yR = [0]
zR = [0]
Df=100

# Ejecucion de matching bajo criterio convergencia

while Df > tol or Df<0:
xL. clear ()
yL. clear ()
zL. clear ()
xR. clear ()
yR. clear ()
zR. clear ()
#Runge - Kutta Izquierda
xL , yL , zL = Runge_Kutta (x0 , y0 , z0 , h, IterL , B, Eo)
#Runge - Kutta Derecha
xR , yR , zR = Runge_Kutta (xR0 , y0 , zR0 , hR , IterR , B, Eo)
# criterio convergecia
Df=(( zL[int( IterL )]/yL[int( IterL )])-(zR[int( IterR )]/yR[int( IterR )]))/(( zL[int(
IterL )]/yL[int( IterL )])+(zR[int( IterR )
]/yR[int( IterR )]))
Eo=Eo+dE

#### Mensajes de informacion ####

print (f"paso de izquierda : { IterL }")
print (f"paso de derecha : {IterR }")
print (f" Energia analitica {E}")
print (f" Energia Encontrada : {Eo}")
print (f"df: {Df}")

# Graficar el resultado
plt. figure ( figsize =(10 , 5))

#plt. subplot (1, 2, 1)

plt.plot(xL , yL , ’b-’)
plt.plot(xR , yR , ’r-’)
plt. xlabel (’x’)
plt. ylabel (’psi ’)
plt. title (" Solucion numerica de la ecuacion diferencial ")
plt.grid(True)

plt.show ()

Este realiza su actividad correctamente aproximadamente para n = 63, esto dado que Colab es una
plataforma en lı́nea y el código para los polinomios de Hermite construido en el código seguramente
no está optimizado de manera correcta.