Atomic interaction strength
JenaAtomicCalculator.InteractionStrength.XLCache — Type
struct InteractionStrength.XLCache ... memoises the effective interaction strengths X^L(abcd) of ONE matrix.
WHY THIS IS A PARAMETER AND NOT A GLOBAL. Within a single CI matrix the same rank and subshell quadruple recur across many CSF
pairs, so the double radial integral is worth doing once. But the key holds subshell LABELS, and labels identify orbitals only
within one basis: two bases can both contain a "2s_1/2" whose radial functions differ entirely. Until 15-Aug-2026 the store was a
module global wiped by whoever built a matrix -- `Hamiltonian.performCI`, `performCIKinkAware` and
`Basics.compute(::CImatrixWithSymmetryJP)` each called an `XL_*_reset_storage` some 200 lines from
the fill -- so the key was unambiguous only because of a promise made in another module, which nothing checked and no signature
mentioned.
Handing the cache to the function that fills it makes that promise a fact: the cache is created by the matrix builder and goes out
of scope when the matrix is finished, so it CANNOT outlive the basis whose labels it uses. It also makes concurrent matrix builds
safe by construction, since two matrices cannot share a cache that neither of them owns.
This is the pattern JAC already uses elsewhere -- `Bsplines.setupLocalMatrix` and
`generateTTpMatrix!` take a `storage::Dict`, `RadialIntegrals.ScreenedPotentialCache` is built and
passed, and the EOL solver threads its own `cache1p`/`cache2p` -- so the XL_* strengths were the one remaining place that kept its
memo out of sight.
+ values ::Dict{XLKey, Float64} ... the memoised strengths.JenaAtomicCalculator.InteractionStrength.XLCache — Method
InteractionStrength.XLCache() ... constructor for an empty cache of interaction strengths; a cache::InteractionStrength.XLCache is returned.
JenaAtomicCalculator.InteractionStrength.XLCoefficient — Type
struct InteractionStrength.XLCoefficient ... defines a type for coefficients of the two-electron (Breit) interaction
+ kind ::Char ... Kind of integral, either 'S' or 'T'
+ nu ::Int64 ... Rank of the integral.
+ a ::Orbital ... Orbitals a, b, c, d.
+ b ::Orbital
+ c ::Orbital
+ d ::Orbital
+ coeff ::Float64 ... corresponding coefficient.JenaAtomicCalculator.InteractionStrength.XLKey — Type
const InteractionStrength.XLKey ... the key under which one interaction strength is memoised: (route, L, a, b, c, d, factor, quadrature), where the four Subshells are those of the orbitals a, b, c, d.
THE ROUTE IS PART OF THE KEY, which is why ONE cache serves every X^L. `XL_Coulomb`,
`XL_CoulombKinkAware` and `XL_Breit` all answer the same kind of question -- a strength for rank L
and four orbitals, asked for by a spin-angular coefficient -- so what separates them belongs here rather than in three separate
dictionaries. `route` is one of :Coulomb, :CoulombKinkAware, :Gaunt or :Breit, and `factor` carries the photon-frequency scaling of
CoulombBreit(factor); it is 0. for every route that has none. `quadrature` is :direct or :swept and carries the two ways of
evaluating a
Breit radial integral -- the same physics by a different summation, so they must not share a memo; it is :direct for every route
that
offers no choice. IT WAS ADDED 04-Sep-2026 AND THE KEY TYPE HAD TO BE WIDENED WITH IT: XLKey is a CONCRETE tuple type, so a key of
the
wrong arity fails at the `setindex!`, deep inside the CI build and ONLY on the cached path -- which is exactly the path a probe that
calls XL_Breit directly does not exercise.
`Subshell` is a plain immutable struct of two Int64 fields, so Julia hashes it structurally and it
enters the key directly -- there is no string to build, and none to read back when debugging.JenaAtomicCalculator.InteractionStrength.MabEmission — Method
InteractionStrength.MabEmission(mp::EmMultipole, gauge::EmGauge, omega::Float64, a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the single-electron reduced matrix element <a || O^(Mp, emission) || b> of the electron-photon multipole interaction, for the multipole mp of the radiation field at photon energy omega and in the given gauge. A value::Float64 is returned.
THE ONE VERSION. Introduced 09-Aug-2026 to replace a family of seven variants that had accumulated along historical routes --
MabEmissionJohnsony, MabEmissionJohnsony_Wu, MbaEmissionJohnsonx, MbaEmissionCheng, MbaAbsorptionCheng, MbaEmissionAndreyOld and
MbaEmissionMigdalek -- which differed in normalisation, in return type, in sign and in argument order, so that amplitudes computed
through different ones could not be added.
ARGUMENT ORDER: the orbitals are passed in the order they appear, `MabEmission(..., a, b, ...)` returning <a || O || b>. Until
03-Sep-2026 the two were declared the other way round, so that the SECOND argument was the one on the left; the signature was
turned round and every call site swapped in the same commit, which changes no number. The old arrangement needed a paragraph of
prose to explain it, and prose that reads like physics but is really about a parameter list is worse than no prose.
THE MULTIPOLE CHOOSES THE OPERATOR AND THE GAUGE ONLY ITS FORM. `mp.electric` alone decides whether the electric or the magnetic
strength is returned, so a magnetic multipole is answered with M_L under ANY gauge -- it has a single form, and `Magnetic` therefore
states nothing that `mp` has not already stated -- while an ELECTRIC multipole under `Magnetic` RAISES, that being the one pairing
with no reading. This lets a caller sweep the electric gauges over a MIXED list of multipoles, as the two-photon modules do, without
each of them having to re-derive the rule; `module-Hfs.jl` and `module-PhotoEmission.jl` had each derived it separately.
THE GAUGES, following Grant, J. Phys. B 7, 12 (1974): `Coulomb` is the velocity form and `Babushkin` the length form of the electric
multipole operator; `Magnetic` is the single form of a magnetic one. For exact one-body eigenfunctions the two electric forms must
agree
at the physical photon energy, and here they do -- H 1s-2p gives Coulomb/Babushkin = 1.000000 on shell. Away from that energy they
legitimately differ: the length form scales with the omega it is given, while the velocity form carries the level difference through
<f|p|i> = i m (E_f - E_i) <f|r|i>, so an OFF-SHELL call is not gauge invariant and must not be expected to be.
THE VALUE IS REAL, and this deserves a word because the literature usually writes it as complex. The Racah phase of the angular
factor is (-1)^(j_b + 1/2); j_b is half-integer, so that exponent is an integer and the phase is +-1, alternating with j_b. Until
09-Aug-2026 `AngularMomentum.JohnsonI` raised (-1+0im) to `jb.num + 1/2`, i.e. to a HALF-integer, which returned a constant -i for
every j_b: it turned every matrix element imaginary and, worse, discarded the alternating sign. With that corrected the quantity is
real, as it should be. Any overall factor i that a given convention prefers is a global phase and cancels from every observable; the
j-dependent sign does NOT cancel and is carried here.
WHAT IS INSIDE, AND WHAT THE CALLER MUST SUPPLY. This function returns the SINGLE-ELECTRON reduced matrix element and nothing else.
A many-electron amplitude is assembled by the caller as
amplitude = sum_(r,s) c_r c_s sum_coeff coeff.T * MabEmission(...) / sqrt(2j_a+1) * sqrt(2J_f+1)
with the angular coefficients from SpinAngular and the CI mixing coefficients. NO FURTHER MULTIPOLARITY FACTOR IS TO BE APPLIED: a
factor sqrt((2L+1)(L+1)/L) appears commented out at the PhotoEmission call site, and it is commented out CORRECTLY -- restoring it
would multiply E1 by 2.449 and E2 by 2.739 and destroy the agreement documented below.
VALIDATED, and additive across multipoles. Against Jitrik & Bunge, J. Phys. Chem. Ref. Data 33, 1059 (2004), hydrogen Z = 1,
point-nucleus Dirac -- the same model as the test:
transition JAC A(Cou) JAC A(Bab) reference ratio
E1 1s-2p_1/2 6.268354e+08 6.268020e+08 6.2649e+08 1.000498
M1 1s-2s_1/2 2.481059e-06 2.481059e-06 2.4946e-06 0.994572
E2 1s-3d_3/2 5.940766e+02 5.940251e+02 5.937500e+02 1.000463
The three ratios agree with one another, which is the statement that E1, M1 and E2 amplitudes computed through this function stand
on a common footing and may be added as they occur in the full electron-photon interaction.
**THE `eps` ORIENTATION BELOW, AND WHAT IT DOES AND DOES NOT AFFECT -- MEASURED 15-Oct-2026.** The
Babushkin branch settles the orientation of its length-form expression from the ORBITAL ENERGIES,
`eps = a.energy <= b.energy`, which is a PROXY for which orbital plays which role. It is exact for an ordinary
transition, where the more strongly bound orbital is also the final state. Inside a SECOND-ORDER sum the
intermediate orbital may be either more or less bound than the initial one, so the two factors of a chain can
receive OPPOSITE orientations -- which is what `MultiPhotonTransition`'s two-photon emission sum does.
**AND THAT TURNS OUT NOT TO MATTER FOR A CONVERGED SUM, WHICH IS WORTH KNOWING BEFORE ANYONE "FIXES" IT.**
For H 2s -> 1s at n_max = 60, the shipped mixed assignment and all four forced combinations (+-1, +-1) agree
to 2e-5 AND ALL REPRODUCE the exact 8.22906 /s, with the Coulomb value identical throughout (eps is
Babushkin-only, so that is the control). A complete sum is a physical object and cannot depend on this.
**WHERE IT DOES BITE IS A SEVERELY TRUNCATED SUM**, and there neither gauge means anything anyway: a
bound-only intermediate set captures about 15 % of this rate in the Coulomb gauge, and over such a set the
Babushkin value moves by a factor 8 between Z = 1 and Z = 2. **So a gauge ratio taken from a truncated
two-photon basis is NOT evidence about this function** -- converge the intermediate space first.
Do not, in any case, replace the test below by a constant: that breaks four test modules (Einstein,
PhotoEmission, PhotoExcitation, Empirical), because a MANY-electron amplitude sums over SUBSHELL pairs whose
binding order does not follow the levels' roles, and there the energy test is doing real work.
`DalgarnoLewis.amplitudeKernel` is this branch with the orientation fixed at +1, valid because its own callers
never swap which argument plays which role; it is the right choice where a caller can guarantee that, and it
is not a general-purpose replacement for this function.
THE COULOMB GAUGE IS STRUCTURALLY ZERO FOR A DIAGONAL ELECTRIC MULTIPOLE, i.e. whenever the two orbitals belong to the SAME subshell
and hence kapa == kapb. The Coulomb branch below is built only from I^+ and I^-, and there both die at once: the prefactor
(kapa-kapb) vanishes, and I^-(a,a) = int j_L (P_a Q_a - Q_a P_a) dr is identically zero. The Babushkin branch keeps J_L = int j_L
(P_a^2 + Q_a^2) dr and stays finite. This is not a defect of either branch: the velocity form of an electric multipole between two
states built on the same orbital vanishes at the one-body level, and the amplitude of a transition INSIDE one configuration (2p^4
1S_0 - 1D_2, say) is carried entirely by the length form. Use Babushkin for such transitions, and do not read the resulting
Coulomb/Babushkin ratio as a gauge-consistency check -- there is nothing there to compare. The magnetic branch is unaffected, since
it carries (kapa+kapb) = 2*kappa and I^+(a,a) != 0; that is why M1 fine-structure rates inside a term come out right to a few parts
in 1000.JenaAtomicCalculator.InteractionStrength.XL_Breit — Method
InteractionStrength.XL_Breit(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, eeint::Union{BreitInteraction, CoulombBreit, CoulombGaunt}, cache::InteractionStrength.XLCache) ... as XL_Breit without a cache, but memoising the result in the given cache. A value::Float64 is returned.
THE KEY CARRIES THE ROUTE AND THE FACTOR, which the former global store did not: it was keyed on rank and subshells alone, so a
CoulombGaunt() strength and a CoulombBreit(1.) strength for the same four orbitals would have collided. That was latent rather than
live, since one matrix build uses a single settings.eeInteractionCI -- but it is exactly the kind of promise this cache no longer
needs to make. See InteractionStrength.XLCache.JenaAtomicCalculator.InteractionStrength.XL_Breit — Method
InteractionStrength.XL_Breit(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, eeint::Union{BreitInteraction, CoulombBreit, CoulombGaunt}) ... computes the effective Breit interaction strength X^LBreit (abcd), or the Gaunt strength X^LGaunt (abcd) for eeint = CoulombGaunt(), for given rank L and orbital functions a, b, c and d at the given grid. A value::Float64 is returned. The factor of CoulombBreit(factor) scales the photon wave number omega = factor |Ea - Ec| / c, so factor = 0 gives the frequency-independent interaction as the exact limit of the same expressions; see the reference formulation heading this section. To memoise the result, use the method that additionally takes an InteractionStrength.XLCache.
THE BREIT INTERACTION IN JAC -- THE REFERENCE FORMULATION
Written 13-Aug-2026 as Stage 1 of the frequency-dependent Breit work, BEFORE any code was changed, so
that the implementation below can be checked against a statement of the physics rather than against
itself.
PROVENANCE, STATED HONESTLY: the standard references are Grant & Pyper, J. Phys. B 9, 761 (1976) and
Grant, "Relativistic Quantum Theory of Atoms and Molecules" (2007), ch. 8. THIS BLOCK WAS NOT
TRANSCRIBED FROM THEM -- it is written from recollection of the standard formulation, cross-checked
against secondary sources only. It must therefore be checked against the primary texts by someone who
has them before any number produced from it is trusted. Where it has been confirmed NUMERICALLY, that
is said at the point in question.
1. THE OPERATOR. Exchange of one transverse photon of frequency omega between electrons 1 and 2, in the
COULOMB GAUGE:
B(omega) = - (alpha_1 . alpha_2) cos(omega r_12) / r_12
+ (alpha_1 . grad_1)(alpha_2 . grad_2) [cos(omega r_12) - 1] / (omega^2 r_12)
The second term is finite as omega -> 0 only through a cancellation: [cos(x) - 1]/x^2 -> -1/2.
2. UNITS OF omega -- AND A DEFECT. omega is a WAVE NUMBER, not an energy. In atomic units
omega = |E_a - E_c| / c, c = 137.036 ,
so that omega*r is the dimensionless phase the Bessel functions below require. Retardation is small
precisely because omega*r ~ (Delta E) r / c << 1 for atomic transitions.
XL_Breit_densities below formed omg_ac = factor * abs(E_a - E_c) and NEVER DIVIDED BY c until
13-Aug-2026, feeding an energy in Hartree into sf_bessel_jl(nu, omega*r) as if it were a wave number
and overstating the phase by c = 137. FIXED. It never affected a published number, since no branch
consumed those values (see point 6).
3. THE TWO omega -> 0 LIMITS ARE DIFFERENT OPERATORS, AND THE DIFFERENCE IS A GAUGE CHOICE.
Coulomb gauge, omega -> 0: B = - 1/(2 r_12) [ alpha_1.alpha_2 + (alpha_1.rhat)(alpha_2.rhat) ]
... the BREIT operator -> JAC: CoulombBreit(0.)
Feynman gauge, omega -> 0: G = - alpha_1.alpha_2 / r_12
... the GAUNT operator -> JAC: CoulombGaunt
These are NOT the same approximation. The total one-photon exchange is gauge independent; truncating
at omega -> 0 is what breaks that, which is why two gauges leave two different instantaneous operators.
The retardation correction to instantaneous Gaunt is O(alpha^2) -- LARGER than the omega-independent
Coulomb-gauge term itself. A user choosing CoulombGaunt over CoulombBreit(0.) is therefore making an
undocumented gauge choice, and the frequency dependence does NOT vanish in either gauge.
4. MULTIPOLE DECOMPOSITION. XL_Breit_coefficients splits the operator into two families, and this split
IS the Gaunt/retardation split (onlyGaunt returns after the 'T' blocks):
'T' (magnetic / GAUNT) nu = L-1, L, L+1, four mu permutations each
'S' (RETARDATION) nu = L +- 1
The many-electron angular factors are NOT computed here: they come from SpinAngular as
Coefficient2p(nu, a, b, c, d, V), and the CI matrix forms V * XL_Breit(nu, ...). The coefficients
below belong to the OPERATOR, not to the CSFs.
5. THE RADIAL KERNELS. The two kinds enter DIFFERENTLY, which is easy to get wrong:
Gaunt / 'T': the static kernel Ubar_nu = r_<^nu / r_>^(nu+1) times a FREQUENCY FACTOR
V_nu = -omega (2nu+1) j_nu(omega r_<) y_nu(omega r_>) -> 1 as omega -> 0.
Retardation / 'S': the kernel W_(L-1,L+1,L) of Grant & Pyper equation (6) IN FULL -- it is not a
factor on Ubar_nu, and for r_1 < r_2 it is a difference of two 1/omega^2-
divergent pieces, which is the whole numerical difficulty.
Both are evaluated through the normalised phi, psi of besselPhiPsi, so the cancellations are taken
ALGEBRAICALLY and each kernel reaches its omega -> 0 limit by construction rather than by a special case.
See the closures V() and W() in XL_Breit_densities for the derivations and their verification.
MEASURED 13-Aug-2026, on the forms that stood here before: V() omitted the leading factor omega
(V*omega/static -> 1.000001 at omega = 1e-3 for nu = 1, while V/static -> 1000), and W() was equation (6)
with the omega missing from its first term AND that term's sign reversed, so its cancellation failed
outright -- neither W, W*omega nor W*omega^2 converged. Neither could ever have been switched on.
6. WHAT IS COMPUTED. Since 14-Aug-2026 both parts are frequency dependent, and the argument `factor` of
CoulombBreit(factor) does exactly what its name says: it scales omega, so that
factor = 0 -> omega = 0, the standard frequency-independent Breit interaction, recovered as the
EXACT limit of the same expressions rather than by a separate code path;
factor = 1 -> the full frequency-dependent interaction at omega = |E_a - E_c| / c.
Before that date nothing frequency dependent was computed at all: omg_ac and omg_bd were formed and then
discarded, factor == 0 taking wy = 1 and factor == 1 taking wy = 1.05, a placeholder with no derivation
that is now gone. No JAC number published before 14-Aug-2026 contains a retardation correction.
NOT included: for a given 'S' permutation only the radial ordering carried by that permutation is
summed, its transpose supplying the other. This is exact at omega = 0 and drops a term of relative
order omega^2 WITHIN the retardation -- O(omega^4) in the interaction -- since W's r_1 > r_2 branch is
itself O(omega^2). With omega ~ 1e-2 for the transitions of interest that is a ~1e-8 relative effect.
7. AUDIT OF THE ANGULAR COEFFICIENTS, 13-Aug-2026. XL_Breit_coefficients was compared TERM BY TERM against
Grant & Pyper's table 2 and against GRASP2018's rci90/cxk.f90, which implements the same table.
RESULT: THE ANGULAR DECOMPOSITION IS CORRECT. Every weight, every kappa factor and every mu ordering
agrees. In GRASP's notation DK1 = kappa_c - kappa_a, DK2 = kappa_d - kappa_b, F1..F4 = DK -+ K,
G1..G4 = DK -+ (K+1), H = the two CL reduced matrix elements with the odd-L sign:
'T', nu = L : JAC -(ka+kc)(kb+kd)/(L(L+1)), equal for all mu == GRASP S(1..4) = -(KA+KC)(KD+KB)H/(K(K+1))
'T', nu = L+1 : JAC L/((L+1)(2L+1)(2L+3)), four kappa products == GRASP A = H*K/((K+1)(2K+1)(2K+3)),
G1G3, G2G4, G1G4, G2G3
'T', nu = L-1 : JAC (L+1)/(L(2L-1)(2L+1)) == GRASP A = H*(K+1)/(K(2K+1)(2K-1)),
F2F4, F1F3, F2F3, F1F4
'S', all 8 mu : JAC 1/(2L+1)^2 times, in order,
F2G3, F4G1, F1G4, F3G2, F2G4, F3G1, F1G3, F4G2 == GRASP S(5), S(6), ..., S(12)
THE ONE STRUCTURAL DIFFERENCE, and it is deliberate rather than a defect: JAC emits each 'S' coefficient
TWICE, at nu = L+1 with weight +[L]/2 and at nu = L-1 with -[L]/2, [L] = 2L+1. That is precisely Grant's
STATIC LIMIT of the retardation kernel, their equations (9)-(10),
W_(nu-1,nu+1,nu) -> -(1/2)[nu] ( Ubar_(nu-1) - Ubar_(nu+1) ),
with Ubar the one-sided kernel of equation (10) -- which the r/s loop below realises by summing only
s <= r and halving the diagonal, since U = Ubar(1,2) + Ubar(2,1). Signs included, JAC matches.
CONSEQUENCE FOR THE FREQUENCY-DEPENDENT RETARDATION, AS IT STOOD ON 13-Aug-2026: it could not be switched
on by changing a multiplier, because the 'S' entries carried the static limit inside their coefficients.
**THAT WORK WAS DONE THE NEXT DAY AND THIS PARAGRAPH IS NO LONGER A TO-DO -- corrected 04-Sep-2026, after
it was read at face value and nearly acted on.** Since 14-Aug-2026 (commit 7c82e45) each mu emits a
SINGLE entry carrying the multipole L itself and the bare coefficient xcc, and the whole kernel
W_(L-1,L+1,L) of equation (6) is supplied by XL_Breit_densities; see the comment at the 'S' block of
XL_Breit_coefficients, which records the collapse and why no extra prefactor is needed. The eight mu
terms are four TRANSPOSED PAIRS, matching the two-term W(1,2) / W(2,1) structure of equation (8).
SO THERE IS NO OUTSTANDING ALGEBRA HERE, and the term count is not padding: the 'T' blocks at
nu = L-1, L, L+1 are three distinct tensor ranks and the eight 'S' mu terms are Grant's table 2 in full.
The only genuine redundancy was entries sharing (kind, nu, a, b, c, d), which differ by a scalar alone;
XL_Breit_densitiesSwept sums those coefficients and sweeps once (commit 94df5bc, 11.94 -> 7.15
sub-coefficients per strength). Measured 04-Sep-2026, generating the coefficients is ~1 % of a swept
Breit strength, so there is no speed argument for touching this decomposition either.JenaAtomicCalculator.InteractionStrength.XL_BreitDamped — Method
InteractionStrength.XL_BreitDamped(tau::Float64, L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, eeint::Union{BreitInteraction, CoulombBreit, CoulombGaunt}) ... computes the effective Breit interaction strength X^LBreit (abcd) for given rank L and orbital functions a, b, c and d at the given grid, with the radial integrand damped by exp(-tau r1 - tau r2) as the DampedSpaceCI Green function approach requires. A value::Float64 is returned. This is XLBreit with that one factor added, so it follows the same gauge, the same frequency dependence and the same coefficients; see XL_Breit and the reference formulation heading this section.
UNTIL 14-Aug-2026 the body of this function was `error("stop a")`, and its signature took SEVEN arguments while its only caller --
the Breit branch of Basics.computeMultipletForGreenApproach for AtomicState.DampedSpaceCI -- passed EIGHT. The path therefore raised
a MethodError before it could even reach the stub. It had never been noticed because every use of DampedSpaceCI in the examples and
in the suite selects a Coulomb-only e-e interaction, so that branch was never taken.JenaAtomicCalculator.InteractionStrength.XL_Breit_coefficients — Method
InteractionStrength.XL_Breit_coefficients(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital; onlyGaunt::Bool=false) ... evaluates the combinations and pre-coefficients of the Breit interaction X^L_Breit(abcd) for given rank L and orbital functions a, b, c and d; a list xcList::Array{XLCoefficient,1} is returned.
THESE COEFFICIENTS ARE FREQUENCY INDEPENDENT and are correct for both cases: the omega dependence enters only through the radial
kernels in XL_Breit_densities, not here. The list splits into kind = 'T' (magnetic / GAUNT, nu = L-1, L, L+1) and kind = 'S'
(RETARDATION, nu = L+-1); onlyGaunt returns after the 'T' blocks, so that split IS the Gaunt/retardation split.JenaAtomicCalculator.InteractionStrength.XL_Breit_densities — Method
InteractionStrength.XL_Breit_densities(xcList::Array{XLCoefficient,1}, factor::Float64, grid::Radial.Grid; tau::Float64=0.) ... computes the the effective Breit interaction strengths X^LBreit (abcd) for given rank L and a list of orbital functions a, b, c, d and angular coefficients at the given grid. A value::Float64 is returned. The argument factor scales the photon wave number omega = factor * |Ea - Ec| / c, so that factor = 0 gives the frequency-independent interaction as the exact limit of the same expressions; see the reference formulation heading this section. A positive tau damps the radial integrand by exp(-tau r1 - tau r_2), as the DampedSpaceCI Green function approach requires; tau = 0 is the undamped interaction and costs nothing extra.
JenaAtomicCalculator.InteractionStrength.XL_Breit_densitiesSwept — Method
InteractionStrength.XL_Breit_densitiesSwept(xcList::Array{XLCoefficient,1}, factor::Float64, grid::Radial.Grid; tau::Float64=0.) ... the same integral as XLBreitdensities, accumulated in ONE PASS over the grid instead of a full double sum. A value::Float64 is returned. Selected by CoulombBreit(factor, :swept); :direct keeps the other form.
WHY THIS IS POSSIBLE AT ALL, and it is the only idea in the function: EVERY Breit kernel factorises into a
function of r_< times a function of r_>, so the inner integral over s <= r is a RUNNING SUM and need not be
redone for each r. Term by term, with s the smaller radius:
'T' (Gaunt) V_nu(r_s,r_r) Ubar_nu = [phi_nu(omega r_s) r_s^nu] * [psi_nu(omega r_r) / r_r^(nu+1)]
'S' at omega -> 0 W = -[nu]/2 (Ubar_(nu-1) - Ubar_(nu+1)) -- TWO such products
'S' at omega > 0 W = -([nu]^2/omega^2) r_s^(nu-1) r_r^-(nu+2) (a + b + a b) -- THREE, since
a depends on r_s alone and b on r_r alone.
The cost falls from O(N^2) to O(N) per sub-coefficient. On a 595-point grid with 11.9 sub-coefficients per
strength the direct form visits 2.11 million grid points per Breit strength; this one visits some thousands.
THE BESSEL FUNCTIONS COME ALONG FOR FREE: the direct form evaluates them per (r,s) PAIR, this one per point,
which is the reuse the maintainer asked for on 04-Sep-2026 -- a corollary of separability, not a separate
optimisation. (In the STATIC case, factor = 0., neither form evaluates a Bessel function at all.)
THE DIAGONAL IS NOT PART OF THE SWEEP FOR 'S'. Grant's W is a DIFFERENT function for r_1 = r_2 than for
r_1 < r_2 -- the direct form reaches its `else` branch there -- so that single term is added separately,
which costs O(N) and keeps the two forms comparable term by term. 'T' has no such split: V is one
expression in r_< and r_>, so its diagonal is carried by the sweep with the same halved weight.
WHAT IT DOES NOT PROMISE: this is NOT bitwise identical to XL_Breit_densities, and cannot be -- the same
products are summed in a different order. It is the same integral, and the difference is the floating-point
associativity of the sum, not a change of physics. TestFrames.testMethod_BreitInteraction(), section (5), compares the two
on real orbitals in both frequency regimes; keep that test, because an unused route rots (see XL_BreitDamped, whose body was
`error("stop a")` behind a signature one argument short of its only caller, unnoticed for months).JenaAtomicCalculator.InteractionStrength.XL_Coulomb — Method
InteractionStrength.XL_Coulomb(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, cache::InteractionStrength.XLCache) ... as XL_Coulomb without a cache, but memoising the result in the given cache and returning the stored value when the same rank and subshells are asked for again. A value::Float64 is returned. See InteractionStrength.XLCache for why the cache is a parameter rather than a global.
JenaAtomicCalculator.InteractionStrength.XL_Coulomb — Method
InteractionStrength.XL_Coulomb(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid) ... computes the effective Coulomb interaction strength X^L_Coulomb (abcd) for given rank L and orbital functions a, b, c and d at the given grid. A value::Float64 is returned. To memoise the result, use the method that additionally takes an InteractionStrength.XLCache.
DO NOT BUILD ONE TRIANGLE OF AN SCF OR CI MATRIX FROM THIS FAMILY AND MIRROR IT WITHOUT VERIFYING FIRST. That optimisation was
applied to Basics.compute(::CImatrixWithSymmetryJP,...) and to Hamiltonian.setupMatrix, where it was checked empirically and is
sound, and it was deliberately NOT extended to the XL_Coulomb family: the symmetry argument LOOKS the same, but this family mixes
Subshell and Orbital roles across its methods and its derivation is not the one that was verified. Being plausible by analogy is
not the same as having been tested. Anything built on it needs its own bit-identical before/after on a real SCF, not an appeal to
the earlier result.
The two neighbouring cases are already settled and are worth knowing, because they are the reason this one looks safe and is not
established: Bsplines.setupLocalMatrix is NOT symmetric and says so in a disabled diagnostic -- the last B-spline breaks it -- and
CrystalField.computeInteractionMatrix Hermitizes with the ADJOINT as a guard against residual floating-point asymmetry, since its
two triangles are summed independently rather than mirrored.JenaAtomicCalculator.InteractionStrength.XL_Coulomb — Method
InteractionStrength.XL_Coulomb(L::Int64, a::Subshell, b::Orbital, c::Orbital, d::Subshell, primitives::Bsplines.Primitives) ... computes the (exchange) Coulomb interaction strengths X^L_Coulomb (.bc.) for given rank L and orbital functions as well as the given primitives. A (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
JenaAtomicCalculator.InteractionStrength.XL_Coulomb — Method
InteractionStrength.XL_Coulomb(L::Int64, a::Subshell, b::Orbital, c::Subshell, d::Orbital, primitives::Bsplines.Primitives) ... computes the (direct) Coulomb interaction strengths X^L_Coulomb (.b.d) for given rank L and orbital functions as well as the given primitives. A (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
JenaAtomicCalculator.InteractionStrength.XL_CoulombDamped — Method
InteractionStrength.XL_CoulombDamped(tau::Float64, L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid) ... computes the the effective Coulomb interaction strengths X^L_Coulomb (abcd) for given rank L and orbital functions a, b, c and d at the given grid. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAware — Method
InteractionStrength.XL_CoulombKinkAware(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, vkCache::Dict{Tuple{Int64,Subshell,Subshell,Int64},Vector{Float64}}) ... as the method without a cache, but passing vkCache down to RadialIntegrals.SlaterRkKinkAware so that the screened potential V_L[b,d] – the expensive part, and a function of only TWO of the four orbitals – is built once per (L, b, d, extent) instead of once per coefficient. A value::Float64 is returned.
NOT TO BE CONFUSED WITH THE `XLCache` METHOD ABOVE, WHICH KEYS ON ALL FOUR SUBSHELLS. That one memoises
the finished integral and is right for a caller that meets the same quadruple twice; it is useless where
every coefficient carries a unique quintuple, which is what the level-optimised field does -- measured
03-Sep-2026 on C-like uranium, 20 083 coefficients with 20 083 distinct quintuples and only 781 distinct
(L,b,d) triples, a redundancy of 25.7x that a quadruple key cannot see. The two caches are
complementary, not alternatives.
THE CACHE IS THE CALLER'S AND IS KEYED ON SUBSHELL LABELS, so it must not outlive the orbitals it was
built from: a caller inside an SCF iteration creates a fresh one per evaluation.JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAware — Method
InteractionStrength.XL_CoulombKinkAware(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, cache::InteractionStrength.XLCache) ... as XL_CoulombKinkAware without a cache, but memoising the result in the given cache. A value::Float64 is returned.
THE OLD DOCSTRING WARNED IN PROSE about the very thing the cache parameter now settles: caching had to be left off (keep=false) at
SelfConsistent.computeTwoElectronV's call site, because that call sits INSIDE the SCF iteration, where the orbitals change from one
iteration to the next and a store keyed on subshell labels would hand back an integral computed for an earlier orbital shape. With
the cache owned by its caller, that is no longer a rule to remember: a caller inside an SCF iteration simply does not create one.
See InteractionStrength.XLCache.JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAware — Method
InteractionStrength.XL_CoulombKinkAware(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid) ... computes the same effective Coulomb interaction strength as XL_Coulomb(L, a, b, c, d, grid), including the same triangular-delta veto and angular reduced-matrix-element prefactor xc, but using the kink-aware RadialIntegrals.SlaterRkKinkAware for the underlying radial integral instead of RadialIntegrals.SlaterRk. A value::Float64 is returned. Shared by Hamiltonian.setupMatrixKinkAware (the CI-matrix Coulomb term for ALField/EOLField) and by SelfConsistent.computeTwoElectronV (their Fock matrix). To memoise the result, use the method that additionally takes an InteractionStrength.XLCache – and see there for why SelfConsistent.computeTwoElectronV must NOT create one.
JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAware — Method
InteractionStrength.XL_CoulombKinkAware(L::Int64, a::Subshell, b::Orbital, c::Subshell, d::Orbital, primitives::Bsplines.Primitives, kernelCache::Dict{Tuple{Int64,Subshell,Subshell},Array{Float64,2}}) ... as the method without a cache, but taking the subshell-independent matrix from kernelCache and computing it only when it is not there; a (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
THE CACHE IS VALID ONLY WHILE THE ORBITALS ARE FIXED, which for the average-level field means WITHIN ONE SWEEP:
`solveAverageLevelField` hands `computeFockMatrix` the old bVectors and reassigns them only at the end of an iteration, so the
partner orbitals do not move during a sweep. A cache carried across iterations would silently serve stale matrices, so the caller
must supply a fresh one each iteration. The key carries both orbital subshells, since the kernel depends on the pair (b,d) in
general even though the direct branch always calls it with b = d.JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAware — Method
InteractionStrength.XL_CoulombKinkAware(L::Int64, a::Subshell, b::Orbital, c::Subshell, d::Orbital, primitives::Bsplines.Primitives) ... computes the same (direct) Coulomb interaction strengths X^LCoulomb (.b.d) as XLCoulomb(L,a::Subshell,b::Orbital,c::Subshell,d::Orbital,primitives), for given rank L and orbital functions as well as the given primitives, but using the kink-aware screened-potential construction (RadialIntegrals.buildScreenedPotential) instead of RadialIntegrals.SlaterRkComponent's naive tensor-product double sum. The screened potential VL(r), which depends only on the fixed orbital pair (b,d), is built ONCE (adaptive quadrature) and then reused cheaply – via the existing grid quadrature weights, since VL(r) is smooth once built – for every B-spline pair (i,k) of the L- and S-block. Isolated from XL_Coulomb; shared by the ALField/EOLField code lines, cf. SelfConsistent.computeTwoElectronV. A (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
JenaAtomicCalculator.InteractionStrength.XL_CoulombKinkAwareKernel — Method
InteractionStrength.XL_CoulombKinkAwareKernel(L::Int64, b::Orbital, d::Orbital, primitives::Bsplines.Primitives) ... builds the B-spline matrix of the screened potential of the orbital pair (b,d) at rank L, WITHOUT the angular prefactor; a (nsL+nsS) x (nsL+nsS) matrix::Array{Float64,2} is returned.
This is the whole cost of XL_CoulombKinkAware and it does NOT depend on the subshell being refined -- that subshell enters only
through the scalar `xc` applied by the caller. Separating the two is what makes the matrix cacheable across a self-consistency
sweep: profiled on W+ [Xe] 4f^14 5d^4 6s, computeFockMatrix is 95% of the average-level SCF time, and the same matrix is rebuilt
3.5x (argon) to 9.1x (Th+) per iteration, the redundancy growing with the number of subshells.
THE EXTRACTION IS ARITHMETICALLY INERT BUT NOT BIT-IDENTICAL, and it is worth knowing why. The source operations and their order are
exactly those of the original loop, yet moving the loop into its own function changes the compiler's inlining and floating-point
contraction decisions, so results agree only to about 32 ULP -- measured, 7.2e-15 relative on the argon Fock matrices, with the
thorium-ion ones unchanged. That is far below the SCF's own convergence, which at the default accuracyScf leaves the orbitals moving
by ~4e-4, but it does mean a memoisation of this kernel cannot be verified by demanding identical converged energies: the last
digits of such an energy are the tolerance, not the change.JenaAtomicCalculator.InteractionStrength.XL_CoulombReference — Method
InteractionStrength.XL_CoulombReference(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid) ... computes the the effective Coulomb interaction strengths X^L_Coulomb (abcd) for given rank L and orbital functions a, b, c and d at the given grid but without optimization. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.XL_CoulombTensor — Method
InteractionStrength.XL_CoulombTensor(L::Int64, a::Subshell, b::Orbital, c::Orbital, cVector::Vector{Float64}, d::Subshell, cacheLL::RadialIntegrals.ScreenedPotentialCache, cacheLS::RadialIntegrals.ScreenedPotentialCache, cacheSS::RadialIntegrals.ScreenedPotentialCache, primitives::Bsplines.Primitives, kernelCache::Dict{Tuple{Int64,Subshell},Array{Float64,2}}) ... as the method without a kernelCache, but taking the subshell-independent exchange matrix from it and computing it only when absent; a (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
The same lifetime rule applies as for XL_CoulombKinkAware: the cache holds matrices built from the partner ORBITALS, so it is valid
within one self-consistency sweep and must be renewed for the next. Keying on the partner subshell alone is sufficient because b and
cVector always describe the same partner in this branch.JenaAtomicCalculator.InteractionStrength.XL_CoulombTensor — Method
InteractionStrength.XL_CoulombTensor(L::Int64, a::Subshell, b::Orbital, c::Orbital, cVector::Vector{Float64}, d::Subshell, cacheLL::RadialIntegrals.ScreenedPotentialCache, cacheLS::RadialIntegrals.ScreenedPotentialCache, cacheSS::RadialIntegrals.ScreenedPotentialCache, primitives::Bsplines.Primitives) ... computes the same (exchange) Coulomb interaction strengths X^LCoulomb (.bc.) as XLCoulomb(L,a::Subshell,b::Orbital,c::Orbital,d::Subshell,primitives) / XLCoulombKinkAware of the same signature, but using PRECOMPUTED RadialIntegrals.ScreenedPotentialCache tensors – built ONCE, outside the SCF iteration, via RadialIntegrals.buildScreenedPotentialCache for rank L – instead of any per-call adaptive quadrature. Re-deriving the original (validated) block structure carefully shows that, in each block, the B-spline row index pairs with orbital c's component matching the COLUMN's type (P for an L-column, Q for an S-column), while orbital b's component matching the ROW's type pairs with the column B-spline index. Consequently it is orbital c – not b – whose OWN B-spline expansion coefficients (cVector, the B-spline coefficient vector carried alongside the orbital during SCF) are needed, to build, for each row i, a "partial potential" Psii(s) = summ cVector[m] * Phi(i,m)(s) as a CHEAP weighted sum of already-cached, already-kink-aware Phi(i,m) entries (only ~band terms, no quadrature at all); orbital b itself stays a plain tabulated orbital, exactly like the column B-spline, entering only the final cheap grid-quadrature dot product. Three caches are needed because the row/column-type combination can be LL, LS, SL, or SS – and, unlike the "direct" signature, a single screened potential cannot be shared across the whole (nsL+nsS) x (nsL+nsS) matrix here, since both B-spline indices (row and column) sit on opposite sides of the two-electron kernel. cacheLL and cacheSS are ordinary same-basis caches (bsplinesL, bsplinesL) and (bsplinesS, bsplinesS); cacheLS is the cross-basis cache (bsplinesL, bsplinesS) and is also used, with indices swapped at lookup, for the SL combination – see RadialIntegrals.buildScreenedPotentialCache. This turns what used to be an expensive per-call adaptive-quadrature computation into one with NO further quadrature at all, for every SCF iteration and every exchange coefficient that shares this rank L, once the caches themselves have been built (see SelfConsistent.solveAverageLevelField for how they get built and cached once per SCF run). Isolated from XLCoulomb; only used by the average-level (ALField) code line. A (nsL+nsS) x (nsL+nsS) matrixV::Array{Float64,2} is returned.
JenaAtomicCalculator.InteractionStrength.XL_CoulombTensorKernel — Method
InteractionStrength.XL_CoulombTensorKernel(L::Int64, b::Orbital, cVector::Vector{Float64}, cacheLL::RadialIntegrals.ScreenedPotentialCache, cacheLS::RadialIntegrals.ScreenedPotentialCache, cacheSS::RadialIntegrals.ScreenedPotentialCache, primitives::Bsplines.Primitives) ... builds the exchange B-spline matrix for the orbital b and the expansion cVector at rank L, WITHOUT the angular prefactor; a (nsL+nsS) x (nsL+nsS) matrix::Array{Float64,2} is returned.
As for XL_CoulombKinkAwareKernel, the subshell being refined enters XL_CoulombTensor only through the scalar `xc`, so this matrix
depends solely on the rank and the partner orbital and can be reused for every subshell of a sweep. This is the larger of the two
hot branches: 58% of the average-level SCF time on W+ against 34% for the direct one.JenaAtomicCalculator.InteractionStrength.XL_Coulomb_DH — Method
InteractionStrength.XL_Coulomb_DH(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid, lambda::Float64) ... computes the effective Coulomb-Debye-Hückel interaction strengths X^LCoulombDH (abcd) for given rank L and orbital functions a, b, c and d at the given grid and for the given screening parameter lambda. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.XL_plasma_ionSphere — Method
InteractionStrength.XL_plasma_ionSphere(L::Int64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, lambda::Float64) ... computes the effective interaction strengths X^L_ion-sphere (abcd) for given rank L and orbital functions a, b, c and d and for the plasma parameter lambda. NOT IMPLEMENTED: it raises, and names the Debye-Hueckel alternative in doing so.
JenaAtomicCalculator.InteractionStrength.X_smsA — Method
InteractionStrength.X_smsA(a::Orbital, b::Orbital, c::Orbital, d::Orbital, nm::Nuclear.Model, grid::Radial.Grid) ... computes the the effective interaction strengths X^1_sms,A (abcd) for fixed rank 1 and orbital functions a, b, c and d at the given grid. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.X_smsB — Method
InteractionStrength.X_smsB(a::Orbital, b::Orbital, c::Orbital, d::Orbital, nm::Nuclear.Model, grid::Radial.Grid) ... computes the the effective interaction strengths X^1_sms,B (abcd) for fixed rank 1 and orbital functions a, b, c and d at the given grid. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.X_smsC — Method
InteractionStrength.X_smsC(a::Orbital, b::Orbital, c::Orbital, d::Orbital, nm::Nuclear.Model, grid::Radial.Grid) ... computes the the effective interaction strengths X^1_sms,C (abcd) for fixed rank 1 and orbital functions a, b, c and d at the given grid. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.besselPhiPsi — Method
InteractionStrength.besselPhiPsi(K::Int64, x::Float64; nmax::Int64=12, tol::Float64=1.0e-16) ... returns the pair (phiK(x), psiK(x)) of NORMALISED spherical Bessel functions
phi_K(x) = (2K+1)!! j_K(x) / x^K psi_K(x) = - x^(K+1) y_K(x) / (2K-1)!!
both of which tend to 1 as x -> 0. They are the natural building blocks of the frequency-dependent Breit kernels, because those
kernels are the static kernel TIMES a product of one phi and one psi: the omega -> 0 limit is then exact by construction rather than
a special case, and nothing has to be recovered from a cancellation between large numbers.
TWO ROUTES, JOINED AT x = 2, because each one fails where the other works. Below the crossover an ascending power series in
-x^2/2 is used: it returns (phi-1) and (psi-1) with full RELATIVE precision, which is what the W kernel of
InteractionStrength.XL_Breit_densities needs, since that kernel multiplies them by [nu]^2/omega^2 -- and forming j_K y_K directly
there loses the answer to cancellation, each factor alone diverging as omega -> 0. Above the crossover the EXACT normalised
functions are returned from GSL's spherical Bessel functions, which is what every other radial integral in JAC already uses.
THE SERIES ALONE IS NOT ENOUGH, AND THAT WAS A DEFECT RATHER THAN A LIMITATION. It carries 12 terms while needing about x^2/2 of
them, so past x ~ 2.5 the truncation shows and past x ~ 5 the partial sum DIVERGES -- measured against the exact functions, the
worst relative error over K = 0..6 runs 9.3e-16 at x = 2, 2.7e-08 at x = 4, 2.8e+01 at x = 12 and 1.2e+25 at x = 100, with nothing
in the returned value to show it. Since the argument is x = omega r with omega = factor |E_a - E_c| / c, which reaches ~9 a.u. for
a 3p-1s pair at Z = 54, x runs into the hundreds across a radial grid and the Breit strength was silently destroyed: the
frequency-dependent correction of example-Ad.jl branch 4 reached 4.4e+97 Ha at factor = 1 where it should be ~5.2.
THE CROSSOVER WAS MEASURED, NOT CHOSEN. The two routes must overlap, and they do only in a narrow window: at x = 2 the series is
right to 9.3e-16 while the exact route still gives (f-1) to 5.4e-15, whereas by x = 2.5 the series has lost 2.3e-13 and by
x = 1e-4 the exact route has lost 6.7e-07 on (f-1). x = 2 is where both are good.
Verified against (2K+1)!! j_K(x)/x^K and -x^(K+1) y_K(x)/(2K-1)!! from GSL to <= 4.6e-16 for K = 0..3 and x = 1e-4..0.5, and to
1.000000000000000 in the limit x -> 0. **THAT RANGE IS THE COVERAGE GAP THAT HID THE DEFECT** -- a verification stopping at
x = 0.5 can say nothing about x = 100, and the function was used there.
The normalisation follows GRASP2018 (rci90/bessel.f90, which stores phi-1 and psi-1); the formulation was read there and re-derived
here rather than transcribed.
A tuple (phi::Float64, psi::Float64) is returned.JenaAtomicCalculator.InteractionStrength.bosonShift — Method
InteractionStrength.bosonShift(a::Orbital, b::Orbital, potential::Array{Float64,1}, grid::Radial.Grid) ... computes the <a|| h^(boson-field) ||b> reduced matrix element of the boson-field shift Hamiltonian for orbital functions a, b. This boson-field shift Hamiltonian just refers to the effective potential of the given isotope due to the (assumed) boson mass. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.breitRouteOf — Method
InteractionStrength.breitRouteOf(eeint::Union{BreitInteraction, CoulombBreit, CoulombGaunt}) ... resolves an e-e interaction into the two things the Breit strength actually depends on: whether only the Gaunt (magnetic) part is wanted, and the factor that scales the photon wave number. A tuple (onlyGaunt::Bool, factor::Float64) is returned.
These two ALSO identify the route for caching purposes, which is why they are resolved in one place: CoulombGaunt() and
CoulombBreit(0.) give the same coefficients but NOT the same strength, and a memo keyed only on rank and subshells would confuse
them. See InteractionStrength.XLCache.JenaAtomicCalculator.InteractionStrength.checkFrequencyIsMeaningful — Method
InteractionStrength.checkFrequencyIsMeaningful(factor::Float64, a::Orbital, b::Orbital, c::Orbital, d::Orbital, grid::Radial.Grid) ... refuses a frequency-dependent Breit strength whose orbitals cannot supply a frequency. Nothing is returned.
WHY THIS HAS TO REFUSE RATHER THAN WARN. The photon wave number is omega = factor |E_a - E_c| / c, taken from the ORBITAL
ENERGIES. Both EOL solvers (SelfConsistent.solveOptimizedLevelField and ...ByRotation) build their orbitals with
`Bsplines.generateOrbitalFromVector(sh, 0.0, ...)` -- a rotation- or functional-optimised orbital is not the eigenfunction of any
one-particle operator, so it carries no eigenvalue and the field is left at zero. Every orbital of a RAS or EOL basis therefore
has energy 0.0 exactly, omega comes out 0 for every pair, and CoulombBreit(1.) silently returns the CoulombBreit(0.) answer:
the retardation the caller asked for is absent and nothing says so. Measured 04-Sep-2026 on Be-like U: all four orbitals of the
reference layer at 0.0, against -4705.73 / -1185.21 / -1174.16 / -1018.99 Ha from a mean-field SCF on the same configurations.
Four bound orbitals at EXACTLY 0.0 is the signature of the unset field and not of physics, so the test is safe; a continuum
orbital carries its own positive energy and an AL or DFS basis its eigenvalues, which is why example-Ad, -Df and -Dv keep working.
The remedy is one of: CoulombBreit(0.), which is the EXACT omega -> 0 limit and what every published JAC RAS number used; or a
mean-field basis, whose orbitals carry eigenvalues. Giving EOL orbitals a defined energy is a physics question -- the diagonal
Lagrange multiplier is the candidate -- and is on the priority list rather than guessed at here.
AND THE OTHER END, ADDED 15-Sep-2026 AND PUT ON THE RIGHT VARIABLE 05-Oct-2026. Nothing guarded LARGE omega. In an Auger or
dielectronic-capture amplitude one orbital is a CONTINUUM electron, so |E_a - E_c| is the continuum energy itself, and amplitudes
measured on 09-Sep-2026 degraded from a 0.2 % correction at Z = 53 to values wrong by 10^6-10^7 at Z = 92 with no warning at all.
THE QUANTITY THAT DECIDES IT IS omega TIMES THE EXTENT OF THE OVERLAP DENSITY, and it was settled by varying one thing at a time
rather than by argument. Two controls, both on C-like carbon:
THE MESH IS INERT. Box fixed at 12.5 a.u., hp refined fourfold -- 474 against 1893 points per oscillation of the kernel --
gives 1.1038/1.1041 at omega*rbox = 4, 1.1627/1.1626 at 7, -0.2162/-0.2558 at 18. So "an oscillatory integrand the
quadrature cannot follow" is REFUTED; that was this guard's stated mechanism for a month.
THE BOX IS INERT TOO. The SAME orbitals in a box enlarged from 12.6 to 50.4 a.u. give 1.1627 against 1.1626 at fixed omega,
while omega*rbox moves 7.0 -> 28.2. A length that changes nothing when changed alone is not the criterion.
So the length belongs to the PAIR, and `InteractionStrength.overlapExtent` forms it. Landmarks, on two bound systems 15x apart
in box size and 9x in Z: already ~21 % below the O(omega^2) law at omega*extent = 1.2; PEAK at 2.1-3.0, where the correction
stops growing with omega and so is unphysical; correction VANISHED by 3.4-4.7; sign REVERSED by 5.5-7.7. The two systems place
these about 40 % apart, so the threshold is the conservative end, 1.2. That the same two systems LOOKED like a clean collapse in
omega*rbox is a two-point coincidence: their extent/rbox are 0.304 and 0.428, so those two points cannot separate the variables.
IT COVERS THE AUGER CASE IT WAS FILED FOR, which a box test was kept here for until it was measured. With a real continuum
orbital at the KLL energy, Li-like U sits at omega*extent = 6.3 and Li-like iodine at 3.7 -- both far past 1.2, not at the
0.5-1.0 the priority item recorded -- so one clause serves both. And the "healthy Z = 53" is not a healthy STRENGTH: refining
the mesh there, XL_Breit(0.) converges to 4.6430e-03 to six figures while XL_Breit(1.) runs -7.12e-02, +6.84e-03, +2.44e+01.
The 0.2 % belongs to the assembled AMPLITUDE, where errors across many strengths partly cancel.
AND IT WARNS RATHER THAN REFUSES, because the 40 % spread in the landmarks is calibrated on two systems and a wrong refusal is
worse than a warning that names the remedy. The check is O(1): two frequencies, two extents and one product, and ordinary
bound-bound work sits near omega*extent ~ 0.03, two orders below the threshold.JenaAtomicCalculator.InteractionStrength.dipole — Method
InteractionStrength.dipole(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| d ||b> reduced matrix element of the dipole operator for orbital functions a, b. A value::Float64 is returned.
NO CALLER, AND NOT THE ONE TO REACH FOR. This returns Grant's reduced matrix element WITHOUT the 1/sqrt(2 j_a + 1)
that JAC's convention requires, so it must never be paired with a bare spin-angular coeff.T -- doing so is too
large by exactly sqrt(2 j_a + 1), which is what module-MultipoleMoment.jl did until 27-Aug-2026. It is the k = 1
case of InteractionStrength.eMultipole, which carries that factor; use eMultipole(1, a, b, grid) instead.JenaAtomicCalculator.InteractionStrength.eMultipole — Method
InteractionStrength.eMultipole(k::Int64, a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(Ek) ||b> reduced matrix element of the dipole operator for orbital functions a, b. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.effectiveExtent — Method
InteractionStrength.effectiveExtent(orb::Orbital, grid::Radial.Grid) ... the radius inside which 99 % of the orbital's radial density lies, i.e. the distance over which it can contribute to an overlap integral. A value::Float64 is returned.
THIS IS NOT THE BOX, and for a continuum orbital the two differ by orders of magnitude -- which is the point: an Auger
amplitude pairs compact bound orbitals with an electron that fills the grid, and the integrand lives where the BOUND
orbitals do. Using the box instead would refuse every Auger run with a frequency-dependent Breit interaction.JenaAtomicCalculator.InteractionStrength.fieldShift — Method
InteractionStrength.fieldShift(a::Orbital, b::Orbital, deltaPotential::Array{Float64,1}, grid::Radial.Grid) ... computes the <a|| h^(field-shift) ||b> reduced matrix element of the field-shift Hamiltonian for orbital functions a, b. This field-shift Hamiltonian just refers to the difference of the nuclear potential deltaPotential of two isotopes, and which is already divided by the difference of the mean-square radii. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.hamiltonian_nms — Method
InteractionStrength.hamiltonian_nms(a::Orbital, b::Orbital, nm::Nuclear.Model, grid::Radial.Grid) ... computes the <a|| h_nms ||b> reduced matrix element of the normal-mass-shift Hamiltonian for orbital functions a, b. A value::Float64 is returned. For details, see Naze et al., CPC 184 (2013) 2187, Eq. (37).
JenaAtomicCalculator.InteractionStrength.hfs_tE1 — Method
InteractionStrength.hfs_tE1(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(E1) ||b> reduced matrix element for the HFS coupling to the electric-dipole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.hfs_tE2 — Method
InteractionStrength.hfs_tE2(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(2) ||b> reduced matrix element for the HFS coupling to the electric-quadrupole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.hfs_tE3 — Method
InteractionStrength.hfs_tE3(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(E3) ||b> reduced matrix element for the HFS coupling to the electric-octupole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.hfs_tM1 — Method
InteractionStrength.hfs_tM1(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(1) ||b> reduced matrix element for the HFS coupling to the magnetic-dipole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
Note (26-Jul-2026): was missing the alpha (fine-structure constant) prefactor required by Andersson & Jonsson (2008), CPC 178, Eq.
(49): <n_a kappa_a || t^(1) || n_b kappa_b> = -alpha(kappa_a+kappa_b) <-kappa_a||C^(1)||kappa_b>[r^-2] -- confirmed by direct
re-reading of the paper (p. 161). This alone does not fully resolve the long-standing H(1s) HFS A-constant discrepancy; see
examples/example-Cb.jl and memory project_zeeman_hfs_bugs.md for the residual after this fix.JenaAtomicCalculator.InteractionStrength.hfs_tM2 — Method
InteractionStrength.hfs_tM2(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(M2) ||b> reduced matrix element for the HFS coupling to the magnetic-dipole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.hfs_tM3 — Method
InteractionStrength.hfs_tM3(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| t^(M3) ||b> reduced matrix element for the HFS coupling to the magnetic-dipole moment of the nucleus for orbital functions a, b. A value::Float64 is returned.
Note (30-Jul-2026): was missing the same alpha (fine-structure constant) prefactor found missing in hfs_tM1 on 26-Jul-2026 --
Andersson & Jonsson (2008), CPC 178, Eq. (49) is generic in the multipole rank L, so the same alpha(kappa_a+kappa_b) prefactor
applies for L=3 (M3) as for L=1 (M1). See examples/example-Cb.jl and memory project_zeeman_hfs_bugs.md.JenaAtomicCalculator.InteractionStrength.multipoleTransition — Method
InteractionStrength.multipoleTransition(mp::EmMultipole, gauge::EmGauge, omega::Float64, b::Orbital, a::Orbital, grid::Radial.Grid) ... to compute the (single-electron reduced matrix element) multipole-transition interaction strength <b || T^(Mp, absorption) || a> due to Johnson (2007) for the interaction with the Mp multipole component of the radiation field and the transition frequency omega, and within the given gauge. A value::Float64 is returned.
JenaAtomicCalculator.InteractionStrength.overlapExtent — Method
InteractionStrength.overlapExtent(x::Orbital, y::Orbital, grid::Radial.Grid) ... the radius inside which 99 % of |Px Py + Qx Qy| lies, i.e. of the TRANSITION DENSITY that a two-electron radial integral actually samples. A value::Float64 is returned.
THIS IS THE LENGTH THAT DECIDES WHERE A FREQUENCY-DEPENDENT BREIT STRENGTH STOPS BEING TRUSTWORTHY, and it is the pair's own
property rather than the grid's. Settled 05-Oct-2026 by the one test that varies a single thing: the same C orbitals in a box
enlarged from 12.6 to 50.4 a.u. return the ratio 1.1627 against 1.1626 at fixed omega, while omega*rbox moves 7.0 -> 28.2.
It is formed per PAIR, since the code builds omg_ac and omg_bd separately, and the larger of the two pairs sets the scale. For an
Auger quadruple -- three compact bound orbitals and a continuum electron filling the grid -- it is the bound orbitals that bound
the density, which is why such a run is not false-alarmed on its box.
Numerically it comes out close to `effectiveExtent` of the more compact partner (0.245 against 0.245 for Ne-like Xe, 5.304
against 5.304 for C-like carbon), so the two are not distinguished by the present measurements; this one is used because it is
the density the integrand contains rather than a proxy for it.JenaAtomicCalculator.InteractionStrength.zeeman_Delta_n1 — Method
InteractionStrength.zeeman_Delta_n1(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| Delta n^(1) ||b> reduced matrix element for the Zeeman-Schwinger contribution to the coupling to an external magnetic field for orbital functions a, b. A value::Float64 is returned.
Note (25-Jul-2026): the prefactor is (g_s-2)/4, not the (g_s-2)/2 of Andersson & Jonsson (2008), CPC, Eq. (26)/(52) as literally
printed -- found and fixed after the printed formula gave a Delta N1 contribution to g_J exactly 2x too large, confirmed against two
independent references: (i) the standard non-relativistic Lande g_J decomposition for H(2p_1/2) and H(2p_3/2) (different kappa,
opposite-sign corrections, both matched after the /4 fix to 5-6 significant figures), and (ii) the paper's own published He 1s2p g_J
table (Fig. 10: 1.5011166/1.5011183/0.9999936 for 3P1/3P2/1P1), matched to 5-6 significant figures only after this fix, not before.
Likely root cause (plausible, not fully proven): the Sigma operator in Eq. (26) is Pauli-normalized (eigenvalue +/-1), while the
physical magnetic-moment operator needs S (eigenvalue +/-1/2) -- a factor-of-2 normalization slip, not a JAC transcription error,
since the code faithfully reproduced what Eq. (52) says.JenaAtomicCalculator.InteractionStrength.zeeman_n1 — Method
InteractionStrength.zeeman_n1(a::Orbital, b::Orbital, grid::Radial.Grid) ... computes the <a|| n^(1) ||b> reduced matrix element for the Zeeman coupling to an external magnetic field for orbital functions a, b. A value::Float64 is returned.
THIS INTEGRAL CARRIES THE WIGNER-ECKART FACTOR ITSELF, and a caller must therefore NOT supply it. The angular part is divided here
by sqrt(2 j + 1) -- of the FIRST argument, which at this point is the SIGN-FLIPPED kappa, so j(-ka) rather than j(ka). A rank-1
spin-angular coefficient is consequently used BARE against this function, as LandeZeeman.amplitude does with coeff.T, and inserting
a further sqrt(2 j_a + 1) at the call site would double it. This is the exception to the convention that the factor sits inside the
coefficient; nothing at a call site reveals it, which is why it is stated here.Basics: data types
JenaAtomicCalculator.Basics.integrate — Function
Basics.integrate() ... generic function for the numerical integration of a (radial) function on a grid; see the methods of Basics.integrate for the integration rules that are available.
JenaAtomicCalculator.Basics.ALField — Type
... to represent an average-level field: a bVector-native SCF built directly around B-spline expansion coefficient vectors (no tabulated Orbital maintained during the SCF iteration at all), a kink-aware (spline + split adaptive quadrature) two-electron Slater integral in place of the naive tensor-product Gauss-Legendre one, and an in-matrix orthogonality projection modeled directly on DBSR_HF (Zatsarinny & Froese Fischer, CPC 202, 287 (2016)); see SelfConsistent.solveAverageLevelField. Validated to 5+ significant figures against literature for He/Be/Ne/Ar. (This type was developed under the working name ALFieldClaude2 during an earlier investigation; an original, buggy ALField implementation – and before that a first-generation kink-aware line, ALFieldClaude – were both superseded by this one and removed.)
JenaAtomicCalculator.Basics.AaDFSField — Type
... to apply the average-atom Dirac-Fock-Slater field, i.e. the relativistic counterpart of AaHSField for the same plasma conditions; cf. Basics.computePotential(::AaDFSField, grid, orbitals, mu, temp).
JenaAtomicCalculator.Basics.AaHSField — Type
... to apply the average-atom Hartree-Slater field, i.e. a mean-field potential for a plasma of given chemical potential mu and temperature; cf. Basics.computePotential(::AaHSField, grid, orbitals, mu, temp).
JenaAtomicCalculator.Basics.Absorption — Type
... to compute the photon-absorption amplitude <f || O^(Mp) || i>; equal to the conjugate of the emission amplitude with initial and final levels interchanged.
JenaAtomicCalculator.Basics.AbstractAnalyzeTheme — Type
abstract type Basics.AbstractAnalyzeTheme ... labels the theme (kind) of a Basics.analyze() call; it is used for dispatch and to avoid string comparisons. Concrete subtypes: + LevelDecompositionOfNRconfigurations ... analyze and list the NR configurations with weight > 5 %. + LevelDecompositionOfCsfR ... analyze and list (up to N) jj-coupled CSF and their weights.
JenaAtomicCalculator.Basics.AbstractAngularMomentum — Type
abstract type Basics.AbstractAngularMomentum ... defines an abstract and a number of concrete types for dealing with angular momentum variables.
+ AngularJ64 ... to deal with (total) angular momenta J >= 0
+ AngularM64 ... to deal with magnetic quantum numbers -J <= M <= J
+ LevelSymmetry ... to deal with an overall J^P symmetry of a level.JenaAtomicCalculator.Basics.AbstractCascadeApproach — Type
abstract type Basics.AbstractCascadeApproach ... defines an abstract and a number of singleton types for the computational approach/model that is applied in order to generate and evaluate all many-electron amplitudes of a given cascade. Lives here (not in Cascade.jl) because DecayYield.Settings needs it as a compile-time field type, and module-DecayYield.jl is included BEFORE module-Cascade.jl in JenaAtomicCalculator.jl, while Cascade itself needs DecayYield.Outcome/Settings as compile-time function-argument types (module-Cascade-inc-computations.jl) – a genuine circular dependency that only a shared, early-loaded supertype (the same pattern already used for AbstractPropertySettings/AbstractProcessSettings) can resolve.
+ struct AverageSCA
... all levels in the cascade are described in single-configuration and single-CSF approximation; this (rather crude) approach neglects
all configuration-interactions and also applies just a single set of one-electron orbitals (from the least-ionized charge state) for
all considered charge states.
+ struct SCA
... all levels in the cascade are described in single-configuration approximation but with 'mixtures' within the configuration;
an individual mean-field is generated for each charge state and all continuum orbitals are generated for the correct transition
energy in the field of the remaining ion. Moreover, all the fine-structure transitions are calculated individually.
+ struct UserMCA
... placeholder for a genuine multiconfiguration cascade approach; declared but NOT (yet) implemented anywhere in the
codebase -- selecting it does not raise an explicit error and currently falls through to the same code path as SCA in the
Cascade-inc-*.jl dispatch sites, which do not special-case it either.JenaAtomicCalculator.Basics.AbstractComputeTheme — Type
abstract type Basics.AbstractComputeTheme ... defines an abstract and a number of singleton types to select the computation theme for Basics.compute(), replacing the former string-key dispatch. + CImatrixWithSymmetryJP ... compute the CI Hamiltonian matrix for a given J^P symmetry block.
THE FOUR RadialOrbital* THEMES WERE RETIRED on 13-Aug-2026: RadialOrbitalBunge1993, RadialOrbitalMcLean1981, RadialOrbitalHydrogenic
and RadialOrbitalThomasFermi. None of them ever worked and none was ever called from anywhere.
Bunge1993 and McLean1981 went first: they promised start orbitals from the Roothaan-Hartree-Fock tables of Bunge et al., ADNDT 53
(1993) 113 and McLean & McLean, ADNDT 26 (1981) 197, but that data has NEVER been part of JAC -- they called `store()`, which only
ever existed as store_Williams2000, inner-shell binding energies and an entirely different table, itself removed at a20163c. See
module-Radial.jl for why importing those tables was decided against.
Hydrogenic and ThomasFermi followed, because they name the wrong thing. A start orbital is chosen per COMPUTATION, through
ManyElectron.AbstractStartOrbitals (StartFromHydrogenic, StartFromThomasFermi, StartFromPrevious) which AsfSettings carries and
SelfConsistent dispatches on -- not per subshell through a compute theme. Thomas-Fermi accordingly arrived where it belongs, as the
screened potential Basics.ThomasFermiField, with the orbitals following from Bsplines.generateOrbitals, which works in any
potential.JenaAtomicCalculator.Basics.AbstractConfigurationRestriction — Type
abstract type Basics.AbstractConfigurationRestriction ... defines an abstract types for dealing with restrictions that need to be applied to a list of configurations. Typically, a loop through is made through all given restrictions and all configurations are tested to obey all these restrictions. Two contradicting restrictions, for instance RestrictParity(plus) & RestrictParity(minus), therefore leads zero configurations in all cases. It remains the reponsibility of the user to make sure that the given restrictions are consistent with what is to be achieved. The given set of restrictions can be easily extended if this need arises by the users.
+ RestrictMaximumDisplacements(..) ... to restrict the maximum replacements wrt a (2nd) configuration.
+ RestrictNoElectronsTo(..) ... to restrict the total number of electron in high subshells.
+ RestrictParity(..) ... to restrict to configurations with a given parity.
+ RestrictToShellDoubles(..) ... to allow only double occupations in high subshells.
+ RequestMinimumOccupation(..) ... to request a minimum occupation in a given set of shells.
+ RequestMaximumOccupation(..) ... to request a maximum occupation in a given set of shells.JenaAtomicCalculator.Basics.AbstractConfigurationTheme — Type
abstract type Basics.AbstractConfigurationTheme ... defines an abstract and a number of concrete (detailed and singleton) data types to distinguish a good number of concrete themes for manipulating (list of) configurations. These themes are listed and briefly explained below; they typically provide the data central to the particular theme, while other input for applying the theme is handled by multiple dispatch.
+ AddElectrons ... to add to the given configurations one or several electrons into specified shells.
+ ExciteElectrons ... to excite for the given configurations one or several electrons into specified shells.
+ RemoveElectrons ... to remove from the given configurations one or several electrons from specified shells.
+ RestrictExcitations ... to restrict the given configurations due to one or several configuration restrictions.
+ ForAutoIonization ... to generate configurations that are related by autoionization (deexcitation + single remove).
+ ForDielectronicCapture ... to generate configurations that are related by dielectronic capture (excitation + single capture).
+ ForDielectronicRecombination ... to compute the DR resonance strength (for pedestrians only).
+ ForElectronCapture ... to generate configurations that are related by the capture of an additional electron.
+ ForImpactIonization ... to estimate electron impact-ionization cross sections (for pedestrians only)
+ ForHollowIons ... to generate configurations that are related by multiple capture into high-n shells.
+ ForPhotoEmission ... to generate configurations that are related by photoemission (single replacement of electrons).
+ ForPhotoIonization ... to generate configurations that are related by photoionization (single removement of electrons).
+ ForPhotoRecombination ... to generate configurations that are related by radiative capture (just single-electron capture).
+ ForStepwiseDecay ... to generate configurations that are related by photoemission and autoionization.
+ ForGivenConfigs ... to perform computations for given configurations.
+ ForIsoelectronicSequence ... to compute configuration-averaged energies along an isoelectronic sequence.
+ GroundConfiguration ... to generate the ground configuration for a given number of electrons.
+ MeanConfiguration ... to generate the mean configuration, i.e. a configuration with mean occupation numbers.
+ RelativisticConfigurations to generate/deal with relativistic configurations.
+ AllShells ... to extract all occupied shells from a set of configurations.
+ ByMultipoles ... to extract the configurations due to multipole selection themes.
+ ByParity ... to extract the configurations due to parity.
+ ClosedCore ... to extract the closed core from the given configuration.
+ ClosedShells ... to extract the closed shells from given configurations.
+ ClosedSubshells ... to extract the closed subshells from given configurations.
+ ContractShells ... to extract the configurations without empty shell occupation (contracted shells).
+ ExcitationLevel ... to determine the excitation level of a configuration.
+ ExpandShells ... to extract the configurations with empty shell occupation (expanded shells).
+ FromBasis ... to extract the configuration from the basis.
+ FromMultiplet ... to extract the configuration from the multiplet(s).
+ GeneralizedConfiguration .. to extract the generalized configuration.
+ GetParity ... to extract the parity of a configurations.
+ IsOccupied ... to extract where a shell or subshell is occupied in the given configuration.
+ LeadingConfiguration ... to extract the leading configuration.
+ LeadingConfigurationR ... to extract the leading relativistic configuration.
+ MeanOccupation ... to extract occupation numbers from given configurations.
+ Multiplicity ... to extract the multiplicity of a configuration.
+ NonrelativisticBasis ... to extract the configurations from a non-relativistic basis.
+ NumberOfElectrons ... to extract the number of electrons from a set of configurations.
+ OccupationDifference ... to extract differences of occupation numbers from given configurations.
+ OpenShells ... to extract the open shells from the given configurations.
+ OpenSubshells ... to extract the open subshells from the given configurations.
+ TotalAM ... to extract the total angular momenta J that are associated with the configuration.
+ ValenceOccupation ... to extract the remaining configuration beyond a given (closed) core configuration.
+ FineStructure ... to display the total J fine-structure levels of a configuration (without energies).
+ FineStructureLS ... to display the total LSJ fine-structure levels of a configuration (without energies).
+ HyperfineStructure ... to display the total F hyperfine-structure levels of a configuration (without energies).
+ HundRules ... to display the total LSJ fine-structure levels, ordered by Hund's themes (not yet).JenaAtomicCalculator.Basics.AbstractContinuumSolutions — Type
abstract type Basics.AbstractContinuumSolutions ... defines an abstract and a number of singleton types for solving the continuum orbitals in a given potential.
+ ContBessel ... generate a pure Bessel function for the large component together with kinetic balance.
+ ContSine ... generate a pure Sine function for the large component together with kinetic balance.
+ NonrelativisticCoulomb ... generate a non-relativistic Coulomb function for the large component together with kinetic balance.
+ AsymptoticCoulomb ... generate a pure (asymptotic) Coulombic function for both components.
+ BsplineGalerkin ... generate a continuum orbital with the Galerkin method.dealing with warnings that are made during a run or
REPL session.JenaAtomicCalculator.Basics.AbstractDiagonalizeTheme — Type
abstract type Basics.AbstractDiagonalizeTheme ... labels the theme (kind) of a Basics.diagonalize() call; it is used for dispatch and to avoid string comparisons. Concrete subtypes: + MatrixWithLinearAlgebra ... diagonalize a single symmetric matrix using LinearAlgebra.eigen(). + GeneralizedEigenvaluesWithLinearAlgebra ... solve a generalized eigenvalue problem using LinearAlgebra.eigen().
JenaAtomicCalculator.Basics.AbstractDisplayTheme — Type
abstract type Basics.AbstractDisplayTheme ... defines an abstract and a number of singleton types to select the display theme for Basics.display(), replacing the former string-key dispatch.
+ PhysicalConstants ... display all currently defined physical constants.
+ CurrentSettings ... display all currently defined settings of the JAC module.JenaAtomicCalculator.Basics.AbstractEeInteraction — Type
abstract type Basics.AbstractEeInteraction ... defines an abstract and a number of singleton types for specifying the electron-electron interaction.
+ struct DiagonalCoulomb ... to represent the Coulomb part of the e-e interaction for just diagonal ME.
+ struct CoulombInteraction ... to represent the Coulomb part of the electron-electron interaction.
+ struct CoulombGaunt ... to represent the Coulomb part of the electron-electron interaction.
+ struct BreitInteraction(factor::Float64)
... to represent the Breit part of the electron-electron interaction, with factor scaling the photon
wave number omega = factor * |E_a - E_c| / c.
factor = 0 gives the standard frequency-independent Breit interaction and factor = 1 the full
frequency-dependent one; the former is the exact omega -> 0 limit of the latter, taken within the
same expressions rather than by a separate code path. Both the Gaunt and the retardation part
are frequency dependent since 14-Aug-2026; before that date no JAC number contained a retardation
correction, and factor = 1 applied a hard-coded 1.05 that had no derivation. See the reference
formulation heading the Breit section of module-InteractionStrength.jl.
NOTE ALSO THE GAUGE: the omega -> 0 limit taken in the Coulomb gauge is the BREIT operator (this
type), whereas the omega -> 0 limit in the Feynman gauge is the GAUNT operator (CoulombGaunt).
They are different approximations, not two names for one.
+ struct CoulombBreit(factor::Float64) ... to represent the Coulomb+Breit part of the electron-electron interaction.JenaAtomicCalculator.Basics.AbstractEmField — Type
abstract type Basics.AbstractEmField ... defines an abstract type to distinguish between different static and time-dependent electric and magnetic fields; this is useful for atomic compass simulations and for the computation of Stark shifts.
+ NoEmField ... No electric and magnetic field is defined.
+ StaticField ... A static field that is characterized by its (real) amplitude into a given direction.
+ TimeHarmonicField ... Define a time-harmonic field that is characterized by its (real) amplitude into a given direction and a
(harmonic) frequency.JenaAtomicCalculator.Basics.AbstractEmissionKind — Type
abstract type Basics.AbstractEmissionKind ... defines an abstract and two singleton types to distinguish between the emission and absorption direction of a radiative amplitude.
+ struct Emission ... to compute the photon-emission amplitude <f || O^(Mp) || i>.
+ struct Absorption ... to compute the photon-absorption amplitude <f || O^(Mp) || i>; equal to the conjugate of the emission amplitude
with initial and final levels interchanged.JenaAtomicCalculator.Basics.AbstractEmpiricalSettings — Type
abstract type Basics.AbstractEmpiricalSettings ... defines an abstract type to distinguish between different settings of empirical processes/computations.
JenaAtomicCalculator.Basics.AbstractEstimateTheme — Type
abstract type Basics.AbstractEstimateTheme ... labels the theme (kind) of a Semiempirical.estimate() call; it is used for dispatch and to avoid string comparisons. Concrete subtypes: + EstimateIonizationPotentialInnerShell ... estimate the ionization potential of an inner-shell electron. + EstimateBindingEnergyWilliams2000 ... estimate binding energies from Williams et al. (2000) tabulation. + EstimateBindingEnergyLarkins1977 ... estimate binding energies from Larkins (1977) tabulation. + EstimateBindingEnergyXrayDataBooklet ... estimate binding energies from X-ray Data Booklet tabulation. + EstimateBindingEnergyNist2025 ... estimate successive ionization potentials from NIST (2025) database.
JenaAtomicCalculator.Basics.AbstractExcitationScheme — Type
abstract type Basics.AbstractExcitationScheme ... defines an abstract and a number of singleton types to distinguish between different schemes for generating configuration lists as they frequently occur in Green function and cascade computations.
+ struct NoExcitationScheme
... dummy scheme for (unsupported) initialization of this abstract tpye.
+ struct DeExciteSingleElectron
... generates all excitations and de-excitations of a single electron from a given list of bound electron configurations. The number of
electrons of the generated configurations is the same as for the given bound configurations.
+ struct DeExciteTwoElectrons
... generates all excitations and de-excitations of one or two electrons from a given list of bound electron configurations. The number
of electrons of the generated configurations is the same as for the given bound configurations.
+ struct AddSingleElectron
... generates configurations by just adding a single electrons to a given list of bound electron configurations. The number of electrons
of the generated configurations is N+1.
+ struct ExciteByCapture
... generates all excitations and de-excitations of one or more electron from a given list of bound electron configurations, together
with an capture of an additional electron. The number of electrons of the generated configurations is N+1.JenaAtomicCalculator.Basics.AbstractFieldValue — Type
abstract type Basics.AbstractFieldValue ... to specify and deal with the function values of different physical fields, such as f(x), f(x,y,z), f(rho,phi), f(r,theta,phi), and for both, scalar and vector fields. Often, such field values are the outcome of some computation which can be used for integration, display, etc.
+ struct Cartesian2DFieldValue{Type} ... to specify a field value of type T in terms of x, y.
+ struct Cartesian3DFieldValue{Type} ... to specify a field value of type T in terms of x, y, z.
+ struct PolarFieldValue{Type} ... to specify a field value of type T in terms of rho, phi.
+ struct SphericalFieldValue{Type} ... to specify a field value of type T in terms of r, theta, phi.JenaAtomicCalculator.Basics.AbstractFieldVector — Type
abstract type Basics.AbstractFieldVector ... to specify and deal with different physical field vectors, such as (Ax, Ay), (Ax, Ay, Az), (A1, A0, A_-1). Often, such field values are used to charaterize electric or magnetic fields (vector potentials).
+ struct Cartesian2DFieldVector{Type} ... to specify a field vector of type T in terms of (Ax, Ay).
+ struct Cartesian3DFieldVector{Type} ... to specify a field vector of type T in terms of (Ax, Ay, Az).JenaAtomicCalculator.Basics.AbstractGenerateTheme — Type
abstract type Basics.AbstractGenerateTheme ... defines an abstract and a number of singleton types to select the generation theme for Basics.generate(), replacing the former string-key dispatch.
+ CondensedMultiplet ... condense/reduce the CSF basis of a multiplet by a single weight.
+ ConfigurationListNRFromBasis ... generate the NR configuration list from a given basis.
+ ConfigurationListNRFromConfiguration ... generate an NR configuration list from a reference configuration with excitations.
+ CsfList ... construct the CSF list from a single relativistic configuration.
+ OrderedShellList ... generate an ordered NR shell list from a set of configurations.
+ OrderedSubshellList ... generate an ordered relativistic subshell list from configurations or two bases.
+ SlaterTypeSpectrum ... generate a complete single-electron STO spectrum (positive and negative states).
+ SlaterTypeSpectrumPositive ... generate the same but return only the positive states.JenaAtomicCalculator.Basics.AbstractLevelPopulation — Type
abstract type Basics.AbstractLevelPopulation ... defines an abstract and a number of singleton types to distinguish between different level population (models).
+ struct BoltzmannLevelPopulation ... to represent a Boltzmann level population.
+ struct SahaLevelPopulation ... to represent a Saha level population.JenaAtomicCalculator.Basics.AbstractLineShiftSettings — Type
abstract type Basics.AbstractLineShiftSettings ... defines an abstract and a number of singleton types for the the (allowed) plasma models.
+ Basics.NoLineShiftSettings ... No line-shift settings are defined.
+ AutoIonization.PlasmaSettings ... Settings for Auger-line computations.
+ PhotoIonization.PlasmaSettings ... Settings for photoionization-line computations.JenaAtomicCalculator.Basics.AbstractMesh — Type
abstract type Basics.AbstractMesh ... to specify different mesh types in terms of their basic parameters; these meshes can be used, for example, for integration or for defining the representation of observables.
+ struct Cartesian2DMesh ... to specify a 2D Cartesian mesh in terms of x and y.
+ struct GLegenreMesh ... to specify a Gauss-Legendre mesh in terms of [a,b] and number of zeros.
+ struct LinearMesh ... to specify a linear mesh in terms of [a,b] and number of points.
+ struct PolarMesh ... to specify a 2D mesh for rho and phi.
+ struct SphericalMesh ... to specify a 3D mesh in terms of r, theta, phi.JenaAtomicCalculator.Basics.AbstractOrbitalSource — Type
abstract type Basics.AbstractOrbitalSource ... defines an abstract and three singleton types to say WHICH one-electron orbital set the multiplets of an Atomic.Computation are built on. It exists because an explicit second-order amplitude is valid only where its initial, intermediate (Green) and final multiplets share ONE orthonormal set: the matrix element such an amplitude needs at a junction whose two CSFs differ in ONE orbital is <r|H - E|s> = <r|h_D|s> + <r|V_ee|s> - E <r|s>, and ManyElectron.matrixElement_HminusE drops the overlap term on exactly that orthonormality assumption. Separate SCF runs make the assumption false. Measured 02-Nov-2026 on examples/example-Dj.jl: a Green space and an initial state from their own SCFs departed by 8.2e-02 at <2s_green|1s_initial>, and the dropped term came to 2.05x the matrix element it would have corrected.
ONE SET IS NOT MORE ACCURATE, IT IS MORE CONSISTENT, and the distinction is worth keeping: no single set can be optimal for
all three states at once, so sharing one is a deliberate COMPROMISE in the description of each of them. What it buys is that
the operator JAC evaluates equals the operator the physics asks for. It does NOT follow that a shared set must give a HIGHER
energy, and an earlier wording of this paragraph wrongly said so: `SelfConsistent.performSCF` is a mean-field procedure and
not a level-specific variational minimisation, so neither number is a variational bound and the ordering can come out either
way. Measured 02-Nov-2026 on Li-like Ne, initial [1s^2 2s, 1s^2 2p] against final [1s^2 2p], the frozen final level came out
1.4e-04 Ha BELOW its own separately converged SCF. `TwoElectronOnePhoton` measures the trade as worth making -- on one set,
explicit second order reproduces full CI to 0.3 % -- but nothing establishes that in general, so the default stays
`SeparateOrbitals()` and no existing result moves.
+ struct SeparateOrbitals ... every multiplet from its own SCF. THE DEFAULT, and what JAC has always done: correct for a
first-order amplitude whose CSFs differ in TWO orbitals, where a one-body operator cannot
contribute at all and `V_ee` is the whole answer.
+ struct InitialStateOrbitals ... one SCF on the initial configurations; every other multiplet is a CI on those frozen orbitals.
The natural choice for an absorption or decay amplitude, since the series is referenced to
`E_i`, its denominators are `E_i - E_n`, and the dropped overlap term carries `E_i`.
+ struct FinalStateOrbitals ... one SCF on the final configurations, with the others frozen onto it; the choice where the FINAL
state is the measured one.
+ struct GivenOrbitals ... the caller supplies the set outright, and EVERY multiplet is a CI on it. This is the one that
completes a SECOND-ORDER computation, because the Green space is built by the caller BEFORE
`perform` runs -- it lives in the process settings -- so the caller already holds the orbitals
and nothing is gained by having `perform` rediscover them. It also lifts the restriction the
other two carry: the SCF may run over a WIDER configuration list than any multiplet's CI, which
is what a 1s^2 initial state needs when its Green space occupies 2s and 2p. Measured
02-Nov-2026 on He-like Be: one SCF over [1s^2, 1s 2s, 1s 2p] carries a 1s^2 initial state and a
[1s, 2s, 2p] Green space with condition (b) MET, at the price of 3.3e-02 Ha (0.24 %) on the
initial-state energy against its own dedicated SCF.
A CONTINUUM orbital's generating field is a SEPARATE question and is not decided here: it is resolved per module from the
relevant `AsfSettings.scField`, for which see `Continuum.resolveExchangeDefault`.JenaAtomicCalculator.Basics.AbstractPlasmaModel — Type
abstract type Basics.AbstractPlasmaModel ... defines an abstract and a number of singleton types for the the (allowed) plasma models.
+ NoPlasmaModel ... No plasma model defined.
+ DebyeHueckelModel ... Debye-Hueckel plasma model; supported for IPD shifts (Plasma.determineIpShifts) and for the screened
CI matrix / amplitudes (Basics.compute(...,plasmaModel)).
+ IonSphereModel ... Ion-sphere model; supported for IPD shifts, not yet for the screened CI matrix / amplitudes
(InteractionStrength.XL_plasma_ionSphere).
+ StewartPyattModel ... Stewart-Pyatt model; supported for IPD shifts only, cf. IonSphereModel.
+ EckerKroellModel ... Ecker-Kroell model; supported for IPD shifts only, cf. IonSphereModel.
+ WithoutAutoionizationModel ... Just excludes all autoionizing levels; no original plasma model.
The note that stood here until 23-Oct-2026 -- that Ecker-Kroell was deliberately not implemented because its strong-coupling
branch could not be confirmed from the secondary literature -- has been DISCHARGED exactly as it asked: the primary reference was
read, and Basics.EckerKroellModel below carries what it says together with the three places where the secondary literature states
it differently.JenaAtomicCalculator.Basics.AbstractPlotTheme — Type
abstract type Basics.AbstractPlotTheme ... defines an abstract and a number of singleton types to select the plot theme for Basics.plot(), replacing the former string-key dispatch.
+ RadialPotentials ... plot one or more radial potentials.
+ RadialOrbitalsLarge ... plot the large component of one or more radial orbitals.
+ RadialOrbitalsSmall ... plot the small component of one or more radial orbitals.
+ RadialOrbitalsBoth ... plot both components of one or more radial orbitals.JenaAtomicCalculator.Basics.AbstractPolarization — Type
abstract type Basics.AbstractPolarization ... defines an abstract type to comprise various polarizations of light and electron beams.
+ LinearPolarization ... to specify a linearly-polarized pulse/beam.
+ LeftCircular ... to specify a left-circularly polarized pulse/beam.
+ RightCircular ... to specify a right-circularly polarized pulse/beam.
+ LeftElliptical ... to specify an elliptically polarized pulse/beam.
+ RightElliptical ... to specify an elliptically polarized pulse/beam.
+ NonePolarization ... to specify an upolarized pulse/beam.JenaAtomicCalculator.Basics.AbstractProcess — Type
abstract type Basics.AbstractProcess ... defines an abstract and a number of singleton types to distinguish different atomic processes.
+ struct Auger ... Auger transitions, i.e. single autoionization or the emission of a single free electron into the
continuum.
+ struct AugerInPlasma ... Auger transitions but calculated for a specified plasma model.
+ struct Compton ... Rayleigh-Compton scattering cross sections.
+ struct ElecCapture ... the (dielectronic) electron-capture process, i.e. the capture of a free electron into a bound shell.
+ struct Coulex ... Coulomb-excitation of target or projeticle electrons by fast, heavy ions.
+ struct Coulion ... Coulomb-ionization of target or projeticle electrons by fast, heavy ions.
+ struct Dierec ... di-electronic recombination, i.e. the dielectronic capture of a free electron and the subsequent emission
of a photon.
+ struct DoubleAuger ... Double Auger rates.
+ struct ImpactExcAuto ... electron-impact excitation with subsequent autoionization, i.e. an inner-shell electron is raised by
electron impact to a level above the ionization threshold, which then autoionizes.
+ struct InternalConv ... internal conversion, i.e. the transfer of nuclear excitation energy to a bound electron which is thereby
ejected.
+ struct NoProcess ... dummy process for the initialization of a Cascade.Step or an atomic computation; it denotes the ABSENCE
of a process and is never computed.
+ struct PairA1P ... one-photon pair annihilation, in which a bound electron and a positron annihilate under emission of a
single photon.
+ struct MultiPhotonDE ... multi-photon excitation and decay rates, including 2-photon, etc. processes.
+ struct MultiPI ... multi-photon (single-electron) ionization.
+ struct Photo ... Photoionization processes, i.e. the emission of a single free electron into the continuum due to an
external light field.
+ struct PhotoDouble ... Photo-double ionization rates.
+ struct PhotoExc ... Photoexcitation rates.
+ struct PhotoExcFluor ... photoexcitation fluorescence rates and cross sections.
+ struct PhotoExcAuto ... photoexcitation autoionization cross sections and collision strengths.
+ struct PhotoInPlasma ... Photoionization processes but calculated for a specified plasma model.
+ struct Radiative ... Radiative (multipole) transitions between bound-state levels of the same charge state.
+ struct Rec ... radiative electron capture, i.e. the capture of a free electron with the simultaneous emission of a
photon.
+ struct ImpactExc ... electron-impact excitation cross sections and collision strengths.
+ struct RAuger ... Radiative Auger rates.JenaAtomicCalculator.Basics.AbstractProcessSettings — Type
abstract type Basics.AbstractProcessSettings ... defines an abstract type to distinguish between different settings of atomic processes.
JenaAtomicCalculator.Basics.AbstractPropertySettings — Type
abstract type Basics.AbstractPropertySettings ... defines an abstract type to distinguish between different settings of atomic level properties.
JenaAtomicCalculator.Basics.AbstractQSpacePerturbation — Type
abstract type Basics.AbstractQSpacePerturbation ... how the Q-space's OWN internal coupling is treated before it is folded into the CI by Hamiltonian.secondOrderBlock – a question separate from Basics.AbstractQTreatment, which decides promote/fold/discard for each configuration, and from AtomicState. AbstractRasStoppingPolicy/AbstractRasShellPolicy (the automatic-RAS-ladder policies), but the same shape: a small, deliberately open family, meant to grow by one new struct and one dispatch method, never by a change to an existing one.
+ struct DiagonalCSFPerturbation ... every Q-space CSF folded as its own, isolated intermediate
state. The default, and what JAC has always done.
+ struct BlockDiagonalizedPerturbation ... a folded Q-space configuration's own CSFs are diagonalized
together FIRST, and the fold then uses ITS eigenstates.JenaAtomicCalculator.Basics.AbstractQTreatment — Type
abstract type Basics.AbstractQTreatment ... defines an abstract type to say how the Q space of a RAS step is to be treated – the configurations the step GENERATES but which need not all enter the CI. The two implementations are not two algorithms but the two ends of one dial, and it is the individual configuration that is routed rather than the step.
+ struct Variational ... every generated configuration enters the CI. What a RAS step has always done.
+ struct SecondOrder ... each configuration is ranked by the fraction of the atomic state function it
carries, and is then promoted into the CI, folded in perturbatively, or dropped.JenaAtomicCalculator.Basics.AbstractQuantizationAxis — Type
abstract type Basics.AbstractQuantizationAxis ... defines an abstract type to distinguish between different choices of the quantization axis in light-atom interactions.
+ DefaultQuantizationAxis ... Use the (default) z-axis for quantization of atomic levels.
+ StaticQuantizationAxis ... Define a static quantization axis in terms of a unit vector.
+ HarmonicQuantizationAxis ... Define a time-harmonic quanization axis in terms of a unit vector and a frequency.JenaAtomicCalculator.Basics.AbstractReadFileTheme — Type
abstract type Basics.AbstractReadFileTheme ... labels the file format for a Basics.read() call; it is used for dispatch and to avoid string comparisons. Concrete subtypes: + ReadCslFileGrasp92 ... read a CSF list from a Grasp92 .csl / GRASP18 .c file. + ReadOrbitalFileGrasp92 ... read orbitals from a (formatted) Grasp92 .rwf file. + ReadMixingFileGrasp18 ... read energies & mixing coefficients from a Grasp18 mixing file.
JenaAtomicCalculator.Basics.AbstractRecastTheme — Type
abstract type Basics.AbstractRecastTheme ... defines an abstract and a number of singleton types to select the recast theme for Basics.recast(), replacing the former string-key dispatch.
+ RecastRateToDecayWidth ... recast a radiative rate (Einstein A, a.u.) to a decay width.
+ RecastRateToEinsteinA ... recast a radiative rate (Einstein A, a.u.) to Einstein A in selected units.
+ RecastRateToEinsteinB ... recast a radiative rate (Einstein A, a.u.) to Einstein B-coefficient.
+ RecastRateToOscillatorGf ... recast a radiative rate (Einstein A, a.u.) to oscillator strength g_f.
+ RecastRateToOscillatorF ... recast a radiative rate (Einstein A, a.u.) to oscillator strength f.
+ RecastRateToLineStrengthS ... recast a radiative rate (Einstein A, a.u.) to line strength S.JenaAtomicCalculator.Basics.AbstractResultKey — Type
abstract type Basics.AbstractResultKey ... defines an abstract type for the keys under which Basics.perform stores a result that has no settings type of its own – the multiplets and the grid. Every OTHER result is asked for by the settings type that produced it, res[PhotoEmission.Settings] or res[Hfs.Settings], so no key has to be invented for it.
THE CONCRETE KEYS LIVE IN THE `ResultKeys` MODULE, deliberately, and that is not a stylistic choice: the
two natural names are already taken by the DATA -- `ManyElectron.Multiplet` and `Radial.Grid`. Putting a
key called `Multiplet` into `Basics` would place it one qualifier away from the datum of the same name,
which is the very near-miss that priority item 39 exists to remove (`"photon emission lines:"` was asked
for where `"radiative lines:"` was meant). A namespace removes the ambiguity without inventing
vocabulary: `ResultKeys.Multiplet` is a key, `Multiplet` is the datum, and neither has to be renamed.
The keys are TYPES rather than instances so that both halves of the interface read alike -- a key is a
bare type qualified by the module that owns it, whether it is `PhotoEmission.Settings` or
`ResultKeys.FinalMultiplet`.JenaAtomicCalculator.Basics.AbstractScField — Type
abstract type Basics.AbstractScField ... defines an abstract and a number of singleton types to distinguish between different self-consistent fields
+ struct ALField ... to represent an average-level field: a bVector-native SCF built directly around B-spline expansion
coefficient vectors (no tabulated Orbital maintained during the SCF iteration at all), a kink-aware
(spline + split adaptive quadrature) two-electron Slater integral in place of the naive tensor-product
Gauss-Legendre one, and an in-matrix orthogonality projection modeled directly on DBSR_HF (Zatsarinny &
Froese Fischer, CPC 202, 287 (2016)); see SelfConsistent.solveAverageLevelField. Validated to 5+
significant figures against literature for He/Be/Ne/Ar. (This type was developed under the working name
ALFieldClaude2 during an earlier investigation; an original, buggy ALField implementation -- and before
that a first-generation kink-aware line, ALFieldClaude -- were both superseded by this one and removed.)
+ struct EOLField ... to represent an (extended) optimized-level field.
+ struct DFSField ... to represent an mean Dirac-Fock-Slater field.
+ struct HSField ... to represent an mean Hartree-Slater field.
+ struct KSField ... to represent an mean Kohn-Sham field.
+ struct CHField ... to represent an mean core-Hartree field.
+ struct NuclearField ... to represent a pure nuclear (potential) field.
+ struct ThomasFermiField ... to represent a Thomas-Fermi screened field. Unlike every other member of this family it is NOT
self-consistent: it needs only the nuclear charge and the number of electrons, and no density at all,
which is exactly what makes it useful as a STARTING potential; see Basics.computePotential and
ManyElectron.StartFromThomasFermi.JenaAtomicCalculator.Basics.AbstractScfRoute — Type
abstract type Basics.AbstractScfRoute ... defines an abstract and a number of types to distinguish HOW the orbitals of a given self-consistent field are found. Basics.AbstractScField says what the orbitals are optimized FOR; this family says by which procedure they are obtained. Basics.scfProcedure already names that second axis, but derives it from the field, so it could not be chosen: these types make it a setting. They form a HIERARCHY by cost – a fast route that may fail, a slow route that is dependable – so that a computation can be repeated on a more expensive route when a cheaper one does not converge; every route reports which one it was and how it ended, since a recorded energy is only meaningful together with the path that produced it.
+ struct AutomaticRoute ... to take the standard route of the given field, i.e. whatever Basics.scfProcedure names; the
default, so that a field alone remains a complete specification.
+ struct MeanFieldRoute ... to iterate a local screened potential to self-consistency (DFS, HS, KS, CH).
+ struct AverageLevelRoute ... to run the average-level variational procedure.
+ struct RotationRoute ... to obtain an optimized level by ORBITAL ROTATION, i.e. by direct minimization of the level
energy. Dependable but slow: it descends monotonically and keeps the basis orthonormal to
1e-15, and it needs hundreds to thousands of iterations to do so (measured 08-Sep-2026 on
C-like uranium: |grad| 7.6e-03 at 400 iterations and 3.3e-04 at 2000, the energy still
falling by 5.4e-04 Ha in between). This is the fallback of the hierarchy.
+ struct FockRoute ... to obtain an optimized level by solving the Fock equations to self-consistency, as GRASP does.
Fast where it works -- tens of iterations rather than thousands -- but it can converge onto a
degenerate stationary point when two near-degenerate CSFs compete for one correlation channel
and the correlating weight runs to zero; cf. the note at SelfConsistent.performSCF.
+ struct NewtonRoute ... reserved for a second-order (Newton) procedure that uses the curvature and not only the
gradient. NOT IMPLEMENTED: it raises rather than silently taking another route.JenaAtomicCalculator.Basics.AbstractSelection — Type
abstract type Basics.AbstractSelection ... defines an abstract and a number of concrete types to distinguish between level- and line-selectors
+ struct LevelSelection ... to specify a list of levels by means of their (level) indices or level symmetries.
+ struct LineSelection ... to specify a list of lines by means of their (level) indices or level symmetries.
+ struct PathwaySelection ... to specify a list of lines by means of their (level) indices or level symmetries.
+ struct ShellSelection ... to specify a list of lines by means of their (level) indices or level symmetries.JenaAtomicCalculator.Basics.AbstractSpectrumKind — Type
abstract type Basics.AbstractSpectrumKind ... defines an abstract and a number of singleton types for specifying different kinds of spectra that need to be displayed
+ struct BarIntensities
... to display just intensity-bars at given x-positions.
+ struct DiscreteLines
... to display lines (for guiding the eyes) but which are only defined at discrete x-points.
+ struct DiscretePoints
... to display discrete points that are defined at discrete x-points.
+ struct LorentzianIntensitiesConstantWidths
... to display the superposition of Lorentzians with given position and intensity but constant widths.
+ struct LorentzianIntensities
... to display the superposition of Lorentzians with given position, intensity and individual widths.JenaAtomicCalculator.Basics.AbstractStarkBroadeningMethod — Type
abstract type Basics.AbstractStarkBroadeningMethod ... selects which closed-form relation StarkBroadening uses to turn a line's own structure (its perturbers, or its own effective quantum numbers) into an electron-impact width/shift – selected BY WHICH CONCRETE TYPE YOU SUPPLY, never by a flag, the same discipline as AbstractScfRoute or AbstractEeInteraction. More than one such method is in active, independent use in the Stark- broadening literature – not one formula with cosmetic variants – so a type per method is the honest representation; see StarkBroadening's own module docstring for the primary sources behind each.
+ struct SimplifiedModifiedSemiempiricalMethod ... the Dimitrijevic & Konjevic (1987) low-temperature
simplification (SMSE): a fully closed form using
only the line's own two levels' effective quantum
numbers and orbital angular momenta -- no
perturber search needed. Carries its OWN physics
parameters, since unlike `StarkBroadening.Settings`'s
density/temperature (properties of the PLASMA),
these are properties of the ION itself.JenaAtomicCalculator.Basics.AbstractTransitionOperator — Type
abstract type Basics.AbstractTransitionOperator ... defines an abstract and a number of types for specifying WHICH OPERATOR carries a transition amplitude. It answers a different question from AbstractEeInteraction, which says which TERMS OF THE HAMILTONIAN are included, and the two are deliberately kept disjoint: an AbstractEeInteraction is consumed by seventeen typeof(kind) in [...] lists across six modules, so a transition operator smuggled in as a subtype of it would fall silently through every one of them – the failure mode that lost CoulombGaunt in ImpactExcitation. A transition operator CARRIES an interaction; it is not one.
+ struct VeeOnly(kind) ... the bare electron-electron interaction, i.e. the historical shortcut.
+ struct HminusE(kind) ... the operator H - E, which is what a transition amplitude actually requires.
WHY THE DISTINCTION IS NOT COSMETIC. An Auger-like amplitude is <f| H - E |i>. Where the two states are built on ONE orthonormal
orbital set and differ in TWO or more orbitals, the one-body part of H cannot connect them and the overlap vanishes, so H - E
reduces exactly to V_ee -- which is why VeeOnly has carried every validated first-order Auger, DR and cascade number in JAC. The
shortcut fails in two places, and both are now live:
* states differing in ONE orbital a -> b, which is what a SECOND-ORDER sum produces at its Green-multiplet junctions. There
<b|h|a> = -<b|U|a> cancels V_ee's spectator direct+exchange <b|U_HF|a> down to the residual <b|(U_HF - U)|a>, and keeping only
V_ee returns the WHOLE mean field. Measured 23-Oct-2026 on Ar 2p^-2 -> 3p^-3: V_ee gives 43.5x the measured rate and dropping
the spectator terms by hand gives 12x too little, a factor 523 apart and bracketing the measurement.
* NON-ORTHOGONAL orbital sets, where <f|i> no longer vanishes and the -E<f|i> term is what represents it. THAT HALF IS NOT
YET IMPLEMENTED: the term vanishes under the orthonormality JAC assumes throughout, so HminusE carries no E field until the
biorthogonal route lifts the assumption and something would actually read it.
THE ONE-BODY TERM IS THE BARE h, not -U, and that is the point: it needs no knowledge of which mean field produced the orbitals and
it stays correct when they are eigenfunctions of nothing.
AND `kind` MUST MATCH THE HAMILTONIAN THAT PRODUCED THE LEVELS AND THEIR ENERGY E. E is an eigenvalue of that Hamiltonian, so a
Coulomb-only multiplet paired with a Coulomb+Breit H - E subtracts against the wrong E and returns a wrong number in silence.
Breit on top of Coulomb-only levels is an ADDITIONAL perturbation and carries no one-body counterterm, since it sits in neither U
nor E. Parameterising on the interaction lets a contraction be defined for matching pairs only, so a mismatch raises a MethodError
naming both types instead.JenaAtomicCalculator.Basics.AbstractWarning — Type
abstract type Basics.AbstractWarning ... defines an abstract and a number of singleton types for dealing with warnings that are made during a run or REPL session. Cf. Defaults.warn().
+ AddWarning ... add a Warning to a warningList.
+ PrintWarnings ... print all warnings into a jac-warn.report file.
+ ResetWarnings ... reset (empty) the warningList, usually at the beginning of a new run.to distinguish between different warningsJenaAtomicCalculator.Basics.AddElectrons — Type
struct Basics.AddElectrons <: AbstractConfigurationTheme ... to add ne electrons in the intoshells for each of the given configurations.
+ ne ::Int64 ... number of electrons to be added.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are added.JenaAtomicCalculator.Basics.AddSingleElectron — Type
... generates configurations by just adding a single electrons to a given list of bound electron configurations. The number of electrons of the generated configurations is N+1.
JenaAtomicCalculator.Basics.AddWarning — Type
... add a Warning to a warningList.
JenaAtomicCalculator.Basics.AllShells — Type
... to extract all occupied shells from a set of configurations.
JenaAtomicCalculator.Basics.AngularJ64 — Method
Basics.AngularJ64(j::Integer) ... constructor for a given integer (numerator). A angularJ64::Basics.AngularJ64 is returned.
JenaAtomicCalculator.Basics.AngularJ64 — Method
Basics.AngularJ64(rational::Rational{Int64}) ... constructor for a given Rational{Int64}. A angularJ64::Basics.AngularJ64 is returned.
JenaAtomicCalculator.Basics.AngularJ64 — Type
struct AngularJ64 <: AbstractAngularMomentum ... defines a type for angular momenta j.
+ num ::Int64 ... numerator
+ den ::Int64 ... denominator, must be 1 or 2JenaAtomicCalculator.Basics.AngularM64 — Method
Basics.AngularM64(j::AngularJ64) ... constructor for a given j::AngularJ64 to define m = j. A angularM64::Basics.AngularM64 is returned.
JenaAtomicCalculator.Basics.AngularM64 — Method
Basics.AngularM64(m::Integer, j::AngularJ64) ... constructor for a given integer (numerator) that is consistent with a given j-value. A angularM64::Basics.AngularM64 is returned.
JenaAtomicCalculator.Basics.AngularM64 — Method
Basics.AngularM64(m::Integer) ... constructor for a given integer (numerator). A angularM64::Basics.AngularM64 is returned.
JenaAtomicCalculator.Basics.AngularM64 — Method
Basics.AngularM64(rational::Rational{Int64}, j::AngularJ64) ... constructor for a given Rational{Int64} that is consistent with a given m-value. A angularM64::Basics.AngularM64 is returned.
JenaAtomicCalculator.Basics.AngularM64 — Method
Basics.AngularM64(rational::Rational{Int64}) ... constructor for a given Rational{Int64}. A angularM64::Basics.AngularM64 is returned.
JenaAtomicCalculator.Basics.AngularM64 — Type
struct Basics.AngularM64 <: AbstractAngularMomentum ... defines a type for angular momentum projections m.
+ num ::Int64 ... numerator
+ den ::Int64 ... denominator, must be 1 or 2JenaAtomicCalculator.Basics.AsymptoticCoulomb — Type
... generate a pure (asymptotic) Coulombic function for both components.
JenaAtomicCalculator.Basics.Auger — Type
... Auger transitions, i.e. single autoionization or the emission of a single free electron into the continuum.
JenaAtomicCalculator.Basics.AugerInPlasma — Type
... Auger transitions but calculated for a specified plasma model.
JenaAtomicCalculator.Basics.AverageLevelRoute — Method
Basics.AverageLevelRoute() ... defines the default budget
JenaAtomicCalculator.Basics.AverageLevelRoute — Type
struct Basics.AverageLevelRoute <: AbstractScfRoute ... defines a type to run the average-level variational procedure.
+ maxIterations ::Int64 ... maximum number of iterations this route may take.JenaAtomicCalculator.Basics.AverageSCA — Type
... all levels in the cascade are described in single-configuration and single-CSF approximation; this (rather crude) approach neglects all configuration-interactions and also applies just a single set of one-electron orbitals (from the least-ionized charge state) for all considered charge states.
JenaAtomicCalculator.Basics.BarIntensities — Type
... to display just intensity-bars at given x-positions.
JenaAtomicCalculator.Basics.BlockDiagonalizedPerturbation — Type
struct Basics.BlockDiagonalizedPerturbation <: Basics.AbstractQSpacePerturbation ... for each folded Q-space configuration, its own CSFs are diagonalized together FIRST, and the fold then uses that configuration's own eigenstates and eigenvalues in place of its bare CSFs' diagonal elements – capturing correlation WITHIN one Q-space configuration that Basics.DiagonalCSFPerturbation cannot see, since that route never asks whether two Q-space CSFs couple to each other at all. More expensive than the diagonal route (one small diagonalization per folded configuration, rather than none), named because the maintainer's own contact with the GRASP community reports this can matter.
JenaAtomicCalculator.Basics.BoltzmannLevelPopulation — Type
... to represent a Boltzmann level population.
JenaAtomicCalculator.Basics.BreitInteraction — Type
... to represent the Breit part of the electron-electron interaction, with factor scaling the photon wave number omega = factor * |Ea - Ec| / c. factor = 0 gives the standard frequency-independent Breit interaction and factor = 1 the full frequency-dependent one; the former is the exact omega -> 0 limit of the latter, taken within the same expressions rather than by a separate code path. Both the Gaunt and the retardation part are frequency dependent since 14-Aug-2026; before that date no JAC number contained a retardation correction, and factor = 1 applied a hard-coded 1.05 that had no derivation. See the reference formulation heading the Breit section of module-InteractionStrength.jl. NOTE ALSO THE GAUGE: the omega -> 0 limit taken in the Coulomb gauge is the BREIT operator (this type), whereas the omega -> 0 limit in the Feynman gauge is the GAUNT operator (CoulombGaunt). They are different approximations, not two names for one.
JenaAtomicCalculator.Basics.BsplineGalerkin — Type
... generate a continuum orbital with the Galerkin method.dealing with warnings that are made during a run or REPL session.
JenaAtomicCalculator.Basics.ByMultipoles — Type
... to extract the configurations due to multipole selection themes.
JenaAtomicCalculator.Basics.ByNumber — Type
struct Basics.ByNumber <: AbstractConfigurationTheme ... to select configurations due to given numbers of electrons.
+ NoElectrons ::Array{Int64,1} ... List of selected electron numbersJenaAtomicCalculator.Basics.ByParity — Type
struct Basics.ByParity <: AbstractConfigurationTheme ... select configurations due to a given parity.
+ P ::Basics.Parity ... Selected parity.JenaAtomicCalculator.Basics.CImatrixWithSymmetryJP — Type
... compute the CI Hamiltonian matrix for a given J^P symmetry block.
JenaAtomicCalculator.Basics.Cartesian2DFieldValue — Type
struct Basics.Cartesian2DFieldValue{Type} <: Basics.AbstractFieldValue ... to specify a scalar field value of type Type in terms of x, y.
+ x ::Float64 ... x-coordinate.
+ y ::Float64 ... y-coordinate.
+ val ::Type ... field value of type Type.JenaAtomicCalculator.Basics.Cartesian2DFieldVector — Type
struct Basics.Cartesian2DFieldVector{Type} <: Basics.AbstractFieldVector ... to specify a scalar field vector of type T in terms of (Ax, Ay).
+ x ::Type ... x-component.
+ y ::Type ... y-component.JenaAtomicCalculator.Basics.Cartesian2DMesh — Type
struct Basics.Cartesian2DMesh <: Basics.AbstractMesh ... to specify a 2D Cartesian mesh in terms of x and y.
+ xMesh ::Basics.AbstractMesh ... mesh for the x-coordinate.
+ yMesh ::Basics.AbstractMesh ... mesh for the y-coordinate.JenaAtomicCalculator.Basics.Cartesian3DFieldValue — Type
struct Basics.Cartesian3DFieldValue{Type} <: Basics.AbstractFieldValue ... to specify a scalar field value of type Type in terms of x, y, z.
+ x ::Float64 ... x-coordinate.
+ y ::Float64 ... y-coordinate.
+ z ::Float64 ... z-coordinate.
+ val ::Type ... field value of type Type.JenaAtomicCalculator.Basics.Cartesian3DFieldVector — Type
struct Basics.Cartesian3DFieldVector{Type} <: Basics.AbstractFieldVector ... to specify a scalar field vector of type T in terms of (Ax, Ay, Az).
+ x ::Type ... x-component.
+ y ::Type ... y-component.
+ z ::Type ... z-component.JenaAtomicCalculator.Basics.ClosedCore — Type
... to extract the closed core from the given configuration.
JenaAtomicCalculator.Basics.ClosedShells — Type
... to extract the closed shells from given configurations.
JenaAtomicCalculator.Basics.ClosedSubshells — Type
... to extract the closed subshells from given configurations.
JenaAtomicCalculator.Basics.Compton — Type
... Rayleigh-Compton scattering cross sections.
JenaAtomicCalculator.Basics.CondensedMultiplet — Type
... condense/reduce the CSF basis of a multiplet by a single weight.
JenaAtomicCalculator.Basics.ConfigurationListNRFromBasis — Type
... generate the NR configuration list from a given basis.
JenaAtomicCalculator.Basics.ConfigurationListNRFromConfiguration — Type
... generate an NR configuration list from a reference configuration with excitations.
JenaAtomicCalculator.Basics.ContBessel — Type
... generate a pure Bessel function for the large component together with kinetic balance.
JenaAtomicCalculator.Basics.ContSine — Type
... generate a pure Sine function for the large component together with kinetic balance.
JenaAtomicCalculator.Basics.ContinuumNormalization — Type
abstract type Basics.ContinuumNormalization ... defines an abstract and a number of singleton types for dealing with the normalization of continuum orbitals.
+ PureSineNorm ... normalize with regard to an (asymtotic) pure sine funtion, sin(kr).
+ CoulombSineNorm ... normalize with regard to an (asymtotic) Coulombic-sine funtion, sin(kr + ...).
+ OngRussekNorm ... normalize by following Ong & Russek (1973).
+ CoulombFunctionNorm ... normalize by matching the orbital's value AND derivative to the EXACT Coulomb
(or spherical Bessel) functions, following Salvat's RADIAL code. Unlike the two
sine conventions above it assumes no asymptotic expansion, so it stays valid at
small radii and large Coulomb parameter. This is the shipped default.JenaAtomicCalculator.Basics.ContractShells — Type
... to extract the configurations without empty shell occupation (contracted shells).
JenaAtomicCalculator.Basics.Coulex — Type
... Coulomb-excitation of target or projeticle electrons by fast, heavy ions.
JenaAtomicCalculator.Basics.Coulion — Type
... Coulomb-ionization of target or projeticle electrons by fast, heavy ions.
JenaAtomicCalculator.Basics.CoulombBreit — Type
... to represent the Coulomb+Breit part of the electron-electron interaction, with factor as for BreitInteraction and quadrature selecting HOW the radial integrals are evaluated – the SAME physics either way. :direct (the default, and what every JAC number before 04-Sep-2026 used) evaluates each sub-coefficient as a full double sum over the grid, O(N^2); :swept exploits the fact that every Breit kernel factorises into a function of r< times a function of r>, and accumulates the inner integral in one pass, O(N) – the same construction the Coulomb path has always used through RadialIntegrals.SlaterRkKinkAware. The two agree to the accuracy of the quadrature but NOT bit for bit, because the summation order differs; :direct is kept as the readable reference form and as the oracle the swept form is tested against. Quadrature is deliberately NOT a separate AbstractEeInteraction: that type answers WHICH TERMS of the Hamiltonian are included and is consumed by seventeen typeof(kind) in [...] lists across six modules, where a missing entry silently drops a whole interaction – as happened to CoulombGaunt in ImpactExcitation.
JenaAtomicCalculator.Basics.CoulombFunctionNorm — Type
... normalize by matching value and derivative to the EXACT Coulomb or Bessel functions (Salvat RADIAL).
JenaAtomicCalculator.Basics.CoulombGaunt — Type
... to represent the Coulomb part of the electron-electron interaction.
JenaAtomicCalculator.Basics.CoulombInteraction — Type
... to represent the Coulomb part of the electron-electron interaction.
JenaAtomicCalculator.Basics.CoulombSineNorm — Type
... normalize with regard to an (asymtotic) Coulombic-sine funtion, sin(kr + ...).
JenaAtomicCalculator.Basics.CsfList — Type
... construct the CSF list from a single relativistic configuration.
JenaAtomicCalculator.Basics.CurrentSettings — Type
... display all currently defined settings of the JAC module.
JenaAtomicCalculator.Basics.DFSField — Method
Basics.DFSField() ... defines the default strength=1.0
JenaAtomicCalculator.Basics.DFSField — Type
struct Basics.DFSField <: AbstractScField ... defines a type to describe a mean Dirac-Fock-Slater field.
THIS IS JAC's DEFAULT FIELD AND ITS ORBITAL EIGENVALUES ARE NOT BINDING ENERGIES. The local-exchange
approximation leaves every valence orbital systematically underbound. Measured against Koopmans, i.e.
against the ionization potential that `PeriodicTable.ionizationPotentials_Nist2025` already carries for
the same ion, where the AL field is the non-local Dirac-Fock comparison on the same grid and basis:
He 1s -eps/IP = 0.57 (DFSField) 1.02 (ALField)
Ne 2p 0.56 1.07
Eu^3+ 4f^6 0.73 1.00 ... an OPEN f shell, measured 19-Oct-2026
So use `Basics.ALField()` wherever an INDIVIDUAL orbital energy matters -- a binding energy, a BEB cross
section, a perturbation-theory denominator -- and note that the underbinding reaches an open f shell as
readily as a closed s one.
WHAT THE CHOICE OF FIELD DOES AND DOES NOT REACH, measured on Eu^3+ 4f^6 against the twelve known levels
of that configuration, is worth knowing before quoting any of it:
* a LANDE g_J IS ESSENTIALLY IMMUNE. Over the ^7F ladder g_J sits within 0.09-0.38 % of the exact LS
value 3/2 and moves by at most 5e-4 relative between the two fields, while eps(4f) moves 27 %. The
same was found for Ti+ 3d^2 4s a^4F. BUT a level that is NEAR-DEGENERATE WITH A SAME-J PARTNER is
the exception and must be checked: ^5D_4 sits 340-610 cm^-1 from ^5G_4, and ITS g_J moves 3.5 %
between the fields, seventy times more than any ^7F level.
* FINE STRUCTURE IMPROVES. The ^7F intervals come out 9-15 % too wide on DFS and 3-11 % on AL.
* A TERM SEPARATION GETS WORSE, and this is the trap. ^5D - ^7F is 10-11 % too large on DFS and
14-18 % too large on AL, so DFS "agrees better" by a CANCELLATION OF ERRORS: its 4f is 3 % more
diffuse, which lowers the Slater integrals and imitates the reduction that correlation -- absent
from a single-configuration calculation -- would supply. Do not choose DFS on that evidence.
+ strength ::Float64 ... Strength factor of the DFS potential (default: strength=1.0)JenaAtomicCalculator.Basics.DeExciteSingleElectron — Type
... generates all excitations and de-excitations of a single electron from a given list of bound electron configurations. The number of electrons of the generated configurations is the same as for the given bound configurations.
JenaAtomicCalculator.Basics.DeExciteTwoElectrons — Type
... generates all excitations and de-excitations of one or two electrons from a given list of bound electron configurations. The number of electrons of the generated configurations is the same as for the given bound configurations.
JenaAtomicCalculator.Basics.DebyeBox — Type
... to apply the Debye-box plasma model.
JenaAtomicCalculator.Basics.DebyeHueckelModel — Method
Basics.DebyeHueckelModel() ... constructor for the default settings of Basics.DebyeHueckelModel(). A debyeHueckelModel::Basics.DebyeHueckelModel is returned.
JenaAtomicCalculator.Basics.DebyeHueckelModel — Type
struct Basics.DebyeHueckelModel <: AbstractPlasmaModel ... to specify (the parameters of) a Debye-Hückel potential, screened as exp(-r/debyeLength) / r.
+ debyeLength ::Float64 ... the (single, independent) Debye screening length lambda_D [a_o].
Some references also speak of a 'Debye radius'; in Debye-Hückel theory this coincides with the Debye length itself, so it is not
carried here as a separate parameter.JenaAtomicCalculator.Basics.DefaultQuantizationAxis — Type
... Use the (default) z-axis for quantization of atomic levels.
JenaAtomicCalculator.Basics.DiagonalCSFPerturbation — Type
struct Basics.DiagonalCSFPerturbation <: Basics.AbstractQSpacePerturbation ... every Q-space CSF is folded as its own, isolated intermediate state, using its own diagonal Hamiltonian element as the Epstein-Nesbet denominator – exactly what Hamiltonian.secondOrderBlock has always done, validated against the exact CI on Cl III (examples/example-Ar.jl branch a) and against tools/probe-secondOrderQ.jl's own measurements. This ignores whether two Q-space CSFs couple to EACH OTHER; see Basics.BlockDiagonalizedPerturbation for the alternative that does not. The default, so every existing caller of Basics.SecondOrder is unaffected.
JenaAtomicCalculator.Basics.DiagonalCoulomb — Type
... to represent the Coulomb part of the e-e interaction for just diagonal ME.
JenaAtomicCalculator.Basics.Dierec — Type
... di-electronic recombination, i.e. the dielectronic capture of a free electron and the subsequent emission of a photon.
JenaAtomicCalculator.Basics.DiscreteLines — Type
... to display lines (for guiding the eyes) but which are only defined at discrete x-points.
JenaAtomicCalculator.Basics.DiscretePoints — Type
... to display discrete points that are defined at discrete x-points.
JenaAtomicCalculator.Basics.DoubleAuger — Type
... Double Auger rates.
JenaAtomicCalculator.Basics.EOLField — Type
... to represent an (extended) optimized-level field.
JenaAtomicCalculator.Basics.EckerKroellModel — Method
Basics.EckerKroellModel() ... constructor for the default settings of Basics.EckerKroellModel(). A eckerKroellModel::Basics.EckerKroellModel is returned.
JenaAtomicCalculator.Basics.EckerKroellModel — Type
struct Basics.EckerKroellModel <: AbstractPlasmaModel ... defines the Ecker-Kroell plasma model [G. Ecker & W. Kroell, Phys. Fluids 6, 62 (1963)] for the IPD shifts (Plasma.determineIpShifts); it is not (yet) supported for the screened CI matrix / amplitudes, cf. IonSphereModel.
The model is PIECEWISE in the total free-particle density n = n_e + n_i, switching at the critical density n_cr of its
Eq. (47). Below n_cr it is Debye-Hueckel; above it the screening length is no longer the ion-sphere radius but the mean
separation r_0 of ALL free particles, electrons included, which is what makes it predict a markedly larger depression
than Stewart-Pyatt at high density. In atomic units, and with q the net charge of the ion BEFORE the ionization step:
Delta I(q) = - (q+1) / lambda_D for n <= n_cr ... Eq. (56), reduced
Delta I(q) = - cEK * (q+1) / r_0 for n > n_cr ... Eq. (57), reduced
with r_0 = (3/(4 pi (n_e+n_i)))^(1/3) and n_cr = (3/(4 pi)) * (kT / qmax^2)^3, both derived on-the-fly in
Plasma.determineIpShifts from the densities and the temperature it already receives, and therefore NOT stored here --
the same division of labour as StewartPyattModel, which stores lambda and derives R0.
THREE POINTS WHERE THE SECONDARY LITERATURE DIFFERS FROM THE PAPER, each checked against the original on 23-Oct-2026,
because each would silently give a different number:
* the charge in n_cr is the LARGEST IONIC CHARGE PRESENT in the plasma (the paper's e_(beta max), Eq. 47), not the atomic
number. The two coincide only when fully-stripped ions are present, which is how "Z, the atomic number" entered the
secondary literature.
* lambda_D is built from ALL charged components, electrons AND ions (Eq. 26, a sum over every component), i.e. exactly the
screening density JAC already forms in Plasma.updateIpdPlasmaModel. An electron-only Debye length is NOT this model.
* cEK is NOT 1 in the paper. Ecker and Kroell fix it by requiring the two branches to join at n_cr (Eq. 53) and evaluate
the resulting lattice constant as 1.73, calling the factor itself "somewhat uncertain". The value 1 that the modern
literature uses is an EXPERIMENTAL choice -- it is what reproduces the LCLS aluminium measurement -- and not the
paper's own number. Both are therefore offered, neither is hidden in the code, and a user who quotes a coefficient
should say which one they used.
+ radius ::Float64 ... the Wigner-Seitz radius R [a_o], carried for symmetry with IonSphereModel and
StewartPyattModel; the model's own radius r_0 is the all-free-particle one above.
+ electronDensity ::Float64 ... the electron density n_e (T) [a_o^-3].
+ lambda ::Float64 ... the Debye screening length lambda_D [a_o], the same quantity as
DebyeHueckelModel.debyeLength.
+ cEK ::Float64 ... the coefficient of the strong-coupling branch; 1.0 reproduces the modern literature and
1.73 is the paper's own value. See the third point above before quoting either.JenaAtomicCalculator.Basics.ElecCapture — Type
... to denote the (dielectronic) electron-capture process, i.e. the capture of a free electron into a bound shell.
JenaAtomicCalculator.Basics.Emission — Type
... to compute the photon-emission amplitude <f || O^(Mp) || i>.
JenaAtomicCalculator.Basics.EstimateBindingEnergyLarkins1977 — Type
... estimate binding energies from Larkins (1977) tabulation.
JenaAtomicCalculator.Basics.EstimateBindingEnergyNist2025 — Type
... estimate successive ionization potentials from NIST (2025) database.
JenaAtomicCalculator.Basics.EstimateBindingEnergyWilliams2000 — Type
... estimate binding energies from Williams et al. (2000) tabulation.
JenaAtomicCalculator.Basics.EstimateBindingEnergyXrayDataBooklet — Type
... estimate binding energies from X-ray Data Booklet tabulation.
JenaAtomicCalculator.Basics.EstimateIonizationPotentialInnerShell — Type
... estimate the ionization potential of an inner-shell electron.
JenaAtomicCalculator.Basics.ExcitationLevel — Type
... to determine the excitation level of a configuration.
JenaAtomicCalculator.Basics.ExciteByCapture — Type
... generates all excitations and de-excitations of one or more electron from a given list of bound electron configurations, together with an capture of an additional electron. The number of electrons of the generated configurations is N+1.
JenaAtomicCalculator.Basics.ExciteElectrons — Type
struct Basics.ExciteElectrons <: AbstractConfigurationTheme ... to excite ne electrons fromShells to the intoshells for each of the given configurations.
+ ne ::Int64 ... number of electrons to be added.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are excited.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are excited.JenaAtomicCalculator.Basics.ExpandShells — Type
struct Basics.ExpandShells <: AbstractConfigurationTheme ... expand a configuration with empty shells due to a given number of shells
+ shells ::Array{Shell,1} ... Shells that will occur in the expanded form.JenaAtomicCalculator.Basics.FineStructure — Type
... to display the total J fine-structure levels of a configuration (without energies).
JenaAtomicCalculator.Basics.FineStructureLS — Type
... to display the total LSJ fine-structure levels of a configuration (without energies).
JenaAtomicCalculator.Basics.FockRoute — Method
Basics.FockRoute(maxIterations::Int64) ... sets the budget and keeps the off-diagonal terms unscaled
JenaAtomicCalculator.Basics.FockRoute — Method
Basics.FockRoute() ... defines the default budget, with the off-diagonal terms kept out of the 1/occ scaling
JenaAtomicCalculator.Basics.FockRoute — Type
struct Basics.FockRoute <: AbstractScfRoute ... defines a type to obtain an optimized-level field by solving the Fock equations to self-consistency.
+ maxIterations ::Int64 ... maximum number of iterations this route may take.
+ unscaledOffDiagonal ::Bool ... True, if the off-diagonal (CSF-pair) contributions are kept OUT of the 1/occ scaling
of the Fock matrix. They carry weight ~ c_r c_s while the generalized occupation
carries ~ c_r^2, so dividing them by it introduces a ratio that grows without bound
as a correlating CSF's own coefficient shrinks. Measured 09-Sep-2026 on Be
1s^2 2s^2 + 1s^2 2p^2: with the scaling in place the competing CSF's weight collapses
to 1.9e-05 and the 2p_3/2 orbital diffuses to <r> = 10.08 against its partner's 2.52;
without it the weight is 0.053 and the energy is 15.8 mHa lower.
NOTE that this is NOT GRASP's inhomogeneous source term, which is still MISSING: an
off-diagonal element such as R^k(2s,2s,2p,2p) differentiates to a term proportional to
P(2s), i.e. to a SOURCE on the right-hand side, and JAC still applies it as a matrix
multiplying P(2p). That is why the converged Fock fixed point sits 8.9 mHa ABOVE the
minimum the rotation route reaches, and it is a defect of the EQUATIONS.JenaAtomicCalculator.Basics.ForAutoIonization — Type
... to generate configurations that are related by autoionization (deexcitation + single remove).
JenaAtomicCalculator.Basics.ForDielectronicCapture — Type
struct Basics.ForDielectronicCapture <: AbstractConfigurationTheme ... to excite one electron fromShells to the toshells and add another electron into the intoShells for each of the given configurations.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are excited from --> to.
+ toShells ::Array{Shell,1} ... The shells to which the electrons are excited from --> to.
+ intoShells ::Array{Shell,1} ... The shells into which the additional electron is captured.JenaAtomicCalculator.Basics.ForDielectronicRecombination — Type
struct Basics.ForDielectronicRecombination <: AbstractConfigurationTheme ... to excite one electron fromShells to the toshells and add another electron into the intoShells for each of the given configurations. The subsequent stabiliztion is considered into the decayShells.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are excited from --> to.
+ toShells ::Array{Shell,1} ... The shells to which the electrons are excited from --> to.
+ intoShells ::Array{Shell,1} ... The shells into which the additional electron is captured.
+ decayShells ::Array{Shell,1} ... The shells into which (radiative) stabilization occurs.JenaAtomicCalculator.Basics.ForElectronCapture — Type
struct Basics.ForElectronCapture <: AbstractConfigurationTheme ... to add ne electrons in the intoshells for each of the given configurations.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are added.JenaAtomicCalculator.Basics.ForGivenConfigs — Type
... to perform computations for given configurations.
JenaAtomicCalculator.Basics.ForHollowIons — Type
struct Basics.ForHollowIons <: AbstractConfigurationTheme ... to excite ne electrons fromShells to the intoshells for each of the given configurations.
+ ne ::Int64 ... number of electrons to be captured.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are captured
+ decayShells ::Array{Shell,1} ... The shells which need to be considered between the shells of the ions and the intoShells in
order to model the decay of hollow ions.JenaAtomicCalculator.Basics.ForImpactIonization — Type
... to estimate electron impact-ionization cross sections (for pedestrians only)
JenaAtomicCalculator.Basics.ForIsoelectronicSequence — Type
... to compute configuration-averaged energies along an isoelectronic sequence.
JenaAtomicCalculator.Basics.ForPhotoEmission — Type
... to generate configurations that are related by photoemission (single replacement of electrons).
JenaAtomicCalculator.Basics.ForPhotoIonization — Type
... to generate configurations that are related by photoionization (single removement of electrons).
JenaAtomicCalculator.Basics.ForPhotoRecombination — Type
struct Basics.ForPhotoRecombination <: AbstractConfigurationTheme ... to add ne electrons in the intoshells for each of the given configurations.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are added.JenaAtomicCalculator.Basics.ForRasExcitations — Type
struct Basics.ForRasExcitations <: AbstractConfigurationTheme ... to excite ne electrons fromShells to the intoshells for each of the given configurations.
+ se ::Bool ... True if single excitations to be included, and false otherwise.
+ de ::Bool ... True if double excitations to be included, and false otherwise.
+ te ::Bool ... True if triple excitations to be included, and false otherwise.
+ qe ::Bool ... True if quadruple excitations to be included, and false otherwise.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are excited.
+ intoShells ::Array{Shell,1} ... The shells into which the electrons are excited.JenaAtomicCalculator.Basics.ForStepwiseDecay — Method
Basics.ForStepwiseDecay(maximallyReleased::Int64) ... constructor for a stepwise-decay theme that adds no shells of its own; an theme::Basics.ForStepwiseDecay is returned.
JenaAtomicCalculator.Basics.ForStepwiseDecay — Type
struct Basics.ForStepwiseDecay <: AbstractConfigurationTheme ... to generate all those configurations that occur due to the stepwise photoemission autoionization of configurations with some inner-shell hole.
+ maximallyReleased ::Int64 ... Maximum number of electrons that can be released from the given configurations.
+ decayShells ::Array{Shell,1}
... Shells that are to take part in the decay even though they do not occur in the given configurations.
The generator decides which shells may participate from the CONFIGURATION itself, so a shell that is
simply absent can never contribute: Configuration("1s^2 2p^4") offers only 2p and therefore yields NO
decay configuration at all, silently, although such an ion plainly decays via its 2s. Listing 2s here
makes it available. A shell already present in a configuration need not be listed.JenaAtomicCalculator.Basics.FromBasis — Type
... to extract the configuration from the basis.
JenaAtomicCalculator.Basics.FromMultiplet — Type
... to extract the configuration from the multiplet(s).
JenaAtomicCalculator.Basics.GLegenreMesh — Method
Basics.GLegenreMesh() ... constructor for the default settings of GLegenreMesh. A gLegenreMesh::Basics.GLegenreMesh is returned.
JenaAtomicCalculator.Basics.GLegenreMesh — Type
struct Basics.GLegenreMesh <: Basics.AbstractMesh ... to specify a Gauss-Legendre mesh in terms of [a,b] and number of zeros.
+ a ::Float64 ... mesh as defined in the interval [a,b].
+ b ::Float64
+ NoZeros ::Int64 ... Number of GL zeros of the mesh.JenaAtomicCalculator.Basics.GeneralizedConfigurations — Type
... theme for Basics.generateConfigurations, to generate generalized configurations in which shell occupations may be given as ranges.
JenaAtomicCalculator.Basics.GeneralizedEigenvaluesWithLinearAlgebra — Type
... solve a generalized eigenvalue problem using LinearAlgebra.eigen().
JenaAtomicCalculator.Basics.GetParity — Type
... to extract the parity of a configurations.
JenaAtomicCalculator.Basics.GroundConfiguration — Type
struct Basics.GroundConfiguration <: AbstractConfigurationTheme ... to generate the ground configuration for a given (Z,N), i.e. the (nuclearCharge, NoElectrons).
+ Z ::Float64 ... nuclear charge Z
+ NoElectrons ::Int64 ... number of electrons.JenaAtomicCalculator.Basics.HSField — Type
... to represent an mean Hartree-Slater field.
JenaAtomicCalculator.Basics.HarmonicQuantizationAxis — Type
struct Basics.HarmonicQuantizationAxis <: AbstractQuantizationAxis ... to specify a time-harmonic quantization axis in terms of a unit vector for its direction and a frequency omega. !!! It need to be explained how omega is related to the components of nVector; perhaps, some further further specification is required to make this axis unique.
+ nVector ::Basics.Cartesian3DFieldValue{Float64} ... 3D unit vector that specifies the quantization axis.
+ omega ::Float64 ... Frequency of the time-harmonic motion.JenaAtomicCalculator.Basics.HminusE — Type
... the operator H - E, with kind the e-e interaction of the Hamiltonian that produced the levels. Required wherever the VeeOnly shortcut fails: a ONE-orbital difference, as every second-order sum produces at its Green-multiplet junctions. kind must match the Hamiltonian behind the levels' energy, or the cancellation is referenced to the wrong one. NO E FIELD: the -E<r|s> term vanishes under the orthonormality JAC already assumes, so nothing would read it; it returns with the biorthogonal route that lifts that assumption.
JenaAtomicCalculator.Basics.HundsRules — Type
... to display the total LSJ fine-structure levels, ordered by Hund's rules (not yet).
JenaAtomicCalculator.Basics.HyperfineStructure — Type
struct Basics.HyperfineStructure <: AbstractConfigurationTheme ... to display the total F hyperfine-structure levels of a configuration (without energies).
+ spinI ::AngularJ64 ... Nuclear spin I.JenaAtomicCalculator.Basics.ImpactExc — Type
... electron-impact excitation cross sections and collision strengths.
JenaAtomicCalculator.Basics.ImpactExcAuto — Type
... electron-impact excitation with subsequent autoionization, i.e. an inner-shell electron is raised by electron impact to a level above the ionization threshold, which then autoionizes.
JenaAtomicCalculator.Basics.InternalConv — Type
... to denote internal conversion, i.e. the transfer of nuclear excitation energy to a bound electron which is thereby ejected.
JenaAtomicCalculator.Basics.IonSphereModel — Method
Basics.IonSphereModel() ... constructor for the default settings of Basics.IonSphereModel(). A ionSphereModel::Basics.IonSphereModel is returned.
JenaAtomicCalculator.Basics.IonSphereModel — Type
struct Basics.IonSphereModel <: AbstractPlasmaModel ... to specify (the parameters of) a ion-sphere potential.
+ radius ::Float64 ... the ion-sphere radius R [a_o].
+ electronDensity ::Float64 ... electron density n_e (T).JenaAtomicCalculator.Basics.IsOccupied — Type
... to extract where a shell or subshell is occupied in the given configuration.
JenaAtomicCalculator.Basics.LeadingConfiguration — Type
... to extract the leading configuration.
JenaAtomicCalculator.Basics.LeadingConfigurationR — Type
... to extract the leading relativistic configuration.
JenaAtomicCalculator.Basics.LeftCircular — Type
... to specify a left-circularly polarized pulse/beam.
JenaAtomicCalculator.Basics.LeftElliptical — Type
struct Basics.LeftElliptical <: Basics.AbstractPolarization
+ ellipticity ::Float64 ... Ellipticity of the beam in the range 0...1.JenaAtomicCalculator.Basics.LevelDecompositionOfCsfR — Type
... analyze and list (up to N) jj-coupled CSF and their weights.
JenaAtomicCalculator.Basics.LevelDecompositionOfNRconfigurations — Type
... analyze and list the NR configurations with weight > 5 %.
JenaAtomicCalculator.Basics.LevelSelection — Method
Basics.LevelSelection(active::Bool; indices::Array{Int64,1}=Int64[], symmetries::Array{LevelSymmetry,1}=LevelSymmetry[], configurations::Array{Configuration,1}=Configuration[]) ... constructor for specifying the details of a LevelSelection. indices and symmetries are alternatives and must not be combined. configurations names the REFERENCE configurations and selects the levels that are built mainly from them, measured by the weight the level carries on those configurations' CSFs; it is the only one of the three that survives an intruder level dropping into the energy ordering, and it is therefore the one to use for the target set of an EOL field. configurations MAY be combined with symmetries, which then restricts the selected reference levels to those J^P: that is the one-orbital-set-per-J route for the RAS layers on top of an AL-optimized reference. See SelfConsistent.selectTargetLevelsEOL. A levelSelection::Basics.LevelSelection is returned.
JenaAtomicCalculator.Basics.LevelSelection — Method
Basics.LevelSelection() ... constructor for an inactive LevelSelection. A levelSelection::Basics.LevelSelection is returned.
JenaAtomicCalculator.Basics.LevelSelection — Type
struct Basics.LevelSelection < Basics.AbstractSelection ... defines a struct to specify a list of levels by means of their (level) indices or level symmetries.
+ active ::Bool ... true, if some selection has been made.
+ indices ::Array{Int64,1} ... List of selected indices.
+ symmetries ::Array{LevelSymmetry,1} ... List of selected symmetriesJenaAtomicCalculator.Basics.LevelSymmetry — Method
Basics.LevelSymmetry(i::Int64, parity::Parity) ... constructor for a given (Int64,Parity). A levelSymmetry::Basics.LevelSymmetry is returned.
JenaAtomicCalculator.Basics.LevelSymmetry — Method
Basics.LevelSymmetry(i::Int64, sa::String) ... constructor for a given (Int64,String). A levelSymmetry::Basics.LevelSymmetry is returned.
JenaAtomicCalculator.Basics.LevelSymmetry — Method
Basics.LevelSymmetry(rational::Rational{Int64}, parity::Parity) ... constructor for a given (Rational,Parity). A levelSymmetry::Basics.LevelSymmetry is returned.
JenaAtomicCalculator.Basics.LevelSymmetry — Method
Basics.LevelSymmetry(rational::Rational{Int64}, sa::String) ... constructor for a given (Rational,String). A levelSymmetry::Basics.LevelSymmetry is returned.
JenaAtomicCalculator.Basics.LevelSymmetry — Type
struct Basics.LevelSymmetry < AbstractAngularMomentum ... defines a struct for defining the overall J^P symmetry of a level.
+ J ::AngularJ64 ... total angular momentum of a level
+ parity ::Parity ... total parity of the levelJenaAtomicCalculator.Basics.LineSelection — Method
Basics.LineSelection(active::Bool; indexPairs::Array{Tuple{Int64,Int64},1}=Tuple{Int64,Int64}[], symmetryPairs::Array{Tuple{LevelSymmetry,LevelSymmetry},1}=Tuple{LevelSymmetry,LevelSymmetry}[]) ... constructor for specifying the details of a LineSelection. A lineSelection::Basics.LineSelection is returned.
JenaAtomicCalculator.Basics.LineSelection — Method
Basics.LineSelection() ... constructor for an inactive LineSelection. A lineSelection::Basics.LineSelection is returned.
JenaAtomicCalculator.Basics.LineSelection — Type
struct Basics.LineSelection < Basics.AbstractSelection ... defines a struct to specify a list of level pair by means of their (level) indices or level symmetries.
+ active ::Bool ... true, if some selection has been made.
+ indexPairs ::Array{Tuple{Int64,Int64},1} ... List of selected index pairs.
+ symmetryPairs ::Array{Tuple{LevelSymmetry,LevelSymmetry},1} ... List of selected symmetry pairs.JenaAtomicCalculator.Basics.LinearMesh — Method
Basics.LinearMesh() ... constructor for the default settings of LinearMesh. A linearMesh::Basics.LinearMesh is returned.
JenaAtomicCalculator.Basics.LinearMesh — Type
struct Basics.LinearMesh <: Basics.AbstractMesh ... to specify a linear mesh in terms of [a,b] and number of mesh points.
+ a ::Float64 ... mesh as defined in the interval [a,b].
+ b ::Float64
+ NoPoints ::Int64 ... Number of mesh points, including a, b.JenaAtomicCalculator.Basics.LinearPolarization — Type
... to specify a linearly-polarized pulse/beam.
JenaAtomicCalculator.Basics.LorentzianIntensities — Type
... to display the superposition of Lorentzians with given position, intensity and individual widths.
JenaAtomicCalculator.Basics.LorentzianIntensitiesConstantWidths — Type
... to display the superposition of Lorentzians with given position and intensity but constant widths.
JenaAtomicCalculator.Basics.MatrixWithLinearAlgebra — Type
... diagonalize a single symmetric matrix using LinearAlgebra.eigen().
JenaAtomicCalculator.Basics.MeanConfiguration — Type
... to generate the mean configuration, i.e. a configuration with mean occupation numbers.
JenaAtomicCalculator.Basics.MeanFieldRoute — Method
Basics.MeanFieldRoute() ... defines the default budget
JenaAtomicCalculator.Basics.MeanFieldRoute — Type
struct Basics.MeanFieldRoute <: AbstractScfRoute ... defines a type to iterate a local screened potential to self-consistency.
+ maxIterations ::Int64 ... maximum number of iterations this route may take.JenaAtomicCalculator.Basics.MeanOccupation — Type
... to extract occupation numbers from given configurations.
JenaAtomicCalculator.Basics.MultiPI — Type
... multi-photon (single-electron) ionization.
JenaAtomicCalculator.Basics.MultiPhotonDE — Type
... multi-photon excitation and decay rates, including 2-photon, etc. processes.
JenaAtomicCalculator.Basics.Multiplicity — Type
... to extract the multiplicity of a configuration.
JenaAtomicCalculator.Basics.NewtonRoute — Method
Basics.NewtonRoute() ... defines the default budget
JenaAtomicCalculator.Basics.NewtonRoute — Type
struct Basics.NewtonRoute <: AbstractScfRoute ... defines a type reserved for a second-order procedure. NOT IMPLEMENTED; it raises where it is used.
+ maxIterations ::Int64 ... maximum number of iterations this route would be allowed to take.JenaAtomicCalculator.Basics.NoEmField — Type
... No electric and magnetic field is defined.
JenaAtomicCalculator.Basics.NoExcitationScheme — Type
... dummy scheme for (unsupported) initialization of this abstract tpye.
JenaAtomicCalculator.Basics.NoLineShiftSettings — Type
... No line-shift settings are defined.
JenaAtomicCalculator.Basics.NoPlasmaModel — Type
... No plasma model defined.
JenaAtomicCalculator.Basics.NoProcess — Type
... dummy process for the initialization of a Cascade.Step or an atomic computation; it denotes the ABSENCE of a process and is never computed.
JenaAtomicCalculator.Basics.NonePolarization — Type
... to specify an upolarized pulse/beam.
JenaAtomicCalculator.Basics.NonrelativisticBasis — Type
... to extract the configurations from a non-relativistic basis.
JenaAtomicCalculator.Basics.NonrelativisticCoulomb — Type
... generate a non-relativistic Coulomb function for the large component together with kinetic balance.
JenaAtomicCalculator.Basics.NuclearField — Type
... to represent a pure nuclear (potential) field.
JenaAtomicCalculator.Basics.NumberOfElectrons — Type
... to extract the number of electrons from a set of configurations.
JenaAtomicCalculator.Basics.OccupationDifference — Type
... to extract differences of occupation numbers from given configurations.
JenaAtomicCalculator.Basics.OngRussekNorm — Type
... normalize by following Ong & Russek (1973).
JenaAtomicCalculator.Basics.OpenShellNumber — Type
... theme for Basics.extractFromConfiguration, to extract the NUMBER of open shells of a configuration.
JenaAtomicCalculator.Basics.OpenShells — Type
... to extract the open shells from the given configurations.
JenaAtomicCalculator.Basics.OpenSubshells — Type
... to extract the open subshells from the given configurations.
JenaAtomicCalculator.Basics.OrderedShellList — Type
... generate an ordered NR shell list from a set of configurations.
JenaAtomicCalculator.Basics.OrderedSubshellList — Type
... generate an ordered relativistic subshell list from configurations or two bases.
JenaAtomicCalculator.Basics.PairA1P — Type
... to denote one-photon pair annihilation, in which a bound electron and a positron annihilate under emission of a single photon.
JenaAtomicCalculator.Basics.PathwaySelection — Method
Basics.PathwaySelection(active::Bool; indexTriples::Array{Tuple{Int64,Int64,Int64},1}=Tuple{Int64,Int64,Int64}[], symmetryTriples::Array{Tuple{LevelSymmetry,LevelSymmetry,LevelSymmetry},1}=Tuple{LevelSymmetry,LevelSymmetry,LevelSymmetry}[]) ... constructor for specifying the details of a PathwaySelection. A pathwaySelection::Basics.PathwaySelection is returned.
JenaAtomicCalculator.Basics.PathwaySelection — Method
Basics.PathwaySelection() ... constructor for an inactive PathwaySelection. A pathwaySelection::Basics.PathwaySelection is returned.
JenaAtomicCalculator.Basics.PathwaySelection — Type
struct Basics.PathwaySelection < Basics.AbstractSelection ... defines a struct to specify a list of level triple (pathways) by means of their (level) indices or level symmetries.
+ active ::Bool ... true, if some selection has been made.
+ indexTriples ::Array{Tuple{Int64,Int64,Int64},1} ... List of selected index triples.
+ symmetryTriples ::Array{Tuple{LevelSymmetry,LevelSymmetry,LevelSymmetry},1} ... List of selected symmetry triples.JenaAtomicCalculator.Basics.PerformResults — Type
struct Basics.PerformResults ... the Dict{String,Any} that perform returns, wrapped so that a WRONG KEY names the keys that exist instead of raising a bare KeyError. It behaves as the Dict did in every other respect – haskey, keys, get, length, iteration and merge all work as before – so no existing script changes.
+ dict ::Dict{String,Any} ... the results themselves.
WHY THIS EXISTS, and the cost it removes. One `perform` can produce any of FORTY-FOUR keys, carrying
spaces, colons and per-module wording -- `"radiative lines:"`, `"photo recombination lines:"` (with a
space), `"AutoIonization lines:"`. Nothing related the key to the settings that produced it and nothing
listed the valid ones, so a near miss was indistinguishable from an absent result. Measured in one week
of application work: four separate wrong-key stalls, among them `"photon emission lines:"` for
`"radiative lines:"` and `"photoRecombination lines:"` for `"photo recombination lines:"`, each costing a
full edit-run cycle.
A NEAR MISS IS NAMED BUT NOT ACCEPTED. Where the requested key differs from an existing one only in
spacing, case or punctuation, the message says which key was meant -- that alone answers the second stall
above -- but it still raises. Silently accepting a fuzzy key would turn a typo into a different kind of
bug, one that returns the wrong result rather than none.JenaAtomicCalculator.Basics.Photo — Type
... Photoionization processes, i.e. the emission of a single free electron into the continuum due to an external light field.
JenaAtomicCalculator.Basics.PhotoDouble — Type
... Photo-double ionization rates.
JenaAtomicCalculator.Basics.PhotoExc — Type
... Photoexcitation rates.
JenaAtomicCalculator.Basics.PhotoExcAuto — Type
... photoexcitation autoionization cross sections and collision strengths.
JenaAtomicCalculator.Basics.PhotoExcFluor — Type
... photoexcitation fluorescence rates and cross sections.
JenaAtomicCalculator.Basics.PhotoInPlasma — Type
... Photoionization processes but calculated for a specified plasma model.
JenaAtomicCalculator.Basics.PhysicalConstants — Type
... display all currently defined physical constants.
JenaAtomicCalculator.Basics.PolarFieldValue — Type
struct Basics.PolarFieldValue{Type} <: Basics.AbstractFieldValue ... to specify a field value of type Type in terms of rho, phi.
+ rho ::Float64 ... rho-coordinate.
+ phi ::Float64 ... phi-coordinate.
+ val ::Type ... field value of type Type.JenaAtomicCalculator.Basics.PolarMesh — Method
Basics.PolarMesh() ... constructor for the default settings of PolarMesh. A polarMesh::Basics.PolarMesh is returned.
JenaAtomicCalculator.Basics.PolarMesh — Type
struct Basics.PolarMesh <: Basics.AbstractMesh ... to specify a 2D polar mesh in terms of rho and phi.
+ rhoMesh ::Basics.AbstractMesh ... mesh for the rho-coordinate.
+ phiMesh ::Basics.AbstractMesh ... mesh for the phi-coordinate.JenaAtomicCalculator.Basics.PrintWarnings — Type
... print all warnings into a jac-warn.report file.
JenaAtomicCalculator.Basics.PureSineNorm — Type
... normalize with regard to an (asymtotic) pure sine funtion, sin(kr).
JenaAtomicCalculator.Basics.RAuger — Type
... Radiative Auger rates.
JenaAtomicCalculator.Basics.RadialOrbitalsBoth — Type
... plot both components of one or more radial orbitals.
JenaAtomicCalculator.Basics.RadialOrbitalsLarge — Type
... plot the large component of one or more radial orbitals.
JenaAtomicCalculator.Basics.RadialOrbitalsSmall — Type
... plot the small component of one or more radial orbitals.
JenaAtomicCalculator.Basics.RadialPotentials — Type
... plot one or more radial potentials.
JenaAtomicCalculator.Basics.Radiative — Type
... Radiative (multipole) transitions between bound-state levels of the same charge state.
JenaAtomicCalculator.Basics.ReadCslFileGrasp92 — Type
... read a CSF list from a Grasp92 .csl / GRASP18 .c file.
JenaAtomicCalculator.Basics.ReadMixingFileGrasp18 — Type
... read energies & mixing coefficients from a Grasp18 mixing file.
JenaAtomicCalculator.Basics.ReadOrbitalFileGrasp92 — Type
... read orbitals from a (formatted) Grasp92 .rwf file.
JenaAtomicCalculator.Basics.Rec — Type
... radiative electron capture, i.e. the capture of a free electron with the simultaneous emission of a photon.
JenaAtomicCalculator.Basics.RecastRateToDecayWidth — Type
... recast a radiative rate (Einstein A, a.u.) to a decay width.
JenaAtomicCalculator.Basics.RecastRateToEinsteinA — Type
... recast a radiative rate (Einstein A, a.u.) to Einstein A in selected units.
JenaAtomicCalculator.Basics.RecastRateToEinsteinB — Type
... recast a radiative rate (Einstein A, a.u.) to Einstein B-coefficient.
JenaAtomicCalculator.Basics.RecastRateToLineStrengthS — Type
... recast a radiative rate (Einstein A, a.u.) to line strength S.
JenaAtomicCalculator.Basics.RecastRateToOscillatorF — Type
... recast a radiative rate (Einstein A, a.u.) to oscillator strength f.
JenaAtomicCalculator.Basics.RecastRateToOscillatorGf — Type
... recast a radiative rate (Einstein A, a.u.) to oscillator strength g_f.
JenaAtomicCalculator.Basics.RelativisticConfigurations — Type
... to generate/deal with relativistic configurations.
JenaAtomicCalculator.Basics.RemoveElectrons — Type
struct Basics.RemoveElectrons <: AbstractConfigurationTheme ... to remove ne electrons fromShells for each of the given configurations.
+ ne ::Int64 ... number of electrons to be added.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are removed.JenaAtomicCalculator.Basics.RequestMaximumOccupation — Type
struct Basics.RequestMaximumOccupation <: AbstractConfigurationRestriction ... request a maximum occupation ne in the given (list of) shells.
+ ne ::Int64 ... maximum electron occupation.
+ shells ::Array{Shell,1} ... list of shells.JenaAtomicCalculator.Basics.RequestMinimumOccupation — Type
struct Basics.RequestMinimumOccupation <: AbstractConfigurationRestriction ... request a minimum occupation ne in the given (list of) shells.
+ ne ::Int64 ... minimum electron occupation.
+ shells ::Array{Shell,1} ... list of shells.JenaAtomicCalculator.Basics.ResetWarnings — Type
... reset (empty) the warningList, usually at the beginning of a new run.to distinguish between different warnings
JenaAtomicCalculator.Basics.RestrictExcitations — Method
Basics.RestrictExcitations(theme::Basics.ExciteElectrons, restrictions::Array{AbstractConfigurationRestriction,1}) ... constructor to specify the paraemterss by the ExciteElectron() theme. A restrictExcitations::Basics.RestrictExcitations is returned.
JenaAtomicCalculator.Basics.RestrictExcitations — Method
Basics.RestrictExcitations(restrictions::Array{AbstractConfigurationRestriction,1}) ... constructor to just provide a set of restriction. A restrictExcitations::Basics.RestrictExcitations is returned.
JenaAtomicCalculator.Basics.RestrictExcitations — Type
struct Basics.RestrictExcitations <: AbstractConfigurationTheme ... to restrict (reduce the number of) the given configurations by applying one or several configuration restrictions.
+ ne ::Int64 ... number of electrons to be added.
+ fromShells ::Array{Shell,1} ... The shells from which the electrons are excited.
+ toShells ::Array{Shell,1} ... The shells into which the electrons are excited.
+ restrictions ::Array{AbstractConfigurationRestriction,1} ... set of restrictions that will be applied.JenaAtomicCalculator.Basics.RestrictMaximumDisplacements — Type
struct Basics.RestrictMaximumDisplacements <: AbstractConfigurationRestriction ... restrict the maximum replacements w.r.t. (another) given configuration, which can have a different number of electrons. A "displacement" is simply defined as the difference of occuation numbers. This restriction is useful to determine allowed configurations in a second-order treatment of atomic processes. An odd number of displacement naturally arise for all configurations which differ by one or three electrons from the reference configurations. Several restrictions of this type can be formulated but are treated separately.
+ conf ::Configuration ... configuration w.r.t. which displacements are taken.
+ maxDisplace ::Int64 ... maximum number of displacements >= 0.JenaAtomicCalculator.Basics.RestrictNoElectronsTo — Type
struct Basics.RestrictNoElectronsTo <: AbstractConfigurationRestriction ... restrict the number of electron in all shells with principal quantum number n >= nmin or orbital angular momentum l >= lmin to a total of ne electrons.
+ ne ::Int64 ... maximum number of (allowed) electrons in the specicied higher subshells.
+ nmin ::Int64 ... principal quantum number nmin.
+ lmin ::Int64 ... orbital angular momentum lmin.JenaAtomicCalculator.Basics.RestrictParity — Type
struct Basics.RestrictParity <: AbstractConfigurationRestriction ... restrict to configurations with a given parity.
+ parity ::Basics.Parity ... given parity.JenaAtomicCalculator.Basics.RestrictToShellDoubles — Type
struct Basics.RestrictToShellDoubles <: AbstractConfigurationRestriction ... restrict to a double electron occupation in all shells with principal quantum number n >= nmin or orbital angular momentum l >= lmin.
+ nmin ::Int64 ... principal quantum number nmin.
+ lmin ::Int64 ... orbital angular momentum lmin.JenaAtomicCalculator.Basics.RightCircular — Type
... to specify a right-circularly polarized pulse/beam.
JenaAtomicCalculator.Basics.RightElliptical — Type
struct Basics.RightElliptical <: Basics.AbstractPolarization
+ ellipticity ::Float64 ... Ellipticity of the beam in the range 0...1.JenaAtomicCalculator.Basics.RotationRoute — Method
Basics.RotationRoute(maxIterations::Int64, nVirtual::Int64, stepping::Symbol) ... the three-argument form used before 07-Oct-2026; it leaves the increment test OFF, so maxIterations decides where the run stops exactly as it did then.
JenaAtomicCalculator.Basics.RotationRoute — Method
Basics.RotationRoute(maxIterations::Int64) ... sets the budget and keeps the standard step space and stepping
JenaAtomicCalculator.Basics.RotationRoute — Method
Basics.RotationRoute() ... defines the values the rotation solver has used since 27-Aug-2026
JenaAtomicCalculator.Basics.RotationRoute — Type
struct Basics.RotationRoute <: AbstractScfRoute ... defines a type to obtain an optimized-level field by orbital rotation, i.e. by direct minimization of the level energy.
+ maxIterations ::Int64 ... maximum number of iterations this route may take.
+ nVirtual ::Int64 ... number of virtual directions per subshell that span the step; the search direction is
assembled inside this span, out of a b-space of nsL + nsS (183 for a C-like uranium RAS
layer), and the reported |grad| is measured in the SAME span. Measured 08-Sep-2026:
raising it from 16 to 32 lowers the energy of that case by 3.7e-04 Ha with the basis
orthonormal to 1e-10, while 96 destroys the line search outright at iteration 41.
+ incrementTolerance ::Float64 ... WHEN TO STOP, as the fraction by which DOUBLING the effort may still move the
result; 0.0 (the default) turns the test off, and then `maxIterations` decides the
answer. A correlation layer never truly converges, so its iteration count has
always been a cost dial rather than a criterion -- and that is why a RAS layer
increment had to be quoted together with its budget. With a positive tolerance the
solver instead compares the descent it has achieved, D(n) = E(1) - E(n), against the
descent at HALF the iterations, D(n/2): if doubling the effort moved the increment
by less than the tolerance, doubling it again will not either, and the run stops.
`maxIterations` is then a CEILING, not the decision.
**THE SCALE IS THE DESCENT ITSELF, which is what frees the test of units and of Z.**
No absolute tolerance can serve both a layer worth 160 mHa (Ti III 3d^2) and one
worth 0.06 mHa (Ca+ 4s with core-s singles), and both were measured on one afternoon.
It never fires before iteration 6: at a budget of 3 a reference step has been
measured to return an energy BELOW its own converged value, so an earlier test can
stop on noise. 0.05 asks for 5 %, which on the ions measured so far is reached well
inside the budgets those layers were being given.
+ stepping ::Symbol ... how the search direction is chosen, one of :plain, :conjugate, :curvature (the default)
and :newton; an unrecognized symbol RAISES rather than falling back silently. The first
three are first-order and differ only in how they choose the downhill direction: :plain
steps straight downhill and zig-zags, undoing part of each previous step; :conjugate
corrects the new direction against the previous one so it stops zig-zagging; :curvature
keeps a short memory of how the slope changed over recent steps and guesses the
curvature from it. The names are Rule 21's and describe what the method does rather
than who wrote it. :newton is second-order and is described below.
## WHEN TO ASK FOR :newton, AND WHEN IT CANNOT HELP
An optimized-level functional re-solves the CI eigenvector at every iteration, so the function minimized at
iteration n is NOT the one minimized at n+1: a first-order method differences the gradients of two different
functions, and its |grad| then oscillates instead of falling. :newton removes that by construction rather than
patching around it -- it solves the REDUCED Hessian system, which contains the CI relaxation exactly, by a
preconditioned truncated conjugate-gradient inner loop.
**It helps exactly where the target symmetry block has CI FREEDOM, and the size of the gain follows the CI
relaxation as a fraction of the orbital-orbital curvature.** Measured 06-Oct-2026 on a Be ladder, the same
layer structure, everything but the direction held fixed:
target block relaxation :curvature :newton
1 CSF (reference) 0 3 iterations 3 iterations ... NO gain
3 CSFs (+2p) 4.1 % 58 iters, |grad| 6.4e-07 6 iters, |grad| 6.2e-08
11 CSFs (+2p3s3p3d) 4.7 % 60 iters, |grad| 1.1e-03, STOPPED 15 iters, |grad| 1.8e-04
**A SINGLE-CSF STEP CANNOT GAIN ANYTHING, by construction**: with one CSF there is no CI vector to re-solve, the
orbital-CI block of the Hessian is empty, and the moving target does not exist. So :newton is for the CORRELATION
layers of a RAS ladder, and an ordinary single-configuration SCF -- however heavy the element -- gains nothing
from it. Ask for it on a layer that will not settle, and leave :curvature on the reference step.
**IT IS NOT FASTER, AND SHOULD NOT BE CHOSEN FOR SPEED.** One reduced-Hessian-vector product costs four orbital
gradients and two CI-matrix builds, so the measured solver time is 1.4x (+2p) to 4.8x (+2p3s3p3d) that of
:curvature, and reaching a GIVEN |grad| costs more arithmetic, not less. What it buys is reliability: on the
11-CSF layer the first-order |grad| rises as often as it falls (0.0092, 0.0124, 0.0092, 0.0047, 0.0041, 0.0050,
0.0055, 0.0061, 0.0064, 0.0055, 0.0069) and stalls, while :newton falls monotonically from iteration 3 through
two orders of magnitude with a full step accepted throughout. Choose it when a layer refuses to converge, not
when one converges slowly.
**ONE RESTRICTION:** the reduced Hessian needs one relaxation term per target level, and two levels of a single
symmetry block couple through it. For a functional with more than one target level :newton therefore says so
once and uses the first-order step instead, rather than returning a Newton step that silently omits the coupling.JenaAtomicCalculator.Basics.SCA — Type
... all levels in the cascade are described in single-configuration approximation but with 'mixtures' within the configuration; an individual mean-field is generated for each charge state and all continuum orbitals are generated for the correct transition energy in the field of the remaining ion. Moreover, all the fine-structure transitions are calculated individually.
JenaAtomicCalculator.Basics.SahaLevelPopulation — Type
... to represent a Saha level population.
JenaAtomicCalculator.Basics.SecondOrder — Method
Basics.SecondOrder(promoteAbove::Float64, discardBelow::Float64, justifyBelow::Float64) ... the three-threshold form every caller before this field existed could reach directly, via Julia's own default constructor; kept as an explicit method now that a fourth field means that default no longer matches three positional arguments.
JenaAtomicCalculator.Basics.SecondOrder — Method
Basics.SecondOrder(promoteAbove::Float64, discardBelow::Float64) ... keeps the default justification bound, which is deliberately NOT tied to promoteAbove – see the docstring above.
JenaAtomicCalculator.Basics.SecondOrder — Method
Basics.SecondOrder(promoteAbove::Float64) ... sets the promotion threshold and keeps the default floor
JenaAtomicCalculator.Basics.SecondOrder — Method
Basics.SecondOrder() ... the calibrated starting point; see the caveat in the docstring above
JenaAtomicCalculator.Basics.SecondOrder — Type
struct Basics.SecondOrder <: Basics.AbstractQTreatment ... ranks every configuration of the step's Q space by |c(K')|^2, the fraction of the atomic state function that configuration carries, and routes it on that number alone:
|c|^2 > promoteAbove into the CI, and diagonalized exactly
discardBelow < |c|^2 < promoteAbove folded in through the second-order effective Hamiltonian
|c|^2 < discardBelow dropped
so that `promoteAbove = 0.` reproduces a variational step and `promoteAbove = Inf` folds the whole layer
in. The weight is obtained from the same quantities as the energy correction, `|c(K')|^2 = dE_PT(K')/D`
with `dE_PT(K') = SUM_chi' |<(K chi J)||V||(K' chi' J)>|^2 / D` and `D = <q|H|q> - E_i`, i.e. Epstein-Nesbet
denominators: each Q-CSF's own diagonal element against the CI eigenvalue. No configuration-average energy
is needed and no H0/V partitioning has to be declared.
+ promoteAbove ::Float64 ... weight above which a configuration is put INTO the CI rather than folded in.
+ discardBelow ::Float64 ... weight below which a configuration is dropped entirely.
+ justifyBelow ::Float64 ... the largest `Sum |c|^2` over the FOLDED part for which the fold-in is still
called justified. INDEPENDENT of `promoteAbove` on purpose; see below.
+ qSpacePerturbation ::Basics.AbstractQSpacePerturbation ... how the FOLDED part's own internal coupling is
treated; `Basics.DiagonalCSFPerturbation()` by default, reproducing every
behaviour this struct had before this field existed. See
`Basics.AbstractQSpacePerturbation`.
WHY A WEIGHT AND NOT AN ENERGY. `dE_PT` is an energy and equals `|c|^2 * D`, so at equal weight a configuration
further away in energy ranks HIGHER -- which is the wrong way round for a spectrum. Measured on Cl III
3s^2 3p^3 (11-Sep-2026): core excitations carry 97.9 % of the total `dE_PT` while their net effect on the
excitation energies is 0.2 %, because their contribution is nearly level-independent (-47.696 / -47.729 /
-47.601 mHa) and cancels to 99.8 %. The weight separates the two classes by three orders of magnitude
(valence-valence 3.1e-02 against core 1.7e-05) where the energy separates them by only two.
WHY SECOND ORDER MAY RANK BUT MUST NOT BE TRUSTED AS AN ENERGY WHERE THE COUPLING IS STRONG. On the same case
it reproduces the exact CI to 0.6-1.3 % for the core and is wrong by 3.6-11.5 % for the valence shells. An
effective Hamiltonian in P repairs part of that -- it must use a LEVEL-INDEPENDENT denominator, so it
over-binds the ground state and makes the SPECTRUM worse (worst splitting error 1021 cm^-1 against 701). This
is why the threshold exists: a strongly coupled configuration is promoted rather than folded, and the fold-in
is then applied only where it is accurate.
WHY `justifyBelow` IS A SEPARATE NUMBER, AND WHY IT HAD TO BECOME ONE. Until 13-Sep-2026 the step judged its own
fold-in by testing `Sum |c|^2` against `promoteAbove` -- the same number that decides what gets folded. Raising
the threshold therefore folded MORE and simultaneously loosened the test of whether folding was legitimate, so
the one setting that most needs policing, `promoteAbove = 1.0` meaning "promote nothing, fold everything", was
exactly the setting at which the gate could never fire. Measured on Fe VII [Ar] 3d^2 that day: the step reported
"a WEAK perturbation; second order is justified here" while returning a 3F term INVERTED and displaced by a
factor of thirty, with `Sum |c|^2 = 0.048` printed on the adjacent line and not judged.
THE DEFAULTS ARE CALIBRATED ON ONE ION and a Z-scan along an isoelectronic sequence has NOT been done. Treat
them as a starting point and read the `Sum |c|^2` a step reports, which is the quantity that says whether the
fold-in was justified at all.JenaAtomicCalculator.Basics.ShellSelection — Method
Basics.ShellSelection(active::Bool; shells::Array{Shell,1}=Shell[], lSymmetries::Array{Int64,1}=Int64[]) ... constructor for specifying the details of a ShellSelection. A shellSelection::Basics.ShellSelection is returned.
JenaAtomicCalculator.Basics.ShellSelection — Method
Basics.ShellSelection() ... constructor for an inactive ShellSelection. A shellSelection::Basics.ShellSelection is returned.
JenaAtomicCalculator.Basics.ShellSelection — Type
struct Basics.ShellSelection < Basics.AbstractSelection ... defines a struct to specify a list of shells by means of different constructors.
+ active ::Bool ... true, if some selection has been made.
+ shells ::Array{Shell,1} ... List of explicitly selected shells.
+ lSymmetries ::Array{Int64,1} ... List of selected l-symmetriesJenaAtomicCalculator.Basics.SimplifiedModifiedSemiempiricalMethod — Type
struct Basics.SimplifiedModifiedSemiempiricalMethod <: AbstractStarkBroadeningMethod ... see AbstractStarkBroadeningMethod's own docstring. Dimitrijevic & Konjevic, Astron. Astrophys. 172, 345 (1987); formula as restated in Dimitrijevic & Popovic, J. Appl. Spectrosc. 68, 893 (2001), Eq. (7).
+ ionizationEnergy ::Float64 ... the ion's own ionization threshold (Hartree, the SAME zero-point as
Level.energy) -- the energy of the series limit this line's upper
AND lower level both lie below.
+ residualCharge ::Float64 ... Z in the formula: the ion's spectroscopic charge AFTER removing the
active electron, PLUS one (Z=1 for a neutral atom's own valence
electron, Z=3 for a twice-ionized ion's valence electron, and so
on) -- the same Z_eff convention Rule 12 already uses elsewhere.JenaAtomicCalculator.Basics.SlaterTypeSpectrum — Type
... generate a complete single-electron STO spectrum (positive and negative states).
JenaAtomicCalculator.Basics.SlaterTypeSpectrumPositive — Type
... generate the same but return only the positive states.
JenaAtomicCalculator.Basics.SphericalFieldValue — Type
struct Basics.SphericalFieldValue{Type} <: Basics.AbstractFieldValue ... to specify a field value of type Type in terms of r, theta, phi.
+ r ::Float64 ... r-coordinate.
+ theta ::Float64 ... theta-coordinate.
+ phi ::Float64 ... phi-coordinate.
+ val ::Type ... field value of type Type.JenaAtomicCalculator.Basics.SphericalMesh — Method
Basics.SphericalMesh() ... constructor for the default settings of Spherical. A sphericalMesh::Basics.SphericalMesh is returned.
JenaAtomicCalculator.Basics.SphericalMesh — Type
struct Basics.SphericalMesh <: Basics.AbstractMesh ... to specify a 3D polar mesh in terms of r, theta and phi.
+ rMesh ::Basics.AbstractMesh ... mesh for the r-coordinate.
+ thetaMesh ::Basics.AbstractMesh ... mesh for the theta-coordinate.
+ phiMesh ::Basics.AbstractMesh ... mesh for the phi-coordinate.JenaAtomicCalculator.Basics.StabilizedFockRoute — Method
Basics.StabilizedFockRoute(maxIterations::Int64) ... sets the budget and keeps both mechanisms
JenaAtomicCalculator.Basics.StabilizedFockRoute — Method
Basics.StabilizedFockRoute() ... both mechanisms on, with a correlation cut of half an electron
JenaAtomicCalculator.Basics.StabilizedFockRoute — Type
struct Basics.StabilizedFockRoute <: AbstractScfRoute ... an EXPLORATORY route: the Fock route carrying the two stabilizing mechanisms of GRASP's rmcdhf that are tractable in a B-spline code. It exists to find out what they are worth here, and is deliberately kept beside Basics.FockRoute rather than replacing it.
The two mechanisms, taken from `src/appl/rmcdhf90/` rather than invented:
(i) ADAPTIVE PER-ORBITAL DAMPING, after dampck.f90. The damping starts at 0.5; when successive relative
changes of an orbital's own energy change SIGN -- an oscillation, `ED1*ED2 < -1e-4` -- it is raised
as `0.1 + 0.9*damping`, and otherwise HALVED, so that a monotonically improving orbital is taken
almost whole. JAC's Fock solver already computes each orbital's eigenvalue and discards it, which
is what this needs, and is the same quantity priority item 11 is about.
(ii) A SPECTROSCOPIC / CORRELATION CLASSIFICATION, after orthy.f90, which orthogonalizes in the order
fixed, spectroscopic, correlation. An orbital counts as a correlation orbital when its generalized
occupation falls below `correlationCut`; those are refined LAST, so that a weakly occupied orbital
is projected against settled ones rather than the other way round.
STATUS, 09-Sep-2026: MEASURED AND SET ASIDE, with the maintainer's agreement. It was built to answer a
question and it answered it -- in the negative. DO NOT ADOPT IT, and do not make either mechanism a
default, without new evidence; equally, do not delete it, since the code is what makes the measurement
below reproducible.
WHAT WAS MEASURED, five cases against the rotation route, one code state (deficits in mHa):
case fock stab note
Be Z=4 8.86 8.69 the only case stab wins, by 0.17
Be Z=10 4.36 6.65
Be Z=26 3.16 5.34
Be 2-shell >8.95 >10.37 reference itself unconverged; stab's orbitals break, 83 % so-dev
C Z=6 10.17 13.94
THE ORDERING MECHANISM IS A NO-OP IN JAC BY CONSTRUCTION, and this is the part worth remembering. JAC
orders subshells by (n, kappa) and the generalized occupation falls monotonically with n -- measured on
the two-shell Be case: 2.000, 1.820, 0.069, 0.110, 0.0015, 0.00002, 0.0003 -- so the spectroscopic
orbitals ALREADY come first and the correlation-last sort returns the basis order unchanged. It has
never altered a number in any case tried. An earlier guess that it was inert only because the kappa
blocks were singletons was WRONG; the reason is structural. To make it act at all, the criterion would
have to become GRASP's own, which sorts by SELF-CONSISTENCY AND ENERGY rather than by class.
ADAPTIVE DAMPING IS NET NEGATIVE. It is worth 13.07 mHa against the GRASP-scaled equation with no
stabilizer at all -- a configuration nobody would ship -- but only 0.17 mHa against the Fock route as it
stands, and it LOSES by 2.2 to 3.8 mHa in four cases of five. It also costs iterations (60 without
converging against 17 that converge, on Be Z=4) and degrades the spin-orbit symmetry of the orbitals
even where it improves the energy.
WHAT NOT TO CONCLUDE FROM THIS. That fixed damping is useless is NOT what was shown, and the reverse was
concluded once already from too blunt a test: raising a FIXED damping to 0.9 and 0.98 made the collapse
more complete, which is a different statement from GRASP's rule, which damps only where successive
relative energy changes change sign and halves it everywhere else.
+ maxIterations ::Int64 ... maximum number of iterations this route may take.
+ adaptiveDamping ::Bool ... True, if the per-orbital damping follows dampck.f90 rather than the
fixed 0.5 the other Fock route uses.
+ correlationCut ::Float64 ... generalized occupation below which an orbital counts as a CORRELATION
orbital rather than a spectroscopic one, and is refined last.JenaAtomicCalculator.Basics.StaticField — Type
struct Basics.StaticField <: AbstractEmField ... to specify a static – electric or magnetic – field that is characterized by its (real) amplitude into a given direction.
+ amplitude ::Basics.Cartesian3DFieldVector{Float64} ... 3D vector that represents the amplitude A_o of the field.JenaAtomicCalculator.Basics.StaticQuantizationAxis — Type
struct Basics.StaticQuantizationAxis <: AbstractQuantizationAxis ... to specify a static quantization axis in terms of a unit vector for its direction.
+ nVector ::Basics.Cartesian3DFieldValue{Float64}
... 3D unit vector that specifies the quantization axis.JenaAtomicCalculator.Basics.StewartPyattModel — Method
Basics.StewartPyattModel() ... constructor for the default settings of Basics.StewartPyattModel(). A stewartPyattModel::Basics.StewartPyattModel is returned.
JenaAtomicCalculator.Basics.StewartPyattModel — Type
struct Basics.StewartPyattModel <: AbstractPlasmaModel ... to specify (the parameters of) a Stewart-Pyatt plasma model.
+ radius ::Float64 ... the Stewart-Pyatt radius R [a_o].
+ electronDensity ::Float64 ... electron density n_e (T).
+ lambda ::Float64
... the Debye screening length lambda_D [a_o], the same quantity as DebyeHueckelModel.debyeLength; the
ion-sphere radius R0 that enters the Stewart-Pyatt formula together with lambda is derived on-the-fly
from the total ion density (cf. Plasma.determineIpShifts), not stored here.JenaAtomicCalculator.Basics.ThomasFermiField — Type
... to represent a Thomas-Fermi screened field. Unlike every other member of this family it is NOT self-consistent: it needs only the nuclear charge and the number of electrons, and no density at all, which is exactly what makes it useful as a STARTING potential; see Basics.computePotential and ManyElectron.StartFromThomasFermi.
JenaAtomicCalculator.Basics.TimeHarmonicField — Type
struct Basics.TimeHarmonicField <: AbstractEmField ... to specify a time-harmonic – electric or magnetic – field that is characterized by its (real) amplitude into a given direction and a (harmonic) frequency.
+ amplitude ::Basics.Cartesian3DFieldVector{Float64} ... 3D vector that represents the amplitude A_o of the field.
+ omega ::Float64 ... Frequency of the time-harmonic field.JenaAtomicCalculator.Basics.TotalAM — Method
Basics.TotalAM() ... constructor for the default TotalAM(true, AngularJ64[]), i.e. ALL total angular momenta to which the CSF of a configuration can couple, with none selected in particular; a theme::Basics.TotalAM is returned. It exists so that this theme is written like every other AbstractConfigurationTheme – ClosedShells(), OpenSubshells(), ValenceShells() are all empty structs called with no argument, and TotalAM is the only one carrying fields, so a caller who writes TotalAM() beside them is following the family rather than making a mistake. The allJ field is exactly what expresses "all of them".
JenaAtomicCalculator.Basics.TotalAM — Type
struct Basics.TotalAM <: AbstractConfigurationTheme ... to extract the total angular momenta (AM) to which the CSF of a configuration can couple.
+ allJ ::Bool ... True, if all J-values (including multiple couplings) are to be returned, and false
otherwise.
+ totalJs ::Array{AngularJ64,1} ... Selected total angular momenta J.JenaAtomicCalculator.Basics.UserMCA — Type
... placeholder for a genuine multiconfiguration cascade approach; declared but NOT (yet) implemented anywhere in the codebase – selecting it does not raise an explicit error and currently falls through to the same code path as SCA in the Cascade-inc-*.jl dispatch sites, which do not special-case it either.
JenaAtomicCalculator.Basics.ValenceOccupation — Type
... to extract the remaining configuration beyond a given (closed) core configuration.
JenaAtomicCalculator.Basics.ValenceShells — Type
... theme for Basics.extractFromConfiguration, to extract the valence shells of a configuration, decided on the configuration itself.
JenaAtomicCalculator.Basics.Variational — Type
struct Basics.Variational <: Basics.AbstractQTreatment ... every configuration a RAS step generates enters the CI, which is the behaviour of every RAS step written before 11-Sep-2026 and remains the default. Equivalent to SecondOrder(0., 0.) and kept as its own type because "treat this layer exactly" is a statement about intent, not a choice of threshold.
JenaAtomicCalculator.Basics.VeeOnly — Type
... the bare electron-electron interaction as the transition operator – the historical shortcut, exact wherever the two states are built on one orthonormal orbital set and differ in two or more orbitals. Every validated first-order Auger, DR and cascade number in JAC is a VeeOnly number.
JenaAtomicCalculator.Basics.ZeemanStructure — Type
struct Basics.ZeemanStructure <: AbstractConfigurationTheme ... to compute the Lande g_J factors of a configuration, and the Zeeman splittings if a field is given.
+ BField ::Float64 ... Magnetic flux density in Tesla; g_J alone needs none, so 0. is the usual value.JenaAtomicCalculator.Basics.add — Method
Basics.add(ma::AngularM64, mb::AngularM64) ... adds the projections of the angular momenta ma + mb and returns a mc::AngularM64.
JenaAtomicCalculator.Basics.incrementTolerance — Function
Basics.incrementTolerance(route::Basics.AbstractScfRoute) ... returns the fraction by which DOUBLING the effort may still move the result before the given route stops, or 0.0 for every route that does not offer the test – so a caller may ask any route without knowing which ones implement it. See Basics.RotationRoute for what the test measures and why its scale is the descent itself. A value::Float64 is returned.
JenaAtomicCalculator.Basics.maxIterations — Function
Basics.maxIterations(route::Basics.AbstractScfRoute) ... returns the iteration budget of the given route. Each solver has its own natural budget – a mean field converges in a handful of iterations where the rotation route needs thousands – which is why the budget belongs to the route and not to the settings as a whole. An AutomaticRoute carries no budget of its own and yields the shared default. A value::Int64 is returned.
JenaAtomicCalculator.Basics.normalizeResultKey — Method
Basics.normalizeResultKey(key::AbstractString) ... reduces a results key to its letters and digits in lower case, so that two keys differing only in spacing, case or punctuation compare equal; a String is returned. "photoRecombination lines:" and "photo recombination lines:" both reduce to "photorecombinationlines".
JenaAtomicCalculator.Basics.oplus — Method
Basics.oplus(ja::AngularJ64, jb::AngularJ64) ... adds the angular momenta ja oplus jb and returns a list::Array{AngularJ64,1} of j-valuescin the interval |ja - jb| <= j <= ja + jb.
JenaAtomicCalculator.Basics.projections — Method
Basics.projections(ja::AngularJ64) ... returns all allowed projections of a given angular momenta ja as a list::Array{AngularM64,1} of m-values, i.e. -ja, -ja+1, ..., j.
JenaAtomicCalculator.Basics.providesPotential — Function
Basics.providesPotential(scField::Basics.AbstractScField) ... answers whether Basics.computePotential can build a radial potential for this field. False by default. Note that the two predicates are INDEPENDENT rather than complementary: DFSField and HSField answer true to both, since a mean field is a potential one can also iterate, while ALField and EOLField answer false here – they are variational procedures that build a Fock matrix and name no local potential at all. A value::Bool is returned.
JenaAtomicCalculator.Basics.providesScfDriver — Function
Basics.providesScfDriver(scField::Basics.AbstractScField) ... answers whether SelfConsistent.performSCF can ITERATE this field, i.e. whether it owns a self-consistent driver. Derived from Basics.scfProcedure, so the two cannot disagree. A value::Bool is returned.
JenaAtomicCalculator.Basics.scfDriverFields — Method
Basics.scfDriverFields() ... names the fields that SelfConsistent.performSCF can iterate, i.e. exactly those for which Basics.providesScfDriver is true. Kept beside the predicates themselves so the two cannot drift apart, and used by performSCF's own refusal message. An Array{String,1} is returned.
JenaAtomicCalculator.Basics.scfProcedure — Function
Basics.scfProcedure(scField::Basics.AbstractScField) ... names the procedure by which SelfConsistent.performSCF determines the orbitals for this field. This is the second of the two axes the AbstractScField family mixes: the first is WHAT the effective potential is, this one is HOW the orbitals follow from it.
:meanFieldIteration ... iterate a local screened potential to self-consistency
:averageLevel ... the average-level variational procedure (a Fock matrix, no local potential)
:optimizedLevel ... the optimized-level variational procedure, by orbital rotation
:hydrogenicStartOnly ... no iteration at all; the generated basis is returned unchanged
:none ... no driver; the field is a potential only
:none is the default, so a newly added field is treated as unsupported until it says otherwise --
the safe direction. A value::Symbol is returned.JenaAtomicCalculator.Basics.standardRoute — Method
Basics.standardRoute(scField::AbstractScField, maxIterations::Int64) ... selects the SCF route that matches the given mean field's own procedure, so that a caller who has chosen a field need not also know which solver belongs to it; the iteration budget is passed straight through. A route::Basics.AbstractScfRoute is returned – a MeanFieldRoute, an AverageLevelRoute or a RotationRoute – and an AutomaticRoute for any field whose procedure is none of those three.
JenaAtomicCalculator.Basics.standardRoute — Function
Basics.standardRoute(scField::Basics.AbstractScField, maxIterations::Int64) ... returns the route by which the given field is normally solved, carrying the given iteration budget. This is what an AutomaticRoute stands for, and it is the way to name a budget without also having to know which solver a field uses – which matters wherever the field is a variable rather than a literal. A route::AbstractScfRoute is returned.
JenaAtomicCalculator.Basics.Configuration — Method
Basics.Configuration(NoElectrons::Int64) ... constructor for a given number of electrons which are filled into the shells in the MADELUNG order, i.e. by increasing n+l and, at equal n+l, by increasing n. A conf::Configuration is returned.
This is the (n+l, n) rule and not the strict (n, l) order that was used until 18-Aug-2026, which placed the
electrons of calcium into 3d instead of 4s and gave `1s^2 2s^2 2p^6 3s^2 3p^6 3d^2`; strontium came out as
4d^2 and xenon as 4f^8. Madelung reproduces the ground configuration of most elements, but NOT of the roughly
twenty exceptions -- Cr, Cu, Nb, Mo, Ru, Rh, Pd, Ag, La, Ce, Gd, Pt, Au, Ac, Th, Pa, U, Np, Cm -- where a
d or f shell is filled at the expense of the outer s. A caller that needs the true ground configuration of a
specific element must therefore not rely on this constructor alone.JenaAtomicCalculator.Basics.Configuration — Method
Basics.Configuration(sa::String) ... constructor for a given configuration string, such as "[He]", "[Ne]", "[Ne] 3s 3p^6" or "1s 2p^6 3s^2 3p". One can also use "1s^0" to represent a (bare-ion) empty configuration. A configuration::Basics.Configuration is returned.
JenaAtomicCalculator.Basics.Configuration — Type
struct Basics.Configuration ... defines a struct for a non-relativistic electron configuration that is fully speficied by its shell notations (such as "1s", "2s", "2p", ....) and the corresponding occupation numbers (>= 0). An electron configuration is independent of any order of the shells, and a zero occupation is assumed for all shells that do not appear as a key in the shell (dictionary). Therefore, the number of keys do not allow any conclusion about the underlying orbital space of any considered computation that include more than just a single configuration.
+ shells ::Dict{Shell,Int64} ... Dictionary that maps shells to their occupation.
+ NoElectrons ::Int64 ... No. of electrons.JenaAtomicCalculator.Basics.ConfigurationR — Type
struct Basics.ConfigurationR ... defines a type for a relativistic electron configuration that is fully speficied by its subshell notations (such as "1s1/2", "2s1/2", "2p_3/2", ....) and the corresponding occupation numbers (>= 0). An electron configuration is independent of any order of the subshells, and a zero occupation is assumed for all shells that do not appears as a key. Therefore, the number of keys do not allow any conclusion about the underlying orbital space of any considered computation that include more than a single configuration.
+ subshells ::Dict{Subshell,Int64} ... Dictionary that maps subshells to their occupation.
+ NoElectrons ::Int64 ... No. of electrons.JenaAtomicCalculator.Basics.CorePolarization — Method
Basics.CorePolarization() ... constructor for the default values of core-polarization contributions. A corePolarization::Basics.CorePolarization is returned.
JenaAtomicCalculator.Basics.CorePolarization — Type
struct Basics.CorePolarization ... defines a type to describe the influence of core-polarization upon the potential or interaction operator.
+ doApply ::Bool ... True if core-polarization is to be applied, and false otherwise.
+ coreAlpha ::Float64 ... Polarizibility of the ionic core.
+ coreRadius ::Float64 ... Radius of the ionic core.
+ coreShells ::Array{Shell,1} ... Shells of the ionic coreJenaAtomicCalculator.Basics.EmGauge — Method
Basics.EmGauge(sa::String) ... constructor for a given String. A gauge::Basics.EmGauge is returned.
JenaAtomicCalculator.Basics.EmGauge — Type
@enum Basics.EmGauge ... defines a enumeration for the (allowed) gauges to deal with the radiation field; this differs from the UseGauge which can be selected for explicit computations.
+ NoGauge ... No gauge define (yet).
+ Coulomb ... Coulomb gauge (= velocity gauge in the non-relativistic limit; Grant, 1974).
+ Babushkin ... Babushkin gauge (= length gauge in the non-relativistic limit; Grant, 1974).
+ Magnetic ... Magnetic gauge (transverse velocity gauge).
+ Velocity ... Transverse velocity gauge (Johnson, 2007).
+ Length ... Length gauge (Johnson, 2007).JenaAtomicCalculator.Basics.EmMultipole — Method
Basics.EmMultipole(sa::String) ... constructor for a given String. A emMultipole::Basics.EmMultipole is returned.
JenaAtomicCalculator.Basics.EmMultipole — Type
struct Basics.EmMultipole ... defines a struct for the em multipoles, E1, M1, E2, ...
+ L ::Int64 ... multipolarity
+ electric ::Bool ... True if the multipole is an electric one, and false otherwise.JenaAtomicCalculator.Basics.EmProperty — Method
Basics.EmProperty(wa::Float64) ... constructor for an constant instance of EmProperty. A emProperty::Basics.EmProperty is returned.
JenaAtomicCalculator.Basics.EmProperty — Type
struct EmProperty ... defines a type to maintain two gauge forms of a computed result that depends on the radiation field.
+ Coulomb ::Float64 ... Value for the Coulomb gauge of the radiation field.
+ Babushkin ::Float64 ... Value for the Coulomb gauge of the radiation field.JenaAtomicCalculator.Basics.EmPropertyC — Method
Basics.EmPropertyC(wa::Complex{Float64}) ... constructor for a gauge-independent (complex) instance.
Added 13-Aug-2026 for amplitudes: a MAGNETIC multipole has no gauge dependence, so its amplitude is the
same number in both components. Saying that with this constructor is what removes the special case in
which a magnetic contribution has to be added to the Coulomb AND the Babushkin sum by hand.
A `emPropertyC::Basics.EmPropertyC` is returned.JenaAtomicCalculator.Basics.EmPropertyC — Method
Basics.EmPropertyC(wa::Float64) ... constructor for an constant instance of EmPropertyC. A emPropertyC::Basics.EmPropertyC is returned.
JenaAtomicCalculator.Basics.EmPropertyC — Type
struct EmPropertyC ... defines a type to maintain two gauge forms of a computed result that depends on the radiation field.
+ Coulomb ::Complex{Float64} ... (Complex) Value for the Coulomb gauge of the radiation field.
+ Babushkin ::Complex{Float64} ... (Complex) Value for the Coulomb gauge of the radiation field.JenaAtomicCalculator.Basics.IsotopicFraction — Method
Basics.IsotopicFraction() ... constructor for an empty instance of IsotopicFraction. A isotopicFraction::Basics.IsotopicFraction is returned.
JenaAtomicCalculator.Basics.IsotopicFraction — Type
struct Basics.IsotopicFraction ... defines a type to deal with different – individual or averaged – isotopic fractions in a computation.
+ Z ::Float64 ... nuclear charge
+ A ::Float64 ... (mean) mass number of the isotope/isotopic mixture.
+ x ::Float64 ... fraction 0 <= x <=1 of the given isotope/isotopic mixture.JenaAtomicCalculator.Basics.MultipoleAmplitude — Type
struct Basics.MultipoleAmplitude ... the contribution of ONE multipole of the electron-photon interaction operator to an amplitude.
+ multipole ::EmMultipole ... Multipole of the photon emission/absorption.
+ amplitude ::EmPropertyC ... Amplitude in BOTH gauges; the gauge is not a label here.
This lives in Basics because it is the SAME type in every process that expands the electron-photon
interaction into multipoles -- PhotoIonization, PhotoRecombination, PhotoEmission and, through the last
of those, DielectronicRecombination. It was defined identically in three modules until 14-Aug-2026.
What differs BETWEEN those modules is not this container but two other things: the physical amplitude
itself, which each module computes in its own `amplitude(...)` function; and the structure AROUND this
type -- a PartialWave with kappa, energy and phase where there is a free electron, a total symmetry
where one kappa serves several, and nothing at all for a bound-bound transition. Those stay per-module.
A MAGNETIC multipole simply has equal components, which is what a gauge-labelled form has to express by
adding Basics.Magnetic to both gauge sums; and a product conj(amplitude) * amplitude' is componentwise,
so two gauges cannot mix however the caller is written.JenaAtomicCalculator.Basics.OrbitalShape — Type
Basics.OrbitalShape ... which job a (n, kappa)-labelled orbital's own radial contraction is for. Ordinarily every orbital of a given label is SCFShape; a second, independently-contracted realization of the SAME (n, kappa) – never orthogonalized against the first – is distinguished by a different value here, never by a different (n, kappa). See the module docstring of SelfConsistent for where this is read.
JenaAtomicCalculator.Basics.Parity — Method
Basics.Parity(sa::String) ... constructor for a given String. A parity::Basics.Parity is returned.
JenaAtomicCalculator.Basics.Parity — Type
@enum Parity ... defines a enumeration for the allowed values of parity.
+ plus, minus ... with obvious meaningJenaAtomicCalculator.Basics.Shell — Method
Basics.Shell(sa::Union{String,SubString{String}}) ... constructor for a given String, such as 1s, 2s, 2p, ... . A shell::Basics.Shell is returned.
JenaAtomicCalculator.Basics.Shell — Type
struct Basics.Shell ... defines a enumeration for the allowed values of a non-relativistic shell.
+ n ::Int64 ... principal quantum number
+ l ::Int64 ... orbital angular quantum numberJenaAtomicCalculator.Basics.Subshell — Method
Basics.Subshell(n::Int64, kappa::Int64) ... convenience constructor defaulting shape to SCFShape, so every existing two-argument call site is unaffected.
JenaAtomicCalculator.Basics.Subshell — Method
Basics.Subshell(sa::String) ... constructor for a given String, such as 1s1/2, 2s1/2, 2p_3/2, ... . A subshell::Basics.Subshell is returned.
JenaAtomicCalculator.Basics.Subshell — Type
struct Basics.Subshell ... defines a type for the allowed values of a relativistic subhell.
+ n ::Int64 ... principal quantum number
+ kappa ::Int64 ... relativistic angular quantum number
+ shape ::OrbitalShape ... which job this orbital's own radial contraction is for; SCFShape unless this
is a second, independently-contracted realization of this (n, kappa).JenaAtomicCalculator.Basics.SubshellStateR — Type
struct Basics.SubshellStateR ... defines a struct for the relativistic antisymmetric subshell states in the seniority scheme; this struct can be accessed only internally and, therefore, the only the standard constructor is supported.
+ subshell ::Subshell ... to refer to a particular subshell.
+ occ ::Int64 ... occupation of the subshell
+ nu ::Int64 ... seniority of the subshell state, often called nu
+ Jsub2 ::Int64 ... 2*JsubJenaAtomicCalculator.Basics.UseGauge — Method
Basics.UseGauge(sa::String) ... constructor for a given String. A gauge::Basics.UseGauge is returned.
JenaAtomicCalculator.Basics.UseGauge — Type
@enum Basics.UseGauge ... defines a enumeration for the (allowed) gauges to be selected in explicit computations
Base.:(==) — Method
Base.:(==)(confa::Configuration, confb::Configuration) ... compares (recursively) two non-relativistic configurations and return true if all subfields are equal, and false otherwise A value::Bool is returned.
Base.:(==) — Method
Base.:(==)(confa::ConfigurationR, confb::ConfigurationR) ... compares (recursively) two relativistic configurations and return true if all subfields are equal, and false otherwise A value::Bool is returned.
Base.convert — Method
Base.convert(::Type{Basics.Subshell}, x::JLD2.ReconstructedStatic) ... bridges a .jld/.jld2 cascade file written before the shape field existed, for a Subshell met as an ORDINARY STRUCT FIELD (as in Radial.Orbital.subshell): JLD2 checks for exactly this convert method when deciding whether a containing struct's own field-by-field reconstruction can proceed normally, so this one method is enough for every struct that merely HOLDS a Subshell field, however deeply nested (Orbital, Level, Multiplet, ...) – no method is needed for each of those in turn. An old file's Subshell is read exactly as the two-argument constructor above defaults it – shape = SCFShape.
Base.hash — Method
Base.hash(conf::Basics.Configuration, h::UInt) ... hash a configuration from its CANONICAL content – the occupied shells in a fixed order, plus the electron number – so that two configurations which compare equal also hash equal. A value::UInt is returned.
THESE EXIST BECAUSE THE DEFAULT HASH BREAKS JULIA'S CONTRACT HERE, and it breaks it SILENTLY: `isequal`
implies equal hashes, so a `Dict` or `Set` keyed by a configuration must find what it stored. Two causes,
and a fix needs both. FIRST, a Configuration holds a `Dict`, so it is not `isbits` and Julia's generic
fallback `hash(x, h) = hash(objectid(x), h)` applies -- OBJECT IDENTITY. Measured 12-Sep-2026: two
configurations built from the same string have `hash(a.shells) == hash(b.shells)` and equal `NoElectrons`,
and still hash differently. SECOND, `==` above deliberately treats a MISSING shell as one of occupation
ZERO, which is the right physics, so hashing the `Dict` as it stands would still disagree whenever one of
the two carries an explicit zero. Dropping the zero occupations is what makes the hash agree with what
`==` MEANS rather than with how the Dict happens to be filled.
The cost was paid twice in unrelated work before this was written: once in the inelastic-H-collision
module, and again on 12-Sep in `Hamiltonian.groupCsfsByConfiguration`, where a `Dict{Configuration,...}`
put 426 CSFs into "425 configurations" -- one per CSF -- and a second-order ranking then listed the same
configuration a dozen times with different weights. Neither produced an error.Base.hash — Method
Base.hash(conf::Basics.ConfigurationR, h::UInt) ... hash a relativistic configuration from its CANONICAL content – the occupied subshells in a fixed order, plus the electron number – so that two configurations which compare equal also hash equal. A value::UInt is returned. The reasons are those given for Base.hash(conf::Basics.Configuration, h::UInt) above: a ConfigurationR holds a Dict and so falls back to OBJECT IDENTITY, and its == treats a missing subshell as one of occupation zero.
Base.hash — Method
Base.hash(sh::Basics.Shell, h::UInt) and Base.hash(sh::Basics.Subshell, h::UInt) ... hash a shell or subshell from its quantum numbers alone, with a fixed seed. A value::UInt is returned.
THESE EXIST TO MAKE Dict ITERATION ORDER REPRODUCIBLE, and that is a correctness matter rather than a
tidiness one. Julia's default hash for a composite type folds in the TYPE's identity, which differs between
precompiled images: measured on 28-Aug-2026, hash(Shell("1s")) was 17510954341873548245 in one build and
15512695893170165806 in the next, for the same source. Every Dict or Set keyed by one of these types then
iterated in a different order from build to build -- so `Basics.generateConfigurations` emitted the
relativistic configurations of 1s^2 2s^2 2p^5 3p^1 in one order or another, the CSF basis followed, and the
SCF total energy moved in the 9th digit for no reason a reader could see. That was priority item 57, and it
cost a day of control runs across two migrations before it was tracked down.
Hashing the quantum numbers with a literal seed removes the type identity from the calculation and makes the
order a property of the physics. Consistency with equality is preserved: neither type defines its own `==`,
so equality is field-wise, and `Subshell`'s equality now also compares `shape` -- but the hash deliberately
does NOT fold `shape` in. Two differently-shaped realizations of the same (n, kappa) are UNEQUAL and so
remain distinct Dict keys; they merely share a hash bucket, which `==` already disambiguates correctly.
Measured 03-Nov-2026: folding `shape` into the hash as well reorders every Dict keyed by Subshell, even
though every Subshell built anywhere today still has shape = SCFShape -- moving a Cl III test calculation's
printed energies in their 11th digit for no reason a reader could see, exactly the item-57 symptom the note
above describes. Leaving the hash as it was keeps this struct extension truly inert; a later plan that
actually puts two shapes in the same Dict can revisit this if the shared bucket ever matters for speed.Base.string — Method
Base.string(conf::Configuration, open::Bool) ... provides, if open=trueM a String notation for the open-shell part of variable conf::Configuration, and the standard printout for open=false. A sa::String is returned.
JLD2.rconvert — Method
JLD2.rconvert(::Type{AbstractDict{Basics.Subshell,V}}, x) ... the companion bridge for a widened field such as ManyElectron.Basis.orbitals (Dict{Subshell,Orbital} -> AbstractDict{Subshell,Orbital}, 08-Nov-2026, priority item 14 – PhotoIonizationPseudostates' lazy, on-demand-materializing orbital dict needs an AbstractDict-typed field to carry it). JLD2 dispatches rconvert/convert on the FIELD's DECLARED type, so widening that type bypasses every Dict{Subshell,V}-specific bridge above – confirmed by the regression this fixes: testModule_Cascade_Simulation's saved-basis load failed with MethodError: Cannot convert an object of type JLD2.SerializedDict to an object of type AbstractDict{Subshell, Orbital} the same day the field was widened, suite run from test/. These three methods restore the same reconstruction for the abstract declared type, in every shape JLD2 was observed to hand a stored dict: a bare Vector, a Vector{<:Pair}, and a JLD2.SerializedDict (unwrapped via its own single field kvvec, which is exactly the same pair-vector shape the other two methods already handle). A Dict{Subshell,V} is returned in every case – itself a valid AbstractDict{Subshell,V}, so the struct constructor's field assignment succeeds.
JLD2.rconvert — Method
JLD2.rconvert(::Type{Dict{Basics.Subshell,V}}, x::Vector{<:Pair}) ... the same bridge as the method above, but for the OTHER shape JLD2 hands back when loading a real saved file: a concrete Vector{Pair{Subshell,Orbital}} (or similar), which JLD2's own rconvert(::Type{T}, x::Vector{<:Pair}) where T<:Union{Dict,IdDict} also claims, making the broad method above ambiguous against it. This method is strictly more specific in BOTH arguments than either competing method, so it resolves the ambiguity without touching the broad method's own case. A Dict{Subshell,V} is returned, exactly as the method above returns one.
JLD2.rconvert — Method
JLD2.rconvert(::Type{Dict{Basics.Subshell,V}}, x::Vector) ... the companion bridge for a Subshell met as a Dict's TYPE PARAMETER rather than a field (Dict{Subshell,Orbital} for an orbital set, Dict{Subshell,Int64} for an occupation, and every other Dict{Subshell,V} in the code share this one route). JLD2 resolves a type PARAMETER by name, independently of the convert method above, so an old file's Subshell keys arrive as JLD2.ReconstructedStatic values inside the pair vector regardless of V; this method bridges exactly that vector for any V, so no method is needed for each value type V in turn. A Dict{Subshell,V} is returned, with every key's shape defaulted to SCFShape as the two-argument constructor above does.
THIS BROAD `x::Vector` METHOD MUST STAY, EVEN THOUGH IT LOOKS REDUNDANT WITH THE NARROWER ONE BELOW.
`testModule_Cascade_Simulation` reaches this bridge with x as a concrete `Vector{Any}`, which is not a
`Vector{<:Pair}` and so only THIS method matches it. Narrowing or removing this one breaks that path --
measured directly, 06-Nov-2026 (see priority list item 10): the saved-dict-as-`Vector{Any}` case failed
with `MethodError: Cannot convert an object of type Vector{Any} to an object of type Dict{Subshell, Orbital}`
once this method was narrowed instead of kept alongside the new one.JenaAtomicCalculator.Basics.displayGaugeConsistency — Method
Basics.displayGaugeConsistency(stream::IO, rows::Array{Tuple{String,Float64,EmProperty},1}; caption::String="") ... prints one compact table of how far the two gauge forms of a result agree, for a list of rows, each a (label, energy ALREADY in the display unit, property) triple that the calling module builds from its own Line type – the conversion stays with the caller, since Defaults is not yet loaded at this point.
THE TWO GAUGE VALUES THEMSELVES ARE DELIBERATELY NOT PRINTED. They stand in the module's own table
directly above this one, in that module's display units, whereas an EmProperty arrives here in atomic
units; printing them again would show the same quantity in two different units a few lines apart, which
is how a reader concludes the code disagrees with itself. What is new here is the DEVIATION, so that is
what the table carries. The
table is shared deliberately: four process modules printing the same indicator in four slightly
different layouts would make the indicator harder to read, not easier. Nothing is returned.JenaAtomicCalculator.Basics.gaugeConsistency — Method
Basics.gaugeConsistency(property::EmProperty) ... measures how far the two gauge forms of a radiation-field result agree, and turns that into a verdict a reader can act on. The relative deviation is |Babushkin - Coulomb| / max(|Babushkin|, |Coulomb|), so it is symmetric in the two gauges and needs no reference value. This is NOT a proof that a number is right – two gauges can agree on a wrong answer when the same correlation is missing from both – but a large deviation is reliable evidence that it is wrong, which is what makes it worth printing.
The thresholds are those already used by PhotoEmission.displayQualityFlags, deliberately: two indicators
that disagreed about the word "ok" would be worse than one. A tuple (deviation::Float64,
verdict::String) is returned; the deviation is NaN where both gauges vanish.JenaAtomicCalculator.Basics.invertParity — Method
Basics.invertParity(p::Parity) ... inverts the given parity plus <–> minus. A parity::Basics.Parity is returned.
JenaAtomicCalculator.Basics.multipoleParity — Method
Basics.multipoleParity(mp::EmMultipole) ... returns the PARITY of the one-particle tensor operator that belongs to the given multipole: an electric 2^L-pole carries parity (-1)^L and a magnetic one (-1)^(L+1), so E1 and E3 are odd while M1, E2 and M3 are even. This is the parity that a spin-angular operator must be constructed with, and it decides which coefficients survive the parity selection rule – an even operator connects orbitals with la + lb even, an odd one those with la + lb odd. A value::Basics.Parity is returned.
IT EXISTS BECAUSE HARD-CODING `plus` IS WRONG AND USED TO BE HARMLESS. `SpinAngularGaigalas.computeCoefficients`
ignores the parity it is given and returns both sets, leaving the radial integral to kill the wrong half;
`SpinAngular` applies the rule, so a caller that passes `plus` for an E1 operator now silently loses
exactly the coefficients E1 needs. Measured on 2s <-> 2p at rank 1: SpinAngularGaigalas returns 9 coefficients
for either parity, SpinAngular returns 5 for plus and 4 for minus.JenaAtomicCalculator.Basics.multipole_p — Method
Basics.multipole_p(mp::EmMultipole) ... returns the kind integer p=0 (magnetic) or p=1 (electric) of the given mp::EmMultipole.
JenaAtomicCalculator.Basics.shellNotation — Method
Basics.shellNotation(l::Int64) ... returns the corresponding spectroscopy letter for a given orbital angular quantum number l.
JenaAtomicCalculator.Basics.shellNotation — Method
Basics.shellNotation(sa::String) ... returns for a given spectroscopy letter the orbital angular quantum number l.
JenaAtomicCalculator.Basics.shellSplitIntoSubshells — Method
Basics.shellSplitIntoSubshells(sh::Shell) ... to convert a non-relativistic shell into a list of its relativistic subshells; an Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.shellSplitOccupation — Method
Basics.shellSplitOccupation(sh::Shell, occ::Int64) ... to split the occupation of a shell into proper subshell occupations; an Array{Dict{Basics.Subshell,Int64},1} is returned.
JenaAtomicCalculator.Basics.subshellGrasp — Method
Basics.subshellGrasp(sa::AbstractString) ... returns a sh::Subshell if sa denotes a (relativistic) Subshell in Grasp-notation.
JenaAtomicCalculator.Basics.subshell_2j — Method
Basics.subshell_2j(sh::Subshell) ... returns the total angular quantum number j for a given sh::Subshell; an AngularJ64 is returned.
JenaAtomicCalculator.Basics.subshell_j — Method
Basics.subshell_j(sh::Subshell) ... returns the total angular quantum number j for a given sh::Subshell; an AngularJ64 is returned.
JenaAtomicCalculator.Basics.subshell_l — Method
Basics.subshell_l(sh::Subshell) ... returns the orbital angular quantum number l for a given sh::Subshell; an Int64 is returned
JenaAtomicCalculator.Basics.Eigen — Type
struct Basics.Eigen ... defines a simple struct to communicate eigenvalues and eigenvectors if different diagonalization procedures are used.
+ values ::Array{Float64,1} ... List of eigenvalues.
+ vectors ::Array{Vector{Float64},1} ... List of eigenvectors.JenaAtomicCalculator.Basics.EmStokes — Type
struct Basics.EmStokes ... defines a type to maintain the (computed) given Stokes parameter for the polarization of emitted photons or electrons.
+ P1 ::EmProperty ... Stokes P1 parameter in Coulomb and Babushkin gauge
+ P2 ::EmProperty ... Stokes P2 parameter.
+ P3 ::EmProperty ... Stokes P3 parameter.JenaAtomicCalculator.Basics.ExpStokes — Method
Basics.ExpStokes() ... constructor for an (empty or unpolarized) Stokes vector. A expStokes::Basics.ExpStokes is returned.
JenaAtomicCalculator.Basics.ExpStokes — Type
struct Basics.ExpStokes ... defines a type to maintain the (experimentally) given Stokes parameter for the polarization of incoming photons or electrons.
+ P1 ::Float64 ... Stokes P1 parameter.
+ P2 ::Float64 ... Stokes P2 parameter.
+ P3 ::Float64 ... Stokes P3 parameter.JenaAtomicCalculator.Basics.LevelKey — Method
Basics.LevelKey() ... constructor for an empty instance of a LevelKey. A levelKey::Basics.LevelKey is returned.
JenaAtomicCalculator.Basics.LevelKey — Type
struct Basics.LevelKey ... defines a struct for identifying a level by its symmetry, energy, etc.
+ sym ::LevelSymmetry ... Level symmetry.
+ index ::Int64 ... Index of this level in its original multiplet, or 0.
+ energy ::Float64 ... Total energy.
+ relativeOcc ::Float64 ... Relative occupation of this level, if part of some multiplet/cascade.JenaAtomicCalculator.Basics.LineKey — Method
Basics.LineKey() ... constructor for an empty instance of a LineKey. A lineKey::Basics.LineKey is returned.
JenaAtomicCalculator.Basics.LineKey — Type
struct Basics.LineKey ... defines a struct for identifying a line by the keys of the initial and final level, its transition energy, decay strength, etc.
+ iLevelKey ::LevelKey ... Key of the initial level.
+ fLevelKey ::LevelKey ... Key of the final level.
+ energy ::Float64 ... Total energy.
+ strength ::Float64 ... Strength of the given line.JenaAtomicCalculator.Basics.ScalarProperty — Method
Basics.ScalarProperty(wa::Float64) ... constructor for an constant instance of ScalarProperty{T}. A scalarProperty::Basics.ScalarProperty is returned.
JenaAtomicCalculator.Basics.ScalarProperty — Type
struct ScalarProperty{T} ... defines a type to maintain a scalar function dependence f(x) but for different types input and function values.
+ arg ::Float64 ... Argument of function f(x).
+ value ::T ... Function value f(x).JenaAtomicCalculator.Basics.SolidAngle — Type
struct Basics.SolidAngle ... defines a type for a solid angle Omega = (theta, phi).
+ theta ::Float64 ... polar angle theta with regard to the z-axis; 0 <= theta <= pi.
+ phi ::Float64 ... azimuthal angle phi (with regard to the x-z plane in mathematical positive direction); 0 <= phi <= 2 pi.JenaAtomicCalculator.Basics.TensorComp — Type
struct Basics.TensorComp ... defines a type for a component of the statistical tensor as associated with an atomic or ionic level.
+ k ::Int64 ... rank of the tensor component
+ q ::Int64 ... q-component
+ comp ::ComplexF64 ... value of the tensor componentJenaAtomicCalculator.Basics.isEqual — Method
Basics.isEqual(a::Eigen, b::Eigen, accuracy::Float64) ... determines whether a == b with the requested accuracy; a value::Bool is returned. The test is made element-wise on abs(a.number - b.number) > accuracy.
JenaAtomicCalculator.Basics.tensorComp — Method
Basics.tensorComp(k::Int64, q::Int64, tcomps::Array{TensorComp,1}; withZeros::Bool = false) ... returns the value of the statistical tensor component rho_kq if it is contained in tcomps.
Basics: electron configurations
JenaAtomicCalculator.Basics.checkConfigurations — Method
Basics.checkConfigurations(theme::Basics.NumberOfElectrons, confs::Array{Configuration,1}, confsMinus1::Array{Configuration,1}) ... checks for and terminates with a comment, if not all the given configurations have the same number of electrons > 0.
JenaAtomicCalculator.Basics.checkConfigurations — Method
Basics.checkConfigurations(theme::Basics.NumberOfElectrons, confs::Array{Configuration,1}) ... checks for and terminates with a comment, if not all the given configurations have the same number of electrons > 0.
JenaAtomicCalculator.Basics.displayConfiguration — Method
Basics.displayConfiguration(stream::IO, theme::Basics.FineStructure, config::Configuration; details::String="", header::Bool=true) ... displays the given configuration along with its fine-structure, i.e. the total J's and their number of levels. Nothing is returned in this case.
JenaAtomicCalculator.Basics.displayConfiguration — Method
Basics.displayConfiguration(stream::IO, theme::Basics.FineStructureLS, config::Configuration; details::String="", header::Bool=true) ... displays the given configuration along with its LSJ-fine-structure, i.e. the total ^(2S+1) L, J's and the number of these LSJ-levels. Nothing is returned in this case.
JenaAtomicCalculator.Basics.displayConfiguration — Method
Basics.displayConfiguration(stream::IO, theme::Basics.HyperfineStructure, config::Configuration; details::String="", header::Bool=true) ... displays the given configuration along with its hyperfine-structure, i.e. the total F's and their number of levels for the nuclear spin I. Nothing is returned in this case.
JenaAtomicCalculator.Basics.displayConfiguration — Method
Basics.displayConfiguration(stream::IO, theme::Basics.MeanConfiguration, confs::Array{Configuration,1}; details::String="") ... displays a mean configuration for all given configurations confs, i.e. an electron configuration with mean occuation numbers. The procedure terminates if configurations with a different number of electrons are given. Nothing is returned.
JenaAtomicCalculator.Basics.displayConfigurationThemes — Method
Basics.displayConfigurationThemes() ... displays and explains the various configurationTheme's <: AbstractConfigurationTheme that are defined to generate, deal with and manipulate individual as well as sets of (electron) configurations. These themes provide a simple means in order to extract information and to manipulate such configuration and are, hence, deep within the use of the atomic-shell model. Whereas further details can be extracted for each of these themes, this (dummy) routine aims to summarize the different themes along with its input parameters. Nothing is done (and returned) by this function. The following topics are distinguished:
Add, excite or remove electrons from some reference configurations
------------------------------------------------------------------
+ AddElectrons(ne::Int64, intoShells::Array{Shell,1})
... to add to the given reference configurations one or several (ne) electrons into the specified intoShells.
+ ExciteElectrons(ne::Int64, fromShells::Array{Shell,1}, intoShells::Array{Shell,1})
... to excite for the given configurations one or several (ne) electrons fromShells --> intoShells.
+ RemoveElectrons(ne::Int64, fromShells::Array{Shell,1})
... to remove from the given configurations one or several (ne) electrons from the specified fromShells.
Generate configurations due to different atomic processes
---------------------------------------------------------
+ ForAutoIonization()
... to generate configurations that are related by autoionization (deexcitation + single remove).
+ ForDielectronicCapture(fromShells::Array{Shell,1}, toShells::Array{Shell,1}, intoShells::Array{Shell,1})
... to generate configurations for the dielectronic capture into a given configuration, and by including
the excitation of an electron fromShells --> toShells as well as the capture of one electron into
the intoShells.
+ ForDielectronicRecombination(fromShells::Array{Shell,1}, toShells::Array{Shell,1}, intoShells::Array{Shell,1},
decayShells::Array{Shell,1})
... to generate configurations for the dielectronic recombination of ions in given initial configurations:
It includes the excitation of an electron fromShells --> toShells, the capture of one electron into
the intoShells, and the decay of the generated (intermediate) configurations into the decayShells.
+ ForElectronCapture()
... to generate configurations for the capture of an electron into a given configuration, i.e. the capture
of one electron into the intoShells.
+ ForHollowIons()
... to generate configurations that are related by multiple capture into high-n shells.
+ ForPhotoEmission()
... to generate configurations that are related by photoemission (single de-excitation of an electron).
+ ForPhotoIonization()
... to generate configurations that are related by photoionization (single removement of electrons).
+ ForPhotoRecombination(intoShells::Array{Shell,1})
... to generate configurations for the capture of an electron into a given configuration, i.e. the
radiative recombination of one electron into the intoShells.
+ ForStepwiseDecay(maximallyReleased::Int64)
... to generate all configurations that may arise from a given configuration by the release of
ne <= maximallyReleased electrons due to photoemission and autoionization.
Generate specific configuration
-------------------------------
+ GroundConfiguration(Z::Float64, NoElectrons::Int64)
... to generate the ground configuration for an ion with nuclear charge Z and the given number of electrons.
+ MeanConfiguration()
... to generate the mean configuration, i.e. a configuration with mean occupation numbers.
+ RelativisticConfigurations()
... to generate/deal with relativistic configurations.
Extract selected configurations from given lists or information about them
--------------------------------------------------------------------------
+ ByMultipoles()
... to extract the configurations due to certain multipole selection themes (not yet).
+ ByParity(P::Basics.Parity)
... to extract the configurations due to the given parity.
+ ClosedCore()
... to extract the closed core from one or several given configurations.
+ ClosedShells()
... to extract the closed shells from one or several given configurations.
+ ClosedSubshells()
... to extract the closed subshells from one or several given configurations.
+ ContractShells()
... to extract/contract the shells to the occupied ones.
+ ExcitationLevel()
... to extract an excitation level for a given configuration (presently not used).
+ ExpandShells()
... to extract/expand the shells to a given shell list.
+ FromBasis()
... to extract configuration(s) from a given many-electron basis::Basis.
+ GeneralizedConfigurations()
.. to extract the generalized configuration from given configurations (not yet).
+ GetParity()
... to extract the parity of a -- relativistic or non-relativistic -- configuration.
+ IsOccupied()
... to extract of whether a shell or subshell is occupied in some given configuration(s).
+ LeadingConfiguration()
... to extract the leading configuration from a given level::Level.
+ LeadingConfigurationR()
... to extract the leading relativistic configuration from a given level::Level.
+ Multiplicity()
... to extract the multiplicity of a configuration.
+ NonrelativisticBasis()
... to extract the configurations from a non-relativistic basis.
+ NumberOfElectrons()
... to extract the numbers of electrons from a given set of configurations.
+ OccupationDifference()
... to extract differences in the occupation numbers between two given -- relativistic or
non-relativistic -- configurations.
+ OpenShells()
... to extract the open shells from a given configurations.
+ OpenSubshells()
... to extract the open subshells from a given -- relativistic or non-relativistic -- configurations.
+ TotalAM()
... to extract all total angular momenta J, to which a configuration gives rise to.
+ ValenceOccupation()
... to extract the occupation of valence-shell electrons from a given configurations with regard to
a closed core configuration.
Display configurations with additional information
--------------------------------------------------
+ FineStructure()
... to display the total J fine-structure levels a configuration (without energies).
+ FineStructureLS()
... to display the total LSJ fine-structure levels a configuration (without energies).
+ HundsRules()
... to display the total LSJ fine-structure levels, ordered by Hund's rules (not yet).
+ HyperfineStructure()
... to display the total F hyperfine-structure levels a configuration (without energies).
A neat table is printed but nothing is returned otherwise.JenaAtomicCalculator.Basics.displayConfigurations — Method
Basics.displayConfigurations(Z::Float64, confs::Array{Configuration,1}; sa::String="") ... group & display the configuration list into sublists with the same No. of electrons; this lists are displayed together with an estimated total energy. An ordered confList::Array{Configuration,1} is returned with configurations of decreasing number of electrons.
JenaAtomicCalculator.Basics.displayConfigurations — Method
Basics.displayConfigurations(stream::IO, theme::Basics.ByNumber, configs::Array{Configuration,1}; details::String="", longForm::Bool=false) ... displays and summarizes all configurations from the given list, ordered by the numbers of electrons. The theme.NoElectrons remains unconsidered in this case. If not specified otherwise, these configurations are displayed in a compact form and nothing is returned in this case. If details are given, they are printed as "... configurations for " * details * " and with ne electrons:" If longForm, the full configurations are displayed with all shells; otherwise, the filled core-shells of all configurations are displayed separately and only the other shells are displayed explicitly. longForm=false is suggested for medium and heavy elements.
JenaAtomicCalculator.Basics.displayConfigurations — Method
Basics.displayConfigurations(stream::IO, theme::Basics.HundsRules, config::Configuration; string::String="..") ... displays ... the generated list of configurations in a compact form; nothing is returned in this case. ... with the occupation numbers
JenaAtomicCalculator.Basics.displayConfigurations — Method
Basics.displayConfigurations(stream::IO, configs::Array{Configuration,1}; details::String="", longForm::Bool=false) ... displays the generated list of configurations in a compact form; nothing is returned in this case. If details are given, they are printed as "... configurations for " * details * ":" If longForm == true, the full configurations are displayed with all shells; otherwise, the filled core-shells of all configurations are displayed separately and only the other (valence) shells are displayed explicitly. longForm=false is suggested for medium and heavy elements.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.ContractShells, conf::Configuration) ... to extract/contract a configuration by removing all empty shells from the shell-list; a (nonrelativistic) conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.ExpandShells, conf::Configuration) ... to extract/expand an (electron) configuration by adding also 'empty' shells; the procedure terminates if shells are occupied in the configuration, which do not occur in theme.shells. A (nonrelativistic) conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.FromBasis, basis::Basis, csf::CsfR) ... extract the (nonrelativistic) configuration of the given CSF as it is defined in basis.csfs. A conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.GroundConfiguration) ... determines the ground (reference) configuration for an ion with nuclear charge Z and NoElectrons. A refConfig::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.LeadingConfiguration, level::ManyElectron.Level) ... extract the leading configuration of the given level; a conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.LeadingConfigurationR, level::ManyElectron.Level) ... extract the leading relativistic configuration of the given level; a conf::ConfigurationR is returned.
JenaAtomicCalculator.Basics.extractConfiguration — Method
Basics.extractConfiguration(theme::Basics.NonrelativisticBasis, csfNR::LSjj.CsfNR, basisNR::LSjj.BasisNR) ... to extract the nonrelativistic configuration from the given csfNR, if this is part of basisNR. A nonrelativistic conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.ByNumber, confs::Array{Configuration,1}) ... extract from confs all those configurations with NoElectrons in theme.NoElectrons; a list of newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.ByParity, confs::Array{Configuration,1}) ... to extract all configurations with the given parity; a list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.ContractShells, confs::Array{Configuration,1}) ... to extract/contract all configuration by removing all empty shells; a list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.FromBasis, basis::Basis) ... extract all (non-relativistic) configurations that contribute to the given set of CSF in basis.csfs. A confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.FromMultiplet, multiplet::Multiplet) ... extract all (non-relativistic) configurations that contribute to the given multiplet. A confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.FromMultiplet, multiplets::Array{Multiplet,1}) ... extract all (non-relativistic) configurations that contribute to the given multiplets. A confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.RelativisticConfigurations, basis::Basis, totalJ::AngularJ64) ... to extract all relativistic configurations from the given basis. Only the CSF with total angular momentum totalJ are considered. A confList::Array{ConfigurationR,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.RelativisticConfigurations, basis::Basis) ... to extract all relativistic configurations from the given basis. A confList::Array{ConfigurationR,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.RestrictExcitations, confs::Array{Configuration,1}) ... extracts a (reduced) list of non-relativistic configurations in which the theme.restrictions are applied to remove unwanted configurations with regard to the given confs. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractConfigurations — Method
Basics.extractConfigurations(theme::Basics.TotalAM, confs::Array{Configuration,1}) ... to extract all configurations that contribute to CSFR with totalJs; a list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.AllShells, conf::Configuration) ... extract all (occupied) shells from the given conf; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ClosedCore, conf::Configuration) ... extract the (nonrelativistic) closed-cire shells in conf; a closedConf::Configuration is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ClosedShells, conf::Configuration) ... extract the (nonrelativistic) closed shells in conf; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ClosedSubshells, conf::ConfigurationR) ... extract the (relativistic) closed subshells in conf; a list::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ClosedSubshells, conf::Configuration) ... extract the closed (relativistic) subshells of the NON-relativistic configuration conf; a list::Array{Subshell,1} is returned. A shell nl contributes BOTH of its spin-orbit partners when it is full, i.e. when its occupation is 2(2l+1), and neither of them otherwise: a partly-filled non-relativistic shell carries no statement about how its electrons are distributed over j = l-1/2 and j = l+1/2, so no subshell of it can be called closed. This mirrors Basics.extractFromConfiguration(ClosedShells(), conf) above, which returns the same shells unsplit.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ClosedSubshells, sa::String) ... to extract the list of (relativistic) subshells for the given closed-shell configuration. Allowed closed-shell strings are [He], [Ne], [Mg], [Ar], [Kr] and [Xe].
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ExcitationLevel, conf::Configuration) ... determines the excitation level of a given configuration, which can be used to compare the degree of excitation between two configurations: exLevelA <= exLevelB. An exLevel::Int64 is returned. This degree of excitation works nicely for multiply and highly-charged ions with the same number of electrons as well as for the comparison of inner-shell holes but (may) fail for pure valence-shell excitations, whose relative energies may overlap and are difficult to predict without explicit computations. This procedure can be further advanced, if the need arises.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.GetParity, conf::ConfigurationR) ... to determine the parity::Parity (Enum Parity) of a given relativistic configuration.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.GetParity, conf::Configuration) ... to determine the parity::Parity (Enum Parity) of a given non-relativistic configuration.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.IsOccupied, conf::Configuration, shell::Shell) ... determines of whether the shell is occupied (> 0) in the given conf.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.Multiplicity, conf::Configuration) ... extracts the multiplicity, i.e. the g-factor, of the configuration conf if all of its levels are considered to be degenerate; this multiplicity is frequently used for empirical computations that are based on configuration-averaged plasma levels. A g::Int64 is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.OpenShellNumber, conf::Configuration) ... determine the number of open (nonrelativistic) shells in conf; a singleton of type LSjj.AbstractOpenShell is returned. This method still need to be combined with the module LSjj.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.OpenShells, conf::Configuration) ... extract the open (nonrelativistic) shells in conf; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.OpenSubshells, conf::ConfigurationR) ... extract the open (relativistic) subshells in conf; a list::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.OpenSubshells, conf::Configuration) ... extract the open (relativistic) subshells in conf; a list::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.TotalAM, conf::Configuration) ... extract the total angular momenta that are associated with the fine-structure of the given configuration; a totalJ::Array{AngularJ64,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ValenceOccupation, conf::Configuration, coreConf::Configuration) ... extracts the valence-part of the given configuration conf without those shells that are given in the core configuration coreConf already. The procedure terminates if the occupation of coreConf does not coincide with those of conf. A valenceConf::Configuration is returned.
JenaAtomicCalculator.Basics.extractFromConfiguration — Method
Basics.extractFromConfiguration(theme::Basics.ValenceShells, conf::Configuration) ... determines the valence shells of a configuration, i.e. all shells including and beyond those with the most inner-shell hole in conf. Hence, the first shell always indicates the inner-shell hole. A valenceShells::Array{Shell,1} is returned
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.AllShells, confs::Array{Configuration,1}) ... extract all (occupied) shells from the given configurations; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.ClosedCore, confs::Array{Configuration,1}) ... extract the (nonrelativistic) closed-core configuration that is common to all the given configurations confs; a closedConf::Configuration is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.ClosedShells, confs::Array{Configuration,1}) ... extract the (nonrelativistic) shells that are closed in all configurations confs; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.MeanOccupation, confs::Array{Configuration,1}) ... extract the (mean) occupation numbers from the given configurations. A dictionary meanShells::Dict{Shell,Float64} is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.NumberOfElectrons, confs::Array{Configuration,1}) ... extracts the number of electrons of all given configurations in a list::Array{Int64,1}. This list can readily be checked for different requests, for instance, that all configurations possess the same number of electrons. A intList::Array{Int64,1} is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.OccupationDifference, confa::Configuration, confb::Configuration) ... extract the differences in the occupation of shells: occupation(confa) - occupation(confb). Only those shells are returned for which qa - qb != 0. A list::Array{Tuple(Shell, Int64),1} is returned.
JenaAtomicCalculator.Basics.extractFromConfigurations — Method
Basics.extractFromConfigurations(theme::Basics.OccupationDifference, confa::ConfigurationR, confb::ConfigurationR) ... extract the differences in the occupation of subshells: occupation(confa) - occupation(confb). Only those subshells are returned for which qa - qb != 0. A list::Array{Tuple(Subshell, Int64),1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.AddElectrons, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which theme.ne electrons are added into the theme.intoshells. The routine updates stepwise the list of configurations until all the required electrons are added, and by taking the "filling themes" of the shells into account. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ExciteElectrons, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which theme.ne electrons are excited from the theme.fromShells into the theme.intoShells. The routine updates stepwise the list of configurations until all the required electrons are excited, and by taking the (de-)excitation of the shells into account. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForAutoIonization, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an inner-shell hole is filled in each given configuration and two new holes appear in some outer shells. All combinations of two outer shells are taken into account, while the most inner-shell hole is always filled. The procedure terminates if (i) no inner-shell hole can be identified, (ii) configurations with a different number of electrons are given or (iii) if the applied algorithm does result in configurations not appropriate for a single Auger emission. The routine excludes the generation of configurations with intra-shell autoionization paths, for which the free-energy of the emitted electron arises purely from the re-coupling of the valence-shell electrons. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForDielectronicCapture, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an electron from the theme.fromShells is excited to the theme.toShells and an additional electron is capture into the theme.intoShells. These excitation-with-capture refers to the first steps of the dielectronic recombination process and is realized for each given configuration. The procedure terminates if (i) configurations with a different number of electrons are given or (ii) if the applied algorithm does not results in configurations just one electron `more' than given originally. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForDielectronicRecombination, confs::Array{Configuration,1}) ... generates a list of (non-relativistic) intermediate and final configurations, based on theme.fromShells, theme.toShells, theme.intoShells as well as theme.decayShells. The intermediate configurations are formed by exciting one electron fromShells –> toShells and, in addition, by adding one electron into the into shells. All generated configurations must have N+1 electrons of course. For the final configurations, we start from these intermediate configurations and allow de-excitations from toShells –> fromShells (+ the low-lying decayShells) as well as de-excitations from intoShells –> decayShells. The procedure terminates if (i) configurations with a different number of electrons are given or (ii) if the applied algorithm does not results in configurations with a proper number of electrons `relative' to the given ones. A tuple of two lists (intermediateConfs::Array{Configuration,1}, finalConfs::Array{Configuration,1}) is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForElectronCapture, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an additional electron is captured into one of the theme.intoShells, so that each configuration has now one electron more. This is done for all given configurations. This is formally the same as the theme::Basics.ForRadiativeRecombination but may later allow to fullfill some additional requirements for non-radiative electron capturForElectronCapturee processes. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForHollowIons, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which one or several additional electron are captured into the theme.intoShells, so that each configuration has a theme.ne electrons more. This is done for all given configurations. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::ForPhotoEmission, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an inner-shell hole is filled due to the creation/move to an outer-shell hole. All given configurations are excluded from the generated list, even if they can be formed by filling a lower-lying shell. The routine terminates if (i) no inner-shell hole can be identified, (ii) configurations with a different number of electrons are given or (iii) if the applied algorithm does result in configurations with a different number of electrons. The routine also excludes the generation of configurations due to intra-shell photoemission, for which the emitted photon energy purely arises from the re-coupling of valence-shell electrons. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForPhotoIonization, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an additional inner-shell hole is created in all occupied shells and for each given configuration. This creation of an additional hole is independent of whether the photon energy is sufficient to release such an photo-electron. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForPhotoRecombination, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which an additional electron is captured into one of the theme.intoShells, so that each configuration has now one electron more. This is done for all given configurations. Cf. also Basics.ForElectronCapture; a list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForRasExcitations, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which single, double, triple, etc. excitations are considered for each given configuration due to the boolean values theme.singles, themes.doubles, ... . Excitation of electrons are considered from theme.fromShells to the theme.intoShells. The procedure terminates if (i) configurations with a different number of electrons are given. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.ForStepwiseDecay, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations that model the stepwise decay of an inner-shell hole by steptwise photoemission and autoionization processes until a certain number of electrons is released. The procedure first determines the most inner-shell hole and continues the stepwise decay until theme.maximallyReleased is reached or no further decay can occur. Intra-shell processes can be considered but are not reflected in the generated configurations. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.GeneralizedConfigurations, confs::Array{Configuration,1}) ... to generate all generalized configurations that are related to the given set of configurations. At present, neither the detailed definition nor their unique generation from a set of non-relativistic configurations has been worked out in good detail. This this therefore a dummy routine whose code still need to be worked out. An error is returned in all cases.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.RelativisticConfigurations, conf::Configuration) ... to split/decompose a (single) non-relativistic configuration into an list of relativistic ConfigurationR[]. The proper occupuation of the relativistic subshells is taken into account. A confList::Array{ConfigurationR,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.RemoveElectrons, confs::Array{Configuration,1}) ... generates a list of non-relativistic configurations in which theme.ne electrons are removed from the theme.fromShells. The routine updates stepwise the list of configurations until all the required electrons are removed, and by taking the removal of electrons from the shells into account. A list of possible newConfs::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(theme::Basics.RestrictExcitations, refConfigs::Array{Configuration,1}) ... generates a (reduced) list of non-relativistic configurations in which theme.ne electrons are excited from the theme.fromShells into the theme.toShells and where, in addition, the set of theme.restrictions is taken into account. This is a simplified procedure to generate RAS sets of configurations. A list of possible confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(lists...) ... to merge any number of configuration lists into a single list and to unify them. The arguments are NOT typed, so this method is reached by every call that no more specific merge method accepts; the result is built as a Configuration[], and anything else raises on the first append. A cList::Array{Configuration,1} is returned.
Basics: functions
JenaAtomicCalculator.Basics.FermiDirac — Method
Basics.FermiDirac(epsilon::Float64, mu::Float64, temp::Float64) ... computes the Fermi-Dirac function f(epsilon, mu; temp) if all parameters are given in atomic (Hartree) units.
JenaAtomicCalculator.Basics.add — Method
Basics.add(pota::Radial.Potential, potb::Radial.Potential) ... to add two radial potentials together that are defined on the same grid. A potential::RadialPotential is returned that inherits its radial size from the potential that is defined in a larger range of r-values.
JenaAtomicCalculator.Basics.addZerosToCsfR — Method
Basics.addZerosToCsfR(nz::Int64, csf::CsfR) ... 'adds' a number of zeros to the occupation, seniorityNr, etc. of a given CsfR.
JenaAtomicCalculator.Basics.analyze — Method
Basics.analyze(orbitals::Dict{Subshell, Orbital}; printout::Bool=false) ... to anaylze the phase of the orbitals and to ensure that all orbitals start `positve' near r –> 0; a set of newOrbitals::Dict{Subshell, Orbital} is returned.
JenaAtomicCalculator.Basics.analyze — Method
Basics.analyze(::LevelDecompositionOfCsfR, level::Level, N::Int64) ... analyzes and lists (up to) N relativistic CSF together with their weight |c_n|^2 in the expansion of the given level; a list of CSF and their corresponding weights is printed, but nothing is returned. Not yet implemented.
JenaAtomicCalculator.Basics.analyze — Method
Basics.analyze(::LevelDecompositionOfNRconfigurations, level::Level) ... analyzes and lists the non-relativistic configurations with a weight larger than 5%; a list of NR configurations with their corresponding weights is printed, but nothing is returned.
JenaAtomicCalculator.Basics.analyzeConvergence — Method
Basics.analyzeConvergence(blocka::Basics.Eigen, blockb::Basics.Eigen) ... to analyze the convergence for two blocks of eigenvalues und eigenvectors; the value > 0 indicates the relative maximum difference abs( a-b/a+b ) between two eigenvalues. The value is set arbitrarely set to 1.0e+2 if the number of eigenvalues differ in the two blocks.
JenaAtomicCalculator.Basics.analyzeConvergence — Method
Basics.analyzeConvergence(a::Radial.Orbital, b::Radial.Orbital) ... to analyze the convergence for two radial orbitals; the value > 0 indicates the relative maximum difference abs( a-b/a+b ) between the energies or (large or small) components of the orbitals. The function assumes that the orbitals are represented on the same grid and that the components are zero if only one of the orbitals is defined beyond some maximum grid point.
JenaAtomicCalculator.Basics.analyzeGrid — Method
Basics.analyzeGrid(shells::Array{Shell,1}, nm::Nuclear.Model, grid::Radial.Grid) ... to analyze the representation of hydrogenic orbitals from shells for the given nuclear charge and grid. The procedure orders the shells, tabulates their (hydrogenic) energy in the given grid and compares them with the exact solution. Nothing is returned otherwise..
NO CALLER IN `src/`, AND THAT IS CORRECT: this is a HAND diagnostic, meant to be run at the REPL when a
computation has failed or a grid is suspected of being under-resolved, and it prints a table for a person to
read. Its automatic counterpart is the Rule 12 guard `Bsplines.checkGridRepresentation`, which REFUSES a bad
grid during a run; this one is how you find out why. Keep both.JenaAtomicCalculator.Basics.determineEnergySharings — Method
Basics.determineEnergySharings(energy::Float64, NoEnergySharings::Int64) ... to determine the NoEnergySharings sharings by using the Gauss-Legendre integration points in the interval [0., energy]; an Array{Tuple{Float64,Float64,Float64},1} of (x, energy-x, weight) is returned. This methods assumes that the package GaussQuadrature is 'used'.
THE WEIGHTS ARE PURE QUADRATURE WEIGHTS FOR Int_0^energy f(x) dx, and nothing else. That is worth
stating because it was not true before 08-Aug-2026: the routine mapped the Gauss-Legendre nodes from
[-1,1] onto [0, energy] but multiplied the weights by `energy` WITHOUT the factor 1/2 of that map, so
sum(weights) came to 2*energy over an interval of length energy and every quadrature built on them was
high BY EXACTLY 2. Measured before the fix, for NoEnergySharings = 4 and 8 and for both f = 1 and
f = x, the ratio to the exact integral was 2.000000.
NO PARTICLE-STATISTICS FACTOR IS INCLUDED HERE, DELIBERATELY, and this is the decision that the missing
1/2 above had been quietly entangled with. When the two shares belong to INDISTINGUISHABLE particles --
the two photons of a two-photon decay, the two electrons of a double ionization -- and the differential
quantity is defined over the FULL range [0, energy], then each physical configuration is counted twice
by this integral and the total carries a further factor 1/2:
total = 1/2 * Int_0^E d(share) [differential] for two identical particles
total = Int_0^E d(share) [differential] for distinguishable shares
That factor belongs to the PHYSICS of the calling process, not to a quadrature rule, and it must be
written at the point where the total is formed so that it can be read there. A quadrature routine that
silently carried a factor 2 which happened to cancel one convention in one caller is precisely how such
a factor stops being visible at all.
THE CONSUMERS, re-derived 04-Nov-2026. THREE of the four form an integral from these weights, and all
three now carry the 1/2:
* PhotoDoubleIonization -- `crossSection += sh.weight * sh.differentialCs`; two ELECTRONS, hence
identical. Applied 03-Nov-2026 (`0f35d139`).
* DoubleAutoIonization -- `trate += sharing.weight * drate`; two ELECTRONS, hence identical.
Applied 04-Nov-2026 (`4b59a6e9`).
* MultiPhotonTransition -- two-photon emission `totalRate`; two PHOTONS, hence identical. Applied
08-Aug-2026; see the note at its computeProperties_2pEmission.
* RadiativeAuger -- stores and displays the weight but does NOT integrate with it, so no
physical result there depends on this factor.
AND THE PREVIOUS VERSION OF THIS LIST IS WHY THE PHOTODOUBLEIONIZATION DEFECT SURVIVED ELEVEN WEEKS.
It said PhotoDoubleIonization "store[s] and display[s] the weight but never integrate[s] with it", which
was TRUE on 08-Aug-2026 and FALSE a week later: the 15-Aug rebuild added the integral, nothing re-read
this list, and that module's own comment then asserted the opposite of the paragraph above -- that the
double counting was "already handled inside Basics.determineEnergySharings". Its sigma(2+) was twice
what it should be until 03-Nov-2026.
SO RE-DERIVE THIS LIST RATHER THAN TRUST IT, and derive it from the CALL rather than from the weight:
grep -n 'determineEnergySharings' src/*.jl ... bounds the consumers; there are four
grep -nE 'sh(aring)?[.]weight [*]' src/*.jl ... says which of those four integrate
The obvious search is the one to avoid: `grep -n 'weight [*]' src/*.jl` returns about a hundred lines,
nearly all of them `RacahExpression.weight` in the RacahAlgebra files -- an unrelated quantity carrying
the same name. Two hits of the recommended search are also NOT consumers, and are worth recognising as
such: `MultiPhotonTransition.determineSharings_3p` builds its own three-photon simplex grid rather than
calling this routine, and the `TestFrames` hit is this very factor's test. A caller that integrates and
is not named above is either a new consumer or a stale entry here, and a statement about what a CALLER
does is exactly the kind that goes quietly false when the caller changes.JenaAtomicCalculator.Basics.determineHoleShells — Method
Basics.determineHoleShells(conf::Configuration) ... to determine the hole-shells of a given non-relativistic configuration; a shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.determineMeanEnergy — Method
Basics.determineMeanEnergy(conf::Configuration, orbitals::Dict{Subshell, Orbital}, nm::Nuclear.Model, grid::Radial.Grid, settings::AsfSettings) ... to determine the mean energy of a configuration WITHOUT DIAGONALIZING IT, from the (2J+1)-weighted trace of the Hamiltonian over the configuration's CSFs. A value::Float64 is returned.
WHY THIS IS EXACT AND NOT AN APPROXIMATION. A similarity transformation preserves the trace, and the CI
matrix is block-diagonal in J^P, so within one block every CSF carries the SAME weight 2J+1 and
SUM_levels (2J_l+1) E_l = SUM_blocks (2J+1) tr(H_block) = SUM_csfs (2J_r+1) H_rr ,
with the two normalisations SUM_levels (2J_l+1) and SUM_csfs (2J_r+1) equal for the same reason. So this
returns the same number as the diagonalising method beside it, to round-off, while doing no eigenvalue
work at all: O(n) diagonal elements instead of an O(n^3) diagonalisation. For an open f shell, where one
configuration can carry thousands of CSFs, that is the difference between affordable and not.
IT IS NOT YET THE CLOSED FORM priority item 22 asks for. Slater's average energy of a configuration is
O(1) in the number of subshell PAIRS and touches no CSF at all; this still enumerates the CSFs, so it
removes the diagonalisation and not the enumeration. It is worth having in its own right, and it is the
natural yardstick for that closed form when it is written -- an identity to check against, rather than a
second approximation.JenaAtomicCalculator.Basics.determineMeanEnergy — Method
Basics.determineMeanEnergy(conf::Configuration, orbitals::Dict{Subshell, Orbital}, nm::Nuclear.Model, grid::Radial.Grid; closedForm::Bool=false) ... to determine the mean energy of a given non-relativistic configuration; this 'mean' energy is calculated as the mean energy of all single-CSF levels and by using the the given set of orbitals. A value::Float64 is returned.
WITH `closedForm = true` THE SAME NUMBER IS OBTAINED WITHOUT BUILDING THE MULTIPLET AT ALL, from Slater's average
energy of a configuration in its relativistic form -- see `meanEnergyInClosedForm` below for what is evaluated and
how it was verified. The two agree to a relative 1.6e-09 or better on nine configurations from 1s^2 to [Xe] 4f^7,
and the closed form is the faster of the two by a margin that GROWS with the CSF count: 1.3x at [Ar] 3d^2, 4.0x at
[Xe] 4f^7, where its own cost is flat because it never enumerates a CSF. Prefer it wherever only the average is
wanted; the default stays `false` so that no existing caller changes behaviour.JenaAtomicCalculator.Basics.determineMeanEnergy — Method
Basics.determineMeanEnergy(multiplet::Multiplet) ... to determine the mean energy of a given multiplet. A value::Float64 is returned.
JenaAtomicCalculator.Basics.determineNearestPoints — Method
Basics.determineNearestPoints(x0::Float64, n::Int64, values::Array{Float64,1}) ... to determine the n points in values that are nearest to x0; two (short) arrays ws::Array{Float64,1}, diffs::Array{Float64,1} of length n are returned that contain the nearest values and differences (value - x0) from x0. An error message is issued of n > length(values).
JenaAtomicCalculator.Basics.determineNonorthogonalShellOverlap — Method
Basics.determineNonorthogonalShellOverlap(finalSubshells::Array{Subshell,1}, initialSubshells::Array{Subshell,1}, grid::Radial.Grid) ... determines the overlap of those shells that do not agree in both sets but have the same symmetry; a zero overlap and Subshell(99,-1) are returned in cases that no such pair can be found. A triple (shella, shellb, overlap) is returned.
JenaAtomicCalculator.Basics.determinePolarizationLambda — Method
Basics.determinePolarizationLambda(kind::Basics.LeftElliptical) ... gives the helicity lambda = 1 of LeftElliptical light; a value::Int64 is returned. Elliptical light is treated by its dominant helicity here.
JenaAtomicCalculator.Basics.determinePolarizationLambda — Method
Basics.determinePolarizationLambda(kind::Basics.RightCircular) ... gives the helicity lambda = -1 of RightCircular light; a value::Int64 is returned.
JenaAtomicCalculator.Basics.determinePolarizationLambda — Method
Basics.determinePolarizationLambda(kind::Basics.RightElliptical) ... gives the helicity lambda = -1 of RightElliptical light; a value::Int64 is returned. Elliptical light is treated by its dominant helicity here.
JenaAtomicCalculator.Basics.determinePolarizationLambda — Method
Basics.determinePolarizationLambda(kind::Basics.LeftCircular) ... determines the (standard) lambda value for the given kind of polarization; a lambda::Int64 is returned.
JenaAtomicCalculator.Basics.determinePolarizationVector — Method
Basics.determinePolarizationVector(q::Int64, kind::Basics.LeftElliptical; star::Bool) ... returns the spherical component u_q of the polarization vector of left-elliptically polarized light of the ellipticity carried by kind, which interpolates between the linear and the left-circular case. With star = true the component of the CONJUGATE vector is returned instead, which is what an outgoing photon needs; star is a keyword with no default, so every caller states which of the two it means. A value::Float64 is returned, and zero for any q outside the components this polarization carries.
JenaAtomicCalculator.Basics.determinePolarizationVector — Method
Basics.determinePolarizationVector(q::Int64, kind::Basics.LinearPolarization; star::Bool) ... returns the spherical component u_q of the polarization vector of linearly polarized light, where the two circular components enter with equal weight. With star = true the component of the CONJUGATE vector is returned instead, which is what an outgoing photon needs; star is a keyword with no default, so every caller states which of the two it means. A value::Float64 is returned, and zero for any q outside the components this polarization carries.
JenaAtomicCalculator.Basics.determinePolarizationVector — Method
Basics.determinePolarizationVector(q::Int64, kind::Basics.RightCircular; star::Bool) ... returns the spherical component u_q of the polarization vector of right-circularly polarized light, which carries the single component q = -1. With star = true the component of the CONJUGATE vector is returned instead, which is what an outgoing photon needs; star is a keyword with no default, so every caller states which of the two it means. A value::Float64 is returned, and zero for any q outside the components this polarization carries.
JenaAtomicCalculator.Basics.determinePolarizationVector — Method
Basics.determinePolarizationVector(q::Int64, kind::Basics.RightElliptical; star::Bool) ... returns the spherical component u_q of the polarization vector of right-elliptically polarized light of the ellipticity carried by kind, which interpolates between the linear and the right-circular case. With star = true the component of the CONJUGATE vector is returned instead, which is what an outgoing photon needs; star is a keyword with no default, so every caller states which of the two it means. A value::Float64 is returned, and zero for any q outside the components this polarization carries.
JenaAtomicCalculator.Basics.determinePolarizationVector — Method
Basics.determinePolarizationVector(q::Int64, kind::Basics.LeftCircular; star::Bool) ... returns the spherical component u_q of the polarization vector of left-circularly polarized light, which carries the single component q = +1. With star = true the component of the CONJUGATE vector is returned instead, which is what an outgoing photon needs; star is a keyword with no default, so every caller states which of the two it means. A value::Float64 is returned, and zero for any q outside the components this polarization carries.
JenaAtomicCalculator.Basics.determineSelectedLines — Method
Basics.determineSelectedLines(lineList::Array{Tuple{Int64,Int64},1}, initialMultiplet::Multiplet, finalMultiplet::Multiplet) ... to determine the specified lines as tupels of initial- and final levels. A level index is 0 in lineList always refers to all levels from the corresponding multiplet. A (unique) newList::Array{Tuple{Int64,Int64},1} is returned.
JenaAtomicCalculator.Basics.determineSelectedPathways — Method
Basics.determineSelectedPathways(pathwayList::Array{Tuple{Int64,Int64,Int64},1}, initialMultiplet::Multiplet, intermediateMultiplet::Multiplet, finalMultiplet::Multiplet) ... to determine the specified pathways as tupels of initial-, intermediate- and final levels. A level index 0 in pathwayList always refers to all levels from the corresponding multiplet. A (unique) newList::Array{Tuple{Int64,Int64,Int64},1} is returned.
JenaAtomicCalculator.Basics.diagonalize — Method
Basics.diagonalize(::GeneralizedEigenvaluesWithLinearAlgebra, matrixA::Array{Float64,2}, matrixB::Array{Float64,2}) ... applies LinearAlgebra.eigen() to the generalized eigenvalue problem (matrixA, matrixB); only the upper-triangular parts of both matrices are used by an explicit symmetrization; an eigen::Basics.Eigen is returned.
JenaAtomicCalculator.Basics.diagonalize — Method
Basics.diagonalize(::MatrixWithLinearAlgebra, matrixA::Array{Float64,2}; range=(0:0)::UnitRange{Int64}) ... applies LinearAlgebra.eigen() to the symmetric matrix matrixA; only the upper-triangular part is used by an explicit symmetrization; an eigen::Basics.Eigen is returned. For a non-default range (e.g. 1:3 for the three lowest eigenpairs), LinearAlgebra.eigen(mA, range) dispatches to LAPACK's partial eigensolver (syevr), which is genuinely faster than a full diagonalization when only a few eigenpairs are wanted out of a large matrix (confirmed 28-Jul-2026: ~2-4x for a few eigenpairs out of a few hundred, growing with matrix size, shrinking as more eigenpairs are requested) – NOT used by Hamiltonian.performCI/performCIKinkAware today (both always call the range=(0:0), full-diagonalization form), so this speedup is not yet realized in the CI pipeline.
JenaAtomicCalculator.Basics.diracDelta — Method
Basics.diracDelta(x::Float64, dx::Float64) ... evaluates Dirac's function delta(x) = 0 for abs(x) > dx/2 and delta(x) = 1/dx for abs(x) <= dx/2; a values::Float64 is returned.
JenaAtomicCalculator.Basics.display — Method
Basics.display(::CurrentSettings) ... to display (all) currently defined settings of the JAC module; nothing is returned.
JenaAtomicCalculator.Basics.display — Method
Basics.display(stream::IO, orbitals::Dict{Subshell, Orbital}, grid::Radial.Grid; longTable::Bool=false) ... displays the (generated) orbitals in a neat and compact form; the default (longTable==false) just prints the subshell, isbound and energies. If longTable==true, it prints in addition the r_max, <r>, ... values. nothing is returned.
JenaAtomicCalculator.Basics.display — Method
Basics.display(stream::IO, channels::Array{AtomicState.GreenChannel,1}) ... displays the (generated Green function) channels in a neat and compact form; nothing is returned in this case.
JenaAtomicCalculator.Basics.display — Method
Basics.display(::PhysicalConstants) ... to display (all) currently defined physical constants; nothing is returned. Cf. Defaults.setDefaults().
JenaAtomicCalculator.Basics.displayLevels — Method
Basics.displayLevels(stream::IO, channels::Array{AtomicState.GreenChannel,1}; N::Int64=10) ... display on stream the lowest N level energies of all levels from the (Green) channles in ascending order, and together with the configuration of most leading term in the level expansion. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.Basics.displayLevels — Method
Basics.displayLevels(stream::IO, multiplets::Array{Multiplet,1}; N::Int64=10, E0::Float64=0.) ... display on stream the level energies of the N lowest levels in ascending order, and together with the configuration of most leading term in the level expansion. All level energies refer to the lowest + E0 [Hartree], which enables one to refer to any level as the (total) 0. energy. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.Basics.displayMeanEnergies — Method
Basics.displayMeanEnergies(stream::IO, multiplets::Array{Multiplet,1}; N::Int64=10, E0::Float64=0.) ... display on stream the mean energy as well as the minimum and maximum energy of all levels from the same (leading) configuration. All these energies are taken with regard to the lowest level energy or are shifted by lowest + E0 [Hartree], which enables one to shift the zero energy to any position. These mean, min and max energies are listed together with the corresponding configuration. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.Basics.displayOrbitalOverlap — Method
Basics.displayOrbitalOverlap(stream::IO, leftOrbitals::Dict{Subshell, Orbital}, rightOrbitals::Dict{Subshell, Orbital}, grid::Radial.Grid; kappas::Array{Int64,1} = [-1,1,-2]) ... display on stream the overlap of the orbitals from the set of leftOrbs and rightOrbs, and for the given kappa-symmetries. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.Basics.displayOrbitalProperties — Method
Basics.displayOrbitalProperties(stream::IO, orbitals::Dict{Subshell, Orbital}, chemMu::Float64, temp::Float64, radiusWR::Float64, nm::Nuclear.Model, grid::Radial.Grid) ... displays the orbital properties:
subshell, energy, Delta energy (wrt Dirac), f(energy; mu, T), occupation No, <r>, <1/r>
for all orbitals with occNo > 0.1 in descending order.
A neat table is printed and nothing is returned otherwise.JenaAtomicCalculator.Basics.expandOrbital — Method
Basics.expandOrbital(orbital::Orbital, boundOrbitals::Dict{Subshell, Orbital}, threshold::Float64, grid::Radial.Grid; printout::Bool=false) ... expand the orbital in the given orbitalList; only those orbitals with <orb | orbital>^2 >= threshold are taken into account. If printout=true, this function 'reports' about the expansion by showing the orbitals, their overlap as well as the total contribution. In general, the given orbital is not normalized and the expansion is usually incomplete. A list of (non-normalized) orbitals is returned in which the large and small components are mutiplied by the corresponding overlap..
JenaAtomicCalculator.Basics.extractMeanEnergy — Method
Basics.extractMeanEnergy(pqn::Int64, basis::Basis) ... extracts the mean orbital energy of all orbitals with principal quantum number pqn; an en::Float64 [Hartree] is returned. This value has a physical meaning only for sufficiently large pqn (Rydberg orbitals).
JenaAtomicCalculator.Basics.extractMeanOccupation — Method
Basics.extractMeanOccupation(basis::Basis) ... extracts the mean occupation numbers for all subshells of the given basis; an meanOccs::Dict{Subshell, Float64} is returned.
JenaAtomicCalculator.Basics.extractNonrelativisticShellList — Method
Basics.extractNonrelativisticShellList(multiplet::Multiplet) ... extract a nonrelativistic shell list from the given multiplet; however, the shells are not ordered. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractNonrelativisticShellList — Method
Basics.extractNonrelativisticShellList(confs::Array{Configuration,1}) ... extract a nonrelativistic shell list from the given configuration list; the shells are not ordered. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractNonrelativisticShellList — Method
Basics.extractNonrelativisticShellList(multiplets::Array{Multiplet,1}) ... extract a nonrelativistic shell list from the given list of multiplets; however, the shells are not ordered. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractNonrelativisticShellList — Method
Basics.extractNonrelativisticShellList(subshells::Array{Subshell,1}) ... extract a nonrelativistic shell list from the given subshell list; the shells appear in the same order as the corresponding subshells. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractOpenShellQNfromCsfR — Method
Basics.extractOpenShellQNfromCsfR(csfR::CsfR, basis::Basis) ... extracts the quantum numbers of the nonrelativistic open shells from the given csfr. Here, we assume that csfR is defined in the given basis, and it is checked that the subshells of each nonrelativistic shell occur subsequently in basis and in the right sequence j = l - 1/2, j = l + 1/2, respectively. An rQN::Dict{Shell, Tuple{Tuple{Int64,Int64,Int64,Int64,Int64}, Tuple{Int64,Int64,Int64,Int64,Int64}}} = Dict(shell => (rQNm, rQNp) ) is returned with rQNm = (idxm, Nm, Qm, Jm, Jmx) and rQNp = (idxp, Np, Qp, Jp, Jpx). The two tuples rQNm, rQNp contains all the subshell quantum numbers and their coupling in csfR.
JenaAtomicCalculator.Basics.extractRelativisticConfigurationFromCsfR — Method
Basics.extractRelativisticConfigurationFromCsfR(csf::CsfR, basis::Basis) ... extract the nonrelativistic configuration from the given CSF that is defined in basis.csfs. A conf::Configuration is returned.
JenaAtomicCalculator.Basics.extractRelativisticSubshellList — Method
Basics.extractRelativisticSubshellList(csf::CsfR, subshells::Array{Subshell,1}) ... extract all (relativistic) subshells that are occupied in the given CSF with regard to the given subshells. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractRelativisticSubshellList — Method
Basics.extractRelativisticSubshellList(level::Level) ... extract all (relativistic) subshells that are occupied in the given level in CSF with weigth > 0.1. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractRelativisticSubshellList — Method
Basics.extractRelativisticSubshellList(rep::Representation) ... extract all (relativistic) subshells that (will) contribute to the given configuration list, and for which (start) orbitals will be needed in course of the computation. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractRelativisticSubshellList — Method
Basics.extractRelativisticSubshellList(confList::Array{Configuration,1}) ... extract all (relativistic) subshells that (will) contribute to the given configuration list, and for which (start) orbitals will be needed in course of the computation. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractRydbergSubshellList — Method
Basics.extractRydbergSubshellList(level::Level, n0::Int64, wx::Float64) ... extract all (relativistic) Rydberg subshells with principal quantum number n > n0, which are occupied in the given level in CSF with weigth > wx. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractShellList — Method
Basics.extractShellList(confList::Array{Configuration,1}) ... extract all (nonrelativistic) shells that (will) contribute to the given configuration list. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.extractShellOccupationFromCsfR — Method
Basics.extractShellOccupationFromCsfR(csfR::CsfR, basis::Basis) ... extracts the nonrelativistic shell list as well as the (nonrelativistic) occupation of the given CsfR. Here, we assume that csfR is defined in the given basis and that all subshells occur in standard sequence for a jjJ-LSJ transformation. A tuple tp::Tuple{Array{Shell,1},Array{Int64,1}} of two arrays of equal length is returned that contains the nonrelativistic shells and their occupation in the specification of csfR.
JenaAtomicCalculator.Basics.extractSubshellList — Method
Basics.extractSubshellList(conf::Configuration, orbitals::Dict{Subshell, Orbital}) ... extract all (relativistic) subshells that do NPT have an orbital in orbitals. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractSubshellList — Method
Basics.extractSubshellList(confList::Array{ConfigurationR,1}) ... extract all (relativistic) subshells that (will) contribute to the given configuration list. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.extractValenceShell — Method
Basics.extractValenceShell(basis::Basis) ... extract the valence shell from basis, ie. the Shell with the (in its magnitude) lowest binding energy. A shell::Shell is returned.
JenaAtomicCalculator.Basics.fixEigenvectorPhase! — Method
Basics.fixEigenvectorPhase!(eigen::Basics.Eigen) ... fixes the arbitrary overall sign of every eigenvector in eigen by the convention that its largest-magnitude component be positive; the eigen is modified in place and returned.
An eigenvector of a Hermitian matrix is defined only up to an overall phase: |psi> and -|psi>
are the same physical state, and every observable is built from |c|^2 or from products in which
the sign cancels. Which of the two a diagonalizer hands back is therefore not physics -- it is
whatever LAPACK's normalisation happened to produce, and it can differ between machines, library
versions and even between two runs on matrices that differ in the last bit. The CI mixing
coefficients ARE printed, however, and so are transition amplitudes built linearly from them, so
an unfixed phase makes those outputs irreproducible for no physical reason. This convention makes
them deterministic without touching a single observable.
Applied to the CI (level mixing) eigenvectors only. It is deliberately NOT applied to the
B-spline orbitals or to the continuum waves: an orbital's sign propagates into every matrix
element built from it, and a continuum wave's phase is fixed by its normalisation at large r
rather than being free.JenaAtomicCalculator.BasicsAZ.meanEnergyInClosedForm — Method
BasicsAZ.meanEnergyInClosedForm(conf::Configuration, orbitals::Dict{Subshell, Orbital}, nm::Nuclear.Model, grid::Radial.Grid) ... to determine the average energy of a configuration in CLOSED FORM, touching no CSF at all: the cost is set by the number of subshell PAIRS and is independent of how many CSFs the configuration carries. A value::Float64 is returned.
WHAT IT EVALUATES. With w_a the occupation of relativistic subshell a, I(a) the one-particle integral and
F^k(ab) = R^k(abab), G^k(ab) = R^k(abba),
E_av = SUM_a w_a I(a)
+ SUM_a w_a(w_a-1)/2 [ F^0(aa) - SUM_{k=2,4,...,2j_a} <a||C^k||a>^2 / (2j_a (2j_a+1)) F^k(aa) ]
+ SUM_{a<b} w_a w_b [ F^0(ab) - SUM_k <a||C^k||b>^2 / ((2j_a+1)(2j_b+1)) G^k(ab) ]
BOTH EXCHANGE PREFACTORS ARE UNITY, and that is the one thing a reader is likely to get wrong: the textbook
NON-RELATIVISTIC average energy carries a 1/2 on the exchange term, and carrying it over here is incorrect.
It was excluded by measurement rather than by assertion -- 1s^2 2s^2 has no same-subshell term and so isolates
the cross-subshell one, and gives the factor as 1.0000; three further closed shells then give the
same-subshell factor as 1.0000, 0.99999883 and 0.99999947.
AND A NON-RELATIVISTIC CONFIGURATION IS A WEIGHTED SUM OVER ITS RELATIVISTIC ONES. `3d^2` is not one jj
configuration but every way of placing two electrons over 3d_3/2 and 3d_5/2, and each is weighted by its
number of magnetic substates, PROD_a binomial(2j_a+1, w_a). That weight is exactly the denominator of the
(2J+1)-weighted trace identity, since SUM_csfs (2J_r+1) over one relativistic configuration IS its
determinant count -- so this returns the same average as the two methods above and not a different one.
MEASURED AGAINST THE EXACT TRACE, 14-Sep-2026, on nine configurations: 1.8e-15 on 1s^2 and a RELATIVE
1.6e-09 or better everywhere through [Xe] 4f^7. The gain grows with the CSF count, which is the point --
[Ar] 3d^2 (9 CSFs) 1.3x, 3d^5 (37) 1.6x, [Xe] 4f^5 (198) 2.8x, 4f^7 (327) 4.0x -- and the closed form's own
time is FLAT across the last two (0.351 s, 0.348 s) where the trace goes 0.97 s to 1.39 s.
THE RADIAL INTEGRALS MUST BE CACHED ACROSS THE RELATIVISTIC CONFIGURATIONS or this is SLOWER than the trace
it replaces: without the cache 4f^7 spends its time rebuilding the same F^k and G^k once per splitting. The
cache is local to the call, never a global, so the method stays free of shared mutable state.JenaAtomicCalculator.Basics.hasSubshell — Method
Basics.hasSubshell(pqn::Int64, subshells::Array{Subshell,1}) ... returns true if one (or more) of subshells has the principal quantum number pqn, and false otherwise. A value::Bool is returned
JenaAtomicCalculator.Basics.interpolateOnGridGrasp92 — Method
Basics.interpolateOnGridGrasp92(from::Tuple{Array{Float64,1},Radial.Grid}, to::Tuple{DataType,Radial.Grid} ) ... to interpolate the (radial) function F from the oldgrid to newgrid, by a call to the Grasp92 Fortran procedures; an function G::Array{Float64,1} is returned. Not yet implemented !
JenaAtomicCalculator.Basics.isStandardSubshellList — Method
Basics.isStandardSubshellList(basis::Basis) ... returns true if the subshell list basis.subshells is in standard order, and false otherwise. It requests especially that both subshells of the same shell (n,l) occur in the sequence j = l-1/2, j = l+1/2 and that l increases before n increases.
JenaAtomicCalculator.Basics.isSymmetric — Method
Basics.isSymmetric(matrix::Array{Float64,2}) ... returns true if the matrix is symmetric and false otherwise; if not symmetric, the function prints the first 10 pairs Mij, Mji which violate the symmetry condition.
JenaAtomicCalculator.Basics.isViolated — Method
Basics.isViolated(conf::Configuration, restriction::AbstractConfigurationRestriction) ... returns true if some rule/limitation is violated, and false otherwise.
(conf::Configuration, restriction::AbstractConfigurationRestriction)... returns true if restriction is violated by the given conf, and false otherwise.
JenaAtomicCalculator.Basics.isZero — Method
Basics.isZero(matrix::Array{Float64,2}) ... returns true if the matrix is zero and false otherwise; it sums up the |M[i,j]^2 and prints the results. If not zero, the function prints the first 10 matrix elements M_ij which violate this condition.
JenaAtomicCalculator.Basics.lastPoint — Method
Basics.lastPoint(wa::Array{Float64,1}, eps::Float64) ... returns the last point p of wa[1:end] for which |wa[p]| >= eps; an index p::Int64 is returned.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(bases::Array{Basis,1}) ... to merge two (or more) atomic bases into a single basis::Basis. This method assumes the same number of electrons in all basis and that the subshell lists are the same or can be made 'consistent' to each other. Two bases have a consistent subshell list if all subshells, that appear in any of the two lists appear always in the same sequence (if they are not missing at all). In the merged basis, the radial orbitals are taken from the basis (in the bases-array}, from where they are found first.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(multiplets::Array{Multiplet,1}) ... to merge two (or more) atomic multiplets into a single multiplet::Multiplet. This method assumes (and checks) that all levels have level.hasStateRep = true and that all levels refer to the same basis.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(aList::Array{Shell,1}, bList::Array{Shell,1}, cList::Array{Shell,1}) ... merges THREE shell lists into one, by applying the two-list method twice; duplicates are removed and the result is sorted. A cList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(aList::Array{Shell,1}, bList::Array{Shell,1}) ... to merge two shell lists into a single list, to unify and to order them; three lists are merged by the method below. A cList::Array{Shell,1} is returned
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(aList::Array{Subshell,1}, bList::Array{Subshell,1}, cList::Array{Subshell,1}) ... merges THREE subshell lists into one, by applying the two-list method twice; duplicates are removed and the result is sorted. A dList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.merge — Method
Basics.merge(aList::Array{Subshell,1}, bList::Array{Subshell,1}) ... to merge two subshell lists into a single list, to unify and to order them; three lists are merged by the method below. A cList::Array{Subshell,1} is returned
JenaAtomicCalculator.Basics.modifyLevelMixing — Method
Basics.modifyLevelMixing(level::Level, enhancementFaktor::Float64) ... to "enhance" the mixing of all CSF with |c_ik|^2 < 1.0e-3 by the given enhancementFaktor. The weights all CSF are renormalized eventually. A (normalized) newLevel::Level is returned.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(theme::AbstractPlotTheme, lines::Array{PhotoEmission.Line,1}, widths::Float64) ... to plot transition rates with Gaussian or Lorentzian broadening. Not yet implemented.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(theme::AbstractPlotTheme, lines::Array{PhotoEmission.Line,1}) ... to plot transition rates or oscillator strengths as function of transition energies. Not yet implemented.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(::RadialOrbitalsBoth, orbitals::Array{Radial.Orbital,1}, grid::Radial.Grid; N = 0) ... plots BOTH the large and the small components of the given orbitals. As the small-component method above, it RAISES and tells the caller to load Plots first. Nothing is returned.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(::RadialOrbitalsLarge, orbitals::Array{Radial.Orbital,1}, grid::Radial.Grid; N = 0) ... plots the LARGE components of the given orbitals, where N is the number of grid points to be shown. It RAISES rather than plotting: the method is a placeholder that tells the caller to load Plots first, since JAC does not depend on a plotting backend. Call using Plots; pyplot() and then plot(...). Nothing is returned.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(::RadialOrbitalsSmall, orbitals::Array{Radial.Orbital,1}, grid::Radial.Grid; N = 0) ... plots the SMALL components of the given orbitals. It RAISES rather than plotting: the method is a placeholder that tells the caller to load Plots first, since JAC does not depend on a plotting backend. Nothing is returned.
JenaAtomicCalculator.Basics.plot — Method
Basics.plot(::RadialPotentials, potentials::Array{Radial.Potential,1}, grid::Radial.Grid; N::Int64 = 0) ... to plot one or more radial potentials, where N::Int64 is the number of grid points to be considered. call: using Plots; pyplot() ... to access this method by plot(...)
JenaAtomicCalculator.Basics.read — Method
Basics.read(::ReadCslFileGrasp92, filename::String) ... reads in the CSF list from the (existing) .csl file filename; a basis::Basis is returned with basis.isDefined = true and with a proper sequence of orbitals, but with basis.orbitals = Orbital[].
JenaAtomicCalculator.Basics.read — Method
Basics.read(::ReadOrbitalFileGrasp92, filename::String) ... reads in the orbitals from a (formatted) .rwf file filename; a list of orbitals::Array{Orbital,1} is returned with all subfields specified.
JenaAtomicCalculator.Basics.readCslFileGrasp92 — Method
Basics.readCslFileGrasp92(filename::String) ... reads in the CSF list from a Grasp92 .csl / GRASP18 .c file; a basis::Basis is returned.
JenaAtomicCalculator.Basics.readFilesGrasp18 — Method
Basics.readFilesGrasp18(grid::Radial.Grid, fileCSF::String, fileWavefunction::String, fileMixing::String)
... reads in the GRASP18 output files `*.c`, `*.w`and `*.m`; a multiplet::Multiplet is returned.JenaAtomicCalculator.Basics.readMixFileRelci — Method
Basics.readMixFileRelci(filename::String, basis::Basis) ... reads in the mixing coefficients from a RELCI .mix file; a multiplet::Multiplet is returned.
JenaAtomicCalculator.Basics.readMixingFileGrasp18 — Method
Basics.readMixingFileGrasp18(filename::String, basis::Basis) ... reads in the mixing coefficients from a Grasp18 .m file by using the given basis; A multiplet::Multiplet is returned.
JenaAtomicCalculator.Basics.readOrbitalFileGrasp92 — Method
Basics.readOrbitalFileGrasp92(filename::String, grid::Radial.Grid) ... reads in the orbitals list from a Grasp92 .w file; a dictionary orbitals::Dict{Subshell,Radial.Orbital} is returned.
JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToDecayWidth, line::Union{Einstein.Line, PhotoEmission.Line, HyperfineInduced.Line, TwoElectronOnePhoton.Line}, wa::Float64) ... recasts a radiative rate (Einstein A, a.u.) into a decay width, taking the selected energy unit into account; a Float64 is returned.
JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToEinsteinA, line::Union{Einstein.Line, PhotoEmission.Line, HyperfineInduced.Line, TwoElectronOnePhoton.Line}, wa::Float64) ... recasts a spontaneous radiative rate (Einstein A, a.u.) into Einstein A in selected units; a Float64 is returned.
JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToEinsteinB, line::Union{Einstein.Line, PhotoEmission.Line, HyperfineInduced.Line, TwoElectronOnePhoton.Line}, wa::Float64) ... recasts a radiative rate (Einstein A, a.u.) into an Einstein B-coefficient; a Float64 is returned.
JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToLineStrengthS, line::Union{Einstein.Line, PhotoEmission.Line, TwoElectronOnePhoton.Line}, wa::Float64) ... recasts a radiative rate (Einstein A, a.u.) into the line strength S; a Float64 is returned.
JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToOscillatorF, line::Union{Einstein.Line, PhotoEmission.Line}, wa::Float64) ... recasts a radiative rate (Einstein A, a.u.) into the absorption oscillator strength f, defined from the emission rate by Aul = 2 alpha^3 omega^2 (gl/gu) flu, so that f = (gu/gl) c^3 A / (2 omega^2) in atomic units; a Float64 is returned.
CORRECTED 7-Sep-2026, and this one was not merely misnamed but WRONG. The old body, c/(12 pi omega) * wa, is not an oscillator
strength in any convention: on hydrogen Lyman-alpha it returned 1.5e-07 where the tabulated f is 0.27750, i.e. it was low by six
orders of magnitude. It was reached only through `Einstein.displayRates`, whose "Osc. strength" column was therefore meaningless.JenaAtomicCalculator.Basics.recast — Method
Basics.recast(::RecastRateToOscillatorGf, line::Union{Einstein.Line, PhotoEmission.Line, TwoElectronOnePhoton.Line}, wa::Float64) ... recasts a radiative rate (Einstein A, a.u.) into the WEIGHTED oscillator strength g_l f, i.e. the absorption oscillator strength multiplied by the statistical weight of the LOWER level, which is the quantity tabulated as "gf" and the one that obeys the Thomas-Reiche-Kuhn sum rule directly; a Float64 is returned.
CORRECTED 7-Sep-2026, and the correction changes printed output. Until that date this method returned the UNWEIGHTED f, which is
what `RecastRateToOscillatorF` is for, so the two recasts returned quantities the other way round from their names. Measured on
hydrogen Lyman-alpha, where the answer is known exactly: for 1s (2)S_1/2 - 2p (2)P_3/2 the old body gave 0.27745 against the
tabulated f = 0.27750, and against g_l f = 0.55500. The name said g_f throughout.JenaAtomicCalculator.Basics.recommendedGrid — Method
Basics.recommendedGrid(occupations::Dict{Shell,Int64}, Z::Float64; tailFactor::Float64=16., rbox::Union{Nothing,Float64}=nothing, rnt::Float64=2.0e-6, h::Float64=5.0e-2, hp::Union{Nothing,Float64}=nothing, printout::Bool=false) ... builds a radial grid whose box is matched to the orbitals that will actually occupy it, which is what Rule 12 of the coding conventions asks for: a box far too WIDE starves the B-spline basis exactly as badly as one too narrow, since the number of splines is fixed and a box wider than the orbitals spends them on empty space. Each shell's outer turning point is evaluated at the charge IT feels – Slater screening, floored at the charge seen at infinity – and the widest shell sets the box, plus tailFactor n / Z_eff for the exponential tail beyond that point. rbox overrides the whole estimate. A grid::Radial.Grid is returned; an empty occupation list or a non-positive Z raises, since neither leaves anything for the box to be matched to.
JenaAtomicCalculator.Basics.recommendedGrid — Method
Basics.recommendedGrid(configs::Array{Configuration,1}, nm::Nuclear.Model; tailFactor::Float64=16., rbox::Union{Nothing,Float64}=nothing, rnt::Float64=2.0e-6, h::Float64=5.0e-2, hp::Union{Nothing,Float64}=nothing, printout::Bool=false) ... derives a radial grid that is matched to the orbitals which the given configurations require, so that the grid need not be chosen by hand; a grid::Radial.Grid is returned.
EACH CONFIGURATION IS JUDGED ON ITS OWN OCCUPATIONS, not on a merge of all of them. Two configurations
never both occupy a correlating shell AT ONCE -- an electron promoted to 4s in one reference and to 4f
in another are the SAME electron in two different states, not two electrons present together -- so
merging their occupations by shell (the per-shell MAXIMUM across configs, tried first and found wrong
08-Nov-2026, priority item 11) invents a configuration with more electrons than any real one has. That
inflates every merged shell's apparent electron count, floors its `Zeff` at `Z - NoElectrons + 1` for
ALL of them alike, and the box then comes from whichever shell has the lowest `l` at that SHARED floor
-- not from the shell that is actually hardest to represent. Measured on O I (`example-Ac.jl` branch
4, six references, one correlating 3d): the merge floors 3s, 3p AND 3d alike at `Zeff = 1.0` and lets
3s "win" (`wa = 66.0`) over the 3d that actually triggers the box-too-small warning (`wa = 62.2`),
because `Basics.slaterScreening`'s s/p rule screens an n-1 shell at 0.85 while its d/f rule screens
the SAME shell at the full 1.00 -- a genuine physical difference the merge erases by crediting every
n = 3 shell with the same, too-generous screening from the OTHER n = 3 shells that are never actually
present together. Evaluating each configuration on its own true occupations restores that difference
(3d alone: `Zeff = 1.0`, `wa = 62.2`; 3s alone: `Zeff = 1.75`, `wa = 37.7`) and correctly identifies 3d
as the limiting shell.
+ configs ::Array{Configuration,1} ... configurations whose shells are to be representable on the grid.
+ nm ::Nuclear.Model ... nuclear model, which supplies the charge Z.JenaAtomicCalculator.Basics.selectLevel — Method
Basics.selectLevel(level::Level, levelSelection::LevelSelection) ... returns true::Bool if the levelSelection is inactive or if the level has been selected due to its indices or symmetries; in all other case, false::Bool is returned.
JenaAtomicCalculator.Basics.selectLevelPair — Method
Basics.selectLevelPair(iLevel::Level, fLevel::Level, lineSelection::LineSelection) ... returns true::Bool if the lineSelection is inactive or if the pair (iLevel, fLevel) has been selected due to its indices or symmetries; in all other case, false::Bool is returned.
JenaAtomicCalculator.Basics.selectLevelTriple — Method
Basics.selectLevelTriple(iLevel::Level, nLevel::Level, fLevel::Level, pathwaySelection::PathwaySelection) ... returns true::Bool if the pathwaySelection is inactive or if the triple (iLevel, nLevel, fLevel) has been selected due to its indices or symmetries; in all other case, false::Bool is returned.
JenaAtomicCalculator.Basics.selectSymmetry — Method
Basics.selectSymmetry(sym::LevelSymmetry, levelSelection::LevelSelection) ... returns true::Bool if the levelSelection is inactive or if the symmetry sym has been selected; in all other case, false::Bool is returned.
JenaAtomicCalculator.Basics.shellTurningPointMax — Method
Basics.shellTurningPointMax(occupations::Dict{Shell,Int64}, Z::Float64, tailFactor::Float64) ... finds the shell in occupations whose classical turning point plus exponential tail needs the LARGEST box, under Slater screening by every shell in occupations (including itself). This is the per-shell loop Basics.recommendedGrid(occupations,Z;...) always ran inline; factored out so a caller that must judge SEVERAL physically distinct occupation sets (one per reference configuration, see Basics.recommendedGrid(configs,nm;...)) can call it once per set and combine the results itself, rather than merge the sets first and call this only once – merging first is wrong whenever two configurations occupy the SAME shell with DIFFERENT electrons (occupying it at different times, never together), since the merge then counts electrons that no one physical state actually has at once; see that method's own docstring for the measured size of the error this causes. A (rMax::Float64, outer::Shell, ZeffOuter::Float64) tuple is returned.
JenaAtomicCalculator.Basics.shiftTotalEnergies — Method
Basics.shiftTotalEnergies(multiplet::Multiplet, energyShift::Float64) ... to shift the energies of all levels in the multiplet by energyShift [a.u.]; a (new) multiplet::Multiplet is returned.
JenaAtomicCalculator.Basics.slaterScreening — Method
Basics.slaterScreening(sh::Shell, occupations::Dict{Shell,Int64}) ... computes the screening constant of Slater's rules for an electron in the shell sh, given the occupation of all shells; a screening::Float64 is returned, so that the effective charge is Z - screening.
Slater's grouping is used unchanged: [1s], [2s,2p], [3s,3p], [3d], [4s,4p], [4d], [4f], ... An electron in
an s or p shell is screened by 0.35 for each other electron of the same n with l <= 1 (0.30 within 1s), by
0.85 for each electron of principal quantum number n-1, and by 1.00 for each electron below that. An
electron in a d or f shell is screened by 0.35 for each other electron of the same shell and by 1.00 for
every electron in a group to its left, which includes the s and p shells of the same n. The electron
itself never screens.
The rules are crude, and for d and f shells notoriously so, but they are cheap, standard and citable, and
they are used here only to size a radial box -- a purpose for which the difference between Zeff = 3.15 and
the asymptotic 1 decides whether the box is usable, while the difference between 3.15 and 3.5 does not.
+ sh ::Shell ... shell whose electron is screened.
+ occupations ::Dict{Shell,Int64} ... occupation of every shell, including sh itself.JenaAtomicCalculator.Basics.sortByEnergy — Method
Basics.sortByEnergy(multiplet::Multiplet) ... to sort all levels in the multiplet into a sequence of increasing energy; a (new) multiplet::Multiplet is returned.
JenaAtomicCalculator.Basics.subshellStateString — Method
Basics.subshellStateString(subshell::String, occ::Int64, seniorityNr::Int64, Jsub::AngularJ64, X::AngularJ64) ... to provide a string of a given subshell state in the form '[2p1/2^occ](seniorityNr, J_sub), X=Xo' ... . A sa::String is returned.
JenaAtomicCalculator.Basics.tabulate — Method
Basics.tabulate(stream::IO, multiplet::Multiplet, levelNos::Array{Int64,1}; detail::Int64=0) ... tabulates the energies from the multiplet with level numbers in levelNos into a neat format due to different criteria; nothing is returned.
+ details = 0: print total energies, relative to immediate and relative to lowest.
+ details = 1: print total energies
+ details = 2: print energies to immediately lower level
+ details = 3: print energies to lowest levelJenaAtomicCalculator.Basics.tabulateKappaSymmetryEnergiesDirac — Method
Basics.tabulateKappaSymmetryEnergiesDirac(kappa::Int64, evalues::Array{Float64,1}, ns::Int64, nuclearModel::Nuclear.Model) ... tabulates the eigenenergies for a given symmetry block kappa together with the corresponding Dirac energies for a point-like nucleus. The index ns tells the number of 'negative-continnum' energies in the given evalues. nothing is returned.
Basics: compute & generate
JenaAtomicCalculator.Basics.compute — Method
Basics.compute(::CImatrixWithSymmetryJP, JP::LevelSymmetry, basis::Basis, nuclearModel::Nuclear.Model, grid::Radial.Grid, settings::AsfSettings; printout::Bool=true) ... to compute the CI matrix for a given J^P symmetry block of basis and by making use of the nuclear model and the grid; a matrix::Array{Float64,2} is returned.
JenaAtomicCalculator.Basics.compute — Method
Basics.compute(JP::LevelSymmetry, basis::Basis, nuclearModel::Nuclear.Model, grid::Radial.Grid, settings::AsfSettings, plasmaModel::Basics.AbstractPlasmaModel; printout::Bool=true) ... to compute the CI matrix for a given J^P symmetry block of basis and by making use of the nuclear model and the grid; a matrix::Array{Float64,2} is returned.
JenaAtomicCalculator.Basics.computeDensity — Method
Basics.computeDensity(level::Level, grid::Radial.Grid) ... computes the electronic density of level; a rho::Array{Float64,1} is returned.
JenaAtomicCalculator.Basics.computeDiracEnergy — Method
Basics.computeDiracEnergy(sh::Subshell, Z::Float64; mass::Float64=1.0) ... computes the Dirac energy for the hydrogenic subshell sh and for a point-like nucleus with nuclear charge Z; a energy::Float64 in atomic units and without the rest energy of the particle is returned. That is the binding energy of a 1s_1/2 electron for Z=1 is -0.50000665.
`mass` is the mass of the bound particle in units of the electron mass, so mass = 1.0 (the default) is an
electron and Defaults.getDefaults("mass: muon") = 206.7683 is a muon. It enters ONLY as an overall factor:
the expression below is m c^2 f(Z alpha), and the fine-structure constant does not depend on which particle
is bound. So for a POINT nucleus a muon level is exactly 206.7683 times the corresponding electron level,
which is a known-answer test of any mass-dependent machinery and is used as such in example-Ta.jl.JenaAtomicCalculator.Basics.computeMeanSubshellOccupation — Method
Basics.computeMeanSubshellOccupation(sh::Subshell, basis::Basis) ... computes the mean subshell occupation for the subshell sh and for the given CSF in the basis; a q::Float64 is returned.
JenaAtomicCalculator.Basics.computeMeanSubshellOccupation — Method
Basics.computeMeanSubshellOccupation(sh::Subshell, levels::Array{Level,1}) ... computes the mean subshell occupation for the subshell sh and for the given levels; a q::Float64 is returned.
JenaAtomicCalculator.Basics.computeMultipletForGreenApproach — Method
Basics.computeMultipletForGreenApproach(approach::AtomicState.CoreSpaceCI, basis::Basis, nModel::Nuclear.Model, grid::Radial.Grid, asfSettings::AsfSettings, greenSettings::GreenSettings; printout::Bool=false) ... computes the (Green channel) multiplet from the given basis with the CoreSpaceCI approach in which the electron-electron interaction is taken into account only between the bound-state orbitals.
JenaAtomicCalculator.Basics.computeMultipletForGreenApproach — Method
Basics.computeMultipletForGreenApproach(approach::AtomicState.DampedSpaceCI, basis::Basis, nModel::Nuclear.Model, grid::Radial.Grid, asfSettings::AsfSettings, greenSettings::GreenSettings; printout::Bool=false) ... computes the (Green channel) multiplet from the given basis with the DampedSpaceCI approach in which the electron-electron interaction strength are all damped by the factor exp(- dampingTau * r).
JenaAtomicCalculator.Basics.computeMultipletForGreenApproach — Method
Basics.computeMultipletForGreenApproach(approach::AtomicState.SingleCSFwithoutCI, basis::Basis, nModel::Nuclear.Model, grid::Radial.Grid, asfSettings::AsfSettings, greenSettings::GreenSettings; printout::Bool=false) ... computes the (Green channel) multiplet from the given basis with the SingleCSFwithoutCI approach.
JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.AaDFSField, grid::Radial.Grid, orbitals::Dict{Subshell, Orbital}, mu::Float64, temp::Float64) ... to compute a (radial) average-atom DFS-type potential for the density as modeled by the given set of orbital and their occupation numbers in the atomic-average model; a potential::RadialPotential is returned. The atomic-average DFS potential is defined by
[ 3 ]^(1/3)
V_DFS(r) = int_0^infty dr' rho_t(r') / r_> -- [----------- rho_t(r) ]
[ 4 pi^2 r^2 ]
but with the occupation numbers (2j_a+1) / [exp(eps-mu/kT) + 1]
with r_> = max(r,r') and rho_t(r) = sum_a (Pa^2(r) + Qa^2(r)) ... charge density of all electrons.
An Radial.Potential with -r * V_DFS(r) is returned to be consistent with an effective charge Z(r).JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.AaHSField, grid::Radial.Grid, orbitals::Dict{Subshell, Orbital}, mu::Float64, temp::Float64) ... to compute a (radial) Hartree-Slater-type potential for the density as modeled by the given set of orbital and their occupation numbers in the atomic-average model; a potential::RadialPotential is returned. Here, the atomic-average HS potential is defined by
(2ja+1) 3 [ 3 ]^1/3 r
V_HS(r) = = - Sum_a -------------------- Y0_aa(r) + - [ --------- rho ] * -
[exp(eps-mu/kT) + 1] 2 [ 4pi^2 r^2 ] 2
with rho(r) = Sum_a (2j_a+1) * (Pa^2(r) + Qa^2(r)) / [1 + exp(epsilon-mu)/kT] ... charge density of all electrons.
An Radial.Potential with V_aa_HS(r) is returned that is consistent with an effective charge Z(r).JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.CHField, grid::Radial.Grid, level::Level) ... to compute a (radial) core-Hartree potential for the given level; a potential::RadialPotential is returned. The core-Hartree potential is defined by
V_CH(r) = int_0^infty dr' rho_c(r') / r_>
with r_> = max(r,r') and rho_c(r) = sum_a (Pa^2(r) + Qa^2(r)) the charge density of the core-electrons.
An Radial.Potential with -r * V_CH(r) is returned to be consistent with an effective charge Z(r).
**WHAT IT IS FOR, and why `performSCF` refuses it -- written 14-Oct-2026 on making this usable.** A
core-Hartree potential is a FROZEN-CORE object: the core orbitals are held at their converged values
and the valence electron moves in their Hartree field, with no exchange and NO self-interaction. That
is not a self-consistent field, so `SelfConsistent.performSCF` is right to refuse it; its use is to be
BUILT FROM an already-converged level and handed to response work as a local potential --
pot = Basics.add( Nuclear.nuclearPotential(nm, grid),
Basics.computePotential(Basics.CHField(), grid, level) )
which matters because `ALField` and `EOLField` have NO local potential of their own, being SCF routes:
this is how orbitals from the better field reach a `DalgarnoLewis.solve`, which needs one.
**THE ONE-LINE CORRECTNESS CHECK, since it is cheap and catches a wrong core.** At large r the core's
Hartree potential tends to N_core/r, so the returned `Zr` tends to **-N_core**. Measured for Li
[He]2s: -2.000 at r = 5 a.u. against two core electrons, with nucleus + core-Hartree therefore giving
Z_eff = 3 - 2 = 1, correct for a neutral atom's valence electron.
**AND THE FROZEN-CORE ERROR IS LARGE -- MEASURED 14-Oct-2026, NOT ASSUMED, AND IT DISQUALIFIES THIS
PAIRING FOR QUANTITATIVE WORK.** A valence orbital from an AL or EOL calculation is not an eigenstate
of V_CH, and `DalgarnoLewis.solve` now reports how far off it is. On Li [He]2s, static E1:
pairing eigenstate residual alpha_0 [a.u.]
DFS orbitals + DFS potential 4.01e-06 224.1740
AL orbitals + core-Hartree 2.16e-01 164.0547
DFS orbitals + core-Hartree 6.05e-01 -256.6837
AL orbitals + DFS potential 1.52e+00 63.2594
**READ THE SECOND ROW WITH THE THIRD.** AL + core-Hartree lands on 164.0547 against Puchalski et
al.'s 164.0740 -- agreement to 0.012 %, which looks like a triumph and is a COINCIDENCE: the operator
carries a 22 % error, and the SAME pairing with DFS orbitals returns -256.68, which no acceptable
method does. Without the residual that number would have been published.
**SO: do not use this for a quantitative valence polarizability.** The usable combination would be a
good field AND a consistent operator, and it does not exist today -- a consistent pair (DFS + DFS)
gives 224.17, i.e. +37 %, because DFS underbinds the valence electron, while the good field has no
local potential at all. A response calculation for AL/EOL orbitals has to be built on the same
orbital set and energy functional as the SCF, not on a local potential. V_CH remains appropriate for
a CORE response, where the frozen core IS the physics and DFS-quality core orbitals are adequate.JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.DFSField, grid::Radial.Grid, basis::Basis) ... to compute the same but for the mean occupation of the orbitals in the given basis.
JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.DFSField, grid::Radial.Grid, level::Level) ... to compute a (radial) Dirac-Fock-Slater potential for the given level; a potential::RadialPotential is returned. The Dirac-Fock-Slater potential is defined by
[ 3 ]^(1/3)
V_DFS(r) = int_0^infty dr' rho_t(r') / r_> -- [----------- rho_t(r) ]
[ 4 pi^2 r^2 ]
with r_> = max(r,r') and rho_t(r) = sum_a (Pa^2(r) + Qa^2(r)) ... charge density of all electrons.
An Radial.Potential with -r * V_DFS(r) is returned to be consistent with an effective charge Z(r).JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.HSField, grid::Radial.Grid, level::Level) ... to compute a (radial) Hartree-Slater potential for the given level; a potential::RadialPotential is returned. Here, the Hartree-Slater potential is defined by
3 [ 3 ]^1/3 r
V_HS(r) = = - Sum_a q_a^bar Y0_aa(r) + - [ --------- rho ] * -
2 [ 4pi^2 r^2 ] 2
with rho(r) = Sum_a q_a^bar * (Pa^2(r) + Qa^2(r)) ... charge density of all electrons.
An Radial.Potential with V_HS(r) is returned that is consistent with an effective charge Z(r).JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.KSField, grid::Radial.Grid, level::Level) ... to compute a (radial) Kohn-Sham potential for the given level; a potential::RadialPotential is returned. The Kohn-Sham potential is defined by
2 [ 81 ]^(1/3)
V_KS(r) = int_0^infty dr' rho_t(r') / r_> -- --- [-------- r * rho_t(r) ]
3 r [ 32 pi^2 ]
with r_> = max(r,r') and rho_t(r) = sum_a (Pa^2(r) + Qa^2(r)) ... charge density of all electrons.
An Radial.Potential with -r * V_KS(r) is returned to be consistent with an effective charge Z(r).JenaAtomicCalculator.Basics.computePotential — Method
Basics.computePotential(scField::Basics.ThomasFermiField, grid::Radial.Grid, Z::Float64, noElectrons::Int64) ... computes the electronic screening part of a Thomas-Fermi potential for nuclear charge Z and the given number of electrons; a potential::Radial.Potential is returned, whose Zr is the SCREENING alone and is therefore <= 0, to be added to the nuclear potential exactly as the other members of this family are.
THIS IS THE ONE MEMBER OF AbstractScField THAT NEEDS NO DENSITY. All its siblings take a Level or a
Basis, because they are built from orbitals that already exist; the Thomas-Fermi field is a statistical
model of the electron cloud and asks only for Z and the electron number. That is precisely why it is
useful as a STARTING potential, where no orbitals exist yet.
The screening function is the Moliere three-exponential fit to the solution of the Thomas-Fermi
equation,
phi(x) = 0.35 exp(-0.3 x) + 0.55 exp(-1.2 x) + 0.10 exp(-6.0 x), x = r / b,
b = 0.8853 Z^(-1/3) [a.u.],
which reproduces the numerical Thomas-Fermi function to about a percent and needs no ODE solve. Note
phi(0) = 0.35 + 0.55 + 0.10 = 1 exactly, so Z(r) -> Z at the origin as it must.
THE LATTER TAIL CORRECTION is applied: the effective charge is not allowed to fall below Z - N + 1,
the charge an electron still sees once it is outside the others. Without it the Thomas-Fermi charge
decays to zero and the potential loses its asymptotic Coulomb tail, so the outer orbitals come out
unbound. For a neutral atom this floor is 1; for a one-electron ion it is Z, so the screening
vanishes identically and the potential reduces to the bare nuclear one -- a useful check.JenaAtomicCalculator.Basics.densityAtNucleus — Method
Basics.densityAtNucleus(orbital::Radial.Orbital, grid::Radial.Grid, nm::Nuclear.Model) ... computes the electron density of a SINGLE orbital at the nucleus, averaged over the nuclear volume; a density::Float64 in atomic units (electrons per bohr^3, for one electron in that orbital) is returned.
WHY AN AVERAGE AND NOT A LIMIT. The quantity wanted is |psi(0)|^2, and one is tempted to take
(P/r)^2 as r -> 0. That works for s_1/2, whose large component behaves as P ~ r, but it is
numerically hopeless for p_1/2: there the large component vanishes as r^2 and the density is carried
by the SMALL component, Q ~ r, which a logarithmic grid resolves poorly near the origin. Measured on
Ho on 04-Sep-2026, (P/r)^2 for the s orbitals was flat to 0.2-1.6 % across the innermost grid points
while (Q/r)^2 for the p_1/2 ones varied by 36 %, by a factor 8 and by a factor 20. An INTEGRAL over
the nuclear volume is stable where a limit is not, and it is also the physically right object: a
nucleus has a finite size and the capture samples the electron density across it.
THE DEFINITION. With the nucleus taken as a homogeneously charged sphere of radius R = nm.radius,
the volume density (P^2 + Q^2)/(4 pi r^2) averaged over that sphere is
<|psi|^2> = int_0^R [ P(r)^2 + Q(r)^2 ] dr / ( 4 pi int_0^R r^2 dr )
since the 4 pi r^2 of the volume element cancels the 1/r^2 of the density. BOTH integrals are formed
with the same quadrature over the same points, so that the error of stopping at the last grid point
inside R cancels between them; dividing by the analytic 4 pi R^3/3 instead leaves the result several
percent low. The p_1/2 contribution
enters through Q and is a purely relativistic effect -- non-relativistically a p electron has no
density at the nucleus at all, which is why p_1/2 orbitals take part in electron capture only in a
relativistic treatment.
A GUARD IS APPLIED rather than a silent result: if fewer than three grid points fall inside the
nucleus the integral is meaningless and the function raises, naming the radius and the count.JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.CiExpansion, rep::AtomicState.Representation; output::Bool=false) ... to generate a configuration-interaction expansion for a single level symmetry, based on the reference configurations of rep and on a number of pre-specified steps; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} whose keys give access to the generated expansion.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.GreenExpansion, rep::AtomicState.Representation; output::Bool=false) ... to generate a Green (function) expansion for a given approach and excitation scheme of the electron, based on the reference configurations of rep, a list of level symmetries and the given settings; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} whose keys give access to the generated Green channels.
EITHER THE GENERATOR RUNS ITS OWN SCF OR IT IS GIVEN THE ORBITALS, according to `rep.orbitalSource`: the default
`Basics.SeparateOrbitals()` is what this generator has always done, while `Basics.GivenOrbitals(orbitals)` builds
the result as a CI on a set the caller already holds, which is the one case where an explicit second-order amplitude
through these levels is valid at all. See the `orbitalSource` note in `AtomicState.Representation`.JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::CondensedMultiplet, multiplet::Multiplet) ... to condense/reduce the number of CSF in the basis of the given multiplet due to a single 'weight'; a multiplet::Multiplet is returned. Not yet implemented !
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::ConfigurationListNRFromBasis, basis::Basis) ... to (re-) generate the list of NR configurations from the given basis; a confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::ConfigurationListNRFromConfiguration, refConf::Configuration, NoExcitations::Int64, fromShells::Array{Shell,1}, toShells::Array{Shell,1}) ... to generate a non-relativistic configuration list, including the given reference configuration (refConf) and with all configurations that differ by NoExcitations from the fromShells into the toShells; an Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::OrderedShellList, confs::Array{Configuration,1}) ... to generate for confs, i.e. all the given (non-relativistic) configurations, a common and ordered shell list; a list::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::OrderedSubshellList, basisA::Basis, basisB::Basis) ... to generate common and ordered subshell list for the two basis A and B; a list::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::SlaterTypeSpectrum, N::Int64, potential::Radial.Potential, grid::Radial.Grid; N_0::Int64=30, alpha_0::Float64=1.0, beta0::Float64=1.1) ... to generate a complete one-electron spectrum with N positive and N negative states, and by using even-tempered Slater-type orbitals (STO) with parameters ``\alphai = \alpha0 \beta0^i``; a spectrum::SingleElecSpectrum is returned where just N0 positive and N_0 negative are kept for later use. Not yet implemented !
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(::SlaterTypeSpectrumPositive, N::Int64, potential::Radial.Potential, grid::Radial.Grid; N_0::Int64=30, alpha_0::Float64=1.0, beta0::Float64=1.1) ... to generate the same but to return only the N0 positive states. Not yet implemented !
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.MeanFieldBasis, rep::AtomicState.Representation; output::Bool=false) ... to generate a mean-field basis (representation) for the set of reference configurations of rep; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} that carries the generated basis under its own keys.
EITHER THE GENERATOR RUNS ITS OWN SCF OR IT IS GIVEN THE ORBITALS, according to `rep.orbitalSource`: the default
`Basics.SeparateOrbitals()` is what this generator has always done, while `Basics.GivenOrbitals(orbitals)` builds
the result as a CI on a set the caller already holds, which is the one case where an explicit second-order amplitude
through these levels is valid at all. See the `orbitalSource` note in `AtomicState.Representation`.JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.MeanFieldMultiplet, rep::AtomicState.Representation; output::Bool=false) ... to generate a mean-field multiplet for the set of reference configurations of rep; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} that carries the generated multiplet.
EITHER THE GENERATOR RUNS ITS OWN SCF OR IT IS GIVEN THE ORBITALS, according to `rep.orbitalSource`: the default
`Basics.SeparateOrbitals()` is what this generator has always done, while `Basics.GivenOrbitals(orbitals)` builds
the result as a CI on a set the caller already holds, which is the one case where an explicit second-order amplitude
through these levels is valid at all. See the `orbitalSource` note in `AtomicState.Representation`.JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.OneElectronSpectrum, rep::AtomicState.Representation; output::Bool=true) ... to generate a one-electron spectrum for the atomic potential from the (given) levels, based on a set of reference configurations as well as for given settings. Relevant intermediate and final results are printed to screen (stdout). Nothing is returned in this case.
+ `(repType::AtomicState.OneElectronSpectrum, representation::AtomicState.Representation; output=true)`
... to generate the same but to return the complete output in a orbitals::Dict{Subshell, Orbital}.JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.RasExpansion, rep::AtomicState.Representation, coreShells::Array{Shell,1}, fromShells::Array{Shell,1}, fixedLayers::Array{AtomicState.RasLayer,1}, auto::AtomicState.RasAutoSettings; output::Bool=false) ... to generate a restricted active-space expansion the SAME way as the plain Basics.generate(repType, rep) above, except that every layer beyond the fixed ones already present in repType.steps is PROPOSED by auto.shellPolicy and judged by auto.stoppingPolicy, rather than being hand-written up front (item 16, competition list). coreShells and fromShells are the same reference shells a hand-built ladder would pass to AtomicState.RasExpansion(symmetries, NoElectrons, coreShells, fromShells, layers, settings); fixedLayers is the layers list that repType.steps was ALREADY built from (typically just the reference layer, [AtomicState.RasLayer(Shell[]; se=false, de=false)]), needed here because AtomicState.RasExpansion itself does not retain it. Every fixed step runs first, through the SAME BasicsAZ.runRasStep! helper the plain driver uses, building the SAME AtomicState.RasLayerVerdict history a hand-built ladder never collects; the automatic part then proposes, runs and judges one layer at a time, stopping when the shell policy has nothing left to propose, when the stopping policy says so, or when auto.maxLayers is reached – whichever comes first, and the ceiling ALWAYS applies regardless of what either policy decides. All intermediate and final results are printed to screen, and a results::Basics.PerformResults dictionary is returned when output=true, nothing otherwise.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(repType::AtomicState.RasExpansion, rep::AtomicState.Representation; output::Bool=false) ... to generate a restricted active-space expansion for a single level symmetry, based on the reference configurations of rep and on a number of pre-specified steps; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} whose keys give access to the expansion of each individual step.
JenaAtomicCalculator.Basics.generate — Method
Basics.generate(representation::AtomicState.Representation; output::Bool=false) ... to generate an atomic representation as specified by the representation.repType::AbstractRepresentationType; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} whose keys depend on the type and the specifications of the representation and give access to the individual steps.
JenaAtomicCalculator.Basics.generateBasis — Method
Basics.generateBasis(refConfigs::Array{Configuration,1}, symmetries::Array{LevelSymmetry,1}, step::AtomicState.RasStep) ... generates the CSF basis for the given reference configurations and single, double, ... excitations of electrons from the corresponding fromShells –> toShells. A basis::Basis is returned but without a valid representation of the radial orbitals
JenaAtomicCalculator.Basics.generateBasis — Method
Basics.generateBasis(confList::Array{Configuration,1}, symmetries::Array{LevelSymmetry,1}) ... generates the CSF basis for the given configuration list and level symmetries; a basis::Basis is returned but without a valid representation of the radial orbitals.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(refConfigs::Array{Configuration,1}, fromShells::Array{Shell,1}, toShells::Array{Shell,1}, noex::Int64; restrictions::Array{AbstractConfigurationRestriction,1}=AbstractConfigurationRestriction[]) ... generates all nonrelativistic configurations with excitation of up to noex electrons fromShells –> toShells for all given reference configurations. Moreover, the list of restrictions (if any is given) is finally applied to restrict the configurations to a given set of limitations. It remains the reponsibility of the user to make sure that the given restrictions do not contradict each other and are consistent with what is to be achieved. The given set of restrictions can be easily extended if this need arises by the users. A confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurations — Method
Basics.generateConfigurations(refConfigs::Array{Configuration,1}, fromShells::Array{Shell,1}, toShells::Array{Shell,1}) ... generates all nonrelativistic configurations due to the (single) excitation of an electron fromShells –> toShells for all given reference configurations. A confList::Array{Configuration,1} is returned.
JenaAtomicCalculator.Basics.generateConfigurationsForExcitationScheme — Method
Basics.generateConfigurationsForExcitationScheme(confs::Array{Configuration,1}, exScheme::Basics.DeExciteSingleElectron, nMax::Int64, lValues::Array{Int64,1}) ... generates a list of non-relativistic configurations for the given (reference) confs and the excitation scheme. All orbitals in standard order are considered up to maxShell = (nmax, lmax).
JenaAtomicCalculator.Basics.generateConfigurationsForExcitationScheme — Method
Basics.generateConfigurationsForExcitationScheme(confs::Array{Configuration,1}, exScheme::Basics.DeExciteTwoElectrons, nMax::Int64, lValues::Array{Int64,1}) ... generates a list of non-relativistic configurations for the given (reference) confs and the excitation scheme. All orbitals in standard order are considered up to maxShell = (nmax, lmax).
JenaAtomicCalculator.Basics.generateConfigurationsForExcitationScheme — Method
Basics.generateConfigurationsForExcitationScheme(confs::Array{Configuration,1}, exScheme::Basics.ExciteByCapture, fromShells::Array{Shell,1}, toShells::Array{Shell,1}, intoShells::Array{Shell,1}, noex::Int64) ... generates a list of non-relativistic configurations for the given (reference) confs with the excitation of upto noex electrons fromShell –> toShells and the additional capture of one electron –> intoShells. All configuration will therefore contain N+1 electrons.
JenaAtomicCalculator.Basics.generateConfigurationsForExcitationScheme — Method
Basics.generateConfigurationsForExcitationScheme(confs::Array{Configuration,1}, exScheme::Basics.NoExcitationScheme, nMax::Int64, lValues::Array{Int64,1}) ... generates a list of non-relativistic configurations for the given (reference) confs and the excitation scheme. All orbitals in standard order are considered up to maxShell = (nmax, lmax).
JenaAtomicCalculator.Basics.generateCsfRs — Method
Basics.generateCsfRs(conf::ConfigurationR, subshellList::Array{Subshell,1}) ... to construct from a given (relativistic) configuration all possible CSF with regard to the subshell order as specified by subshellList; a list::Array{CsfR,1} is returned.
JenaAtomicCalculator.Basics.generateFieldCoordinates — Method
Basics.generateFieldCoordinates(mesh::Basics.AbstractMesh) ... generates a list of field values of proper type due to the specification by the given mesh; this specification determines both, the number and kind of coordinates as well as the type of the array. A list::Array{...FieldValue{Type},1} is returned.
JenaAtomicCalculator.Basics.generateLevelWithExtraElectron — Method
Basics.generateLevelWithExtraElectron(newOrbital, symt::LevelSymmetry, level::Level) ... generates a (new) level with one extra electron in subshell newOrbital.subshell and with overall symmetry symt. The function assumes that all CSF in the basis of level have the same symmetry as the level itself, that the new subshell is not yet part of the basis and that CSF with the total symmetry can be constructed; it terminates with an error if one of this assumptions is violated. A newLevel::Level with the same number of CSF and the same representation (eigenvector) as the given level is returned. From a physics viewpoint, newLevel refers to a antisymmetrized product state of [level x orbital(sh, energy)] J^P (symt) and with an total energy = level.energy + newOrbital.energy.
JenaAtomicCalculator.Basics.generateLevelWithExtraSubshell — Method
Basics.generateLevelWithExtraSubshell(sh::Subshell, level::Level, ns::Int64) ... generates a (new) level with one extra subshell sh but with the same overall symmetry as before. The function assumes that the new subshell is not yet part of the basis and terminates if this assumptions is not fulfilled. It builts the subshell sh at position ns and moves all other subshells further. A newLevel::Level with the same symmetry, number of CSF, energy and the same representation (eigenvector) as the given level is returned.
JenaAtomicCalculator.Basics.generateLevelWithExtraSubshell — Method
Basics.generateLevelWithExtraSubshell(sh::Subshell, level::Level) ... generates a (new) level with one extra subshell sh but with the same overall symmetry as before. The function assumes that the new subshell is not yet part of the basis; it terminates with an error if one of this assumptions is violated. A newLevel::Level with the same symmetry, number of CSF, energy and the same representation (eigenvector) as the given level is returned.
JenaAtomicCalculator.Basics.generateLevelWithExtraSubshells — Method
Basics.generateLevelWithExtraSubshells(subshells::Array{Subshell,1}, level::Level) ... generates a (new) level with one or several extra subshells but with the same overall symmetry as before. The function assumes that the new subshell is not yet part of the basis. A newLevel::Level with the same symmetry, number of CSF, energy and the same representation (eigenvector) as the given level is returned.
JenaAtomicCalculator.Basics.generateLevelWithExtraTwoElectrons — Method
Basics.generateLevelWithExtraTwoElectrons(orb1::Orbital, symx::LevelSymmetry, orb2::Orbital, symt::LevelSymmetry, level::Level) ... generates a (new) level with two extra electrons in subshells orb1.subshell and orb2.subshell and with intermediate symmetry symx and overall symmetry symt. The function assumes that all CSF in the basis of level have the same symmetry as the level itself, that the new subshells are not yet part of the basis and that CSF with the intermediate and total symmetries can be constructed; it terminates with an error if one of this assumptions is violated. A newLevel::Level with the same number of CSF and the same representation (eigenvector) as the given level is returned. From a physics viewpoint, newLevel refers to a antisymmetrized product state of [ [level x orbital1(sh, energy)] Jx^Px x orbital1(sh, energy)] J^P (symt) and with an total energy = level.energy + orb1.energy + orb2.energy.
JenaAtomicCalculator.Basics.generateLevelWithSymmetryReducedBasis — Method
Basics.generateLevelWithSymmetryReducedBasis(level::Level, subshells::Array{Subshell,1}) ... generates a level with a new basis and representation that only includes the CSF with the same symmetry as the level itself. It also ensures that the new basis is based on the given subshells so that it can be later used with levels which have one or several subshells more (at it often appears in ionization processes). Both, the underlying CSF basis and the eigenvectors are adopted accordingly. The procedures only supports the 'addition' of subshells but it stops if (1) the individual sequence differs or if the basis of level contains more subshells than the given subshell-list. A (new) level::levelR is returned.
JenaAtomicCalculator.Basics.generateMeshCoordinates — Method
Basics.generateMeshCoordinates(mesh::Basics.AbstractMesh) ... generates the coordinates of the given mesh: the Gauss-Legendre zeros mapped onto [a, b] for a GLegenreMesh, or NoPoints equally spaced points for a LinearMesh. A coords::Array{Float64,1} is returned, and any other mesh type raises. The Gauss-Legendre WEIGHTS are computed on the way and discarded, so a caller that needs them must obtain them separately.
JenaAtomicCalculator.Basics.generateOrbitalSuperposition — Method
Basics.generateOrbitalSuperposition(a::Orbital, b::Orbital, cx::Float64, grid::Radial.Grid) ... generates a superposition a + cx * b of two given orbitals; the function just takes the linear combination of the large and small components as well as the energy. The function assumes that both orbitals are defined on the same grid. A re-normalized newOrbital::Orbital is returned for which the derivatives are not defined. This function is used to accelerate the convergence (hopefully).
JenaAtomicCalculator.Basics.generateOrbitalsForBasis — Method
Basics.generateOrbitalsForBasis(basis::Basis, frozenShells::Array{Shell,1}, priorBasis::Basis, startOrbitals::Dict{Subshell, Orbital}) ... generates a dict of (relativistic) orbitals as specificed by subshells of the basis. These orbitals are taken from priorBasis if contained in frozen-shells, and from spectrum (start orbitals) otherwises. An error message is issued if some requested orbital is not found. A orbList::Dict{Subshell, Orbital} is returned.
JenaAtomicCalculator.Basics.generateShellList — Method
Basics.generateShellList(nMin::Int64, nMax::Int64, lMax::Int64) ... generates a list of (non-relativistic) shells in standard order that contains all shells with principal quantum numbers from nMin .. nMaxthe and orbital angular momenta l <= lMax. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.generateShellList — Method
Basics.generateShellList(nMin::Int64, nMax::Int64, symMax::String) ... generates a list of (non-relativistic) shells in standard order that contains all shells with principal quantum numbers from nMin .. nMaxthe and orbital angular momenta l <= l(symMax), and where symMax is the symmetry character string ("s", "p", ...,"z") of the corresponding orbital angular momentum. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.generateShellList — Method
Basics.generateShellList(nMin::Int64, nMax::Int64, lValues::Array{Int64,1}) ... generates a list of (non-relativistic) shells in standard order that contains all shells with principal quantum numbers from nMin .. nMaxthe and orbital angular momenta from lValues. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.generateShellList — Method
Basics.generateShellList(confs::Array{Configuration,1}, nMax::Int64, lValues::Array{Int64,1}) ... generates a list of (non-relativistic) shells in standard order that contains all shells from the given list of configurations as well as the shells up to the principal quantum number nMax and the list of orbital quantum numbers lValues. A shellList::Array{Shell,1} is returned.
JenaAtomicCalculator.Basics.generateSpectrumLorentzian — Method
Basics.generateSpectrumLorentzian(xIntensities::Array{Tuple{Float64,Float64},1}, widths::Float64; energyShift::Float64=0., resolution::Int64=500) ... to generate the Lorentzian spectrum for the given intensities (x-position, y-intensity) and the (constant) width. A tuple of an xList::Array{Float64,1} (positions) and yList::Array{Float64,1} (valiues) is returned that can immediately be plotted. The energy shift is provided already in 'current' units and is simply added to all energies.
JenaAtomicCalculator.Basics.generateSubshellList — Method
Basics.generateSubshellList(confs::Array{ConfigurationR,1}) ... to generate for confs, i.e. all the given (relativistic) configurations, common and ordered subshell list; a list::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.generateSubshellList — Method
Basics.generateSubshellList(shells::Array{Shell,1}) ... generates a list of relativistic subshells from the given shell list, and by keeping the same order. A subshellList::Array{Subshell,1} is returned.
JenaAtomicCalculator.Basics.printRasStepDiagnostic — Method
Basics.printRasStepDiagnostic(istep::Int64, multiplet::Multiplet, basis::Basis, refConfigs::Array{Configuration,1}, frozenShells::Array{Shell,1}, grid::Radial.Grid) ... prints, for one step of a RAS expansion, the two numbers that say what the layer actually did: the weight of each of the lowest levels on the REFERENCE CSFs, and the mean radius of every subshell the step newly introduced. Nothing is returned. See priority item 25 for why a step that prints only its multiplet is not enough.
JenaAtomicCalculator.BasicsAZ.assertNoDualShapeLabel — Method
BasicsAZ.assertNoDualShapeLabel(subshells::Array{Subshell,1}) ... raises if subshells carries two entries that share the same (n, kappa) label – which would let a single CSF occupy both the Basics.SCFShape and Basics.CoreValenceCorrelationShape realization of one label at once, breaking the antisymmetrization the CSF formalism assumes. This is a backstop, not a limiter: a shape-crossing RAS step (BasicsAZ.retagShapedSubshells, below) builds its Q space as its own separate Basis precisely so this cannot arise from retagging alone – it exists against a FUTURE caller that merges two shapes into one basis by mistake. nothing is returned when the check passes.
JenaAtomicCalculator.BasicsAZ.generateOrbitalsForShapedBasis — Method
BasicsAZ.generateOrbitalsForShapedBasis(basis::Basis, frozenShells::Array{Shell,1}, priorBasis::Basis, startOrbitals::Dict{Subshell,Orbital}, nm::Nuclear.Model, grid::Radial.Grid) ... generates the orbitals dict for a basis returned by BasicsAZ.retagShapedSubshells. Every ORDINARY (SCFShape) subshell is handled exactly as Basics.generateOrbitalsForBasis always has – reused from priorBasis where frozen or already present, from startOrbitals otherwise – since those keys are unchanged by the retagging. The newly CoreValenceCorrelationShape-tagged subshell(s) are a label priorBasis and startOrbitals were never built to serve (their keys all carry Basics.SCFShape), so each is instead given a fresh hydrogenic/warm start, generated here in the same mean potential Basics.generate(::AtomicState.RasExpansion, ...) builds its own startOrbitals from – cheap, since it is one or a few orbitals, not a whole spectrum. A orbitals::Dict{Subshell,Orbital} is returned.
JenaAtomicCalculator.BasicsAZ.representationOrbitals — Method
BasicsAZ.representationOrbitals(rep::AtomicState.Representation, repTypeName::String) ... resolves rep.orbitalSource for a generator that CAN be put on an orbital set the caller already holds. nothing is returned for Basics.SeparateOrbitals(), which means the generator runs its own SCF exactly as it always has, and the orbital dictionary is returned for Basics.GivenOrbitals(orbitals), which means the generator instead builds every multiplet as a CI on that set. Any other source RAISES, naming the two that mean something for a representation. An orbitals::Union{Nothing,Dict{Subshell,Orbital}} is returned.
JenaAtomicCalculator.BasicsAZ.requireSeparateOrbitals — Method
BasicsAZ.requireSeparateOrbitals(rep::AtomicState.Representation, repTypeName::String, why::String) ... guards a generator that CANNOT be put on a caller-supplied orbital set, and raises an error quoting why whenever rep.orbitalSource asks for one; nothing is returned. It exists so that orbitalSource is never a SILENT no-op: a field that some generators honour and others ignore without saying so is worse than no field at all, because the calculation then runs on the orbitals the user believes they replaced.
JenaAtomicCalculator.BasicsAZ.retagShapedSubshells — Method
BasicsAZ.retagShapedSubshells(basis::Basis, shapedShells::Array{Shell,1}) ... returns a new Basis, identical to basis except that every subshell whose (n, l) matches one of shapedShells is retagged Basics.CoreValenceCorrelationShape instead of the default Basics.SCFShape. basis.csfs is untouched: a CSF's occupation is indexed by POSITION in basis.subshells, not by the Subshell value itself, so relabeling one entry in place changes no CSF. basis.orbitals comes back empty, since the retagged subshells are new Dict KEYS (Basics.Subshell's == compares shape, though its hash deliberately does not) that the caller must still fill in – see BasicsAZ.generateOrbitalsForShapedBasis. BasicsAZ.assertNoDualShapeLabel is applied to the result before it is returned. A basis::Basis is returned.
JenaAtomicCalculator.BasicsAZ.runRasStep! — Method
BasicsAZ.runRasStep!(istep::Int64, step::AtomicState.RasStep, repType::AtomicState.RasExpansion, rep::AtomicState.Representation, priorMultiplet::Multiplet, priorIsLayer::Bool, startOrbitals::Dict{Subshell,Orbital}, nModel::Nuclear.Model; newShells::Array{Shell,1}=Shell[]) ... runs ONE layer of a AtomicState.RasExpansion: builds this step's basis and orbitals, performs its SCF (variational) or second-order (Q-space) treatment exactly as Basics.generate(::RasExpansion, rep) has always done inside its own loop over a hand-built step list, and prints the same per-layer diagnostics (the doubling test, and the boundary check that a variational layer must not end above the layer it sits on). Pulled out of that loop so the SAME per-layer physics can also be driven, layer by layer, by an automatic ladder (AtomicState.RasAutoSettings) that has not built its full step list up front. newShells is not read by this function; it only labels the returned verdict, since a hand-built AtomicState.RasStep carries no such field of its own – the caller supplies it where it is known (an automatic driver, from its own shell policy) and leaves it empty where it is not (a hand-built ladder). A (multiplet::Multiplet, verdict::AtomicState.RasLayerVerdict) tuple is returned.
Basics: perform
Base.getindex — Method
Base.getindex(r::Basics.PerformResults, key::AbstractString) ... returns the result stored under key; where the key is absent the error NAMES the keys that are present, and names the intended one where the request differs from it only in spacing, case or punctuation.
Base.getindex — Method
Base.getindex(r::Basics.PerformResults, T::Type) ... returns the result belonging to the settings type or ResultKeys key T – res[PhotoEmission.Settings], res[Hfs.Settings], res[ResultKeys.FinalMultiplet]. A wrong name is an UndefVarError where it is WRITTEN, naming the name, rather than a KeyError where the result is used.
Where `T` is a type this computation did not produce a result for, the error says so and lists the settings
types and keys that ARE present, translated back from the strings they are still stored under.Base.haskey — Method
Base.haskey(r::Basics.PerformResults, T::Type) ... true where this computation produced a result for the settings type or ResultKeys key T; a value::Bool is returned. It completes the typed interface: a caller that must branch on whether a result exists – Cascade.Simulation does, since a cascade may or may not carry photoexcitation lines – can now ask that question in the same vocabulary it uses to fetch the answer.
JenaAtomicCalculator.Basics.checkGridConvergence — Method
Basics.checkGridConvergence(computation::Atomic.Computation, extract::Function; factor::Float64=2.0, tolerance::Float64=1.0e-2, printout::Bool=true) ... re-performs computation on a twin grid whose outer step hp is finer by factor, with the radial BOX held, and compares whatever number(s) extract pulls out of the two result dictionaries. It is the check that both measured tables in Basics.recommendedGrid end on – halve hp until the answer stops moving – and it is here because nothing else in JAC performs it: every other grid and continuum guard is A PRIORI, read off the grid before the answer exists, while the failure this one catches is POSTERIOR. extract is handed the Basics.PerformResults of Basics.perform(...; output=true) – an AbstractDict{String,Any} read by TYPED keys – and may return a number or a collection of numbers. A value::NamedTuple with the fields converged, relative, index, coarse, fine, coarseGrid and fineGrid is returned.
Basics.checkGridConvergence(comp, r -> [lev.energy for lev in r[ResultKeys.Multiplet].levels])
Basics.checkGridConvergence(comp, r -> [ln.crossSection.Coulomb for ln in r[PhotoIonization.Settings]])
WHY THE MEAN FIELD IS RE-DERIVED RATHER THAN THE ORBITALS CARRIED OVER. A halved `hp` shares NO mesh with the
original -- measured 06-Nov-2026, 2 of 1330 points survive and both lie at r ~ 1e-8 -- because the harmonic blend of
`h*r` and `hp` carries the step change inward to every radius, not only to the outer linear part. So nothing can be
restricted onto the finer mesh, and JAC has no interpolation either (`Basics.interpolateOnGridGrasp92` is a stub that
raises). Re-performing the whole computation is therefore the only honest route, and it is what both of those tables
actually did. The cost is that the computation runs TWICE.
THE DEFAULT `tolerance` IS MEASURED, and the calibration is the second table in that same docstring: RR into 1s 4s of
H-like Bi with the box fixed at 142 a.u. gives sigma_C = 3.8338e-10, 5.0133e-09, 9.7472e-03, 1.1324e-02, 1.1324e-02 b
at hp = 0.472, 0.200, 0.100, 0.050, 0.025. Read as this check reads it -- each grid against its own halving -- those
are relative changes of 1.00, 1.00, 0.139 and 0.000, so EVERY threshold in (0, 0.139) separates the three unconverged
grids from the converged one and none outside it does. 1.0e-2 sits inside that interval. Note what the same table
says about the alternatives: the two gauges agree to better than 2 % at every row, so a gauge comparison is BLIND
here while the answer is wrong by seven orders.
AND THE BOX IS HELD ONLY TO WITHIN ONE OUTER STEP, since `Radial.Grid` lands on the first mesh point beyond the
requested `rbox`: 20.1267 against 20.0046 a.u. for hp = 2e-2 against 1e-2, i.e. 0.6 %. That is harmless under
`CoulombFunctionNorm`, measured insensitive to the box, and is NOT harmless under a sine convention, where the number
of oscillations in the box is what the normalization fits -- so under those conventions a failed verdict may mean
"the box moved" rather than "the answer has not converged".
+ computation ::Atomic.Computation ... the computation to be repeated; its own grid is the coarse one of the pair.
+ extract ::Function ... pulls the number(s) to be compared out of the result dictionary of `Basics.perform`.
+ factor ::Float64 ... factor by which the outer step `hp` is refined; it must exceed 1.
+ tolerance ::Float64 ... largest relative change that still counts as converged.
+ printout ::Bool ... whether the two grids and the comparison are printed.JenaAtomicCalculator.Basics.perform — Method
Basics.perform(computation::Atomic.Computation; output::Bool=false) ... to perform the computation as prescribed by computation, i.e. the SCF and CI steps followed by whichever properties and processes its settings request; all relevant intermediate and final results are printed to screen (stdout). With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned, an AbstractDict{String,Any} whose keys depend on the type and the specifications of the computation.
JenaAtomicCalculator.Basics.typedKeyFor — Method
Basics.typedKeyFor(key::AbstractString) ... names the typed key that replaces a deprecated string key; a String is returned, empty where the string is not one JAC ever used. It is the migration aid for apps/ scripts: the deprecation warning points at it, and it answers in one call what the table below would otherwise have to be read for.
JenaAtomicCalculator.BasicsAZ.allResultKeyTypes — Method
BasicsAZ.allResultKeyTypes() ... lists every type that labels a result – the forty settings types and the ResultKeys – so that a string can be mapped back to the typed key that replaces it; an Array{Type,1} is returned.
JenaAtomicCalculator.BasicsAZ.checkFrozenOrbitalsSpan — Method
BasicsAZ.checkFrozenOrbitalsSpan(frozenOrbitals::Dict{Subshell,Radial.Orbital}, configs::Array{Configuration,1}, configName::String, sourceName::String) ... tests that frozenOrbitals holds every subshell the given configurations occupy and RAISES an error naming the absent ones if it does not; nothing is returned. It exists because the failure it replaces is otherwise a bare KeyError: key 2s_1/2 not found thrown by Dict inside the CI matrix setup and wrapped in a TaskFailedException – loud, but telling a user nothing about what to change. MEASURED 02-Nov-2026: an SCF on [1s^2] yields the single orbital 1s_1/2, so a Green space of [1s, 2s, 2p] frozen onto it lacks 2s_1/2, 2p_1/2, 2p_3/2, while the same SCF over the union [1s^2, 1s 2s, 1s 2p] lacks none. That is the whole content of the check: ONE orbital set is usable only where it SPANS every subshell the multiplets built on it occupy.
JenaAtomicCalculator.BasicsAZ.resultKeyStrings — Method
BasicsAZ.resultKeyStrings(T::Type) ... gives the string key(s) under which Basics.perform stores the result belonging to T, where T is either a settings type or one of the ResultKeys; an Array{String,1} is returned, EMPTY where the type is not one that produces a result.
IT RETURNS A LIST, AND THERE ARE TWO REASONS. The first is that JAC stores some quantities under MORE THAN
ONE STRING: the Cascade modules write `"autoionization lines:"`, `"photoemission lines:"` and
`"photoexcitation lines:"` where `Basics.perform` writes `"AutoIonization lines:"`, `"radiative lines:"`
and `"photo-excitation lines:"` -- the same physical quantities under keys differing in case, in spacing
or in the word chosen, and `"name"`/`"name:"` differ by a colon. **One typed key lists every variant, so
the caller never meets the second vocabulary at all.** That is the whole of the maintainer's instruction
of 05-Oct-2026 that there should not be two vocabularies, and it needed no renaming to carry out.
The second reason: `DielectronicRecombination.Settings` produces
either `"dielectronic recombination lines:"` or `"hyperfine-resolved dielectronic recombination lines:"`
depending on a field of those very settings. Asking by TYPE makes that ambiguity disappear for the
caller -- they ask for the DR result and are handed whichever was computed -- where a string key forced
them to know which branch had run. It is the one place where the typed key is not merely safer but says
something the string could not.
THIS TABLE IS THE MIGRATION, and it is derived from `Basics.perform` itself: forty settings types, one key
each but for the DR pair, and six `ResultKeys` for the results that have no settings type. While the
strings remain accepted, this is the only place the correspondence is written down.