{{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}}