def _radial_integral(n1,
l1,
n2,
l2,
numerov=False,
numerov_step=0.005,
numerov_rmin=0.65):
"""Calculate the radial integral (cached).
Parameters
----------
n1 : int
principal quantum number, state 1
l1 : int
orbital angular momentum, state 1
n2 : int
principal quantum number, state 2
l2 : int
orbital angular momentum, state 2
numerov=False : bool
numerov_step=0.005 : float
numerov_rmin=0.65 : float
Returns
-------
float
Examples
--------
>>> # sympy
>>> radial_integral(10, 4, 11, 5)
63.4960193562957
>>> # numerov
>>> radial_integral(10, 4, 11, 5, numerov=True)
63.496017658724504
Nb. If numerov fails, automatically reverts to sympy
"""
if numerov:
ri = float(
radial_numerov(n1,
l1,
n2,
l2,
step=numerov_step,
rmin=numerov_rmin))
if not np.isnan(ri):
return ri
else:
# TODO fix numerov.radial_integral()
warnings.warn(
f"numerov.radial_integral returned nan for n1={n1}, l1={l1}, n2={n2}, l2={l2}.\\Fallback to scipy"
)
var("r")
return float(
integrate(R_nl(n1, l1, r) * r**3 * R_nl(n2, l2, r),
(r, 0, oo)).evalf())
def getOrbitals(self):
orbitals = []
self.nShells = int(ceil(pow(self.nOrbitals,1.0/3.0)) + 1)
o = 0
for n in range(1,self.nShells+1):
for l in range(n):
for m in range(-l,l+1):
self.nlm[o] = [n,l,m]
o += 1
o = 0
for i in range(len(self.nlm)):
n,l,m = self.nlm[i]
func = self.getSphericalFunc(l, m)
func = R_nl(n,l,r3d,Z=k) * func
func = func.simplify().collect(x).collect(y).collect(z)
orbitals.append(self.removeConstants(func).collect(k))
if o >= self.nOrbitals:
break
o += 1
return orbitals
def test_radial_integral(n1=12, l1=5, n2=15, l2=4):
""" compare radial integral with sympy
"""
var("r")
integral_sympy = integrate(
R_nl(n1, l1, r) * r**3 * R_nl(n2, l2, r), (r, 0, oo)).evalf()
integral_numerov = radial_integral(n1, l1, n2, l2, step=STEP)
frac_diff = abs(integral_numerov - integral_sympy) / integral_sympy
assert frac_diff < FRAC_DIFF
def x_ex(n, l, m):
x_ex = 0.0
for l0 in range(2 * l + 1):
# zenghui's note for more general cases: cg(l0,lj,0)*cg(l0,lj,mj) * cg(l0,li,0)*cg(l0,li,mi)
x_ex += (cg(l0,l,0)*cg(l0,l,m))**2 * \
( integrate( R_nl(n, l, r1)**2 * \
(r1**(1-l0) * integrate( r2**(l0+2) * R_nl(n, l, r2)**2, (r2, 0, r1)) \
+ r1**(l0+2) * integrate( R_nl(n,l,r2)**2 * r2**(1-l0), (r2, r1, oo))), (r1, 0, oo)) )
return -x_ex / 2
def do_plot(n, l, color="k"):
x = arange(0, 100, 0.1)
var("z")
f = R_nl(n, l, 1, z)
y = [f.subs(z, _x) for _x in x]
plot(x, y, color + "-", lw=2, label="$R_{%d%d}$" % (n, l))
xlabel("$\\rho$")
ylabel("$R_{nl}(\\rho)$")
title("Eigenvectors (l=%d, Z=1)" % l)
legend()
def do_plot(n, l, color="k"):
x = arange(0, 100, 0.1)
var("z")
f = R_nl(n, l, 1, z)
y = [f.subs(z, _x) for _x in x]
plot(x, y, color + "-", lw=2, label="$R_{%d%d}$" % (n, l))
xlabel("$\\rho$")
ylabel("$R_{nl}(\\rho)$")
title("Eigenvectors (l=%d, Z=1)" % l)
legend()
def main():
print("Hydrogen radial wavefunctions:")
a, r = symbols("a r")
print("R_{21}:")
pprint(R_nl(2, 1, a, r))
print("R_{60}:")
pprint(R_nl(6, 0, a, r))
print("Normalization:")
i = Integral(R_nl(1, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 1, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
def test_wavefunction():
a = 1 / Z
R = {
(1, 0):
2 * sqrt(1 / a**3) * exp(-r / a),
(2, 0):
sqrt(1 / (2 * a**3)) * exp(-r / (2 * a)) * (1 - r / (2 * a)),
(2, 1):
S(1) / 2 * sqrt(1 / (6 * a**3)) * exp(-r / (2 * a)) * r / a,
(3, 0):
S(2) / 3 * sqrt(1 / (3 * a**3)) * exp(-r / (3 * a)) *
(1 - 2 * r / (3 * a) + S(2) / 27 * (r / a)**2),
(3, 1):
S(4) / 27 * sqrt(2 / (3 * a**3)) * exp(-r / (3 * a)) *
(1 - r / (6 * a)) * r / a,
(3, 2):
S(2) / 81 * sqrt(2 / (15 * a**3)) * exp(-r / (3 * a)) * (r / a)**2,
(4, 0):
S(1) / 4 * sqrt(1 / a**3) * exp(-r / (4 * a)) *
(1 - 3 * r / (4 * a) + S(1) / 8 * (r / a)**2 - S(1) / 192 *
(r / a)**3),
(4, 1):
S(1) / 16 * sqrt(5 / (3 * a**3)) * exp(-r / (4 * a)) *
(1 - r / (4 * a) + S(1) / 80 * (r / a)**2) * (r / a),
(4, 2):
S(1) / 64 * sqrt(1 / (5 * a**3)) * exp(-r / (4 * a)) *
(1 - r / (12 * a)) * (r / a)**2,
(4, 3):
S(1) / 768 * sqrt(1 / (35 * a**3)) * exp(-r / (4 * a)) * (r / a)**3,
}
for n, l in R:
assert simplify(R_nl(n, l, r, Z) - R[(n, l)]) == 0
def radial_func(Z, n, l):
"""
This function provides the formal definition of the radial part of the hydrogen wavefunction which are Laguerre polynomials.
---
Parameters:
r, array: An array of the r values.
n, int: The principle quantum number of the hydrogen system.
l, int: The angular momentum quantum number of the hydrogen system.
---
Returns:
prob_amps, array: An array of the radial components of the hydrogen wavefunction.
"""
## Importing sympy modules that are only used in this function.
from sympy import Symbol
from sympy.physics.hydrogen import R_nl
from sympy.utilities.lambdify import lambdify
# Making r into a variable.
r = Symbol('r', real=True, positive=True)
## Generating the r array.
stop = 10
r_vals = np.linspace(0, stop, num=stop**4)
## Creating the radial arrays.
prob_amps = []
for i in l:
rad_func = lambdify([r], R_nl(n, i, r, Z))
values = []
for j in r_vals:
values.append(rad_func(j))
prob_amps.append(values)
return r_vals, prob_amps
def test_sympy(n=10, l=5):
""" test that sympy wf and numerov are approximately equal
"""
r_cy, y_cy = radial_wf_cy(n, l, step=STEP)
y_sympy = np.array([R_nl(n, l, r).evalf() for r in r_cy])
max_diff = np.max(np.abs(y_cy - y_sympy))
assert max_diff < MAX_DIFF
def test_wavefunction():
a = 1 / Z
R = {
(1, 0):
2 * sqrt(1 / a**3) * exp(-r / a),
(2, 0):
sqrt(1 / (2 * a**3)) * exp(-r / (2 * a)) * (1 - r / (2 * a)),
(2, 1):
S.Half * sqrt(1 / (6 * a**3)) * exp(-r / (2 * a)) * r / a,
(3, 0):
Rational(2, 3) * sqrt(1 / (3 * a**3)) * exp(-r / (3 * a)) *
(1 - 2 * r / (3 * a) + Rational(2, 27) * (r / a)**2),
(3, 1):
Rational(4, 27) * sqrt(2 / (3 * a**3)) * exp(-r / (3 * a)) *
(1 - r / (6 * a)) * r / a,
(3, 2):
Rational(2, 81) * sqrt(2 / (15 * a**3)) * exp(-r /
(3 * a)) * (r / a)**2,
(4, 0):
Rational(1, 4) * sqrt(1 / a**3) * exp(-r / (4 * a)) *
(1 - 3 * r / (4 * a) + Rational(1, 8) * (r / a)**2 - Rational(1, 192) *
(r / a)**3),
(4, 1):
Rational(1, 16) * sqrt(5 / (3 * a**3)) * exp(-r / (4 * a)) *
(1 - r / (4 * a) + Rational(1, 80) * (r / a)**2) * (r / a),
(4, 2):
Rational(1, 64) * sqrt(1 / (5 * a**3)) * exp(-r / (4 * a)) *
(1 - r / (12 * a)) * (r / a)**2,
(4, 3):
Rational(1, 768) * sqrt(1 / (35 * a**3)) * exp(-r /
(4 * a)) * (r / a)**3,
}
for n, l in R:
assert simplify(R_nl(n, l, r, Z) - R[(n, l)]) == 0
def HFunc(r, theta, phi, n, l, m):
#Full wavefunction (radial and spherical harmonics functions)
# between an electron and nucleus of atomic number Z. The function was
#taken from http://www.pitt.edu/~djb145/python/utilities/2016/03/07/Plot-Density/
sphHarm = spe.sph_harm(m, l, phi,
theta) # Note the different convention from doc
return R_nl(n, l, r, Z) * sphHarm
def test_norm():
# Maximum "n" which is tested:
n_max = 2
# you can test any n and it works, but it's slow, so it's commented out:
#n_max = 4
for n in range(n_max + 1):
for l in range(n):
assert integrate(R_nl(n, l, r)**2 * r**2, (r, 0, oo)) == 1
def main():
print "Hydrogen radial wavefunctions:"
var("r a")
print "R_{21}:"
pprint(R_nl(2, 1, a, r))
print "R_{60}:"
pprint(R_nl(6, 0, a, r))
print "Normalization:"
i = Integral(R_nl(1, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 1, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
def test_norm():
# Maximum "n" which is tested:
n_max = 2 # it works, but is slow, for n_max > 2
for n in range(n_max + 1):
for l in range(n):
assert integrate(R_nl(n, l, r)**2 * r**2, (r, 0, oo)) == 1
from sympy.printing.theanocode import *
from sympy.physics.hydrogen import R_nl
import theano
from sympy import Derivative, simplify, Symbol, pprint, latex, count_ops
n, l, Z = 6, 2, 6
x = Symbol('x')
expr = R_nl(n, l, x, Z)
for e in (expr, expr.diff(x), simplify(expr.diff(x))):
print latex(e)
print "Operations: ", count_ops(e)
print
print latex(Derivative(expr, x))
print '\n\n\n'
# Theano simplification functions
def fgraph_of(*exprs):
""" Transform SymPy expressions into Theano Computation """
outs = map(theano_code, exprs)
ins = theano.gof.graph.inputs(outs)
ins, outs = theano.gof.graph.clone(ins, outs)
return theano.gof.FunctionGraph(ins, outs)
def theano_simplify(fgraph):
""" Simplify a Theano Computation """
from sympy.physics.hydrogen import Psi_nlm, R_nl
from sympy.physics import hydrogen
from sympy import Symbol, symbols, Matrix
from sympy import integrate, conjugate, pi, sin
r_axis = Matrix(r_axis)
phi, theta = symbols('phi theta', real=True)
r = Symbol('r', real=True, positive=True)
Z, n, l, m = symbols('Z n l m', positive=True, integer=True, real=True)
n = 3
l = 1
m = 0
wf = R_nl(n, l, r, Z) #Psi_nlm(n, l, m, r, phi, theta)
abs_sqrd = wf * conjugate(wf)
def getRadialFunc(self, n, l):
return R_nl(n, l, r3d, Z=k)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 19 13:35:48 2018
@author: gustavo
"""
from sympy.utilities.lambdify import implemented_function
from sympy.physics.hydrogen import R_nl
a, r = symbols('a r')
psi_nl = implemented_function('psi_nl', Lambda([a, r], R_nl(1, 0, a, r)))
psi_nl(a, r)
def Rnl(n, l, x):
return lambdify(r, R_nl(n, l, r), modules=['numpy'])(x)
"""
This example shows how to work with the Hydrogen radial wavefunctions.
"""
from sympy import var, pprint, Integral, oo, Eq
from sympy.physics.hydrogen import R_nl
print "Hydrogen radial wavefunctions:"
var("r a")
print "R_{21}:"
pprint(R_nl(2, 1, a, r))
print "R_{60}:"
pprint(R_nl(6, 0, a, r))
print "Normalization:"
i = Integral(R_nl(1, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 0, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
i = Integral(R_nl(2, 1, 1, r)**2 * r**2, (r, 0, oo))
pprint(Eq(i, i.doit()))
if 'left' in spines:
ax.yaxis.set_ticks_position('left')
else:
# no yaxis ticks
ax.yaxis.set_ticks([])
if 'bottom' in spines:
ax.xaxis.set_ticks_position('bottom')
else:
# no xaxis ticks
ax.xaxis.set_ticks([])
#n=1,l=0
r = linspace(0, 10, 100)
lam_R_nl = lambdify(x, R_nl(1, 0, x))
ax = fig.add_subplot(6, 1, 1)
ax.plot(r,
r**2 * abs(lam_R_nl(r))**2,
'k',
clip_on=False,
label=r'$a_0^2|R_{nl}(r)|^2$')
ax.fill(r, r**2 * abs(lam_R_nl(r))**2, color=[.7, .7, .7])
ax.plot(r, lam_R_nl(r), 'k:', clip_on=False, label=r'$R_{nl}(r)$')
ax.plot([1, 1],
[min(r**2 * abs(lam_R_nl(r))**2),
max(r**2 * abs(lam_R_nl(r))**2)], 'k--')
ax.set_ylim([0, 1.])
P.legend(frameon=False, fontsize=14, loc='best', ncol=2)
adjust_spines(ax, ['left'])
from sympy.physics.hydrogen import E_nl, E_nl_dirac, R_nl
from sympy import var
var("n Z")
var("r Z")
var("n l")
E_nl(n, Z)
E_nl(1)
E_nl(2, 4)
E_nl(n, l)
E_nl_dirac(5, 2) # l should be less than n
E_nl_dirac(2, 1)
E_nl_dirac(3, 2, False)
R_nl(5, 0, r) # z = 1 by default
R_nl(5, 0, r, 1)
def dRnl(n, l, x):
return lambdify(r, diff(R_nl(n, l, r), r), modules=['numpy'])(x)
if Problem=='Hydrogen atom (Helium correction)':
if atomic_number.value=='1 (Show Hydrogen energies)':
z=1
if atomic_number.value=='2 (Correct Helium first energy)':
z=2
large=0
omega=0
# Energías del átomo hidrogenoide
En=z*E_nl(n,z)
# Funciones de onda del átomo de hidrógeno
# Número cuántico l=0
q=0 # La variable l ya esta siendo utilizada para el largo de la caja por ello se sustituyo por q
Psin=(R_nl(n,q,r1,z)*R_nl(n,q,r2,z))
# Límites del átomo de hidrógeno de 0 a oo para sympy
li_sympy=0
ls_sympy=oo
# Límites del átomo de hidrógeno de 0 a oo para scipy
li_scipy=0
ls_scipy=inf
# Para sistemas no degenerados, la corrección a la energía a primer orden se calcula como
#
# $$ E_{n}^{(1)} = \int\psi_{n}^{(0)*} H' \psi_{n}^{(0)}d\tau$$
# ** Tarea 1 : Programar esta ecuación si conoces $H^{0}$ y sus soluciones. **
