{{indexmenu_n>11}}
====== Dirac operator ======
;;#
Modified in 0.9.1
;;#
###
//NewOperator("Dirac", NF, Z, indices, G, F, Options)// creates the one-electron Dirac operator of an atom: the kinetic energy, the rest mass and the attraction by the nucleus. It acts on atomic orbitals given by their radial functions, for example the functions calculated by //[[documentation:language_reference:functions:calculateatomicbasisfunctions|CalculateAtomicBasisFunctions()]]//. Together with the Coulomb interaction of //[[documentation:standard_operators:atomic_coulomb_repulsion|NewOperator("AU", ...)]]// it gives the relativistic many-electron Hamiltonian of the atom.
###
###
The operator is
$$
h_D = c\,\boldsymbol{\alpha}\cdot\mathbf{p} + (\beta - 1)\,c^2 + V_N(r),
$$
with $\boldsymbol{\alpha}$ and $\beta$ the Dirac matrices and $V_N(r)$ the potential energy of the electron in the field of the nucleus, $V_N(r) = -Z/r$ for a point nucleus. The rest mass $c^2$ is subtracted, so a bound electron has a negative energy and a free electron at rest has energy 0. All energies are in Hartree, all lengths in bohr, and $c$ is the speed of light in atomic units, //PhysicalConstants.cAU.value//.
###
###
An orbital $a$ with the quantum numbers $\kappa$ and $\mu$ is the four-component spinor
$$
\psi_{a}(\mathbf{r}) = \frac{1}{r}\begin{pmatrix} P_a(r)\,\Omega_{\kappa\mu}(\hat{r}) \\ i\,Q_a(r)\,\Omega_{-\kappa\mu}(\hat{r}) \end{pmatrix},
\qquad \int_0^\infty \left(P_a^2 + Q_a^2\right) \mathrm{d}r = 1,
$$
with the large component $P(r) = r g(r)$ given in //G// and the small component $Q(r) = r f(r)$ given in //F//. The operator is diagonal in $\kappa$ and $\mu$ and couples orbitals of the same $\kappa$, for example 1s and 2s:
$$
\langle a|h_D|b\rangle = \delta_{\kappa_a\kappa_b}\delta_{\mu_a\mu_b}\int_0^\infty \left[ P_a V_N P_b + Q_a \left(V_N - 2c^2\right) Q_b + c\left(P_a' Q_b + Q_a P_b'\right) + \frac{c\,\kappa}{r}\left(P_a Q_b + Q_a P_b\right) \right] \mathrm{d}r.
$$
###
===== Input =====
* //NF// : Integer, the number of fermionic modes (spin-orbitals) in the one particle basis.
* //Z// : Real, the nuclear charge. A non-integer charge is allowed. Modified in 0.9.1
* //indices// : Table, for every orbital the list of its $2|\kappa|$ fermion indices, from $\mu = -j$ to $\mu = j$, and the field //kappas// with the $\kappa$ of every orbital. //[[documentation:language_reference:functions:createatomicindiceslist|CreateAtomicIndicesList]](labels, { {"Kappas", true} })// makes this table from the orbital labels, for example //Atom.Labels//.
* //G// : Table, the large components $P(r)$ of the orbitals, interpolating functions in the order of //indices//.
* //F// : Table, the small components $Q(r)$ of the orbitals, in the same order.
* Options : (optional) A table of options, only for radial functions of type //"DKBSpline"// (see below). The options give the model of the nucleus, as for //[[documentation:language_reference:functions:calculateatomicbasisfunctions|CalculateAtomicBasisFunctions()]]//; //Atom.Nucleus// of that function is such a list, so that the operator has the nucleus the functions were calculated with. Possible options are: New in 0.9.1
* //"Nucleus"// : String, the model of the nucleus: //"Point"// (default), //"Gaussian"//, //"Uniform"// (a homogeneously charged sphere), //"Fermi"//, //"Function"// or //"Function3D"//. Note that the default differs from that of //CalculateAtomicBasisFunctions()//, which is //"Gaussian"//.
* //"A"// : Real, the mass number. The radius of the nucleus is then $R_{\mathrm{rms}} = (0.836 A^{1/3} + 0.570)$ fm. A //"Gaussian"//, //"Uniform"// or //"Fermi"// nucleus needs //"A"// or //"Rrms"//.
* //"Rrms"// : Real, the root-mean-square radius of the nucleus in bohr, in place of //"A"//.
* //"FermiThickness"// : Real, the skin thickness of the Fermi nucleus in bohr. Default value is 2.30 fm.
* //"Density"// : Function, the charge density of the nucleus (charge per volume) for //"Function"// ($\rho(r)$) and //"Function3D"// ($\rho(x,y,z)$). It is rescaled to the charge //Z//. Of a //"Function3D"// nucleus only the spherical part enters the Dirac operator; the rest is the operator //[[documentation:standard_operators:nuclear_multipole|NewOperator("NuclearMultipole", ...)]]//.
* //"DensityTolerance"// : Real, a warning is printed when the charge of //"Density"// differs from //Z// by more than this, relative. Default value is $10^{-10}$.
* //"NucleusLmax"//, //"NucleusNTheta"//, //"NucleusNPhi"// : Integers, the multipole expansion of a //"Function3D"// nucleus, see //[[documentation:standard_operators:nuclear_multipole|NewOperator("NuclearMultipole", ...)]]//.
===== Output =====
* O : Operator, the one-particle Dirac operator, real.
===== Radial functions =====
###
The operator is calculated in one of two ways, depending on the type of the interpolating functions in //G// and //F//.
###
* Functions of type //"DKBSpline"//, from //[[documentation:language_reference:functions:calculateatomicbasisfunctions|CalculateAtomicBasisFunctions()]]//: the matrix elements are calculated exactly on the B-spline basis of the atom, without a radial grid, for the nucleus given by the options. For the orbitals of a bare nucleus and //Atom.Nucleus// the operator is diagonal, with the orbital energies on the diagonal (see the examples). All functions must come from the same call (one set of knots), and //PhysicalConstants.cAU.value// must not change between that call and //NewOperator//; otherwise an error is raised. New in 0.9.1
* Other interpolating functions, for example from //[[documentation:language_reference:functions:readfplobasisfunctions|ReadFPLOBasisFunctions()]]//: the integrals are taken numerically on the points of //G[1]// with a point nucleus $-Z/r$. The accuracy is then limited by the spacing of these points (the error decreases as its square). The option //"Nucleus"// is not possible for these functions.
===== Speed of light =====
;;#
Modified in 0.9.1
;;#
###
The speed of light is $c$ = //PhysicalConstants.cAU.value// = 137.035999177 (CODATA 2022), read when the operator is created; up to version 0.9.0 it was 137.0. A script can change //PhysicalConstants.cAU.value//, for example to approach the nonrelativistic limit. For functions of type //"DKBSpline"// the value must then be set before //CalculateAtomicBasisFunctions()// is called, since these functions depend on $c$.
###
===== Example =====
;;#
New in 0.9.1
;;#
###
The orbitals of a bare nucleus (a hydrogen-like ion) are the eigenfunctions of the Dirac operator. For a point nucleus the diagonal elements equal the energies of the Dirac formula
$$
E_{n\kappa} = c^2\left[1 + \left(\frac{Z/c}{n - |\kappa| + \sqrt{\kappa^2 - Z^2/c^2}}\right)^{2}\right]^{-1/2} - c^2 .
$$
###
==== Input ====
-- the Dirac operator of a bare nucleus (a hydrogen-like ion) against the Dirac formula
Z = 50
G, F, Atom = CalculateAtomicBasisFunctions(Z, {{"Configuration", "1s0 2s0 2p0"}, {"Nucleus", "Point"}})
indices, NF = CreateAtomicIndicesList(Atom.Labels, {{"Kappas", true}})
H0 = NewOperator("Dirac", NF, Z, indices, G, F) -- a point nucleus without options
c = PhysicalConstants.cAU.value
M = OperatorToMatrix(H0)
for i, orb in ipairs(Atom.Orbitals) do
local k = indices[i][1] + 1
local gamma = math.sqrt(orb.kappa^2 - (Z/c)^2)
local exact = c^2/math.sqrt(1 + (Z/c/(orb.n - math.abs(orb.kappa) + gamma))^2) - c^2
print(string.format("%-6s = %.10f Dirac formula %.10f Hartree", orb.Label, M[k][k], exact))
end
1s1/2 = -1294.6261491231 Dirac formula -1294.6261491231 Hartree
2s1/2 = -326.4948040415 Dirac formula -326.4948040415 Hartree
2p1/2 = -326.4948040415 Dirac formula -326.4948040415 Hartree
2p3/2 = -315.1443548105 Dirac formula -315.1443548105 Hartree
###
The second example shows the role of the options. The functions of a bare lead nucleus are calculated with the default nucleus of //CalculateAtomicBasisFunctions()//, a Gaussian nucleus of $^{208}$Pb. With //Atom.Nucleus// as options the Dirac operator has the same nucleus, and its diagonal elements are the orbital energies. Without options the operator has a point nucleus: its diagonal elements are then the energies of the same functions in the field of a point nucleus. They are lower, most of all for the $s_{1/2}$ and $p_{1/2}$ orbitals, which have a large density at the nucleus.
###
==== Input ====
-- the 1s, 2s and 2p functions of a bare lead nucleus, with a Gaussian nucleus of 208Pb (the default)
Z = 82
G, F, Atom = CalculateAtomicBasisFunctions(Z, {{"Configuration", "1s0 2s0 2p0"}})
indices, NF = CreateAtomicIndicesList(Atom.Labels, {{"Kappas", true}})
for _, option in ipairs(Atom.Nucleus) do print(option[1], option[2]) end
-- the Dirac operator with the nucleus of the atom and with a point nucleus (no options)
Mfinite = OperatorToMatrix(NewOperator("Dirac", NF, Z, indices, G, F, Atom.Nucleus))
Mpoint = OperatorToMatrix(NewOperator("Dirac", NF, Z, indices, G, F))
for i, orb in ipairs(Atom.Orbitals) do
local k = indices[i][1] + 1
print(string.format("%-6s energy %.8f Gaussian nucleus %.8f point nucleus %.8f Hartree",
orb.Label, orb.Energy, Mfinite[k][k], Mpoint[k][k]))
end
Nucleus Gaussian
Rrms 0.0001043751188888
1s1/2 energy -3730.58142854 Gaussian nucleus -3730.58142854 point nucleus -3732.63192638 Hartree
2s1/2 energy -957.25337765 Gaussian nucleus -957.25337765 point nucleus -957.60902932 Hartree
2p1/2 energy -957.64455819 Gaussian nucleus -957.64455819 point nucleus -957.67525551 Hartree
2p3/2 energy -860.20158333 Gaussian nucleus -860.20158333 point nucleus -860.20158371 Hartree
###
For a point nucleus the operator is linear in $Z$: $h_D(Z) = h_D(0) - Z/r$. The difference of two Dirac operators therefore gives the operator $1/r$, here for the Dirac-Fock orbitals of Ne. Its diagonal elements are the expectation values $\langle r^{-1} \rangle$ that //CalculateAtomicBasisFunctions()// returns.
###
==== Input ====
-- the operator is linear in Z, h(Z) = T - Z/r for a point nucleus, so h(0) - h(1) = 1/r
G, F, Atom = CalculateAtomicBasisFunctions(10, {{"Nucleus", "Point"}}) -- Ne, Dirac-Fock
indices, NF = CreateAtomicIndicesList(Atom.Labels, {{"Kappas", true}})
rinv = NewOperator("Dirac", NF, 0, indices, G, F) - NewOperator("Dirac", NF, 1, indices, G, F)
M = OperatorToMatrix(rinv)
for i, orb in ipairs(Atom.Orbitals) do
local k = indices[i][1] + 1
print(string.format("%-6s <1/r> = %.10f RExpectation[-1] = %.10f bohr^-1", orb.Label, M[k][k], orb.RExpectation[-1]))
end
1s1/2 <1/r> = 9.6427570146 RExpectation[-1] = 9.6427570146 bohr^-1
2s1/2 <1/r> = 1.6370756395 RExpectation[-1] = 1.6370756395 bohr^-1
2p1/2 <1/r> = 1.4390137783 RExpectation[-1] = 1.4390137783 bohr^-1
2p3/2 <1/r> = 1.4346030588 RExpectation[-1] = 1.4346030588 bohr^-1
###
For the many-electron Hamiltonian of an atom, with the Coulomb interaction added, see the examples of //[[documentation:standard_operators:atomic_coulomb_repulsion|NewOperator("AU", ...)]]// and //[[documentation:language_reference:functions:newoperator|NewOperator()]]//.
###
===== Table of contents =====
{{indexmenu>.#1|msort}}