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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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).
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.
source
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.
source
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.

source
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.
source
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.

source
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.
source
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.

source
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.
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.

source
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.
source
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.
source
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.
source
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.

source
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.
source
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.

source
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).

source
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.

source
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.

source
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.

source
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.
source
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.

source
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.
source
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.

source
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.
source
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.
source
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.
source

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.

source
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.)

source
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).

source
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).

source
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.

source
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.
source
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.
source
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.
source
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.
source
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).
source
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.
source
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().

source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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.
source
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).
source
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.
source
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.
source
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.
source
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.
source
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`.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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`.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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 warnings
source
JenaAtomicCalculator.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.
source
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.

source
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.

source
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 2
source
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.
source
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.

source
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.

source
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.

source
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 numbers
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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)
source
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.

source
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.

source
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.
source
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.

source
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.
source
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.

source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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.

source
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).
source
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.

source
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 symmetries
source
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 level
source
JenaAtomicCalculator.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.

source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.
source
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.

source
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-symmetries
source
JenaAtomicCalculator.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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
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.
source
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".

source
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.
source
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.

source
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.

source
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.

source
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.
source
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.

source
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.

source
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".

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.

source
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.

source
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.
source
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.

source
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.
source
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.
source
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 core
source
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).
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.

source
JenaAtomicCalculator.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.

source
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 number
source
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).
source
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*Jsub
source
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.

source
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.

source
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.

source
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.
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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.
source
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).
source
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.
source
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 component
source
JenaAtomicCalculator.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.

source
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.

source

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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.

source
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.

source
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

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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].

source
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.

source
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.

source
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.

source
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.

source
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.

source
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

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source

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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.
source
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.
source
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.
source
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).

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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..

source
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).

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.
source
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

source
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 !

source
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.

source
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.

source
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.
source
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.

source
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.

source
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.

source
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.

source
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

source
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.

source
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

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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(...)

source
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[].

source
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.

source
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.
source
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.

source
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.

source
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.

source
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.

source
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.
source
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.
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.

source
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.

source
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.
source
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.

source
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 level
source
JenaAtomicCalculator.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.

source

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.

source
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.

source
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.
source
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.

source
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).

source
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.

source
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).
source
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).
source
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.
source
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).
source
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).
source
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).
source
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.
source
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.
source
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.

source
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`.
source
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 !

source
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.

source
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.

source
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.

source
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.

source
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 !

source
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 !

source
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`.
source
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`.
source
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}.
source
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.

source
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.

source
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.

source
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

source
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.

source
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.

source
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.

source
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).

source
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).

source
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.

source
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).

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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).

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source
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.

source

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.

source
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.
source
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.

source
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.
source
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.

source
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.

source
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.

source
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.

source
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.
source