Table of Contents
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 CalculateAtomicBasisFunctions(). Together with the Coulomb interaction of 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. 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 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 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 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 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 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
- Example.Quanty
-- 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 <h_D> = %.10f Dirac formula %.10f Hartree", orb.Label, M[k][k], exact)) end
- Example.out
1s1/2 <h_D> = -1294.6261491231 Dirac formula -1294.6261491231 Hartree 2s1/2 <h_D> = -326.4948040415 Dirac formula -326.4948040415 Hartree 2p1/2 <h_D> = -326.4948040415 Dirac formula -326.4948040415 Hartree 2p3/2 <h_D> = -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
- Example.Quanty
-- 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 <h_D> Gaussian nucleus %.8f point nucleus %.8f Hartree", orb.Label, orb.Energy, Mfinite[k][k], Mpoint[k][k])) end
- Example.out
Nucleus Gaussian Rrms 0.0001043751188888 1s1/2 energy -3730.58142854 <h_D> Gaussian nucleus -3730.58142854 point nucleus -3732.63192638 Hartree 2s1/2 energy -957.25337765 <h_D> Gaussian nucleus -957.25337765 point nucleus -957.60902932 Hartree 2p1/2 energy -957.64455819 <h_D> Gaussian nucleus -957.64455819 point nucleus -957.67525551 Hartree 2p3/2 energy -860.20158333 <h_D> 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
- Example.Quanty
-- 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
- Example.out
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 NewOperator("AU", ...) and NewOperator().
Table of contents
-