{{indexmenu_n>13}} ====== Atomic coulomb repulsion ====== ;;# Modified in 0.9.1 ;;# ### NewOperator("AtomicU",NF,indices,RadialWavefunctions1,RadialWavefunctions2,options) calculates the full Coulomb interaction operator between all given atomic orbitals. NewOperator("AtomicU",NF,indices,RadialWavefunctions1,RadialWavefunctions2,kappas1,kappas2,options) calculates only the interaction between the orbitals in kappas1 and kappas2. Together with the one-electron //[[documentation:standard_operators:dirac_operator|Dirac operator]]// it gives the relativistic many-electron Hamiltonian of an atom. ### ===== Input ===== * NF : the number of fermionic modes (spin-orbitals) in the 1-particle basis * indices : indices of atomic orbitals belonging to the radial wave-functions * RadialWavefunctions1 : table of InterpolatingFunction objects * RadialWavefunctions2 : optional - table of InterpolatingFunction objects - if given, the function calculates relativistic Slater integrals where RadialWavefunctions1 are the large parts and RadialWavefunctions2 the small ones * kappas1, kappas2 : optional - tables of the quantum numbers $\kappa$ of the core orbitals (the first orbitals of indices) and of the valence orbitals (the others). Only the direct and exchange interaction between one core and one valence electron is calculated. * options : possible Options are {"conserve", bool} and {"1P-Operator", bool} * "conserve" : (default false) if true only the Slater integrals that conserve the occupation of every orbital are calculated, the direct and exchange integrals $(ab|ab)$ and $(ab|ba)$. Without kappas1 and kappas2 only. * "1P-Operator" : (default true) with kappas1 and kappas2 only. If true the core-valence interaction is returned as the one particle operator it is when the core is filled, the Hartree-Fock potential of the core acting on the valence orbitals (see the second example). If false the two particle core-valence interaction is returned. For radial functions on a grid the core orbitals must also have the lowest fermion indices, 0 to the number of core spin-orbitals minus 1. ;;# New in 0.9.1 ;;# ### The radial wave-functions can be read from FPLO with //ReadFPLOBasisFunctions()//, or calculated with //[[documentation:language_reference:functions:calculateatomicbasisfunctions|CalculateAtomicBasisFunctions()]]//. For the functions of //CalculateAtomicBasisFunctions()// the Slater integrals are calculated exactly on the B-spline basis of the atom, without a radial grid (see the second example). All functions must then come from the same call. ### ===== Example ===== ;;# New in 0.9.1 ;;# ### The example below shows how to create the full Coulomb interaction between multiple atomic orbitals with relativistic wave-functions. It is recommended to use CreateAtomicIndicesList(orbitallabels,{ {"Kappas",true} }) for index creation, since it automatically calculates the quantum numbers kappa and stores them in the field ind.kappas which needs to be set when calling NewOperator("AtomicU",...) with relativistic wave-functions. ### ==== Input ==== -- the Coulomb interaction of the electrons of Ne on its own Dirac-Fock orbitals G, F, Atom = CalculateAtomicBasisFunctions(10) ind, NF = CreateAtomicIndicesList(Atom.Labels, {{"Kappas", true}}) U = NewOperator("AU", NF, ind, G, F) psi = NewWavefunction(NF, 0, { {string.rep("1", NF), 1} }) print(string.format(" = %.8f Hartree, Edirect + Eexchange = %.8f Hartree", psi*U*psi, Atom.Edirect + Atom.Eexchange)) = 54.08660432 Hartree, Edirect + Eexchange = 54.08660432 Hartree ### The second example calculates the interaction of the electrons in the 3d and 4s orbitals of Fe with its [Ar] core. With the core filled this is a one particle operator, the Hartree-Fock potential of the core. For a state with the core filled and one valence electron, the full Coulomb interaction gives the same energy plus the interaction within the core. ### ==== Input ==== -- the Hartree-Fock potential of the [Ar] core of Fe on its 3d and 4s orbitals G, F, Atom = CalculateAtomicBasisFunctions(26) ind, NF = CreateAtomicIndicesList(Atom.Labels, {{"Kappas", true}}) NCore = 7 -- 1s, 2s, 2p1/2, 2p3/2, 3s, 3p1/2, 3p3/2 kappasCore, kappasValence = {}, {} for i = 1, #ind do if i <= NCore then kappasCore[i] = ind.kappas[i] else kappasValence[i - NCore] = ind.kappas[i] end end U = NewOperator("AU", NF, ind, G, F) Ucore = NewOperator("AU", NF, ind, G, F, kappasCore, kappasValence) -- the core filled, without and with one valence electron core = {} for i = 1, NCore do for _, k in ipairs(ind[i]) do core[k + 1] = true end end function Determinant(extra) local s = {} for k = 1, NF do s[k] = (core[k] or k == extra + 1) and "1" or "0" end return NewWavefunction(NF, 0, {{table.concat(s), 1}}) end psiCore = Determinant(-1) for i = NCore + 1, #ind do psi = Determinant(ind[i][1]) print(string.format("%-6s - = %.10f = %.10f Hartree", Atom.Labels[i], psi*U*psi - psiCore*U*psiCore, psi*Ucore*psi)) end 3d3/2 - = 19.2150519829 = 19.2150519829 Hartree 3d5/2 - = 19.1391273600 = 19.1391273600 Hartree 4s1/2 - = 6.8098698278 = 6.8098698278 Hartree ===== Table of contents ===== {{indexmenu>.#1|msort}}