Autoionization
JenaAtomicCalculator.AutoIonization.Line — Type
struct AutoIonization.Line ... defines a type for an Auger transition between an initial (autoionizing) and a final level, and carries the emitted electron as a list of partial waves; the total rate and the intrinsic angular parameter of the line are stored alongside them.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ electronEnergy ::Float64 ... Energy of the emitted Auger electron.
+ totalRate ::Float64 ... Total rate of this line.
+ angularAlpha ::Float64 ... Intrinsic angular parameter alpha_2.
+ partialWaves ::Array{PartialWave,1} ... one entry per partial wave of the free electron.
The total symmetry of the scattering state is NOT stored: it is LevelSymmetry(initialLevel.J, initialLevel.parity) for every partial
wave, and it is recomputed where needed as LevelSymmetry(line.initialLevel.J, line.initialLevel.parity).JenaAtomicCalculator.AutoIonization.PartialWave — Type
struct AutoIonization.PartialWave ... ONE partial wave of the emitted Auger electron, and its amplitude.
+ kappa ::Int64 ... partial wave of the free electron.
+ energy ::Float64 ... energy of the free electron.
+ phase ::Float64 ... scattering phase; a property of (energy, kappa).
+ amplitude ::Complex{Float64} ... Auger amplitude of this partial wave.
`amplitude` is a plain Complex{Float64} and deliberately NOT an EmPropertyC. The Coulomb-Breit operator has no gauge;
`settings.operator` selects CoulombInteraction() or BreitInteraction(), which is a choice of OPERATOR, not a pair of representations
computed together. An EmPropertyC here would assert that two gauges exist. (Measured: this module contains no occurrence of
`EmProperty` or `gauge` at all.)JenaAtomicCalculator.AutoIonization.PlasmaSettings — Type
struct AutoIonization.PlasmaSettings <: Basics.AbstractLineShiftSettings ... defines a type for the details and parameters of computing Auger rates with plasma interactions.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.JenaAtomicCalculator.AutoIonization.PlasmaSettings — Method
AutoIonization.PlasmaSettings() ... constructor for a standard instance of AutoIonization.PlasmaSettings. A plasmaSettings::AutoIonization.PlasmaSettings is returned.
JenaAtomicCalculator.AutoIonization.Settings — Type
struct Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing Auger lines.
+ calcAnisotropy ::Bool ... True, if the intrinsic alpha_2,4 angular parameters are to be calculated, and false
otherwise.
+ calcTeAuger ::Bool
... True, if contributions of the two-electron Auger transitions are to be calculated, and false otherwise;
this flag requires a proper (resonant) Green function that supports the TEA transitions.
+ calcBiorthogonal ::Bool
... True, if the (bound) initial- and final-state multiplets are first brought into a bi-orthogonal
representation (`BiOrthogonal.computeTransformation`) before the free (Auger) electron orbital is
generated and the transition amplitudes are evaluated, and false (the default) otherwise. As for
PhotoIonization, this transforms ONLY the bound spectator orbitals shared between the N-electron
autoionizing initial multiplet and the (N-1)-electron final-ion multiplet -- the core relaxation
upon Auger decay -- and must be applied BEFORE the free electron is generated: the free-electron
partial wave is built fresh per line via `Continuum.generateOrbitalForLevel`, with the matching
"empty slot" on the initial side filled by `Basics.generateLevelWithExtraSubshell`'s dummy,
all-zero placeholder orbital; a transformation applied any later would LU-decompose a singular
per-kappa overlap matrix built partly from that placeholder. See PhotoIonization.Settings'
calcBiorthogonal docstring for the same reasoning in full, including the still-open question of
whether BiOrthogonal.computeTransformation is rigorously valid for the resulting N-vs-(N-1)
electron-count mismatch (empirically it runs and gives plausible results, but has not yet been
checked against an independent known-answer test).
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ augerEnergyShift ::Float64 ... An overall energy shift for all Auger (free-electron) energies.
+ minAugerEnergy ::Float64 ... Minimum energy of free (Auger) electrons to be included.
+ maxAugerEnergy ::Float64 ... Maximum energy of free (Auger) electrons to be included.
+ maxKappa ::Int64 ... Maximum kappa value of partial waves to be included.
+ operator ::AbstractEeInteraction
... Auger operator that is to be used for evaluating the Auger amplitudes; allowed values are:
CoulombInteraction(), BreitInteraction(), ...
+ gMultiplet ::Multiplet
... Mean-field multiplet of intermediate levels in the computations, sometimes referred to as
(resonant) Green function.
+ gCoreMultiplet ::Multiplet
... Mean-field multiplet of the (N-1)-electron IONIC CORES of the CONTINUUM intermediate levels of the two-electron Auger sum, i.e.
of those intermediate states that carry one electron already in the continuum. An empty Multiplet() -- the default -- omits
that contribution and leaves the sum over bound intermediates (gMultiplet) alone. The two spaces are DISJOINT, since they are
the 16- and the (15 + 1 free)-electron parts of one complete intermediate set, and they add COHERENTLY; see
AutoIonization.computeTeaContinuumAmplitude.
+ NoIntermediateEnergies ::Int64
... Number of quadrature points in the integral over the INTERMEDIATE electron energy, i.e. in the REGULAR part R(eps) of the
continuum branch; see AutoIonization.computeTeaRegularAmplitude. ZERO -- the default -- omits R(eps) entirely and leaves only
the delta piece, so that the field is opt-in and an existing computation is unchanged by its presence. It truncates a complete
set and is therefore a CONVERGENCE PARAMETER, not a tuning knob.
+ intermediateEnergyFactor ::Float64
... Factor by which the intermediate-energy range exceeds the energetically allowed maximum. It must EXCEED ONE: an intermediate
state is virtual, so its energy is not restricted by energy conservation, and the on-shell pole must lie strictly INSIDE the
interval or there is nothing to regularize. Like the point count it is a convergence parameter.
+ continuumExchange ::Union{Nothing,Bool}
... True/false to force exchange between the free (Auger) electron and the bound electrons on or off; `nothing` --
the default -- lets `Basics.perform` decide automatically from the final-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99): on for `ALField`/`EOLField`, off otherwise. A caller of
`AutoIonization.computeLines` OUTSIDE `Basics.perform` that leaves this `nothing` gets `false`, the behaviour
this field did not change.JenaAtomicCalculator.AutoIonization.Settings — Method
AutoIonization.Settings(set::AutoIonization.Settings; calcAnisotropy::Union{Nothing,Bool}=nothing, calcTeAuger::Union{Nothing,Bool}=nothing, calcBiorthogonal::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, augerEnergyShift::Union{Nothing,Float64}=nothing, minAugerEnergy::Union{Nothing,Float64}=nothing, maxAugerEnergy::Union{Nothing,Float64}=nothing, maxKappa::Union{Nothing,Int64}=nothing, operator::Union{Nothing,AbstractEeInteraction}=nothing, gMultiplet::Union{Nothing,Multiplet}=nothing, gCoreMultiplet::Union{Nothing,Multiplet}=nothing, NoIntermediateEnergies::Union{Nothing,Int64}=nothing, intermediateEnergyFactor::Union{Nothing,Float64}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... constructor for modifying the given AutoIonization.Settings by 'overwriting' the previously selected parameters.
A `settings::AutoIonization.Settings` is returned.JenaAtomicCalculator.AutoIonization.Settings — Method
AutoIonization.Settings() ... constructor for the default values of AutoIonization line computations. A settings::AutoIonization.Settings is returned.
JenaAtomicCalculator.AutoIonization.amplitude — Method
AutoIonization.amplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, continuumLevel::Level, initialLevel::Level, grid::Radial.Grid, plasmaModel::Basics.AbstractPlasmaModel; printout::Bool=true) ... to compute the Auger amplitude as AutoIonization.amplitude(...) above, but with the electron-electron Coulomb interaction Debye-Hueckel-screened according to the given plasma model (InteractionStrength.XLCoulombDH in place of XL_Coulomb) – the plasma parameters thereby enter the transition operator itself, not only the level energies. Only kind = CoulombInteraction() is supported, consistent with Basics.compute(...,plasmaModel) which also excludes the Breit interaction from plasma computations. For plasmaModel = Basics.NoPlasmaModel(), this delegates directly to the field-free method above, so that the computation of the standard (field-free) Auger process is never touched by this plasma-specific code path. A value::ComplexF64 is returned.
JenaAtomicCalculator.AutoIonization.amplitude — Method
AutoIonization.amplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, continuumLevel::Level, initialLevel::Level, grid::Radial.Grid; printout::Bool=true) ... to compute the kind in CoulombInteraction(), BreitInteraction(), CoulombBreit(), CoulombGaunt() Auger amplitude <(alphaf Jf, kappa) Ji || O^(Auger, kind) || alphai J_i> due to the interelectronic interaction for the given final and initial level. A value::ComplexF64 is returned.
THIS IS THE OUTGOING-WAVE (decay) amplitude, and its phase convention belongs to that direction: the real reduced matrix element is
multiplied by i^l exp(-i phase). For the reverse, i.e. for the DIELECTRONIC CAPTURE of a free electron, do NOT take the complex
conjugate of this value -- use `AutoIonization.captureAmplitude`, whose docstring explains why the two differ by (-1)^l and when
that matters.JenaAtomicCalculator.AutoIonization.amplitudeForPhotoionizationConvention — Method
AutoIonization.amplitudeForPhotoionizationConvention(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, continuumLevel::Level, initialLevel::Level, grid::Radial.Grid; printout::Bool=true) ... to compute the SAME outgoing-wave Auger decay amplitude as AutoIonization.amplitude, but with the real reduced matrix element multiplied by i^(-l) exp(-i phase) – PhotoIonization.amplitude's own continuum-phase convention – rather than this module's native i^(+l) exp(-i phase). A value::ComplexF64 is returned.
WHY THIS EXISTS, AND WHY A PLAIN CALL TO `amplitude` IS NOT IT. Both conventions share the SAME phase factor exp(-i phase)
-- both describe an OUTGOING continuum electron -- but differ in the l-PREFACTOR: i^(+l) here against i^(-l) there, a
mismatch of i^(2l) = (-1)^l. That factor is harmless in any quantity that squares the amplitude (an ordinary Auger rate,
for instance), which is why it is easy to miss; it is NOT harmless when this amplitude is added COHERENTLY to a
`PhotoIonization` amplitude reaching the same (f, kappa) channel, as in `PhotoIonizationInterference`, because (-1)^l
depends on the partial wave and therefore reweights the partial waves against one another inside the coherent sum. This is
the exact counterpart, for photoionization, of why `AutoIonization.captureAmplitude` exists for recombination -- there the
two conventions differ in the PHASE (exp(+i phase) against exp(-i phase)); here they differ in the L-PREFACTOR instead,
so the fix is a real sign (-1)^l rather than a phase rotation exp(2i phase).JenaAtomicCalculator.AutoIonization.captureAmplitude — Method
AutoIonization.captureAmplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, continuumLevel::Level, initialLevel::Level, grid::Radial.Grid; printout::Bool=true) ... to compute the DIELECTRONIC-CAPTURE amplitude <alphai Ji || O^(capture, kind) || (alphaf Jf, kappa) J_i>, i.e. the amplitude for the reverse of the Auger decay computed by AutoIonization.amplitude, in the INCOMING-WAVE convention. A value::ComplexF64 is returned.
WHY THIS EXISTS, AND WHY conj(amplitude) IS NOT IT. A continuum orbital in JAC is real; the physics of a given direction sits in
the phase factor that each caller attaches to it, and JAC does not use one convention throughout:
AutoIonization.amplitude multiplies the real reduced matrix element by i^l exp(-i phase) (outgoing wave)
PhotoRecombination.amplitude multiplies its own reduced matrix element by i^l exp(+i phase) (incoming wave)
The capture amplitude has to describe the SAME scattering state |c> = i^l exp(+i phase)|real orbital> that a recombination amplitude
describes, so it is the Auger amplitude with its phase factor turned round,
captureAmplitude = amplitude * exp(2 i phase) = i^l exp(+i phase) * M with M real,
whereas conj(amplitude) = (-i)^l exp(+i phase) * M differs from it by (-1)^l.
That factor is harmless in any quantity that squares the amplitude, which is why `ElectronCapture.amplitude` may take the conjugate
and still obtain correct capture RATES, and why the discrepancy went unnoticed. It is NOT harmless when a capture amplitude is
added COHERENTLY to another amplitude -- as in the interference of dielectronic with radiative recombination -- because (-1)^l
depends on the partial wave and therefore reweights the partial waves against one another inside the coherent sum rather than
producing an overall sign. Use this function, and not a conjugate, whenever the result is to be added to something rather than
squared.JenaAtomicCalculator.AutoIonization.computeAmplitudesProperties — Method
AutoIonization.computeAmplitudesProperties(line::AutoIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::AutoIonization.Settings; printout::Bool=true, nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... computes the Auger amplitude of every partial wave of the given line and, from them, the total rate and – if the settings ask for it – the intrinsic angular parameter alpha_2. The rate is summed INCOHERENTLY over the partial waves. The two keywords carry the nuclear potential and the B-spline primitives, which are constant for a whole computation and are therefore passed in rather than rebuilt per line. A newLine::AutoIonization.Line with all amplitudes and properties evaluated is returned.
JenaAtomicCalculator.AutoIonization.computeAmplitudesPropertiesPlasma — Method
AutoIonization.computeAmplitudesPropertiesPlasma(line::AutoIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::AutoIonization.PlasmaSettings, plasmaModel::Basics.AbstractPlasmaModel; printout::Bool=true) ... to compute all amplitudes and properties of the given line but for the given plasma model; both the continuum orbital and the Auger (e-e Coulomb) transition operator are screened according to plasmaModel, cf. Continuum.generateOrbitalForLevel(...,plasmaModel) and AutoIonization.amplitude(...,plasmaModel). A line::AutoIonization.Line is returned for which the amplitudes and properties are now evaluated.
JenaAtomicCalculator.AutoIonization.computeIntrinsicAlpha — Method
AutoIonization.computeIntrinsicAlpha(k::Int64, line::AutoIonization.Line) ... computes the intrinsic angular parameter alpha_k of the given line, which determines the anisotropy of the emitted Auger electrons; a value::ComplexF64 is returned.
Pairs are formed ACROSS partial waves -- kappa and kappa' are independent, and that interference is the physical content of the
parameter. Within a pair, l and j belong to the outer partial wave and lp, jp to the inner one.
The `if false` block of the flat version -- an unfinished comparison against M. H. Chen, PRA 47 (1993) 3733, which "does not agree
exactly so far" -- is NOT carried over. It is dead code with a println, and the place to finish it is the flat function.JenaAtomicCalculator.AutoIonization.computeLines — Method
AutoIonization.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::AutoIonization.Settings; output=true, printout::Bool=true) ... computes the Auger amplitudes and all requested properties for the lines between the levels of the two given multiplets; this is the standard entry point of this module. The continuum orbitals are generated on a shared nuclear potential and B-spline basis. A list of lines::Array{AutoIonization.Line,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.AutoIonization.computeLinesCascade — Method
AutoIonization.computeLinesCascade(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::AutoIonization.Settings; output::Bool=true, printout::Bool=true) ... to compute the Auger transition amplitudes and all properties as requested by the given settings. The computations and printout is adapted for large cascade computations by including only lines with at least one channel and by sending all printout to a summary file only. A list of lines::Array{AutoIonization.Lines} is returned.
JenaAtomicCalculator.AutoIonization.computeLinesFromOrbitals — Method
AutoIonization.computeLinesFromOrbitals(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::AutoIonization.Settings, contOrbitals::Dict{Subshell, Orbital}, contPhases::Dict{Subshell, Float64}; output::Bool=true, printout::Bool=true) ... to compute the Auger transition amplitudes and all properties as requested by the given settings but by using the given set of continuum orbitals and their scattering phases, both keyed on the continuum subshell. The computations and printout is adapted for large cascade computations by including only lines with at least one channel and by sending all printout to a summary file only. The phase cancels in the total rate, which is an incoherent sum over the partial waves, but NOT in the intrinsic angular parameter, where amplitudes of different kappa interfere. A list of lines::Array{AutoIonization.Line,1} is returned.
JenaAtomicCalculator.AutoIonization.computeLinesPlasma — Method
AutoIonization.computeLinesPlasma(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::AutoIonization.PlasmaSettings, plasmaModel::Basics.AbstractPlasmaModel; output=true) ... to compute the Auger transition amplitudes and all properties as requested by the given settings and plasma model. A list of lines::Array{AutoIonization.Lines} is returned.
JenaAtomicCalculator.AutoIonization.computeTeaAmplitude — Method
AutoIonization.computeTeaAmplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, continuumLevel::Level, gMultiplet::Multiplet, initialLevel::Level, grid::Radial.Grid, nuclearPotential::Radial.Potential; printout::Bool=true) ... to compute the kind in CoulombInteraction(), BreitInteraction(), CoulombBreit() total Auger amplitude for the two-electron Auger transitions via the gMultiplet as the resonant Green function:
<(alpha_f J_f, kappa) J_i || O^(TEA, kind) || alpha_i J_i>
<(alpha_f J_f, kappa) J_i || O^(Auger, kind) || alpha_in J_n> <J_n || H - E || alpha_i J_i>
= ---------------------------------------------------------------------------------------------------
E_i - E_n
due to the interelectronic interaction as well as the given initial, intermediate (gMultiplet), and final (continuum) levels and the
given kind of interaction. The outgoing-electron factor i^l exp(-i*phase) is applied to the total, exactly as in
AutoIonization.amplitude, so that the two may be added coherently; it is a pure phase and does not affect a rate on its own.
A value::ComplexF64 is returned.
BOTH MATRIX ELEMENTS CARRY H - E, BECAUSE BOTH ARE MATRIX ELEMENTS OF THE ONE PERTURBATION V = H - H_0. With
H_0 = sum_a [h_D(a) + U(r_a)] the perturbation is V = sum_{a<b} v(ab) - sum_a U(a) exactly, so it has a two-body half AND a
one-body half. Where two states differ in TWO orbitals the one-body half vanishes identically and V^(e-e) is the whole answer --
the first-order Auger case. Where they differ in ONE orbital of the same kappa the two-body half returns the WHOLE spectator mean
field <b|U_HF|a>, counted a second time after it had already generated both orbitals, and the one-body half is what reduces it to
the residual <b|(U_HF - U)|a> that first-order perturbation theory asks for.
THE DECAY STEP IS SUCH A ONE-ORBITAL CASE, WHICH IS WHY IT NEEDED CHANGING. For Ar 2p^-2 -> 3p^-3 the dominant intermediates are
the five 3p^-2 levels, whose decay is the single replacement 3p -> eps; only the 2p^-1 3p^-1 levels decay by two. Measured
26-Oct-2026 on the kappa = -2 partial wave: of the 15 CSF pairs 11 move two or more orbitals and the one-body half is exactly zero
on every one of them, while the two that move one and match in kappa carry the dominant V^(e-e) = 0.6185 and 0.2753 and are
cancelled by the one-body half to 0.005 % and 0.5 %. Keeping V^(e-e) alone there left a decay matrix element 19 to 208 times too
large, depending on the form of the counterterm, and that single term carried 81.5 % of the whole bound-intermediate amplitude.
AND THE OVERLAP TERM IS NOT WHAT BLOCKS IT. An earlier form of this docstring kept V^(e-e) on the decay step because the final
state carries a continuum orbital whose overlap with the bound set does not vanish, so that H - E would need the -E <f|n>
counterterm ManyElectron.matrixElement_HminusE does not implement. The overlap was never measured; it is <eps|3p> = 1.9e-04,
and under the orthonormality that the whole second-order path already assumes the term is zero by the same assumption that makes
the junction's own one-body part exact. The remaining difference between the bare-h form used here and an explicit -<b|U|a> is
NOT that overlap but the AoC non-canonicity of the orbital set -- eps and 3p are eigenfunctions of different mean fields -- which
was measured on bound pairs of equal kappa at 2 to 6 % and sets the accuracy of the residual, not of the cancellation.
`nuclearPotential` must be the nuclear potential on `grid`; it now enters the one-body integral of BOTH steps.JenaAtomicCalculator.AutoIonization.computeTeaContinuumAmplitude — Method
AutoIonization.computeTeaContinuumAmplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, electronEnergy::Float64, cOrbital::Orbital, finalIonLevel::Level, gCoreMultiplet::Multiplet, initialLevel::Level, grid::Radial.Grid, nuclearPotential::Radial.Potential; printout::Bool=true) ... to compute that part of the two-electron Auger amplitude which proceeds through the CONTINUUM intermediate states, i.e. through intermediate states that carry one electron already in the continuum, and to return a value::ComplexF64. It is the companion of AutoIonization.computeTeaAmplitude, which carries the BOUND intermediate states, and the two must be added: the sum over intermediate states of a second-order amplitude runs over a COMPLETE set, which partitions by bound-electron count into a 16-electron part and a (15 + 1 free)-electron part. The two parts are disjoint and add COHERENTLY, so neither is a correction to the other and their relative SIGN is physical.
WHAT IS COMPUTED, AND WHAT IS NOT. Writing the intermediate as |g_core, eps kappa> with g_core a level of gCoreMultiplet, the
step that leads to the final state splits EXACTLY into a singular and a regular part,
<f| V |g_core, eps> = delta(eps - eps_f) * <f_core| V |g_core> + R(eps),
because the continuum electron is a pure SPECTATOR of a junction that acts on the ionic core alone and therefore enters only
through its own overlap -- and for orbitals normalized per unit energy that overlap is a delta function. Integrating the delta
piece places the intermediate electron at the energy of the OBSERVED electron and leaves no integral at all, which is what this
method computes. The regular part R(eps) is a Cauchy principal-value integral over the intermediate electron energy with an
on-shell pole at eps = E_i - E_g, and it is NOT computed here; it needs the quadrature and the retarded propagator of
PhotoDoubleIonization.generateIntermediateLevels and PhotoDoubleIonization.assemblePrincipalValue.
THE DELTA PIECE THEREFORE READS
A = sum_g <(f_core J_f, kappa) J_i | O^(Auger, kind) ... > ...
A^(Auger)(i --> g_core, eps_f kappa) * <f_core || H - E || g_core>
A = sum_g ------------------------------------------------------------------
E_i - E_g - eps_f
and every factor in it is already validated machinery. The numerator's first factor is an ORDINARY first-order Auger amplitude
into the intermediate channel, taken at the energy of the observed electron rather than on shell, and it is evaluated by
AutoIonization.amplitude itself -- which is why the outgoing-electron factor i^l exp(-i*phase) is carried exactly once and nothing
further is applied to the total here. The second factor is the junction of item 98, now between the two BOUND (N-1)-electron
cores; the continuum electron has been integrated out of it by the delta function and does not appear.
THE JUNCTION IS A SCALAR ON THE CORE, which fixes the angular algebra completely and introduces no new Wigner coefficient: in the
coupled basis |(J_core, kappa) J_i> a rank-0 operator acting on the core leaves the coupling untouched, so the matrix element is
delta(J_g, J_f) times the core matrix element, with a geometric factor of exactly one. Only cores of the final level's own J and
parity are therefore reached, and the loop below skips the others rather than relying on the spin-angular coefficients to vanish.
AND THE DENOMINATOR IS WRITTEN AS E_i - E_g - eps_f RATHER THAN AS E_f - E_g, although energy conservation makes the two equal:
the first form is the second-order propagator of the state actually constructed, it stays correct under a non-zero
settings.augerEnergyShift, and it makes the comparison with the bound branch's E_i - E_n an OUTPUT rather than an assumption.
Measured on argon 26-Oct-2026, the two denominators come out as the same quantity with OPPOSITE SIGN -- the dominant bound family
at +252.7 to +256.7 eV against the whole continuum family at -234.0 to -246.8 eV -- so the two parts of the sum interfere
destructively; see tools/probeTeaDenominators.jl.
+ cOrbital ::Orbital ... the SAME continuum orbital the final state carries; the delta function identifies the two, and
generating a second one here would break that identity.
+ finalIonLevel ::Level ... the (N-1)-electron final ionic level, with its basis already symmetry-reduced.
+ initialLevel ::Level ... the initial level carrying the empty continuum slot, as AutoIonization.amplitude requires.JenaAtomicCalculator.AutoIonization.computeTeaRegularAmplitude — Method
AutoIonization.computeTeaRegularAmplitude(kind::AbstractEeInteraction, kappa::Int64, phase::Float64, finalScattLevel::Level, gCoreMultiplet::Multiplet, initialLevel::Level, nm::Nuclear.Model, grid::Radial.Grid, nuclearPotential::Radial.Potential, contSettings::Continuum.Settings, maxKappa::Int64, noIntEnergies::Int64, intEnergyFactor::Float64; printout::Bool=true) ... to compute the REGULAR part R(eps) of the continuum branch of the two-electron Auger amplitude, i.e. that part in which the free electron is NOT a spectator but PARTICIPATES, and to return a value::ComplexF64. It is the companion of AutoIonization.computeTeaContinuumAmplitude, which carries the singular (delta) part of the very same branch, and of AutoIonization.computeTeaAmplitude, which carries the bound intermediates; all three are parts of ONE second-order sum and must be added. A noIntEnergies of zero – the default – returns zero, so R(eps) is opt-in and an existing computation is unchanged.
WHAT IT IS PHYSICALLY. Reading g_core --> f_core, a 3p electron fills the 2p hole and the free electron carries off the energy
released, going eps --> eps_f. That is the outgoing Auger electron scattering INELASTICALLY off the ion it has just left, and the
energy bookkeeping closes on itself: eps_f = eps + (E_g - E_f), so with a pole at eps* = E_i - E_g the observed electron comes out
at the energy the first-order calculation already predicts.
THE OPERATOR IS THE PLAIN TWO-BODY INTERACTION, AND THAT IS NOT A CHOICE. The states f = (f_core, eps_f) and g = (g_core, eps)
each carry one free electron beside their bound ones and differ in TWO orbitals -- the core's 3p --> 2p and the free electron's
eps --> eps_f. Two orbital differences are exactly where H - E reduces to V^(e-e) identically, so no junction reasoning enters
here; the delta piece was the one-orbital case and that is precisely why it needed H - E.
THE PHASE FACTOR BELONGS TO THE TOTAL AMPLITUDE AND IS APPLIED ONCE, at the end. The observed electron carries
i^l exp(-i*phase); the intermediate electron is an internal line of a sum over a COMPLETE SET OF REAL BASIS STATES and carries no
boundary-condition phase of its own. Each matrix element is therefore taken BARE, which is what passing kappa = -1 and phase = 0
to AutoIonization.amplitude achieves -- its own factor is then i^0 exp(0) = 1 exactly. In the delta piece this distinction did not
arise, because there eps = eps_f and the two kappas coincide, so attaching the factor to either factor of the product gave the
same number; here the two kappas differ and it matters.
TWO PROPERTIES OF THE QUADRATURE, BOTH LEARNED IN PhotoDoubleIonization AND NOT TO BE REDISCOVERED (priority item 33, closed
05-Oct-2026). A plain Gauss-Legendre sum of 1/x through a pole HAS NO LIMIT -- refining the mesh merely puts nodes nearer the
pole -- so the principal value is subtracted from the start rather than added once a number exists. And an intermediate state is
VIRTUAL, so its energy is not restricted by energy conservation: the range must extend BEYOND the energetically allowed maximum,
with the pole strictly inside, which is what intEnergyFactor > 1 secures.
A (core, kappa) BLOCK THAT VANISHES IS SKIPPED AFTER ONE ENERGY, not evaluated at every node. The zero is a SELECTION RULE
independent of eps: once the free electron's own eps --> eps_f is counted it consumes one of the two slots of a two-body operator,
so R(eps) reaches only cores ONE orbital away from f_core, whereas the delta piece reached every core its junction could connect.
The two branches therefore sample DIFFERENT core spaces and must be converged separately. Measured on argon 26-Oct-2026, 36 of 82
blocks were such zeros; see tools/probeTeaRegularPart.jl, where the same probe also confirms hermiticity to 3.8e-10 and that every
live block depends on eps.
+ finalScattLevel ::Level ... the FINAL SCATTERING state, i.e. the final ion with the observed continuum electron already
attached; it is the bra of R(eps) and is the same level the first-order amplitude uses.
+ noIntEnergies ::Int64 ... quadrature points over the intermediate electron energy; zero omits R(eps) altogether.JenaAtomicCalculator.AutoIonization.determineChannels — Method
AutoIonization.determineChannels(finalLevel::Level, initialLevel::Level, settings::AutoIonization.Settings) ... determines the partial waves of the emitted Auger electron for the given transition, by applying AngularMomentum.allowedKappaSymmetries(symi, symf) and discarding every kappa with abs(kappa) > settings.maxKappa. No total symmetry is stored with a partial wave: it is symi for all of them and hence a property of the line. An Array{AutoIonization.PartialWave,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.AutoIonization.determineLines — Method
AutoIonization.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::AutoIonization.Settings) ... selects the Auger lines to be computed by forming all pairs of an initial and a final level that pass the line selection and for which the electron energy – the transition energy shifted by settings.augerEnergyShift – is positive. An Array{AutoIonization.Line,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.AutoIonization.displayLifetimes — Method
AutoIonization.displayLifetimes(stream::IO, lines::Array{AutoIonization.Line,1}) ... derives the lifetime of every autoionizing level from the total Auger rate of all lines that start from it, and lists it together with the corresponding level width. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.AutoIonization.displayLines — Method
AutoIonization.displayLines(stream::IO, lines::Array{AutoIonization.Line,1}) ... lists the Auger lines that have been selected, together with the electron energy and the kappa values of the partial waves that will be computed for each of them, and counts the lines and partial waves involved. The total symmetry is taken from the autoionizing level, which is where it belongs. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.AutoIonization.displayRates — Method
AutoIonization.displayRates(stream::IO, lines::Array{AutoIonization.Line,1}, settings::AutoIonization.Settings) ... lists, for every Auger line, the transition energy, the energy of the emitted electron and the total Auger rate; the intrinsic angular parameter alpha_2 is shown in addition whenever settings.calcAnisotropy is true. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.AutoIonization.photoDoubleIonizationModule — Method
AutoIonization.photoDoubleIonizationModule() ... to return the PhotoDoubleIonization module::Module, whose second-order machinery – the intermediate continuum levels and the principal-value assembly – is general rather than specific to that process and is therefore shared rather than copied.
WHY IT CANNOT SIMPLY BE NAMED. PhotoDoubleIonization is included AFTER this module in JenaAtomicCalculator.jl, so
`using ..PhotoDoubleIonization` at module-definition time fails. Writing the parent's own name inside a function body does not
work either, although it looks as though it should: a submodule does NOT see a binding for the module that encloses it, and
`JenaAtomicCalculator.PhotoDoubleIonization` raises an UndefVarError from here -- measured 26-Oct-2026, after exactly that form
had been checked from the top level, where it DOES resolve and therefore proves nothing about this scope. `parentmodule` does see
it, and the lookup happens at CALL time, once every include has run.Crystal-field-resolved emission
JenaAtomicCalculator.CrystalFieldEmission.Channel — Type
struct CrystalFieldEmission.Channel ... a single multipole/gauge transition channel between two Stark sublevels. It mirrors what PhotoEmission.Channel was before that module was retired; this one is CrystalFieldEmission's own and is unaffected.
+ multipole ::EmMultipole ... multipole of the photon emission/absorption.
+ gauge ::EmGauge ... gauge used for the radiation field.
+ amplitude ::ComplexF64 ... crystal-field-resolved amplitude of this channel.JenaAtomicCalculator.CrystalFieldEmission.Line — Type
struct CrystalFieldEmission.Line ... a transition between one Stark sublevel of an initial CfMultiplet and one Stark sublevel of a final CfMultiplet, mirroring PhotoEmission.Line with CrystalField.CfLevel in place of ManyElectron.Level.
+ initialCfLevel ::CrystalField.CfLevel ... initial Stark sublevel.
+ finalCfLevel ::CrystalField.CfLevel ... final Stark sublevel.
+ omega ::Float64 ... transition energy (Hartree).
+ channels ::Array{CrystalFieldEmission.Channel,1} ... list of multipole/gauge channels.JenaAtomicCalculator.CrystalFieldEmission.Settings — Type
struct CrystalFieldEmission.Settings <: Basics.AbstractProcessSettings ... defines the settings for computing crystal-field-resolved multipole transitions between an initial and a final multiplet.
+ multipoles ::Array{EmMultipole,1} ... multipoles to be included.
+ gauges ::Array{UseGauge,1} ... gauges to be included.
+ lattice ::CrystalField.Lattice ... the external point-charge lattice (same for both sides).
+ model ::CrystalField.AbstractCrystalFieldModel ... the crystal-field model to be applied.
+ maxRank ::Int64 ... maximum tensor rank for the crystal-field splitting itself.
+ includeJmixing ::Bool ... whether to J-mix within each side's own splitting.
+ printBefore ::Bool ... True if a list of selected lines is printed before computing.
+ minEnergy ::Float64 ... minimum transition energy (Hartree) to be included.
+ maxEnergy ::Float64 ... maximum transition energy (Hartree) to be included.JenaAtomicCalculator.CrystalFieldEmission.Settings — Method
CrystalFieldEmission.Settings(set::CrystalFieldEmission.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, lattice::Union{Nothing,CrystalField.Lattice}=nothing, model::Union{Nothing,CrystalField.AbstractCrystalFieldModel}=nothing, maxRank::Union{Nothing,Int64}=nothing, includeJmixing::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, minEnergy::Union{Nothing,Float64}=nothing, maxEnergy::Union{Nothing,Float64}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::CrystalFieldEmission.Settings.
A `settings::CrystalFieldEmission.Settings` is returned.JenaAtomicCalculator.CrystalFieldEmission.Settings — Method
CrystalFieldEmission.Settings() ... constructor for the default values of crystal-field-resolved transitions. A settings::CrystalFieldEmission.Settings is returned.
JenaAtomicCalculator.CrystalFieldEmission.computeLineAmplitude — Method
CrystalFieldEmission.computeLineAmplitude(mp::EmMultipole, gauge::EmGauge, finalCfLevel::CrystalField.CfLevel, initialCfLevel::CrystalField.CfLevel, grid::Radial.Grid) ... computes the crystal-field-resolved multipole transition amplitude between one final and one initial Stark sublevel, following the Wigner-Eckart expansion <Jf Mf|O^mp_q|Ji Mi> = (-1)^(Jf-Mf) (Jf mp.L Ji; -Mf q Mi) <Jf||O^mp||Ji>, where q = Mf-Mi is fixed by the 3-j projection selection rule and the reduced matrix element <Jf||O^mp||Ji> is PhotoEmission.amplitude(Emission(),...) between the two CfBasisVectors' parent levels (cached per distinct parent-level pair, using the PARENT levels' own energy difference as the emission-operator's omega – an excellent approximation since crystal-field-induced shifts are always tiny compared to a genuine parent-level transition energy). The resulting (final CfBasisVector) x (initial CfBasisVector) matrix is sandwiched between the two levels' mixing vectors: adjoint(finalCfLevel.mc) * matrix * initialCfLevel.mc (adjoint, not transpose, since CfLevel.mc is complex). A value::ComplexF64 is returned.
JenaAtomicCalculator.CrystalFieldEmission.computeLines — Method
CrystalFieldEmission.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::CrystalFieldEmission.Settings) ... the standard top-level driver of the module, called automatically by Basics.perform(::Atomic.Computation) once computation.processSettings isa CrystalFieldEmission.Settings (mirroring PhotoEmission.computeLines's role exactly – final-multiplet-first argument order, matching PhotoEmission throughout). Splits both finalMultiplet and initialMultiplet by the same settings.lattice via CrystalField.computeOutcomes(...), then forms the Cartesian product of all (initial CfLevel, final CfLevel) pairs across those outcomes, skipping pairs whose energy difference falls outside [settings.minEnergy, settings.maxEnergy]. For each surviving pair, one CrystalFieldEmission.Channel per requested (multipole,gauge) combination is computed via CrystalFieldEmission.computeLineAmplitude(...); as in PhotoEmission.determineChannels, only one Magnetic-gauge channel is kept per multipole regardless of how many gauges were requested. An Array{CrystalFieldEmission.Line,1} is returned.
JenaAtomicCalculator.CrystalFieldEmission.displayLines — Method
CrystalFieldEmission.displayLines(stream::IO, lines::Array{CrystalFieldEmission.Line,1}) ... prints the crystal-field-resolved transition lines to stream, mirroring PhotoEmission.displayLines/displayRates: one row per Line, one column per requested (multipole,gauge) channel showing |amplitude|^2. Rows are labeled by sublevel energy rather than by level index, since a CfLevel has no single index (unlike a plain Level). Nothing is returned.
+ stream ::IO ... the output stream.
+ lines ::Array{CrystalFieldEmission.Line,1} ... the computed crystal-field-resolved lines.Decay yields
JenaAtomicCalculator.DecayYield.Outcome — Type
struct DecayYield.Outcome ... defines a type to keep the outcome of a fluorescence and Auger yield computation as well other results.
+ level ::Level ... Atomic level to which the outcome refers to.
+ NoPhotonLines ::Int64 ... Number of photon decay lines
+ NoAugerLines ::Int64 ... Number of Auger decay lines
+ rateR ::EmProperty ... Total fluorescence rate
+ rateA ::Float64 ... Total Auger rate
+ omegaR ::EmProperty ... fluorescence yield
+ omegaA ::EmProperty ... Auger yieldJenaAtomicCalculator.DecayYield.Outcome — Method
DecayYield.Outcome() ... constructor for an empty instance of DecayYield.Outcome for the computation of fluorescence and Auger yields. A outcome::DecayYield.Outcome is returned.
JenaAtomicCalculator.DecayYield.Settings — Type
struct DecayYield.Settings <: AbstractPropertySettings ... defines a type for the details and parameters of computing fluorescence and Auger yields.
+ approach ::Basics.AbstractCascadeApproach ... Cascade approach applied for the yields:
Basics.AverageSCA(), Basics.SCA() or Basics.UserMCA().
+ printBefore ::Bool ... True if the selected levels is to be printed before the actual computations start.
+ geant4 ::Bool ... True, if decay probabilities for the Geant code are to be generated and printed.
+ levelSelection ::LevelSelection ... Specifies the selected levels, if any.
+ decayShells ::Array{Shell,1} ... Additional shells to be included among Cascade.StepwiseDecayScheme's decayShells,
on top of those already occurring in the initial configuration(s); needed, for
instance, to communicate a spectator shell that is completely absent from a
double-core-hole initial configuration (e.g. "1s^2 2p^5" needs 2s added
explicitly so the cascade knows this shell can become populated during decay).JenaAtomicCalculator.DecayYield.Settings — Method
DecayYield.Settings(set::DecayYield.Settings; approach::Union{Nothing,Basics.AbstractCascadeApproach}=nothing, printBefore::Union{Nothing,Bool}=nothing, geant4::Union{Nothing,Bool}=nothing, levelSelection::Union{Nothing,LevelSelection}=nothing, decayShells::Union{Nothing,Array{Shell,1}}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::DecayYield.Settings.
A `settings::DecayYield.Settings` is returned.JenaAtomicCalculator.DecayYield.Settings — Method
DecayYield.Settings() ... constructor for an empty instance of DecayYield.Settings for the computation of fluorescence and Auger yields. A settings::DecayYield.Settings is returned.
JenaAtomicCalculator.DecayYield.computeOutcomes — Method
DecayYield.computeOutcomes(initialConfigs::Array{Configuration,1}, asfSettings::AsfSettings, multiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::DecayYield.Settings; output=true) ... to compute (as selected) the fluorescence and Auger yields for the levels of the given multiplet and as specified by the given settings. The results are printed in neat tables to screen but nothing is returned otherwise.
JenaAtomicCalculator.DecayYield.determineOutcomes — Method
DecayYield.determineOutcomes(multiplet::Multiplet, settings::DecayYield.Settings) ... to determine a list of Outcomes's for the fluorescence and Auger yields of the levels of the given multiplet. It takes into account the particular selections and settings. An Array{DecayYield.Outcome,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.
JenaAtomicCalculator.DecayYield.displayOutcomes — Method
DecayYield.displayOutcomes(outcomes::Array{DecayYield.Outcome,1}) ... to display a list of levels that have been selected for the computations. A small neat table of all selected levels and their energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.DecayYield.displayResults — Method
DecayYield.displayResults(stream::IO, outcomes::Array{DecayYield.Outcome,1}, settings::DecayYield.Settings) ... to display the energies, M_ms and F-parameters, etc. for the selected levels. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.DecayYield.extractGenerationZeroLevels — Method
DecayYield.extractGenerationZeroLevels(genMultiplets::Array{Multiplet,1}, decayInitialConfigs::Array{Configuration,1}) ... to pick out, from a Cascade.StepwiseDecayScheme's own generated multiplets: result, the multiplet(s) that represent "generation 0" – the initial configuration(s) themselves, computed under the SAME mean-field approach (cApproach) that also produced the radiative and Auger lines these levels will later be matched against. Cascade.generateBlocks appends the initial configurations to the end of its own configuration list and builds one block per configuration in that same order, so the last length(decayInitialConfigs) entries of genMultiplets are exactly the generation-0 blocks, in order; this is verified rather than assumed, by comparing each block's own extracted configuration against the one it is expected to match. A combined multiplet::Multiplet of all their levels is returned.
Dielectronic Recombination
JenaAtomicCalculator.DielectronicRecombination.AbstractCorrections — Type
abstract type DielectronicRecombination.AbstractCorrections ... defines an abstract type to distinguish different types of corrections to the decay rates and strength. These corrections are based on the classification of shells:
n^(core) < n^(final) < n^(hydrogenic) < n^(lowest-captured) <= n^(max) ... where
n^(core) ... refers to the (maximum) principal quantum number to which initial core electrons are excited;
n^(final) ... the maximum number for which shells are treated explicitly in the representation of the final
levels f, EXCLUDING the shell the electron was captured into (which is always present in the
final basis and would otherwise swallow this number);
n^(hydrogenic) ... to the maximum n-shell, to which the radiative decay is modeled by scaled-hydrogenic rates,
... and which can be omitted also from the list.
n^(lowest-captured) ... is the lowest, high-n shell, into which the additional electron is captured and which must
(of course) occur explicitly in the basis of the intermediate and final levels.
n^(max) ... the highest shell for which the DR resonances are still estimated, by extrapolating the
explicitly computed Rydberg series; all shells with n > n^(max) are neglected completely.
+ struct DielectronicRecombination.RydbergTailCorrection
... to extrapolate the explicitly computed Rydberg series to the shells n^(lowest-captured) < n <= n^(max) that are
too numerous to be treated explicitly, and -- optionally -- to the orbital angular momenta l that exist at those
shells but were never computed. The capture and Auger rates are scaled as n^(-3), the core radiative rate is
held n-independent, and the radiative decay of the Rydberg spectator itself is computed (not scaled) by the
hydrogenic machinery. Replaces the former EmpiricalCorrections, whose scalings could not be reconstructed.
+ struct DielectronicRecombination.HydrogenicCorrections
... to add for missing final decay levels to the (total) photon decay rates by scaling the corresponding rates
of non-relativistic hydrogenic ions with a suitable effective charge (Zeff); these hydrogenic corrections improve
goth, the total photon rate as well as the resonance strength.
+ struct DielectronicRecombination.MaximumlCorrection
... to exclude all subshells with l > l_max in the hydrogenic corrections; this restriction does not apply to the
given resonance levels, which can be controlled (and are specified) by the list of intermediate configurations.
+ struct DielectronicRecombination.ResonanceWindowCorrection
... to keep only those resonances whose capture energy falls inside a given window [E_min, E_max], for instance the
range actually scanned in an EBIT or storage-ring measurement.JenaAtomicCalculator.DielectronicRecombination.CaptureLine — Type
struct DielectronicRecombination.CaptureLine ... represents one capture step i + e^- –> m, carrying the partial waves of the captured electron together with the two total widths of the intermediate level m and the resonance strength of the resonance.
+ initialLevel ::Level ... initial-(state) level i of the recombining ion.
+ intermediateLevel ::Level ... intermediate-(state), autoionizing level m.
+ electronEnergy ::Float64 ... energy of the captured electron.
+ captureRate ::Float64 ... Auger rate A_a(m --> i) of THIS channel alone.
+ totalAugerRate ::Float64 ... Gamma_a(m) = sum over ALL initial levels i.
+ totalPhotonRate ::EmProperty ... Gamma_r(m) = sum over ALL final levels f.
+ resonanceStrength ::EmProperty ... DR resonance strength of this (i,m) resonance.
+ capturePartialWaves ::Array{AutoIonization.PartialWave,1} ... partial waves of the captured electron.JenaAtomicCalculator.DielectronicRecombination.EmpiricalTreatment — Type
struct DielectronicRecombination.EmpiricalTreatment ... defines an (internal) type to communicate and distribute the physical (and technical) parameters that are utilized to make the requested empirical corrections or just nothing. This data type should not be applied by the user but is initialized by the given (set of) corrections. Otherwise, it is treated like any other type in JAC. All parameters are made physically "explicit", even if they were "missing" originally, and can be directly applied in the empirical treatment of the DR process. The following hierarchy of shells is used:
n^(core) < n^(final) < n^(hydrogenic) < n^(lowest-captured) <= n^(max)
+ doRydbergTailCorrection ::Bool ... True, if the Rydberg series is to be extrapolated, false o/w.
+ doHydrogenicCorrections ::Bool ... True, if hydrogenic corrections are needed, false o/w.
+ doMaximumlCorrection ::Bool ... True, if a maximum l values is used, false o/w.
+ doResonanceWindowCorrection ::Bool ... True, if a window of resonances is specified, false o/w.
+ nCore ::Int64
... (maximum) principal quantum number to which initial core electrons are excited;
+ nFinal ::Int64
... the maximum number for which shells are treated explicitly in the representation of the final levels f,
EXCLUDING the shell the electron was captured into.
+ nHydrogenic ::Int64
... maximum n-shell, to which the radiative decay is modeled by scaled-hydrogenic rates.
+ nLowestCaptured ::Int64
... lowest, high-n shell, into which the additional electron is captured and which must (of course) occur
explicitly in the basis of the intermediate and final levels.
+ nMax ::Int64
... highest n-shell for which the DR resonances are still estimated by extrapolating the explicitly computed
Rydberg series; all shells with n > nMax are neglected completely.
+ maximum_l ::Int64 ... maximum l value; is set to a large value if not specified by the user.
+ lMaxTail ::Int64
... highest l to extrapolate to in the tail; equal to the largest computed l when no l extrapolation is wanted.
+ nExponent ::Float64 ... exponent of the n-scaling of the capture and Auger rates.
+ hydrogenicEffectiveZ ::Float64 ... effective charge Z_eff for the hydrogenic correction.
+ hydrogenicRateScaling ::Float64 ... scaling factor to modify the estimated hydrogenic rates.
+ tailEffectiveZ ::Float64 ... effective Z seen by the Rydberg electron in the tail extrapolation.
+ resonanceEnergyMin: ::Float64 ... minimum energy [Hartree] of the resonances to be considered.
+ resonanceEnergyMax: ::Float64 ... maximum energy [Hartree] of the resonances to be considered.JenaAtomicCalculator.DielectronicRecombination.HfCaptureLine — Type
struct DielectronicRecombination.HfCaptureLine ... defines a type for a hyperfine-resolved dielectronic capture line, i.e. the step i + e- –> m between two hyperfine levels, together with the two total widths of the intermediate hyperfine level. It is the exact pendant of DielectronicRecombination.CaptureLine, with Hfs.HfLevel in place of Level.
+ initialLevel ::Hfs.HfLevel ... initial hyperfine level
+ intermediateLevel ::Hfs.HfLevel ... intermediate (resonant) hyperfine level
+ electronEnergy ::Float64 ... energy of the captured electron
+ captureRate ::Float64 ... A_a(m --> i) for THIS channel only
+ totalAugerRate ::Float64 ... Gamma_a(m), summed over all initial hyperfine levels
+ totalPhotonRate ::EmProperty ... Gamma_r(m), summed over all final hyperfine levels
+ resonanceStrength ::EmProperty ... S(i,m)
Unlike CaptureLine this type carries NO channel list. The channels live on the electronic capture line
from which this one was recoupled; keeping a second copy here would duplicate state that cannot be kept
consistent, which is the failure mode this whole re-structuring exists to remove.JenaAtomicCalculator.DielectronicRecombination.HfCaptureLine — Method
DielectronicRecombination.HfCaptureLine() ... constructor for an 'empty' HfCaptureLine. A hfCaptureLine::DielectronicRecombination.HfCaptureLine is returned.
JenaAtomicCalculator.DielectronicRecombination.HfPhotonLine — Type
struct DielectronicRecombination.HfPhotonLine ... defines a type for one hyperfine-resolved radiative stabilization m –> f + hv; the pendant of DielectronicRecombination.PhotonLine.
+ intermediateLevel ::Hfs.HfLevel ... intermediate (resonant) hyperfine level
+ finalLevel ::Hfs.HfLevel ... final hyperfine level
+ photonEnergy ::Float64 ... energy of the emitted photon
+ photonRate ::EmProperty ... A_r(m,f)JenaAtomicCalculator.DielectronicRecombination.HfPhotonLine — Method
DielectronicRecombination.HfPhotonLine() ... constructor for an 'empty' HfPhotonLine. A hfPhotonLine::DielectronicRecombination.HfPhotonLine is returned.
JenaAtomicCalculator.DielectronicRecombination.HydrogenicCorrections — Type
struct DielectronicRecombination.HydrogenicCorrections <: DielectronicRecombination.AbstractCorrections ... to add for missing final decay levels the photon decay rates for non-relativistic hydrogenic ions; this improves the total photon rate as well as the resonance strength. These corrections are taken into account for all shells with n^{final}+1 <= n <= nHydrogenic
+ nHydrogenic ::Union{Int64,Missing}
... upper principal quantum number nHydrogenic for which hydrogenic corrections to the radiative photon rates are
calculated explicitly; the photon rates are further scaled if some proper effectiveZ and/or rateScaling
is provided.
+ effectiveZ ::Union{Float64,Missing} ... effective charge Z_eff for the hydrogenic correction.
+ rateScaling ::Union{Float64,Missing} ... scaling factor to scale the photon ratesJenaAtomicCalculator.DielectronicRecombination.MaximumlCorrection — Type
struct DielectronicRecombination.MaximumlCorrection <: DielectronicRecombination.AbstractCorrections ... to exclude all subshells with l > l_max, both in the treatment of the corrections shells.
+ maximum_l ::Union{Int64,Missing}
... maximum orbital angular momentum quantum number for which contributions to the DR strengths are
taken into account. This number applies for all subshells for which other corrections are
requested, whereas the "physical subshells" are defined by the configuration lists.JenaAtomicCalculator.DielectronicRecombination.PhotonLine — Type
struct DielectronicRecombination.PhotonLine ... represents one stabilization step m –> f + hv, carrying one entry per MULTIPOLE, each of which holds both gauges.
+ intermediateLevel ::Level ... intermediate-(state), autoionizing level m.
+ finalLevel ::Level ... final-(state) level f of the recombined ion.
+ photonEnergy ::Float64 ... energy of the emitted photon.
+ photonRate ::EmProperty ... radiative rate A_r(m --> f) of this line.
+ photonAmplitudes ::Array{MultipoleAmplitude,1} ... one entry per multipole.JenaAtomicCalculator.DielectronicRecombination.ResonanceSelection — Type
struct DielectronicRecombination.ResonanceSelection ... defines a type for selecting classes of resonances in terms of leading configurations.
+ active ::Bool ... initial-(state) level
+ fromShells ::Array{Shell,1} ... List of shells from which excitations are to be considered.
+ toShells ::Array{Shell,1} ... List of shells to which (core-shell) excitations are to be considered.
+ intoShells ::Array{Shell,1} ... List of shells into which electrons are initially placed (captured).JenaAtomicCalculator.DielectronicRecombination.ResonanceSelection — Method
DielectronicRecombination.ResonanceSelection() ... constructor for an 'empty' instance of a ResonanceSelection() A resonanceSelection::DielectronicRecombination.ResonanceSelection is returned.
JenaAtomicCalculator.DielectronicRecombination.ResonanceWindowCorrection — Type
struct DielectronicRecombination.ResonanceWindowCorrection <: DielectronicRecombination.AbstractCorrections ... to exclude all DR resonances outside of a given "window [Emin, Emax]" of resonance energies with regard to the initial level.
+ energyMin ::Float64 ... minimum energy [Hartree] of the resonances to be considered.
+ energyMax ::Float64 ... maximum energy [Hartree] of the resonances to be considered.JenaAtomicCalculator.DielectronicRecombination.RydbergTailCorrection — Type
struct DielectronicRecombination.RydbergTailCorrection <: DielectronicRecombination.AbstractCorrections ... to estimate the DR resonances of the shells n^(lowest-captured) < n <= nMax by extrapolating the Rydberg series that WAS computed explicitly, and – optionally – the orbital angular momenta that exist at those shells but were never computed. This matters because a Rydberg series does not stop where one runs out of computer time: while the resonances remain Auger dominated their strength per (n,l) is nearly independent of n, so the shells just above the explicit ones can carry a large part of alpha(T).
The extrapolation rests on ONE scaling assumption, A_a ~ n^(-3), which follows from the normalization of a
Rydberg orbital near the core and which this module VERIFIES against the user's own data whenever two
Rydberg shells were computed explicitly. Everything else is either exact (the Rydberg energy shift) or
computed rather than scaled (the radiative decay of the spectator, via HydrogenicCorrections).
+ nMax ::Int64
... highest principal quantum number included in the tail sum; shells above it are neglected completely.
Physically the series is cut by field ionization or by collisions in the plasma, so this is a property
of the experiment and not of the atom.
+ effectiveZ ::Union{Float64,Missing}
... effective charge seen by the Rydberg electron; derived as Z - n^(core) if missing.
+ lMax ::Union{Int64,Missing}
... highest l to extrapolate to at each shell. The l values present at n^(lowest-captured) are extrapolated
in n in any case; this field additionally extrapolates in l, up to lMax or until the contribution has
fallen below 1e-4 of the l = 0 term. Set to a value <= the largest computed l, or leave missing, to
suppress the l extrapolation entirely.
+ nExponent ::Union{Float64,Missing}
... exponent of the n-scaling of the capture and Auger rates; 3.0 if missing.
SETTLED 02-Sep-2026, AND THE DEFAULT 3.0 IS RIGHT. Measured on H-like C5+ (the system of
examples/example-Df.jl branches g and h) with each Rydberg shell computed in a basis OF ITS OWN, so that
no two shells can mix:
l = 1, the only l whose level content is the same at every shell (10 levels at n = 8, 9 and 10):
p(8->9) = 3.066 p(9->10) = 3.064 p(8->10) = 3.065
Three independent pairs agreeing to +-0.001. The residual 2 % above 3 is small, systematic and not fully
explained -- a quantum defect of the right sign accounts for at most 3.01 -- and it costs the tail sum
(n = 10..30 scaled from n0 = 9) only 2.7 %, which is far inside any other uncertainty a DR rate
coefficient carries. So `nExponent = 3.0` stands.
WHAT THE EARLIER LOW VALUES WERE. Branch h reported p = 1.27 for l = 1, and that number is an ARTIFACT OF
PUTTING n = 8 AND n = 9 IN ONE CI BASIS, not a property of the law. Measured both ways on the same system:
W(8, l=1) falls 8.137e-4 -> 7.296e-4 (-10.3 %) and W(9, l=1) rises 5.671e-4 -> 6.279e-4 (+10.7 %) when the
two shells share a basis, while their SUM is conserved to 1.7 % and 72 % of what n = 8 loses reappears at
n = 9. That is redistribution between the shells, and the ratio of two shells is exactly what the exponent
is formed from -- so a shared basis flattens it towards zero. See the warning in `measureRydbergExponent`.JenaAtomicCalculator.DielectronicRecombination.Settings — Type
struct DielectronicRecombination.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing dielectronic recombination pathways.
+ multipoles ::Array{EmMultipoles} ... Multipoles of the radiation field that are to be included.
+ gauges ::Array{UseGauge} ... Specifies the gauges to be included into the computations.
+ calcOnlyPassages ::Bool
... Only compute resonance strength but without making all the pathways explicit. This option is useful
for the capture into high-n shells or if the photons are not considered explicit. It also treats the
shells differently due to the given core shells < final-state shells < hydrogenically-scaled shells <
capture-shells < asymptotic-shells. Various correction and multi-threading techniques can be applied
to deal with or omit different classes of these shells.
+ calcRateAlpha ::Bool
... True, if the DR rate coefficients are to be calculated, and false o/w.
+ calcHyperfineResolved ::Bool
... True, if the DR resonance strength are calculated for hyperfine-resolved levels, and false o/w.
If true, it need to come together with calcOnlyPassages = true, and no fine-structure resolved rates
and strength are computed in this case.
+ hfDrivenCapture ::Bool
... True, if the capture is DRIVEN BY the hyperfine transition of the core itself, i.e. if the resonance
exists only because the core flips F' -> F and so supplies the energy E_res = E_HFS - E_b(nlj). It
requires calcHyperfineResolved = true, and it changes two things that the ordinary hyperfine-resolved
route does deliberately: the intermediate and final ions keep their FULL nuclear moments instead of
mu = Q = 0, since it is their hyperfine structure that lifts the intermediate above threshold; and the
electronic capture amplitude is COMPUTED at the hyperfine resonance energy rather than looked up from
the fine-structure route, which has no such line because the intermediate is electronically bound.
It is a DECLARED mode and not the default, because mu = Q = 0 is a good approximation for the ordinary
case and this mode is several times more expensive: one continuum orbital per hyperfine pair rather
than per electronic pair, the hyperfine energies being all different.
+ calcPhotonSpectrum ::Bool
... True, if the individual PhotonLine's (m --> f) are to be RETAINED and displayed, i.e. if the DR satellite
spectrum is wanted, and false o/w. Note that this flag controls RETENTION, not computation: the total
radiative width Gamma_r(m) = sum_f A_r(m,f) is needed for every resonance strength, so each m --> f rate
is evaluated in either case. Setting it false accumulates those rates into Gamma_r and discards them,
which saves memory (the point for large Rydberg manifolds) but essentially no computing time.
Only used by the fine-structure resolved route.
+ printBefore ::Bool
... True, if all energies and pathways are printed before their evaluation.
+ pathwaySelection ::PathwaySelection ... Specifies the selected levels/pathways, if any.
+ electronEnergyShift ::Float64
... An overall energy shift for all electron energies (i.e. from the initial to the resonance levels [Hartree].
+ photonEnergyShift ::Float64
... An overall energy shift for all photon energies (i.e. from the resonance to the final levels.
+ mimimumPhotonEnergy ::Float64
... minimum transition energy for which photon transitions are included into the evaluation.
+ temperatures ::Array{Float64,1}
... list of temperatures for which plasma rate coefficients are displayed; however, these rate coefficients
only include the contributions from those pathways that are calculated here explicitly.
+ mergedBeamKT ::Tuple{Float64,Float64}
... (kT_perp, kT_par) [Hartree] of the FLATTENED Maxwellian of a merged-beam (storage-ring) experiment.
This is a different average from `temperatures`, which is the isotropic plasma one: an electron cooler
leaves the longitudinal spread far smaller than the transverse, and the observed line shape follows
from that anisotropy. (0., 0.) means no merged-beam rate coefficient is wanted.
+ mergedBeamEnergies ::Array{Float64,1}
... detuning energies E_d [Hartree] at which the merged-beam rate coefficient is reported, i.e. the mesh
the experiment scans. Empty means none is wanted.
+ corrections ::Array{DielectronicRecombination.AbstractCorrections,1}
... Specify, if appropriate, the inclusion of additional corrections to the rates and DR strengths.
+ augerOperator ::AbstractEeInteraction
... Auger operator that is to be used for evaluating the Auger amplitude's; the allowed values are:
CoulombInteraction(), BreitInteration(), CoulombBreit(), CoulombGaunt().
+ continuumExchange ::Union{Nothing,Bool}
... True/false to force exchange between the captured electron and the bound electrons on or off; `nothing` --
the default -- lets `Basics.perform` decide automatically from the INITIAL-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99): the captured electron approaches the initial ion, as in
`PhotoRecombination` and `ElectronCapture`.JenaAtomicCalculator.DielectronicRecombination.Settings — Method
DielectronicRecombination.Settings(set::DielectronicRecombination.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, calcOnlyPassages::Union{Nothing,Bool}=nothing, calcRateAlpha::Union{Nothing,Bool}=nothing, calcHyperfineResolved::Union{Nothing,Bool}=nothing, hfDrivenCapture::Union{Nothing,Bool}=nothing, calcPhotonSpectrum::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, pathwaySelection::Union{Nothing,PathwaySelection}=nothing, electronEnergyShift::Union{Nothing,Float64}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing, mimimumPhotonEnergy::Union{Nothing,Float64}=nothing, temperatures::Union{Nothing,Array{Float64,1}}=nothing, mergedBeamKT::Union{Nothing,Tuple{Float64,Float64}}=nothing, mergedBeamEnergies::Union{Nothing,Array{Float64,1}}=nothing, corrections::Union{Nothing,Array{AbstractCorrections,1}}=nothing, augerOperator::Union{Nothing,AbstractEeInteraction}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... constructor for modifying the given DielectronicRecombination.Settings by 'overwriting' the previously selected parameters.
A `settings:: (set::DielectronicRecombination.Settings` is returned.JenaAtomicCalculator.DielectronicRecombination.Settings — Method
DielectronicRecombination.Settings() ... constructor for the default values of dielectronic recombination pathway computations. A settings::DielectronicRecombination.Settings is returned.
JenaAtomicCalculator.DielectronicRecombination.applyResonanceWindow — Method
DielectronicRecombination.applyResonanceWindow(captureLines::Array{DielectronicRecombination.CaptureLine,1}, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to keep only those capture lines whose electron energy falls inside [energyMin, energyMax], for instance the range actually scanned in an EBIT or storage-ring measurement. A tuple (lines, report::String) is returned. The number of lines dropped is always reported: a silently shortened list looks exactly like a calculation that found fewer resonances.
JenaAtomicCalculator.DielectronicRecombination.buildTailLine — Method
DielectronicRecombination.buildTailLine(refLine::DielectronicRecombination.CaptureLine, electronEnergy::Float64, captureRate::Float64, gammaA::Float64, gammaR::EmProperty) ... to assemble one extrapolated CaptureLine with its resonance strength already formed. The strength uses exactly the expression of setTotalRates – written out here rather than shared, because these lines deliberately do NOT pass through that aggregation: they carry the level identity of their reference line, so an index-keyed sum would fold the whole extrapolated series back onto the reference level. That is precisely the defect that made the previous implementation of this idea inflate Gamma_a for every member of the series.
JenaAtomicCalculator.DielectronicRecombination.checkConsistentMultiplets — Method
DielectronicRecombination.checkConsistentMultiplets(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet) ... to check that the given initial-, intermediate- and final-state levels and multiplets are consistent to each other and to avoid later problems with the computations. An error message is issued if an inconsistency occurs, and nothing is returned otherwise.
JenaAtomicCalculator.DielectronicRecombination.checkOrbitalRepresentation — Method
DielectronicRecombination.checkOrbitalRepresentation(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet) ... to check (and analyze) that all high nl orbitals in these multiplets are properly represented on the given grid. The function prints for each symmetry block kappa the high-nl orbitals and checks that they are all bound. An error message is issued if this is not the case, and nothing is returned otherwise.
JenaAtomicCalculator.DielectronicRecombination.computeCaptureAmplitudes — Method
DielectronicRecombination.computeCaptureAmplitudes(captureLine::DielectronicRecombination.CaptureLine, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::DielectronicRecombination.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... computes the Auger amplitudes of the capture step on its partial waves; a CaptureLine with the amplitudes and the capture rate filled is returned. The two total widths and the resonance strength remain zero here.
JenaAtomicCalculator.DielectronicRecombination.computeCaptureLines — Method
DielectronicRecombination.computeCaptureLines(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::DielectronicRecombination.Settings; output::Bool=true) ... to compute dielectronic recombination in the re-structured, fine-structure resolved representation. This is the driver of this file and the analogue of computePathways of the old route. A tuple (captureLines, photonLines) is returned if output = true, and nothing otherwise; photonLines is empty unless settings.calcPhotonSpectrum.
JenaAtomicCalculator.DielectronicRecombination.computeHfCaptureAmplitudes — Method
DielectronicRecombination.computeHfCaptureAmplitudes(hfLine::DielectronicRecombination.HfCaptureLine, eCaptureLines::Dict{Tuple{Int64,Int64},DielectronicRecombination.CaptureLine}, spinI::AngularJ64) ... to obtain the capture rate of one hyperfine capture line by RECOUPLING the electronic capture amplitudes that the fine-structure route has already computed. A new HfCaptureLine is returned.
For each partial wave kappa separately -- different kappa are distinct, incoherent channels -- the
components of the two hyperfine levels are summed COHERENTLY:
A(kappa) = sum_{p,q} mc_i[p] mc_m[q] * <((I J_i^p) F_i, j_e) F_m | (I,(J_i^p j_e) J_m^q) F_m>
* A_electronic(i^p, kappa --> m^q)
captureRate = 2 pi * sum_kappa |A(kappa)|^2
The 2 pi and the sum over kappa are exactly as in the fine-structure computeCaptureAmplitudes, so that the
two routes coincide term by term when I = 0.JenaAtomicCalculator.DielectronicRecombination.computeHfCaptureLines — Method
DielectronicRecombination.computeHfCaptureLines(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::DielectronicRecombination.Settings; output::Bool=true) ... to compute hyperfine-resolved dielectronic recombination. The driver of this file and the analogue of computeCaptureLines. A tuple (hfCaptureLines, hfPhotonLines) is returned if output = true.
The three ELECTRONIC multiplets are passed in exactly as for the fine-structure route; the hyperfine
multiplets are built here. The initial ion keeps the full nuclear moments of nm, whereas the intermediate
and final ions are given mu = Q = 0, so that their hyperfine Hamiltonian vanishes and their levels come
out as pure |(I J) F> degenerate with their electronic parents. Their F is retained because it carries the
angular factors, and summed over on display.JenaAtomicCalculator.DielectronicRecombination.computeHfDrivenCaptureAmplitudes — Method
DielectronicRecombination.computeHfDrivenCaptureAmplitudes(hfLine::DielectronicRecombination.HfCaptureLine, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::DielectronicRecombination.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... obtains the capture rate of one hyperfine capture line whose resonance exists ONLY because the core flips F' -> F, by COMPUTING the electronic capture amplitudes at the hyperfine resonance energy and recoupling them. A new HfCaptureLine is returned.
WHY THIS CANNOT LOOK THE AMPLITUDES UP, which is what `computeHfCaptureAmplitudes` does. That function
takes the electronic capture amplitude from the fine-structure route, and for a hyperfine-driven resonance
the fine-structure route HAS NO SUCH LINE: the intermediate 1s(F) nl is electronically BOUND with respect
to 1s + e, so `determineCaptureLines` computes a negative electron energy and skips the pair. Measured on
H-like Bi: a core-excited 2p 3s intermediate sits +66 156 eV above the initial state and yields a line,
while the core-unchanged 1s 3s sits -11 337 eV and yields none. The only thing that lifts the intermediate
above threshold is E_HFS = 5.167 eV, and the lookup route cannot supply it, so the rate came out ZERO --
silently, which was half the defect.
WHERE THE ENERGY COMES FROM. The resonance condition is read off the HYPERFINE levels rather than the
electronic ones, E_res = E(m; F_m) - E(i; F_i), which for a core hyperfine transition is
E_HFS - E_b(nlj): positive, and so a real resonance, only for n high enough that the Rydberg electron is
bound by less than the hyperfine splitting. `determineHfCaptureLines` already forms exactly this
difference and already discards the closed pairs, so nothing here re-derives it -- but it is only correct
once the intermediate carries its FULL nuclear moments, which is what `hfDrivenCapture` arranges.
THE OPERATOR IS PURELY ELECTRONIC AND NO NEW ONE IS INTRODUCED. The capture is driven by the
electron-electron interaction as always, and the nucleus enters only through the recoupling coefficient,
the same `hfCaptureRecoupling` the ordinary route uses, verified unitary over 515 combinations. Two
things differ from the ordinary route: the ENERGY at which the electronic amplitude is evaluated, each
hyperfine pair needing its own; and the amplitude itself, which must EXCLUDE the spectator-direct terms
because the core is electronically unchanged and their interaction is already in the mean field --
`hfDrivenAugerAmplitude` does that, and its docstring carries the measurement that forced it.
A(kappa) = sum_{p,q} mc_i[p] mc_m[q] * <((I J_i^p) F_i, j_e) F_m | (I,(J_i^p j_e) J_m^q) F_m>
* A_electronic(i^p, kappa --> m^q; E_res)
captureRate = 2 pi * sum_kappa |A(kappa)|^2
identical in form to the lookup route, with the electronic amplitude supplied by
`hfDrivenAugerAmplitude` rather than taken from the fine-structure route.
THE COST IS ONE CONTINUUM ORBITAL PER HYPERFINE PAIR, not per electronic pair, because every hyperfine
pair has its own E_res. That is why this is a declared mode rather than a generalization of the default.JenaAtomicCalculator.DielectronicRecombination.computeHfPhotonAmplitudes — Method
DielectronicRecombination.computeHfPhotonAmplitudes(hfLine::DielectronicRecombination.HfPhotonLine, ePhotonLines::Dict{Tuple{Int64,Int64},DielectronicRecombination.PhotonLine}, spinI::AngularJ64) ... to obtain the radiative rate of one hyperfine photon line by recoupling the electronic photon amplitudes already computed by the fine-structure route. A new HfPhotonLine is returned.
Each (multipole, gauge) is an incoherent channel; within one, the components of the two hyperfine levels
are summed coherently with the rank-L recoupling factor. The Einstein prefactor is that of the
fine-structure route with (2J_m+1) replaced by (2F_m+1), the statistical weight of the EMITTING level:
Gamma_r contribution = 8 pi alpha omega / (2F_m + 1) * |A|^2
Together with the identity sum_{F_f} |recoupling|^2 = (2F_m+1)/(2J_m+1) this gives Gamma_r(F_m) =
Gamma_r(J_m), i.e. hyperfine coupling leaves the radiative width of a level untouched -- which is the
first thing to check if this route is ever in doubt.JenaAtomicCalculator.DielectronicRecombination.computeHydrogenicPhotonRate — Method
DielectronicRecombination.computeHydrogenicPhotonRate(intermediateLevel::Level, electronEnergy::Float64, empTreatment::EmpiricalTreatment) ... to estimate the radiative rate by which the captured Rydberg electron itself stabilizes the resonance, i.e. the sum of the hydrogenic rates A(nR, lR –> nf, lR +- 1) over all n^(final) < nf <= n^(hydrogenic). These are decay channels into shells that are NOT represented explicitly in the final multiplet, so the explicitly computed Gammar(m) = sumf Ar(m –> f) misses them entirely and is too small.
This is a genuine physical decay channel, not a fudge: for high-n capture the spectator electron carries
almost no binding, its decay is hydrogenic to good accuracy, and it stabilizes the ion below the
autoionization threshold exactly as a core transition does. What IS adjustable is how well it is modeled --
effectiveZ and rateScaling are sensitivity knobs, and a computation that leans hard on them is telling you
that n^(final) was chosen too small, not that the physics is uncertain.
RE-AUTOIONIZATION CUTOFF. Not every such decay actually completes the recombination.
The strength formula S = C * Gamma_r/(Gamma_a+Gamma_r) treats each radiative decay as TERMINATING the
process, which is true only if the state one lands in lies below the autoionization threshold. The core
stays excited during a spectator decay, so after n_R --> n_f the ion sits at
E(landing) - E(threshold) = E_electron + B(n_R) - B(n_f), B(n) = Zeff^2 / (2n^2),
with E_electron the capture energy of this resonance. Where that is still positive the ion can Auger
straight back to the initial level: the photon was emitted and the electron then left again, so counting
the rate in Gamma_r overestimates the DR yield. The sum is therefore cut at the largest n_f satisfying
B(n_f) > E_electron + B(n_R), i.e.
n_f <= n^(bound) = floor( 1 / sqrt( 2*E_electron/Zeff^2 + 1/n_R^2 ) ).
Two properties worth knowing. First, this is automatically consistent with the capture step: for the
resonance group whose core excitation is what makes n_R the LOWEST capturable shell, E_electron is small
and n^(bound) comes out as n_R - 1, so nothing is removed. Only groups built on a larger core excitation
-- a 2p_3/2 rather than a 2p_1/2 hole, say -- are cut back, which is exactly right, since those sit far
above threshold and the spectator must fall much further to get underneath it. Second, the cut makes the
result a LOWER bound rather than the truth: a landing state above threshold may still radiate a second
time -- the core decaying, or the spectator falling further -- and stabilize then. Resolving that needs a
radiative cascade with branching at every step; the uncut sum is the upper bound and this one the lower,
and both are reported so the bracket is visible.
A tuple (rate::Float64 [a.u.], nRydberg::Int64, lRydberg::Int64, nBound::Int64, dropped::Float64 [a.u.])
is returned, where `dropped` is the rate removed by the cutoff; all entries are zero if no hydrogenic
corrections were requested.
THE SUMMATION RANGE. computeHydrogenicRate returns exactly 0.0 unless nf < n_R, so the sum runs DOWNWARD
from the captured Rydberg shell, nf = nFinal+1 : min(nHydrogenic, n_R - 1). Two mistakes are easy here and
either one makes the whole correction identically zero:
(1) running nf = nFinal+1 : nHydrogenic, i.e. UPWARD from the explicit final shells;
(2) taking nFinal as the largest n in the final basis, which always contains the captured Rydberg shell
itself, so that nFinal = n^(lowest-captured) and the range starts above n_R even in principle.
The evidence that (1) is a slip and not a convention: the comment sitting directly above that loop reads
"Compute and add hydrogenic rates A(ni,li --> nDetailed < n <= ni-1, li +- 1)", i.e. it describes the
bound ni-1 that the code does not use; and the second, disabled copy of the same block in computeResonances
-- the one carrying the note "This code need to be adapted" -- does loop nf = nDetailed+1 : ni-1.
So the correct range was written down twice and executed never.
With both repaired, the range is n^(final) < n_f <= min(n^(hydrogenic), n_R - 1) and reads as the
documented hierarchy intends: the shells below the Rydberg electron that are NOT represented explicitly.JenaAtomicCalculator.DielectronicRecombination.computeHydrogenicRate — Method
DielectronicRecombination.computeHydrogenicRate(ni::Int64, li::Int64, nf::Int64, lf::Int64, Zeff::Float64) ... to compute the non-relativistic electric-dipole rate for the transition from shell ni,li –> nf,lf of a hydrogenic ion with effective charge Zeff. The recursion formulas by Infeld and Hull (1951) are used together with the absorption oscillator strength. This makes the overall formulation/computation rather obscure, unfortunately. Uses SpecialFunctions.logfactorial. A rate::Float64 [a.u.] is returned. This procedure has been worked out by Stefan Schippers (2023).
Moved here unchanged from module-DielectronicRecombination-inc-FS-resolved.jl when that route was retired
(05-Aug-2026); the numerics are deliberately untouched.JenaAtomicCalculator.DielectronicRecombination.computeLTailLines — Method
DielectronicRecombination.computeLTailLines(byL::Dict{Int64,Array{DielectronicRecombination.CaptureLine,1}}, lComputed::Array{Int64,1}, empTreatment::DielectronicRecombination.EmpiricalTreatment, pUsed::Float64) ... to estimate the contribution of the orbital angular momenta that EXIST at the Rydberg shells but were never computed at the reference shell. A tuple (lines::Array{CaptureLine,1}, shells::Array{Int64,1}, report::String) is returned.
At shell n the orbital angular momentum runs to n-1, whereas the explicit calculation carries only the few l
the user could afford. Those missing l are not negligible in general: the capture rate falls with l, but the
number of states rises as (2l+1), and the two only cancel once the centrifugal barrier bites.
This is the most assumption-laden part of the correction and it is fenced accordingly. The weighted capture
strength W(l) = sum_m A_a(m) (2J_m+1) is fitted by ln W = a + b l over the computed l, and the fit is used only
if it DECAYS and rests on at least three points; otherwise no l extrapolation happens and the report says so.
The extrapolation stops at lMax, at n-1, or once a term has fallen below 1e-4 of the l = 0 term.JenaAtomicCalculator.DielectronicRecombination.computeMergedBeamRateCoefficient — Method
DielectronicRecombination.computeMergedBeamRateCoefficient(captureLine::DielectronicRecombination.CaptureLine, Ed::Float64, kTperp::Float64, kTpar::Float64; nTheta::Int64=4001) ... to compute the merged-beam rate coefficient alpha(Ed) [cm^3/s] of a SINGLE resonance, i.e. the average of v*sigma over the FLATTENED (anisotropic) Maxwellian of an electron cooler with transverse kTperp and longitudinal kTpar, at detuning energy Ed. An alpha::EmProperty is returned.
THIS IS A DIFFERENT AVERAGE FROM `computeRateCoefficient`, which is the isotropic PLASMA one, and a
storage-ring measurement needs this one: the cooler leaves kT_par orders of magnitude below kT_perp, so
the observed line shape and its peak position follow from the anisotropy and not from the natural width.
THE RESONANCE IS TAKEN IN THE DELTA-FUNCTION LIMIT, sigma(E) = S delta(E - E_res), which is what a
resonance strength is. That is safe exactly while the natural width is small against the beam: on the
209Bi(82+) resonances it was measured at Gamma ~ 0.01 meV against kT of 0.02-5 meV, a factor of a few
thousand. Where a width approaches kT this function is the wrong tool and the profile must be folded.
With that limit the three-dimensional average collapses to ONE angular integral, written out here rather
than taken from a closed form so that the geometry stays visible:
alpha(E_d) = sqrt(2/pi) S E_r / (kT_perp sqrt(kT_par))
INT_0^pi dtheta sin(theta) exp[ -E_r sin^2(theta)/kT_perp
-(sqrt(E_r) cos(theta) - sqrt(E_d))^2/kT_par ]
where theta is between the electron velocity and the beam axis. **It is integrated in u = cos(theta),
not in theta**, which is worth a sentence because it is what makes the result accurate: the substitution
absorbs the sin(theta) weight exactly, leaving INT_(-1)^(+1) du of a smooth exponential, and in the
isotropic limit below that integrand is CONSTANT so the trapezoidal rule is then exact rather than merely
convergent. Integrating in theta instead leaves the sin(theta) factor to be sampled, and its trapezoidal
error h^2/6 shows up as a floor -- measured at 5.1e-08 with 4001 points, which is where this started.
ITS OWN CHECK IS INTERNAL AND EXACT: set kT_perp = kT_par = kT and E_d = 0 and the exponent becomes
-E_r/kT independent of angle, so the integral is 2 exp(-E_r/kT) and alpha reduces to
4/sqrt(2pi) kT^(-3/2) E_r exp(-E_r/kT) S -- which is `computeRateCoefficient` term by term. Any change
here that breaks that identity is wrong.JenaAtomicCalculator.DielectronicRecombination.computePhotonAmplitudes — Method
DielectronicRecombination.computePhotonAmplitudes(photonLine::DielectronicRecombination.PhotonLine, grid::Radial.Grid) ... computes the multipole amplitudes of the stabilization step m –> f + hv; a PhotonLine with the amplitudes and the radiative rate filled is returned.
THIS IS WHERE EmPropertyC EARNS ITS PLACE. A three-way accumulation over the gauges --
if gauge == Coulomb rateC += ...; elseif Babushkin rateB += ...; elseif Magnetic BOTH
-- reduces to a single line, because abs2 of an EmPropertyC is an EmProperty and a magnetic amplitude has
equal components and so enters both gauges by itself.
The Einstein-A prefactor is 8pi * alpha * omega / (2J_m + 1), with NO (2J_f+1) and NO 1/pi.JenaAtomicCalculator.DielectronicRecombination.computeRateCoefficient — Method
DielectronicRecombination.computeRateCoefficient(captureLine::DielectronicRecombination.CaptureLine, temp::Float64) ... to compute the DR plasma rate coefficient alpha^DR (T) of the given capture line for the temperature temp [K], in the isolated-resonance (delta-like) approximation. An alphaDR::EmProperty is returned in cm^3/s.
JenaAtomicCalculator.DielectronicRecombination.computeRydbergTailLines — Method
DielectronicRecombination.computeRydbergTailLines(captureLines::Array{DielectronicRecombination.CaptureLine,1}, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to estimate the DR capture lines of the Rydberg shells n^(lowest-captured) < n <= nMax that are too numerous to be computed explicitly, by extrapolating the series that WAS computed. A tuple (tailLines::Array{CaptureLine,1}, tailShells::Array{Int64,1}, report::String) is returned, where tailShells[k] is the principal quantum number of tailLines[k] – a CaptureLine does not carry it, and recovering it afterwards from the energy would be guesswork; the lines are fully formed – their two total widths and their resonance strength are set here – so that they never pass through setTotalRates and cannot contaminate the aggregation of the explicit levels, which is exactly how the previous implementation of this idea went wrong.
For each shell n and each computed l, with n0 = n^(lowest-captured) and B(n) = Zeff^2/(2n^2):
E_e(n) = E_e(n0) + B(n0) - B(n) exact Rydberg shift, no ansatz
A_a(n) = A_a(n0) * (n0/n)^p p measured where possible, else 3
Gamma_a(n) = Gamma_a(n0) * (n0/n)^p
Gamma_r(n) = Gamma_r,core(n0) + hydrogenic spectator(n,l) core part n-INDEPENDENT, spectator computed
S(n) = pi^2/k^2 * A_a * (2J_m+1)/(2J_i+1) * Gamma_r/(Gamma_a+Gamma_r)
Holding the core radiative rate fixed while scaling the Auger rate is the physical content: the stabilizing
core transition does not know where the spectator sits, whereas the capture amplitude samples the Rydberg
wavefunction at the core and therefore carries the n^(-3). This is also what makes the tail matter -- the
branching ratio Gamma_r/(Gamma_a+Gamma_r) creeps towards 1 as n grows, so the strength per shell falls much
more slowly than the capture rate until the two widths cross.JenaAtomicCalculator.DielectronicRecombination.determineCaptureChannels — Method
DielectronicRecombination.determineCaptureChannels(intermediateLevel::Level, initialLevel::Level, settings::DielectronicRecombination.Settings) ... determines the partial waves of the electron captured in the step i + e^- –> m; an Array{AutoIonization.PartialWave,1} is returned with all amplitudes still zero.
Note that this is NOT AutoIonization.determineChannels: that one applies settings.maxKappa from an
AutoIonization.Settings, which a DielectronicRecombination.Settings does not carry, and the flat
determineCaptureChannels applies no kappa restriction at all. The selection rule itself --
allowedKappaSymmetries(symi, symn) -- is the same, and is reproduced here unrestricted, exactly as the
flat version has it.JenaAtomicCalculator.DielectronicRecombination.determineCaptureLines — Method
DielectronicRecombination.determineCaptureLines(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, settings::DielectronicRecombination.Settings) DielectronicRecombination.determinePhotonLines(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, settings::DielectronicRecombination.Settings) ... to determine the capture and photon lines for which amplitudes are subsequently computed; the selection, the energy shifts and the "keep the pair if SOME third level makes the triple selected" rule are reproduced exactly.
JenaAtomicCalculator.DielectronicRecombination.determineEmpiricalTreatment — Method
DielectronicRecombination.determineEmpiricalTreatment(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, nm::Nuclear.Model, initialMultiplet::Multiplet, settings::DielectronicRecombination.Settings) ... to determine an instance of empiricalTreatment::EmpiricalTreatment that is (internally) applied to simplify the use of "corrections" to the DR strengths. This data structure summarizes all parameters that help introduce several empirical corrections. The procedure is simple but slightly sophisticated as we wish to support "missing" parameters in the individual corrections as well as the knowledge that can be derived internally. The definition of EmpiricalTreatment() can readily be extended as the need arises from the user side.
A missing maximum_l resolves to 1000, i.e. no limit, so that MaximumlCorrection(missing) means what a user
writing it intends; resolving it to 1 would silently suppress every Rydberg shell with l > 1.JenaAtomicCalculator.DielectronicRecombination.determineHfCaptureLines — Method
DielectronicRecombination.determineHfCaptureLines(intermediateHfMultiplet::Hfs.HfMultiplet, initialHfMultiplet::Hfs.HfMultiplet, settings::DielectronicRecombination.Settings) ... to determine the skeletons of all hyperfine capture lines (i,m) that are energetically allowed, i.e. for which the captured electron has a positive energy. An Array{HfCaptureLine,1} is returned. The pendant of DielectronicRecombination.determineCaptureLines.
JenaAtomicCalculator.DielectronicRecombination.determineHfPhotonLines — Method
DielectronicRecombination.determineHfPhotonLines(finalHfMultiplet::Hfs.HfMultiplet, intermediateHfMultiplet::Hfs.HfMultiplet, settings::DielectronicRecombination.Settings) ... to determine the skeletons of all hyperfine radiative stabilization lines (m,f) with a positive photon energy. An Array{HfPhotonLine,1} is returned. The pendant of determinePhotonLines.
JenaAtomicCalculator.DielectronicRecombination.determinePhotonChannels — Method
DielectronicRecombination.determinePhotonChannels(finalLevel::Level, intermediateLevel::Level, settings::DielectronicRecombination.Settings) ... determines the multipole components of the stabilization step m –> f + hv; an Array{MultipoleAmplitude,1} is returned with all amplitudes still zero.
THIS IS A CALL, NOT A COPY. The selection rule is asked of the module that owns it, so that neither the
gauge loop nor the hasMagnetic flag is repeated here. A wrapper exists at all only because
PhotoEmission.determineChannels expects a PhotoEmission.Settings, so the multipoles have to be handed over.JenaAtomicCalculator.DielectronicRecombination.determinePhotonLines — Method
DielectronicRecombination.determinePhotonLines(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, settings::DielectronicRecombination.Settings) ... determines the radiative-stabilisation lines of a fine-structure-resolved DR computation: every transition from an intermediate (doubly-excited) level down to a final level, with its photon energy shifted by settings.photonEnergyShift. A photonLines::Array{DielectronicRecombination.PhotonLine,1} is returned.
JenaAtomicCalculator.DielectronicRecombination.displayCaptureLines — Method
DielectronicRecombination.displayCaptureLines(stream::IO, captureLines::Array{DielectronicRecombination.CaptureLine,1}) ... to display a list of capture lines and channels that have been selected due to the prior settings. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.DielectronicRecombination.displayHfResults — Function
DielectronicRecombination.displayHfResults(stream::IO, hfCaptureLines::Array{DielectronicRecombination.HfCaptureLine,1}, eCaptureLines::Array{DielectronicRecombination.CaptureLine,1}, nm::Nuclear.Model, hfDriven::Bool=false) ... to list the hyperfine-resolved DR resonance strengths, resolved in Fi and SUMMED over Fm. Nothing is returned.
Why summed over F_m (and, inside Gamma_r, over F_f): the intermediate and final levels were given
mu = Q = 0, so their hyperfine sublevels are exactly degenerate and their F is a bookkeeping label with
no observable consequence. Displaying it would suggest a structure that has been set to zero and would
bury the one splitting that IS observable, that of the initial ion.
THE SUM RULE is evaluated and printed here rather than left to a separate script, because it is the only
check that this route is right and it costs nothing once the numbers are in hand. With every hyperfine
level degenerate with its electronic parent,
sum_{F_i} (2F_i+1)/((2I+1)(2J_i+1)) * sum_{F_m} S(F_i --> F_m) == sum_m S(J_i --> J_m)
i.e. the statistically averaged hyperfine strength must reproduce the fine-structure one EXACTLY -- it is
an identity among recoupling coefficients, not an approximation. A deviation localises immediately to a
wrong phase, a missing sqrt(2F+1) or a mis-ordered 6-j.JenaAtomicCalculator.DielectronicRecombination.displayHydrogenicCorrections — Method
DielectronicRecombination.displayHydrogenicCorrections(stream::IO, seen::Array{Tuple{Int64,Int64,Int64,Float64,Float64,Int64,Float64},1}, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to list, for every intermediate level m, the hydrogenic rate that has been ADDED to the explicitly computed Gamma_r(m) in order to account for the radiative stabilization of the captured Rydberg spectator itself. A neat table is printed but nothing is returned otherwise.
Two columns carry the message. `fraction` is how much of the corrected width the correction itself supplies:
a few per cent means the explicit final-state set does most of the work and the estimate merely tidies up
the tail, whereas anything approaching unity means the answer is being carried by a hydrogenic model with an
adjustable Z_eff, and n^(final) should be raised instead of trusting it. `dropped` is the rate removed by
the re-autoionization cutoff at n^(bound), i.e. spectator decays that emit a photon but leave the ion still
above threshold; adding it back gives the upper bound of the bracket described on computeHydrogenicPhotonRate.JenaAtomicCalculator.DielectronicRecombination.displayMergedBeamRateCoefficients — Method
DielectronicRecombination.displayMergedBeamRateCoefficients(stream::IO, captureLines::Array{DielectronicRecombination.CaptureLine,1}, settings::DielectronicRecombination.Settings) ... to list the merged-beam rate coefficient alpha(E_d) [cm^3/s] over the requested detuning mesh, i.e. what a storage-ring experiment with this electron cooler would measure; nothing is returned.
NOTHING IS PRINTED UNLESS BOTH `mergedBeamKT` AND `mergedBeamEnergies` ARE SET, and this average is
INDEPENDENT of `calcRateAlpha`: a run may ask for the plasma rate coefficient, for this one, for both or
for neither. They answer different questions -- an isotropic Maxwellian against a flattened one -- and
nothing is gained by making the user choose between them at the start of a computation.JenaAtomicCalculator.DielectronicRecombination.displayPhotonLines — Method
DielectronicRecombination.displayPhotonLines(stream::IO, photonLines::Array{DielectronicRecombination.PhotonLine,1}) ... to display a list of photon lines and channels that have been selected due to the prior settings. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.DielectronicRecombination.displayRateCoefficients — Function
DielectronicRecombination.displayRateCoefficients(stream::IO, captureLines::Array{DielectronicRecombination.CaptureLine,1}, settings::DielectronicRecombination.Settings, tailLines::Array{DielectronicRecombination.CaptureLine,1}=DielectronicRecombination.CaptureLine[]) ... to list, if settings.calcRateAlpha, the DR plasma rate coefficients for the selected temperatures. Both the individual and the total rate coefficients are printed; nothing is returned otherwise.
When a Rydberg tail was extrapolated, alpha(T) is reported SPLIT into the explicitly computed part and the
extrapolated one. That split is the number which says whether any of the extrapolation mattered: a tail
contributing a per cent or two can be quoted with the total, whereas one contributing half of alpha(T) means
the result is being carried by a scaling law and the explicit calculation needs more shells. The split is also
strongly temperature dependent -- the tail sits at higher electron energies than the explicit resonances only
marginally, but it multiplies the level density -- so a single number would hide the effect.JenaAtomicCalculator.DielectronicRecombination.displayResults — Method
DielectronicRecombination.displayResults(stream::IO, captureLines::Array{DielectronicRecombination.CaptureLine,1}, photonLines::Array{DielectronicRecombination.PhotonLine,1}, settings::DielectronicRecombination.Settings) ... to list the total Auger and radiative rates and the resonance strengths of all capture lines and, if settings.calcPhotonSpectrum, the individual DR satellite lines that follow by combining the two line types. Neat tables are printed but nothing is returned otherwise.
The first table is deliberately identical in layout and column content to displayResults(stream, resonances,
settings) of the old route, so that the two implementations can be compared line by line.JenaAtomicCalculator.DielectronicRecombination.displayRydbergTail — Method
DielectronicRecombination.displayRydbergTail(stream::IO, tailLines::Array{DielectronicRecombination.CaptureLine,1}, tailShells::Array{Int64,1}, report::String, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to summarize the extrapolated Rydberg tail: how it was built, what each shell contributes, where the two total widths cross, and whether the sum has converged by nMax. Nothing is returned.
The shell-by-shell table is the one to read, and the last two columns say whether to believe the total.
If the LAST shell still carries a noticeable share, nMax was set too low and the sum is still climbing.
The Gamma_a/Gamma_r column says which regime each shell is in: while it is >> 1 the resonance is Auger
dominated and its strength is nearly independent of n, so truncating there discards a lot; once it falls
below 1 the strength has begun its n^(-3) descent and the remaining tail is genuinely small.JenaAtomicCalculator.DielectronicRecombination.electronicComponents — Method
DielectronicRecombination.electronicComponents(hfLevel::Hfs.HfLevel) ... to return the list of (mc, electronic Level) pairs that make up the given hyperfine level, dropping the components whose weight is numerically zero. An Array{Tuple{Float64,Level},1} is returned.
With mu = Q = 0 -- the intermediate and final levels of this route -- every hyperfine level is a pure
|(I J) F> and this returns exactly one component with mc = 1.JenaAtomicCalculator.DielectronicRecombination.extractMergedBeamRateCoefficients — Method
DielectronicRecombination.extractMergedBeamRateCoefficients(captureLines::Array{DielectronicRecombination.CaptureLine,1}, settings::DielectronicRecombination.Settings) ... to sum the merged-beam rate coefficient of every capture line at each requested detuning energy; an alphas::Array{EmProperty,1} of the same length as settings.mergedBeamEnergies is returned, and an empty array if no merged-beam average was requested.
JenaAtomicCalculator.DielectronicRecombination.extractRateCoefficients — Method
DielectronicRecombination.extractRateCoefficients(captureLines::Array{DielectronicRecombination.CaptureLine,1}, settings::DielectronicRecombination.Settings) ... to extract the total DR plasma rate coefficients, summed over all capture lines, for each of the selected temperatures. An Array{EmProperty,1} of length length(settings.temperatures) is returned, and an empty array if settings.calcRateAlpha is false or no temperature is given.
JenaAtomicCalculator.DielectronicRecombination.fitLProfile — Method
DielectronicRecombination.fitLProfile(wByL::Dict{Int64,Float64}) ... to fit ln W(l) = a + b*l by least squares over the computed orbital angular momenta, so that the l values which EXIST at a Rydberg shell but were never computed can be estimated. Returns a tuple (a::Float64, b::Float64, maxResidual::Float64, ok::Bool).
`ok` is false -- and no l extrapolation must then be attempted -- when fewer than three l values are available
or when the fit does not DECAY (b >= 0). Both cases mean the data do not constrain a profile, and inventing one
would put an unbounded amount of strength into shells nobody has looked at. Refusing is the honest answer.
The exponential ansatz is the crude part of this whole correction and is labelled as such wherever it is used:
the capture rate falls with l because the centrifugal barrier keeps the electron away from the core, which is
not exactly an exponential in l. What makes it tolerable is that it is fitted to the user's own numbers, that
the residuals are reported, and that the SHARE of the total carried by the extrapolated l is reported too --
if that share is large, the answer is to compute more l, not to trust the fit.JenaAtomicCalculator.DielectronicRecombination.hfCaptureRecoupling — Method
DielectronicRecombination.hfCaptureRecoupling(spinI::AngularJ64, Ji::AngularJ64, Fi::AngularJ64, je::AngularJ64, Jm::AngularJ64, Fm::AngularJ64) ... to return the coefficient that connects the two ways of coupling nucleus, initial ion and free electron:
<((I J_i) F_i, j_e) F_m | (I, (J_i j_e) J_m) F_m>
= (-1)^(I+J_i+j_e+F_m) sqrt((2F_i+1)(2J_m+1)) {I J_i F_i; j_e F_m J_m}
A value::Float64 is returned. This is NOT an operator matrix element but a recoupling of three angular
momenta (Edmonds 6.1.5): the physical state has the free electron coupled to the hyperfine level F_i,
whereas the electronic capture amplitude is computed with it coupled to the electronic J_i to give J_m.
VERIFIED (work/diag-recoupling.jl, 05-Aug-2026) over 515 combinations: at FIXED F_m, the sum over J_m of
the squared coefficient is 1 to better than 1e-15, as it must be, since the two coupling schemes are
complete bases of the same space and the transformation between them is unitary. Note that summing over
F_m as well is NOT an identity -- that counts independent final states. For I = 0 the factor reduces to 1.JenaAtomicCalculator.DielectronicRecombination.hfDrivenAugerAmplitude — Method
DielectronicRecombination.hfDrivenAugerAmplitude(iLevel::Level, mLevel::Level, kappa::Int64, eEnergy::Float64, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::DielectronicRecombination.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... the electronic capture amplitude of one partial wave for a HYPERFINE-DRIVEN resonance, with the mean-field (spectator-direct) terms EXCLUDED; an amplitude::ComplexF64 is returned.
WHY THIS DIFFERS FROM `AutoIonization.amplitude`, AND IT IS THE WHOLE POINT OF THE MODE. In a
hyperfine-driven capture the core is electronically UNCHANGED -- the free electron drops into nl and the
energy goes into the core's F' -> F flip -- so the two-particle sum contains a term in which one electron
keeps its orbital. Measured on 1s + e(s) -> 1s 10s in H-like Bi, the four coefficients are
nu bra (a,b) ket (c,d) V R^nu V R^nu
0 (1s, eps s) (1s, 10s) +0.5 1.619259e-01 +8.096e-02 <- spectator direct
0 (1s, eps s) (10s, 1s ) -0.5 1.194135e-02 -5.971e-03 <- exchange
1 (1s, eps s) (1s, 10s) -0.167 0.0 0
1 (1s, eps s) (10s, 1s ) +0.167 0.0 0
and the first is 13.6 times the second. But R^0(1s, eps s; 1s, 10s) with the 1s unchanged is nothing but
the matrix element of the 1s MONOPOLE POTENTIAL between eps s and 10s -- and that potential is already in
the DFS mean field that generated both orbitals. The autoionization operator is V_ee - U, and this term
IS U. Keeping it double counts. For an ORDINARY Auger transition the core orbital changes, no such term
arises, and `AutoIonization.amplitude` is right as it stands; that path is untouched.
MEASURED, AND THE SCALING IS THE PROOF. A genuine two-electron Auger rate into a Rydberg state must fall
as 1/n^3, because that is how the Rydberg electron's density at the core falls. At eps = 0.2 eV:
n full (as AutoIonization) exchange only
20 2.661489e-02 5.420412e-05
28 1.528247e-02 p = 1.649 1.957580e-05 p = 3.027
40 8.479111e-03 p = 1.652 6.669699e-06 p = 3.019
60 4.320206e-03 p = 1.663 1.966046e-06 p = 3.013
1.66 against 3.02. The spurious term is not a small correction -- it is 99.95 % of the rate at n = 60 --
and only without it does the answer obey the law it must obey. This is also what the source literature
says: for a core that is electronically unchanged the direct Coulomb contribution drops out and the
exchange integral is the whole amplitude.
THE TEST IS ON THE COEFFICIENT, NOT ON THE ORBITAL NAMES: a term is excluded when one electron keeps its
orbital, `coeff.a == coeff.c` or `coeff.b == coeff.d`, which is exactly the statement that that electron
is a spectator and its interaction is already in the mean field.JenaAtomicCalculator.DielectronicRecombination.hfPhotonRecoupling — Method
DielectronicRecombination.hfPhotonRecoupling(spinI::AngularJ64, Ja::AngularJ64, Fa::AngularJ64, Jb::AngularJ64, Fb::AngularJ64, L::Int64) ... to return the factor that converts an ELECTRONIC reduced matrix element of rank L into the corresponding hyperfine one, for an operator that acts on the electrons alone:
<(I J_b) F_b || T^L || (I J_a) F_a>
= (-1)^(I+J_b+F_a+L) sqrt((2F_a+1)(2F_b+1)) {J_b F_b I; F_a J_a L} <J_b || T^L || J_a>
A value::Float64 is returned. Derived from the standard result for a tensor acting on one part of a
coupled system (Edmonds 7.1.7), with the nucleus as the untouched spectator.
VERIFIED (work/diag-recoupling.jl, 05-Aug-2026) over 454 combinations of I, J_a, J_b, F_a and L = 1, 2:
sum over F_b of the squared factor equals (2F_a+1)/(2J_a+1) to better than 1e-15. That identity is
exactly what leaves a radiative width unchanged by hyperfine coupling, since the rate carries a
compensating 1/(2F_a+1): Gamma_r(F_a) = Gamma_r(J_a). For I = 0 the factor reduces to 1.JenaAtomicCalculator.DielectronicRecombination.hydrogenicRateAt — Method
DielectronicRecombination.hydrogenicRateAt(n::Int64, l::Int64, electronEnergy::Float64, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to evaluate the hydrogenic spectator rate for a Rydberg electron at shell (n,l) directly from the quantum numbers, i.e. without needing a Level to read them off. Same summation range and same re-autoionization cutoff as computeHydrogenicPhotonRate; an EmProperty is returned, gauge-independent because the estimate is.
JenaAtomicCalculator.DielectronicRecombination.isResonanceToBeExcluded — Method
DielectronicRecombination.isResonanceToBeExcluded(level::Level, refLevel, rSelection::ResonanceSelection) returns true, if level is to be excluded from the valid resonances, and false otherwise. It returns false if the ResonanceSelection() is inactive or if level belongs to the selected resonances. It is true only of ResonanceSelection() is active but the level does not belong to the selected resonances.
JenaAtomicCalculator.DielectronicRecombination.measureRydbergExponent — Method
DielectronicRecombination.measureRydbergExponent(captureLines::Array{DielectronicRecombination.CaptureLine,1}, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to MEASURE the exponent of the n-scaling of the capture rates from the user's own data, whenever two or more Rydberg shells were computed explicitly. Returns a tuple (exponent::Float64, nShells::Int64, details::String); exponent is NaN when fewer than two shells are available, in which case nothing can be measured.
WHY THIS EXISTS. The whole Rydberg-tail extrapolation rests on a single assumption, A_a ~ n^(-p) with p = 3,
which follows from the normalization of a Rydberg orbital near the core -- the capture amplitude samples the
wavefunction where the core is, and |psi_nl(r->0)|^2 scales as n^(-3). That is textbook, but it is an
assumption about THIS calculation only until it has been checked against it, and a computation that includes
two Rydberg shells contains the check for free:
p = ln( W(n1,l) / W(n2,l) ) / ln( n2 / n1 ), W(n,l) = sum_m A_a(m) (2J_m+1) at shell n, momentum l
The weighted sum W rather than a single A_a, because the individual levels of a shell need not correspond
one-to-one between two shells, whereas the (2J+1)-weighted total over a given l does.
WHAT THIS CANNOT SEE, established 02-Sep-2026 and the reason the result is a DIAGNOSTIC and not a test of
the law. The exponent is only measurable when two Rydberg shells were computed explicitly -- and two shells
computed explicitly are two shells IN THE SAME CI BASIS, which is exactly the condition under which they
MIX. The mixing moves capture strength from the lower shell to the upper one, and the ratio W(n1)/W(n2) is
precisely what it corrupts. Measured on H-like C5+, n = 8 and 9, l = 1: computing each shell in a basis of
its own gives p = 3.066, and putting both in one basis gives p = 1.27, because W(8) falls 10.3 % and W(9)
rises 10.7 % while their sum is conserved to 1.7 %.
SO A LOW p HERE IS EVIDENCE OF MIXING, NOT OF A BROKEN SCALING LAW, and the law itself was confirmed at
p = 3.065 +- 0.001 over three separated pairs (see the RydbergTailCorrection docstring). The level-count
guard below is necessary but NOT sufficient: at n = 8 -> 9 the l = 1 channel had 10 levels on both sides,
passed the guard, and was the most corrupted of the three. To test the law rather than the mixing, compute
each shell separately.JenaAtomicCalculator.DielectronicRecombination.rydbergShellOf — Method
DielectronicRecombination.rydbergShellOf(level::Level, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to return the (n,l) of the single Rydberg shell occupied in the given level, or nothing if the level has no Rydberg electron above n^(lowest-captured) - 1 or has more than one, in which case the Rydberg-series picture does not apply to it and it must simply be left alone rather than guessed at.
JenaAtomicCalculator.DielectronicRecombination.setHfTotalRates — Method
DielectronicRecombination.setHfTotalRates(hfCaptureLines::Array{HfCaptureLine,1}, hfPhotonLines::Array{HfPhotonLine,1}) ... to accumulate, for every intermediate HYPERFINE level m, the two total widths
Gamma_a(m) = sum_i A_a(m --> i) Gamma_r(m) = sum_f A_r(m --> f)
and to store them, with the resulting resonance strength, on each hyperfine capture line. A new
Array{HfCaptureLine,1} is returned. The single aggregation point of this route, exactly as
setTotalRates is for the fine-structure one, and for the same reason: it is where the capture and the
photon side couple, and it is the step both old implementations got wrong.
Keyed on (F, energy) rather than a level index, because Hfs.HfLevel carries no index; two hyperfine
levels of equal F and equal energy are the same level.JenaAtomicCalculator.DielectronicRecombination.setTotalRates — Method
DielectronicRecombination.setTotalRates(captureLines::Array{DielectronicRecombination.CaptureLine,1}, photonLines::Array{DielectronicRecombination.PhotonLine,1}, empTreatment::DielectronicRecombination.EmpiricalTreatment) ... to accumulate, for every intermediate level m, the two total widths
Gamma_a(m) = sum_i A_a(m --> i) Gamma_r(m) = sum_f A_r(m --> f) [ + hydrogenic ]
and to store them, together with the resulting resonance strength, on each capture line. A new
Array{DielectronicRecombination.CaptureLine,1} is returned.
This is deliberately a separate pass rather than something folded into the amplitude loops: it is the one
place where the capture and the photon side couple, and it is exactly the step that both implementations of
the old route got wrong -- once by assigning where it had to sum, once by producing NaN. Keeping it alone
and short makes it readable and lets the two identities it establishes be tested directly.
It is also the natural home of the HydrogenicCorrections: the decay of the captured Rydberg spectator is a
contribution to Gamma_r(m) and to nothing else, so it belongs where Gamma_r(m) is formed. The old route
instead evaluated it inside the per-(i,m) amplitude loop, which recomputed the same m-only quantity once for
every initial level. Note the consequence for the internal identity: with hydrogenic corrections active,
sum_f A_r(m --> f) over the PhotonLines + hydrogenic(m) = totalPhotonRate(m),
i.e. the plain sum over PhotonLines no longer reproduces the stored width. The added amount is printed per
intermediate level so that it can always be subtracted back out.
No `!` in the name: CaptureLine is immutable, so a new array is built rather than the old one modified.Hyperfine-induced transitions
JenaAtomicCalculator.HyperfineInduced.Channel — Type
struct HyperfineInduced.Channel ... one channel of a hyperfine-induced transition, i.e. one (multipole, gauge) of the radiation field.
+ multipole ::EmMultipole ... multipole of the emitted photon.
+ gauge ::EmGauge ... gauge.
+ amplitude ::Complex{Float64} ... transition amplitude.
+ rate ::Float64 ... rate of this channel.JenaAtomicCalculator.HyperfineInduced.Line — Type
struct HyperfineInduced.Line ... one hyperfine-induced transition between two IJF-coupled levels.
+ initialLevel ::Hfs.HfLevel ... initial hyperfine level.
+ finalLevel ::Hfs.HfLevel ... final hyperfine level.
+ omega ::Float64 ... photon energy.
+ photonRate ::EmProperty ... total rate, summed over the channels.
+ channels ::Array{HyperfineInduced.Channel,1} ... the individual (multipole, gauge) channels.JenaAtomicCalculator.HyperfineInduced.Line — Method
HyperfineInduced.Line(initialLevel::Hfs.HfLevel, finalLevel::Hfs.HfLevel, omega::Float64) ... constructor for a line without channels or rate yet. A line::HyperfineInduced.Line is returned.
JenaAtomicCalculator.HyperfineInduced.Settings — Type
struct HyperfineInduced.Settings <: AbstractProcessSettings ... defines the details and parameters for computing hyperfine-induced transitions.
+ multipoles ::Array{EmMultipole,1}
... multipoles of the RADIATION FIELD to be included, i.e. of the emitted photon.
+ hfMultipoles ::Array{EmMultipole,1}
... multipoles of the HYPERFINE INTERACTION that mixes the IJF-coupled levels [M1, E2, E3, ...]. These two
lists are independent: the 235U case, for instance, emits an E1 photon while the mixing is carried by
the nuclear E3 moment.
+ gauges ::Array{UseGauge,1} ... gauges to be included into the computations.
+ isomers ::Array{Nuclear.Isomer,1}
... the nuclear states to be included in the hyperfine basis. ONE isomer gives ordinary hyperfine
quenching; TWO or more admit nuclear hyperfine mixing, since two nuclear levels of equal F then
appear as separate basis vectors and are mixed by the diagonalization.
+ mixingLevels ::Array{Int64,1}
... electronic levels admitted into the hyperfine basis, so that they can LEND their strength through the
hyperfine admixture. Empty -- the default -- means the WHOLE multiplet mixes, which is both the
physically correct choice and a cheap one, since a hyperfine matrix has the dimension of a handful of
levels times a handful of F values. Restricting it is an optimization, never physics: it changes the
AMPLITUDE, not merely what is printed.
+ initialFvalues ::Array{AngularJ64,1} ... F values retained in the initial basis; all, if empty.
+ finalFvalues ::Array{AngularJ64,1} ... as above, for the final hyperfine levels.
+ calcOverview ::Bool
... run in OVERVIEW mode: build the multiplets and the full hyperfine representation, print the electronic
levels with their roles, the hyperfine levels with their stable indices, and a RANKED list of the
admixture channels that will carry the transition -- then stop, without computing any amplitude. This
is the cheap first pass that tells a user which levels matter, so that lineSelection can be written
from evidence instead of guessed at and corrected.
+ printBefore ::Bool ... print the selected lines before computing them.
+ calcLifetimes ::Bool ... compute and tabulate level lifetimes from the summed rates.
+ lineSelection ::LineSelection ... selected lines, if any.
+ photonEnergyShift ::Float64 ... an overall shift of all photon energies.
HOW TRANSITIONS ARE SELECTED -- read this before setting anything (redesigned 06-Aug-2026).
THERE IS EXACTLY ONE SELECTOR, `lineSelection`, and it works on HYPERFINE levels:
lineSelection = LineSelection(true, indexPairs = [(3,1), (3,2)])
lineSelection = LineSelection(true, symmetryPairs = [(LevelSymmetry(AngularJ64(1), Basics.minus),
LevelSymmetry(AngularJ64(2), Basics.minus))])
* `indexPairs` are (initial, final) indices of HYPERFINE levels -- the stable, energy-ordered index that
Hfs.computeHyperfineRepresentation assigns and that every table in this module prints. They are NOT
electronic level indices.
* `symmetryPairs` are (initial, final) LevelSymmetry built from F and the parity -- the HYPERFINE F, not the
electronic J.
* Empty / inactive means every energetically allowed line is computed.
GET THE INDICES FROM `calcOverview = true`, which builds everything, prints each hyperfine level with its
index, its F^P, its dominant electronic parent and its dominant nuclear parent, ranks the admixture channels
that will carry the transition, and stops without computing an amplitude. That is the intended first step on
any new system; writing indices without it is guesswork.
WHY THERE IS ONLY ONE. Earlier versions also selected by electronic parent (`iLevelIndex`/`iAddIndices`,
later `initialLevels`/`finalLevels`) and briefly by nuclear parent. Both were wrong in practice:
* selecting by electronic parent CANNOT express the question an isomer lifetime asks. In B-like 205Pb77+ the
isomer-dominated hyperfine levels sit on BOTH 2p_1/2 and 2p_3/2, so any electronic selection that keeps
them also keeps the ordinary 2p_3/2 -> 2p_1/2 M1 line at 1e11 /s and buries the hyperfine-induced effect
by ten orders of magnitude.
* `iAddIndices` additionally widened the BASIS and the set of REPORTED levels at the same time, so naming a
perturber silently reported its own allowed decay as though it were the line of interest.
A hyperfine level is identified by neither parent alone; it is identified by its index. Hence one selector,
on that index, and `mixingLevels` -- which is about the basis and therefore about the amplitude -- kept
strictly separate from it.JenaAtomicCalculator.HyperfineInduced.Settings — Method
HyperfineInduced.Settings(set::HyperfineInduced.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, hfMultipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, isomers::Union{Nothing,Array{Nuclear.Isomer,1}}=nothing, mixingLevels::Union{Nothing,Array{Int64,1}}=nothing, initialFvalues::Union{Nothing,Array{AngularJ64,1}}=nothing, finalFvalues::Union{Nothing,Array{AngularJ64,1}}=nothing, calcOverview::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, calcLifetimes::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing)
... the standard JAC keyword copy-constructor, which this Settings previously lacked.
A `settings::HyperfineInduced.Settings` is returned.JenaAtomicCalculator.HyperfineInduced.Settings — Method
HyperfineInduced.Settings() ... constructor for the default values. A settings::HyperfineInduced.Settings is returned.
JenaAtomicCalculator.HyperfineInduced.amplitude — Method
HyperfineInduced.amplitude(::Emission, mp::EmMultipole, gauge::EmGauge, omega::Float64, finalLevel::Hfs.HfLevel, initialLevel::Hfs.HfLevel, grid::Radial.Grid; printout::Bool=true) ... to compute the hyperfine-induced transition amplitude between two IJF-coupled levels; an amplitude::ComplexF64 is returned.
THE STRUCTURE. Each hyperfine level is a superposition sum_k mc[k] |(I_k J_k) F>, so the amplitude is a
double sum over the components of the two levels, weighted by their mixing coefficients. Within one pair
of components exactly one of two things can happen, since the radiation operator acts either on the
nucleus or on the electrons but never on both:
* the ELECTRONIC level changes while the isomer does not -- the ordinary multipole amplitude, recoupled
with Hfs.recouplingElectronicOperator (nucleus as spectator);
* the NUCLEAR level changes while the electronic level does not -- the nuclear multipole matrix element
<I_p||W^L||I_q>, recoupled with Hfs.recouplingNuclearOperator (electrons as spectator), and multiplied
by the multipole-field factor below so that it carries the same normalization as the electronic one.
Both are summed here, which is what lets ONE routine cover purely electronic, purely nuclear and mixed
hyperfine-induced transitions. The mixing coefficients themselves already contain all the hyperfine
amplitudes and energy denominators, having come out of the diagonalization in
Hfs.computeHyperfineRepresentation.
REPLACES an amplitude that omitted the sqrt((2F+1)(2F'+1)) of the recoupling, gated the nuclear term on a
magic `abs(mc*mc) > 0.8`, and used a double factorial defined only for L = 3, 5, 7. The `0.8` gate in
particular silenced the nuclear term for exactly the strongly mixed cases the module exists to describe.JenaAtomicCalculator.HyperfineInduced.computeAmplitudesProperties — Method
HyperfineInduced.computeAmplitudesProperties(line::HyperfineInduced.Line, grid::Radial.Grid, settings::HyperfineInduced.Settings; printout::Bool=true) ... to compute all amplitudes and the rate of the given line; a new HyperfineInduced.Line is returned.
THE STATISTICAL FACTOR, corrected 06-Aug-2026. The rate is
A = 8 pi alpha omega / (2 F_initial + 1) * |amplitude|^2
exactly as PhotoEmission.computeAmplitudesProperties forms it for an electronic line, with the hyperfine
weight (2F+1) of the EMITTING level in place of (2J+1). The previous version instead multiplied by
`Basics.twice(line.finalLevel.F)`, i.e. by 2F of the FINAL level -- the wrong level, and 2F rather than
2F+1, differing by about a factor twenty for F = 2. Using PhotoEmission's own prefactor also makes the
I -> 0 limit exact rather than approximate: with no nuclear spin every hyperfine level coincides with its
electronic parent, the recoupling factors reduce to 1, and this rate must reproduce PhotoEmission's for
the same transition. That is the check to run first if the absolute scale is ever in doubt.JenaAtomicCalculator.HyperfineInduced.computeHfsCoefficientsAB — Method
HyperfineInduced.computeHfsCoefficientsAB(multiplet::Multiplet, isomer::Nuclear.Isomer, index::Int64, grid::Radial.Grid) ... to compute the ordinary hyperfine A and B coefficients of one electronic level, as a diagnostic on the nuclear input BEFORE any transition amplitude is evaluated. A tuple (A, B)::Tuple{Float64,Float64} in atomic units is returned.
Renamed from `splitting_AB` (06-Aug-2026). It is worth running: A and B depend on the same nuclear moments
and the same electronic matrix elements as the hyperfine mixing does, but are directly comparable with
tabulated values, so a wrong mu, Q or level index shows up here rather than in a final rate.JenaAtomicCalculator.HyperfineInduced.computeLines — Method
HyperfineInduced.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::HyperfineInduced.Settings; output=true) ... to compute all hyperfine-induced transition amplitudes and properties as requested by the settings; a list of lines::Array{HyperfineInduced.Line,1} is returned if output = true.
The two multiplets always refer to the ELECTRONIC system; every piece of nuclear information comes from
settings.isomers, which replaces the isotopic data of an ordinary structure computation. Passing two or
more isomers is what admits nuclear hyperfine mixing.JenaAtomicCalculator.HyperfineInduced.determineChannels — Method
HyperfineInduced.determineChannels(finalLevel::Hfs.HfLevel, initialLevel::Hfs.HfLevel, settings::HyperfineInduced.Settings) ... to determine the (multipole, gauge) channels of one hyperfine-induced transition; an Array{HyperfineInduced.Channel,1} is returned. The selection rules are those of the TOTAL angular momenta F and the TOTAL parity, nuclear x electronic – which is the point of working in the IJF basis: a transition forbidden for the electrons alone, or for the nucleus alone, may still be allowed for F.
JenaAtomicCalculator.HyperfineInduced.determineHyperfineMultiplet — Method
HyperfineInduced.determineHyperfineMultiplet(multiplet::Multiplet, isomers::Array{Nuclear.Isomer,1}, mixingLevels::Array{Int64,1}, Fvalues::Array{AngularJ64,1}, grid::Radial.Grid, settings::HyperfineInduced.Settings; printout::Bool=false) ... to build and diagonalize the IJF-coupled hyperfine representation for the selected electronic levels and nuclear states; an Hfs.HfMultiplet is returned.
`mixingLevels` names every electronic level admitted to the expansion: the level whose hyperfine structure
is wanted, together with the neighbours whose admixture makes the transition possible in the first place.JenaAtomicCalculator.HyperfineInduced.determineLines — Method
HyperfineInduced.determineLines(finalMultiplet::Hfs.HfMultiplet, initialMultiplet::Hfs.HfMultiplet, settings::HyperfineInduced.Settings) ... to determine all hyperfine-induced lines with a positive photon energy and at least one open channel; an Array{HyperfineInduced.Line,1} is returned.
JenaAtomicCalculator.HyperfineInduced.displayAdmixtureRanking — Method
HyperfineInduced.displayAdmixtureRanking(stream::IO, hfMultiplet::Hfs.HfMultiplet, role::String; nShow::Int64=20) ... to list, ranked by size, every admixture channel that can carry a hyperfine-induced transition out of the given hyperfine multiplet, labelled as ELECTRONIC or NUCLEAR; nothing is returned.
THIS IS THE TABLE THE OVERVIEW MODE EXISTS FOR. A hyperfine-induced transition happens only because the
decaying level is not pure, so the admixture coefficients ARE the physics: their squares set the rate, and
their ranking says which perturbers matter and which may be ignored.
ELECTRONIC and NUCLEAR channels are ranked TOGETHER, deliberately. Both are the same thing -- a coupling
matrix element over an energy denominator -- and treating them separately would make 229Th89+ look like a
special case. It is not: there the electronic list is simply EMPTY, because the ion has a single 1s level
and nothing electronic to mix with, and the whole effect is carried by one nuclear channel between the two
isomers. A user reading that learns the true situation rather than meeting a fallback rule.
The coefficients are taken from the DIAGONALIZED representation, so they are exact rather than the
first-order V/dE estimate; dE is printed alongside, since a small denominator is what a user scanning for
candidate perturbers is really looking for.JenaAtomicCalculator.HyperfineInduced.displayElectronicBasis — Method
HyperfineInduced.displayElectronicBasis(stream::IO, multiplet::Multiplet, mixingLevels::Array{Int64,1}, role::String) ... to list the electronic levels that enter the hyperfine basis, with index, symmetry and energy; nothing is returned.
Every level listed here contributes to the AMPLITUDE through its hyperfine admixture, whether or not any
transition involving it is finally reported -- reporting is settled separately, by lineSelection on the
hyperfine indices. The table exists so that a user can see what `mixingLevels` did, since its default is
to admit the whole multiplet.JenaAtomicCalculator.HyperfineInduced.displayHyperfineComposition — Method
HyperfineInduced.displayHyperfineComposition(stream::IO, hfMultiplet::Hfs.HfMultiplet, role::String; threshold::Float64=1.0e-7, nAlways::Int64=3) ... to list, for every reported hyperfine level, the electronic levels and nuclear states that compose it, with their mixing coefficients; nothing is returned.
THIS IS THE TABLE THAT ANSWERS "which additional levels are of interest". The mixing coefficients are the
physics: a hyperfine-induced transition happens because the decaying level is not pure, and the size of
each admixture says directly how much each perturber contributes. Reading it also shows whether the basis
was large enough -- if the largest admixture sits on the level highest in the basis, the basis is probably
too small.JenaAtomicCalculator.HyperfineInduced.displayLifetimes — Method
HyperfineInduced.displayLifetimes(stream::IO, lines::Array{HyperfineInduced.Line,1}, settings::HyperfineInduced.Settings) ... to list, for every initial hyperfine level, the summed hyperfine-induced decay rate and the resulting lifetime; nothing is returned.
This is the quantity the whole module exists to produce: for 229Th89+ it is the isomeric lifetime that
nuclear hyperfine mixing shortens from hours to tens of milliseconds, and for 205Pb77+ the one that drops
from about fifteen minutes to some tens of milliseconds. Note that only the hyperfine-induced channels
computed here enter -- any competing decay path (internal conversion, ordinary electronic transitions) is
NOT included, so a lifetime printed here is an upper bound on the true one.JenaAtomicCalculator.HyperfineInduced.displayLines — Method
HyperfineInduced.displayLines(stream::IO, lines::Array{HyperfineInduced.Line,1}) ... to list the selected hyperfine-induced lines and their channels before the computation; nothing is returned.
JenaAtomicCalculator.HyperfineInduced.displayRates — Method
HyperfineInduced.displayRates(stream::IO, lines::Array{HyperfineInduced.Line,1}, settings::HyperfineInduced.Settings) ... to list the transition rates of all computed hyperfine-induced lines; nothing is returned.
JenaAtomicCalculator.HyperfineInduced.dominantElectronicLevel — Method
HyperfineInduced.dominantElectronicLevel(level::Hfs.HfLevel) ... to return the electronic level that carries the largest weight in the given hyperfine level; a Level is returned, and its .index is the index in the original electronic multiplet.
This is what decides whether a hyperfine level is REPORTED as decaying or is present only to lend its
strength: a level is "the 3P_0 level" if 3P_0 dominates it, whatever small admixtures it also carries.JenaAtomicCalculator.HyperfineInduced.dominantNuclearState — Method
HyperfineInduced.dominantNuclearState(level::Hfs.HfLevel) ... to return the isomer that carries the largest weight in the given hyperfine level; a Nuclear.Isomer is returned.
Every level of a hyperfine-mixed computation is a superposition of nuclear states, so strictly speaking
no level "is" the isomer. It is nevertheless always dominated by one of them -- the admixture that drives
the whole effect is typically of order a per cent -- and naming that one is what makes an output table
readable.JenaAtomicCalculator.HyperfineInduced.doubleFactorial — Method
HyperfineInduced.doubleFactorial(n::Int64) ... to return the double factorial n!! for n >= -1, as a Float64.
Written out because the previous implementation was a three-branch lookup that returned values for
n = 3, 5, 7 and called error("stop a") for anything else -- which silently confined the whole module to
multipoles L = 1, 2, 3 and would have aborted on the E3 hyperfine interaction of 235U at L = 3 combined
with any higher radiation multipole.JenaAtomicCalculator.HyperfineInduced.nuclearStateLabel — Method
HyperfineInduced.nuclearStateLabel(level::Hfs.HfLevel) ... to return a short label "I^P" for the nuclear state dominating the given hyperfine level, with an asterisk marking an excited isomer; a String is returned.
WHY THIS IS NEEDED (06-Aug-2026): F alone does not identify a level once more than one nuclear state is
in the basis. In H-like 229Th89+ the ground state (I = 5/2) gives F = 2, 3 and the isomer (I = 3/2) gives
F = 1, 2, so F = 2 occurs TWICE -- and two physically quite different transitions, one that de-excites
the nucleus and one that merely relaxes its hyperfine state, both printed as "1+ --> 2+". Tables that
show only F^P are genuinely ambiguous and were misread as soon as they were produced.JenaAtomicCalculator.HyperfineInduced.selectHyperfineBasisVectors — Method
HyperfineInduced.selectHyperfineBasisVectors(basis::Array{Hfs.HfBasisVector,1}, Fvalues::Array{AngularJ64,1}) ... to keep only those basis vectors whose total angular momentum F appears in Fvalues; all vectors are kept if Fvalues is empty. An Array{Hfs.HfBasisVector,1} is returned.
Renamed from `generateBasis` (06-Aug-2026): it never generated anything, it selected from a basis that
Hfs.defineHyperfineBasis had already built.Electron Impact Excitation
JenaAtomicCalculator.ImpactExcitation.Channel — Type
struct ImpactExcitation.Channel ... defines a type for a electron-impact excitaiton channel to help characterize the incoming and outgoing (continuum) states of many electron-states with a single free electron
+ initialKappa ::Int64 ... partial-wave of the incoming free electron
+ finalKappa ::Int64 ... partial-wave of the outgoing free electron
+ symmetry ::LevelSymmetry ... total angular momentum and parity of the scattering state
+ initialPhase ::Float64 ... phase of the incoming partial wave
+ finalPhase ::Float64 ... phase of the outgoing partial wave
+ amplitude ::Complex{Float64} ... Collision amplitude associated with the given channel.JenaAtomicCalculator.ImpactExcitation.Line — Type
struct ImpactExcitation.Line ... defines a type for a electron-impact excitation line that may include the definition of channels and their corresponding amplitudes.
+ initialLevel ::Level ... initial- (bound-state) level
+ finalLevel ::Level ... final- (bound-state) level
+ initialElectronEnergy ::Float64 ... energy of the incoming (initial-state) free-electron
+ finalElectronEnergy ::Float64 ... energy of the outgoing (final-state) free-electron
+ crossSection ::Float64 ... total cross section of this line
+ collisionStrength ::Float64 ... total collision strength of this line
+ channels ::Array{ImpactExcitation.Channel,1} ... List of ImpactExcitation channels of this line.
+ convergence ::Float64 ... convergence of calculationJenaAtomicCalculator.ImpactExcitation.Line — Method
ImpactExcitation.Line(initialLevel::Level, finalLevel::Level, crossSection::Float64) ... constructor for an electron-impact excitation line between a specified initial and final level. A line::ImpactExcitation.Line is returned.
JenaAtomicCalculator.ImpactExcitation.Line — Method
ImpactExcitation.Line() ... 'empty' constructor for an electron-impact excitation line between a specified initial and final level. A line::ImpactExcitation.Line is returned.
JenaAtomicCalculator.ImpactExcitation.RateCoefficients — Type
struct ImpactExcitation.RateCoefficients ... Defines a type for the output results from excitation rate or effective collision strengths calculations
+ initialLevel ::Level ... initial- (bound-state) level
+ finalLevel ::Level ... final- (bound-state) level
+ temperatures ::Array{Float64,1} ... Temperatures in [K] to calculate excitation rates and effective collision strengths
+ alphas ::Array{Float64,1} ... Excitation rate coefficients in [cm^3/s] for the input temperatures
+ effOmegas ::Array{Float64,1} ... Effective collision strengths for the input temperaturesJenaAtomicCalculator.ImpactExcitation.RateCoefficients — Method
ImpactExcitation.RateCoefficients() ... constructor for the default values of electron-impact excitation rate coefficient or effective collision strength computations. A rateCoefficients::ImpactExcitation.RateCoefficients is returned.
JenaAtomicCalculator.ImpactExcitation.Settings — Type
struct ImpactExcitation.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing electron-impact excitation lines.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ electronEnergies ::Array{Float64,1} ... List of impact-energies of the incoming elecgtrons (in user-defined units).
+ energyShift ::Float64 ... An overall energy shift for all transitions |i> --> |f>.
+ maxKappa ::Int64 ... Maximum kappa value of partial waves to be included.
+ calcRateCoefficient ::Bool ... True, if the plasma rate coefficients to be calculated, false otherwise.
+ maxEnergyMultiplier ::Float64 ... Maximum initial electron energy for eff. collision strength integration.
(maxEnergyMultiplier * Excitation threshold energy), after this assymptotic limit is applied.
+ numElectronEnergies ::Int64 ... No. of different electron energy points at which collision strengths to compute
in electron energy range [0, (maxEnergyMultiplier * Excitation threshold energy)]
+ temperatures ::Array{Float64, 1} ... Electron temperatures [K] for eff. collision strengths and rate coefficients.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ operator ::AbstractEeInteraction
... Interaction operator that is to be used for evaluating the e-e interaction amplitudes; allowed values are:
CoulombInteraction(), BreitInteraction(), ...
+ continuumExchange ::Union{Nothing,Bool}
... True/false to force exchange between the impacting/scattered electron and the bound electrons on or off;
`nothing` -- the default -- lets `Basics.perform` decide automatically from the final-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99).JenaAtomicCalculator.ImpactExcitation.Settings — Method
ImpactExcitation.Settings(set::ImpactExcitation.Settings; lineSelection::Union{Nothing, LineSelection} = nothing, electronEnergies::Union{ Nothing, Array{Float64,1} } = nothing, energyShift::Union{Nothing, Float64} = nothing, maxKappa::Union{Nothing, Int64} = nothing, calcRateCoefficient::Union{Nothing, Bool} = nothing, maxEnergyMultiplier::Union{Nothing, Float64} = nothing, numElectronEnergies::Union{Nothing, Int64} = nothing, temperatures::Union{ Nothing, Array{Float64,1} } = nothing, printBefore::Union{Nothing, Bool} = nothing, operator::Union{Nothing, AbstractEeInteraction} = nothing, continuumExchange::Union{Nothing, Bool} = nothing )
... constructor for modifying the given ImpactExcitation.Settings by 'overwriting' the previously selected parameters.
A `settings::ImpactExcitation.Settings` is returned.JenaAtomicCalculator.ImpactExcitation.Settings — Method
ImpactExcitation.Settings() ... constructor for the default values of electron-impact excitation line computations. A settings::ImpactExcitation.Settings is returned.
JenaAtomicCalculator.ImpactExcitation.amplitude — Method
ImpactExcitation.amplitude(kind::AbstractEeInteraction, channel::ImpactExcitation.Channel, cFinalLevel::Level, cInitialLevel::Level, grid::Radial.Grid; printout::Bool=true) ... to compute the kind in CoulombInteraction(), BreitInteraction(), CoulombBreit() electron-impact interaction amplitude <(alphaf Jf, kappaf) Jt || O^(e-e, kind) || (alphai Ji, kappai) Jt> due to the interelectronic interaction for the given final and initial (continuum) level. A value::ComplexF64 is returned.
JenaAtomicCalculator.ImpactExcitation.computeAmplitudesProperties — Method
ImpactExcitation.computeAmplitudesProperties(line::ImpactExcitation.Line, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::ImpactExcitation.Settings; printout::Bool=true, nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... to compute all amplitudes and properties of the given line; a line::ImpactExcitation.Line is returned for which the amplitudes and properties are now evaluated. The two keywords carry quantities that are CONSTANT for a whole computation and are otherwise rebuilt for every line and every partial wave: the nuclear potential depends only on the nuclear model and the grid, the B-spline primitives only on the grid. Nothing is cached; omitting them reproduces the previous behaviour exactly.
JenaAtomicCalculator.ImpactExcitation.computeEffStrengths — Method
ImpactExcitation.computeEffStrengths(lines::Array{ImpactExcitation.Line, 1}, settings::ImpactExcitation.Settings) ... computes Effective collision strengths from the calculated line collision strengths at temperature(s) [K]. Returns an Array{ImpactExcitation.RateCoefficients,1}.
JenaAtomicCalculator.ImpactExcitation.computeLines — Method
ImpactExcitation.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactExcitation.Settings; output=true) ... to compute the electron-impact excitation transition amplitudes and all properties as requested by the given settings. A list of lines::Array{ImpactExcitation.Lines} is returned.
JenaAtomicCalculator.ImpactExcitation.computeLinesCascade — Method
ImpactExcitation.computeLinesCascade(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactExcitation.Settings; output::Bool=true, printout::Bool=true) ... to compute the electron-impact excitation amplitudes and cross sections as requested by the given settings. The computations and printout are adapted for larger cascade computations by including only lines with at least one channel and by reducing the printout. A list of lines::Array{ImpactExcitation.Line,1} is returned.
This is the cascade counterpart of `ImpactExcitation.computeLines` and follows the same pattern as
`PhotoExcitation.computeLinesCascade` and `AutoIonization.computeLinesCascade`. It was CALLED by
Cascade.computeSteps(::ImpactExcitationScheme, ...) but had never been defined, so every electron-impact
excitation cascade raised an UndefVarError at its first step.JenaAtomicCalculator.ImpactExcitation.computeRateCoefficients — Method
ImpactExcitation.computeRateCoefficients(lines::Array{ImpactExcitation.Line,1}, settings::ImpactExcitation.Settings) ... computes Exitation rate coefficients from the calculated collsion strengths at a temperature(s) [K]. The rate coefficients are returned in [cm^3/s]. Returns an Array{ImpactExcitation.RateCoefficients,1}.
JenaAtomicCalculator.ImpactExcitation.determineChannels — Method
ImpactExcitation.determineChannels(finalLevel::Level, initialLevel::Level, settings::ImpactExcitation.Settings) ... to determine a list of electron-impact excitation Channels for a transitions from the initial to the final level and by taking into account the particular settings of for this computation; an Array{ImpactExcitation.Channel,1} is returned.
JenaAtomicCalculator.ImpactExcitation.determineLines — Method
ImpactExcitation.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::ImpactExcitation.Settings) ... to determine a list of ImpactExcitation.Line's for transitions between levels from the initial- and final-state multiplets, and by taking into account the particular selections and settings for this computation; an Array{ImpactExcitation.Line,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.
JenaAtomicCalculator.ImpactExcitation.displayLines — Method
ImpactExcitation.displayLines(lines::Array{ImpactExcitation.Line,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.ImpactExcitation.displayResults — Method
ImpactExcitation.displayResults(stream::IO, allRates::Array{ImpactExcitation.RateCoefficients,1}) ... the same table, but written to the given stream so that a cascade can also place it into the summary file. A rate coefficient is the quantity such a computation is run for and should not go to the screen alone. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ImpactExcitation.displayResults — Method
ImpactExcitation.displayResults(line::ImpactExcitation.Line) ... to display energies, cross sections, collision stregths, convergence etc. for a single line immediatly after the calculation for that line is completed. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ImpactExcitation.displayResults — Method
ImpactExcitation.displayResults(lines::Array{ImpactExcitation.Line,1}) ... to list all results, energies, cross sections, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ImpactExcitation.displayResults — Method
ImpactExcitation.displayResults(allRates::Array{RateCoefficients,1}) ... to list the excitation rate coefficients and effective collision strengths for the selected lines at the selected temperatures. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ImpactExcitation.groupLines — Method
ImpactExcitation.groupLines(lines::Array{ImpactExcitation.Line,1}, settings::ImpactExcitation.Settings) ... groups lines having the same initial and final level but different energies returns an Array{Array{ImpactExcitation.Line,1},1}
JenaAtomicCalculator.ImpactExcitation.groupLines — Method
ImpactExcitation.groupLines(lines::Array{ImpactExcitation.Line,1}) ... groups lines having the same initial and final level but different energies returns an Array{Array{ImpactExcitation.Line,1},1}
JenaAtomicCalculator.ImpactExcitation.interpolateCS — Method
ImpactExcitation.interpolateCS(x::Float64, xa::Vector{Float64}, ya::Vector{Float64}, isE1Allowed::Bool) ... interpolates the cross section or collision stregths for a given initial electron Energy if the energy is beyond the upper bound then uses asymptotic approximation for extrapolation, depending on the transition is E1 allowed or not. Returns a Float64.
JenaAtomicCalculator.ImpactExcitation.interpolateCS — Method
ImpactExcitation.interpolateCS(x::Float64, xa::Vector{Float64}, ya::Vector{Float64}) ... interpolates the cross section or collision stregths for a given initial electron Energy returns a Float64.
Photoemission
JenaAtomicCalculator.PhotoEmission.Line — Type
struct PhotoEmission.Line ... defines a type for a radiative transition between two fine-structure levels, and carries one amplitude entry per contributing MULTIPOLE; since every amplitude holds both gauges, no separate entry per gauge is needed.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega ::Float64 ... Transition frequency of this line.
+ photonRate ::EmProperty ... Total rate of this line.
+ angularBeta ::EmProperty ... Angular beta_2 coefficient.
+ amplitudes ::Array{MultipoleAmplitude,1} ... one entry per contributing multipole.
The cancellation factors are deliberately NOT a field here. A `Line` records the TRANSITION, whereas the cancellation factor
records how well-conditioned the particular CSF expansion was that produced it: the same line computed in a larger basis has a
different factor and the same rate. It is a diagnostic of a calculation, not a property of a line, and so it travels beside the
lines rather than inside them -- see PhotoEmission.computeAmplitudesProperties, which returns the two together. Keeping `Line`
at six fields also leaves the stored-cascade contract untouched; see the note on .jld files in Cascade.
A photo emission is bound-bound, so there is no free electron and hence no partial wave: a line simply carries one amplitude per
multipole, and each amplitude holds both gauges.JenaAtomicCalculator.PhotoEmission.LineQuality — Type
struct PhotoEmission.LineQuality ... carries the two cheap quality indicators of ONE multipole contribution to a line. Neither is a physical observable: both say how far the computed amplitude may be trusted, and both are free – the cancellation factor falls out of the sum that already forms the amplitude, and the gauge ratio out of two rates that are already computed.
+ multipole ::EmMultipole ... the multipole this refers to.
+ cancellation ::EmProperty
... Cowan's cancellation factor CF, one value per gauge,
CF = | SUM_rs c_f(r) M(r,s) c_i(s) | / SUM_rs | c_f(r) M(r,s) c_i(s) |
i.e. the coherent sum that IS the amplitude, divided by the sum of the magnitudes of its terms. CF = 1
means every CSF pair contributes with the same sign and nothing cancels; CF near 0 means the amplitude
is a small residue of large opposing contributions, so that a small error in any mixing coefficient
moves the result by a large factor. Cowan's rule of thumb: a transition with CF < 0.10 should be
treated as unreliable, and below 0.05 the value carries essentially no information.
A magnetic multipole has no second gauge, so both components hold the same number.JenaAtomicCalculator.PhotoEmission.Settings — Type
struct PhotoEmission.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing radiative lines.
+ multipoles ::Array{EmMultipoles} ... Specifies the (radiat. field) multipoles to be included.
+ gauges ::Array{UseGauge} ... Gauges to be included into the computations.
+ calcAnisotropy ::Bool ... True, if the anisotropy (structure) functions are to be calculated and false
otherwise
+ printBefore ::Bool ... True, if all energies and lines are printed before comput.
+ corePolarization ::CorePolarization ... Parametrization of the core-polarization potential/contribution.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ photonEnergyShift ::Float64 ... An overall energy shift for all photon energies.
+ mimimumPhotonEnergy ::Float64 ... minimum transition energy for which (photon) transitions are included into the
computation.
+ maximumPhotonEnergy ::Float64 ... maximum transition energy for which (photon) transitions are included.
+ calcBiorthogonal ::Bool ... True, if the initial- and final-state multiplets are first brought into a
bi-orthogonal representation (`BiOrthogonal.computeTransformation`) before the
transition amplitudes are evaluated, and false (the default) if the two
multiplets are used as they are.JenaAtomicCalculator.PhotoEmission.Settings — Method
PhotoEmission.Settings(set::PhotoEmission.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge}}=nothing, calcAnisotropy::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, corePolarization::Union{Nothing,CorePolarization}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing, mimimumPhotonEnergy::Union{Nothing,Float64}=nothing, maximumPhotonEnergy::Union{Nothing,Float64}=nothing, calcBiorthogonal::Union{Nothing,Bool}=nothing)
... constructor for modifying the given PhotoEmission.Settings by 'overwriting' the previously selected parameters.
A `settings::PhotoEmission.Settings` is returned.JenaAtomicCalculator.PhotoEmission.Settings — Method
PhotoEmission.Settings() ... constructor for the default values of radiative line computations A settings::PhotoEmission.Settings is returned.
JenaAtomicCalculator.PhotoEmission.amplitude — Method
PhotoEmission.amplitude(::Absorption, Mp::EmMultipole, gauge::EmGauge, omega::Float64, finalLevel::Level, initialLevel::Level, grid::Radial.Grid; display::Bool=false, printout::Bool=false) ... to compute the photon absorption amplitude as the conjugate of the emission amplitude with swapped levels, i.e. conj( <initialLevel || O^(Mp) || finalLevel> ). A value::ComplexF64 is returned.
JenaAtomicCalculator.PhotoEmission.amplitude — Method
PhotoEmission.amplitude(kind::Emission, Mp::EmMultipole, gauge::EmGauge, omega::Float64, finalLevel::Level, initialLevel::Level, grid::Radial.Grid; display::Bool=false, printout::Bool=false) ... to compute the photon emission amplitude alone, discarding the cancellation factor that PhotoEmission.amplitudeAndCancellation returns beside it. Kept so that every caller which wants only the amplitude reads as it always did. A value::ComplexF64 is returned.
**WHAT THE SIGN OF THIS VALUE MEANS, measured rather than argued (priority item 63, 13-Oct-2026).** A
level's own eigenvector carries an arbitrary overall sign -- a diagonalization convention, not physics --
fixed within one run but not guaranteed across a different CSF/configuration-list order, a different
basis size, or an independent re-diagonalization of the same CI matrix. So in principle the sign of a
SINGLE call to this function, or the sign of a RATIO of two calls sharing only one level, is not something
a caller may assume is invariant -- only a CLOSED LOOP (a product of amplitudes around a cycle, where each
level's arbitrary sign appears exactly twice and cancels, e.g. `<P1/2||E1||S> * <P3/2||M1||P1/2> *
<S||E1||P3/2>` for an S-P1/2-P3/2 triangle) is convention-free BY CONSTRUCTION, independently of anything
measured below.
**MEASURED, on a representative Li-like S/P1/2/P3/2 case with genuine 2-3 CSF mixing in each symmetry
block:** the sign of a single amplitude, the sign of a ratio of two amplitudes sharing one level, AND the
closed-loop product all stayed stable under four different perturbations -- reordering a 2- and a 3-
configuration list, enlarging the basis, and an independent `Hamiltonian.performCI` re-diagonalization of
the identical matrix. This is NOT a proof that a single sign or ratio is safe in general -- the
convention argument above still stands, and a more strongly mixed or near-degenerate case could behave
differently -- but no instability was found in this realistic, genuinely-mixing test. A caller who needs
a GUARANTEE, not an empirical observation, should use a closed-loop product; a caller who only needs what
was actually tested here can trust a single sign or ratio with that caveat attached.JenaAtomicCalculator.PhotoEmission.amplitudeAndCancellation — Method
PhotoEmission.amplitudeAndCancellation(::Emission, Mp::EmMultipole, gauge::EmGauge, omega::Float64, finalLevel::Level, initialLevel::Level, grid::Radial.Grid; display::Bool=false, printout::Bool=false) ... to compute the photon emission amplitude <alphaf Jf || O^(Mp) || alphai Ji> for the interaction with a photon of multipolarity Mp and for the given transition energy and gauge, TOGETHER with Cowan's cancellation factor of that same sum. A tuple (amplitude::ComplexF64, cancellation::Float64) is returned. The amplitude value is printed to screen if display=true.
JenaAtomicCalculator.PhotoEmission.computeAmplitudesProperties — Method
PhotoEmission.computeAmplitudesProperties(line::PhotoEmission.Line, grid::Radial.Grid, settings::PhotoEmission.Settings; printout::Bool=true) ... computes all amplitudes of the given line, one per contributing multipole and each in both gauges, and from them the total photon rate and the angular beta_2 coefficient. A newLine::PhotoEmission.Line with all amplitudes and properties evaluated is returned.
An electric multipole is evaluated twice, once per gauge, into one EmPropertyC; a magnetic multipole once, into an EmPropertyC with
equal components. `abs2` of an EmPropertyC is an EmProperty, so the rate accumulates in both gauges at once and a magnetic
amplitude, having equal components, enters both.
The rate is summed INCOHERENTLY over the multipoles.JenaAtomicCalculator.PhotoEmission.computeAnisotropyFunctions — Method
PhotoEmission.computeAnisotropyFunctions(line::PhotoEmission.Line) ... computes the anisotropy (structure) functions f2 and f4 of the given line; a tuple (f2, f4)::Tuple{EmPropertyC,EmPropertyC} is returned, each holding BOTH gauges.
The two gauges need no separate sums: the product conj(ampa) * ampb of two EmPropertyC is componentwise, so Coulomb meets Coulomb
and Babushkin meets Babushkin, while a magnetic amplitude has equal components and therefore enters both. The pair of multipoles is
destructured into (mpa, ampa) and (mpb, ampb), which keeps the outer and the inner partner visibly apart in the angular factors.
This function is the single place where f_2 and f_4 are evaluated; displayAnisotropies prints what it returns.JenaAtomicCalculator.PhotoEmission.computeLines — Method
PhotoEmission.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::PhotoEmission.Settings; output=true) ... computes the radiative transition amplitudes and all requested properties for the lines between the levels of the two given multiplets; this is the standard entry point of this module. A list of lines::Array{PhotoEmission.Line,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.PhotoEmission.computeLinesCascade — Method
PhotoEmission.computeLinesCascade(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::PhotoEmission.Settings; output=true, printout::Bool=true) ... computes the radiative transition amplitudes for a set of lines that has been selected beforehand, as needed within a cascade computation; no line selection and no printout of the selected lines is made here. A list of lines::Array{PhotoEmission.Line,1} is returned.
The "drop a line that does not contribute" test loses its explicit loop: abs2 of an EmPropertyC is an EmProperty, so summing it
gives both gauges at once and either component answers the question.JenaAtomicCalculator.PhotoEmission.determineChannels — Method
PhotoEmission.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoEmission.Settings) ... determines which multipoles contribute to the transition between the two given levels, by applying ... determines which multipoles contribute to the transition between the two given levels, by applying AngularMomentum.isAllowedMultipole to every multipole that is requested in the settings. One entry per multipole is created, and each of them carries both gauges, so that the requested gauges need not be iterated over here. An Array{MultipoleAmplitude,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.PhotoEmission.determineLines — Method
PhotoEmission.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoEmission.Settings) ... selects the radiative lines to be computed by forming all pairs of an initial and a final level that pass the line selection, and whose transition energy – shifted by settings.photonEnergyShift – lies within the requested energy window. An Array{PhotoEmission.Line,1} is returned, with all rates and amplitudes still zero.
JenaAtomicCalculator.PhotoEmission.displayAnisotropies — Method
PhotoEmission.displayAnisotropies(stream::IO, lines::Array{PhotoEmission.Line,1}, settings::PhotoEmission.Settings) ... lists the anisotropy (structure) functions f2 and f4 of every line in both gauges; these describe the angular distribution of the emitted photons. The values are obtained from PhotoEmission.computeAnisotropyFunctions, which this table only prints. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoEmission.displayLifetimes — Method
PhotoEmission.displayLifetimes(stream::IO, lines::Array{PhotoEmission.Line,1}, settings::PhotoEmission.Settings) ... derives the lifetime of every initial level from the total decay rate of all lines that start from it, and lists it together with the corresponding decay width, separately for the Coulomb and the Babushkin gauge. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoEmission.displayLines — Method
PhotoEmission.displayLines(stream::IO, lines::Array{PhotoEmission.Line,1}) ... lists the radiative lines that have been selected, together with the multipoles and gauges that will be computed for each of them. One row is printed per (multipole, gauge): an amplitude carries both gauges, so that expansion is made here, where the gauge is a property of the table rather than of the amplitude. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoEmission.displayQualityFlags — Method
PhotoEmission.displayQualityFlags(stream::IO, lines::Array{PhotoEmission.Line,1}, qualities::Array{Array{PhotoEmission.LineQuality,1},1}, settings::PhotoEmission.Settings) ... to display, for every line and every contributing multipole, the two cheap indicators of how far the computed rate may be trusted: Cowan's cancellation factor in each gauge, and the Babushkin/Coulomb rate ratio. Neither is an observable, and neither costs anything – the cancellation factor comes from the sum that already forms the amplitude, and the ratio from two rates that are already computed. A neat table is printed but nothing is returned otherwise.
HOW TO READ THE TWO COLUMNS, since they fail in different ways and a line can be bad in one and fine in the
other:
+ CF is about the AMPLITUDE OF ONE GAUGE. It is the coherent sum divided by the sum of the magnitudes of its
terms, so CF = 1 means nothing cancels and CF near 0 means the amplitude is a small residue of large
opposing contributions. Cowan's rule of thumb: below 0.10 treat the transition as unreliable, below 0.05 as
carrying no information. A SMALL CF does not mean the number is wrong -- it means a small error in any
mixing coefficient moves it by a large factor.
+ The GAUGE RATIO is about the ORBITALS AND THE CORRELATION. Length and velocity forms agree exactly only for
exact wave functions, so a ratio far from 1 says the description is incomplete. It says nothing about
cancellation: a transition can have CF = 1 in both gauges and still disagree by a factor of two. It is
shown PER MULTIPOLE and reads `n/a` where no such ratio exists -- for every magnetic multipole, which has
a single form, and for an electric one between two orbitals of the SAME subshell, where the velocity form
vanishes identically (`InteractionStrength.MabEmission` derives it). A transition INSIDE one configuration
is of that kind, so its length form carries the whole amplitude and an enormous "ratio" means only that
the other column is empty. Read the CANCELLATION FACTOR on such a line instead.
The verdict column flags whichever is worse. Neither test can prove a number right; both can show one that
should not be quoted without saying so.JenaAtomicCalculator.PhotoEmission.displayRates — Method
PhotoEmission.displayRates(stream::IO, lines::Array{PhotoEmission.Line,1}, settings::PhotoEmission.Settings) ... lists, for every line, the Einstein A and B coefficients, the WEIGHTED oscillator strength gf = g_lower * f, the decay width and – for E1 – the line strength. One row is printed per (multipole, gauge), so an electric multipole contributes two rows and a magnetic one a single row. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoEmission.lastQualityFlags — Method
PhotoEmission.lastQualityFlags() ... returns the quality summaries of the most recent PhotoEmission.computeLines, in the order of the lines it returned, so that a script can ASK how far a rate may be trusted instead of reading a printed table. A Vector of the NamedTuples described under PhotoEmission.lineQualitySummary is returned, or nothing if that routine has not run in this session.
ADVISORY, NEVER GATING: nothing in JAC reads this and no computation is blocked by it. Read
`worstCancellation` rather than `verdict` wherever a number will do, and read `lineQualitySummary`'s own
documentation for where the gauge indicator is evidence and where it is blind.JenaAtomicCalculator.PhotoEmission.lineQualitySummary — Method
PhotoEmission.lineQualitySummary(line::PhotoEmission.Line, qualities::Array{PhotoEmission.LineQuality,1}) ... condenses one line's quality indicators into the measured quantities a caller can assert on; a NamedTuple (initialLevel, finalLevel, omega, worstCancellation, worstMultipole, gaugeRatio, gaugeDeviation, verdict, cancellations, gaugeRatios, totalRateRatio) is returned. cancellations keeps the per-multipole detail as (multipole, Coulomb, Babushkin) triples, and worstCancellation is the smallest of them over both gauges.
**THE FIELD TO ASSERT ON IS `worstCancellation`, AND `gaugeDeviation` MUST NOT BE USED ALONE.** Below 0.10
a transition is unreliable and below 0.05 it carries no information -- Cowan's own thresholds -- and that
test is local to the amplitude, so it works wherever the amplitude does. **The gauge ratio does not:
measured, it exposed a 6.7 % grid error on neutral hydrogen and was BLIND to a SEVEN-ORDER error on H-like
Bi, where the two gauges agreed to 2 % throughout.** So gauge agreement is evidence on a near-neutral
system and no evidence at all on a highly charged one, and the two indicators fail INDEPENDENTLY: a line
can be sound in one and not the other, and CF = 1 is not an endorsement.
**`gaugeRatio` IS PER ELECTRIC MULTIPOLE SINCE 09-Nov-2026, AND IT IS THE WORST ONE THAT EXISTS.** It used to
be the ratio of the line's TOTAL rates, which on a mixed multipole list is not a gauge ratio at all;
`gaugeRatios` now carries one entry per multipole, `NaN` where the question does not apply, and
`PhotoEmission.multipoleGaugeRatio` holds the measurement that made this necessary. A line all of whose
multipoles are magnetic, or whose electric ones have a structurally zero velocity form, therefore reports
`gaugeRatio = NaN` and the verdict `gauge n/a` -- which is the honest reading and was previously a loud
alarm pointing at a defect that does not exist.
**AND THE TOTAL-RATE RATIO IS KEPT BESIDE IT AS `totalRateRatio`, BECAUSE THE TWO ANSWER DIFFERENT QUESTIONS
AND NEITHER REPLACES THE OTHER.** The total says how far apart the two gauges put THIS LINE'S RATE, which is
what a user quoting the rate needs; the per-multipole number says WHICH multipole is responsible, which the
total cannot. Measured on the suite's own Kr case, `15 -> 1`: the total ratio is 1.82 and the E2 ratio is
**3.76e+04**, and that is not a subdominant multipole being ignored -- E2 carries 7.21e+03 /s of the
Babushkin rate against M1's 8.76e+03 /s and essentially nothing of the Coulomb rate (1.92e-01 /s). The old
single number was therefore not merely mis-attributed but BLIND: on that one test case 28 electric rows read
`ok` on a total pinned near 1 by a dominant partner, while their own multipole stood at 2x, 8x, 15x, 30x and
once 3.8e+04. **That is the reverse of this project's usual detector failure, and the more dangerous
direction.**JenaAtomicCalculator.PhotoEmission.multipoleGaugeRatio — Method
PhotoEmission.multipoleGaugeRatio(line::PhotoEmission.Line, mp::EmMultipole) ... the Babushkin/Coulomb RATE ratio carried by the single multipole mp of line, i.e. |ABab|^2 / |ACou|^2 formed from that multipole's OWN amplitude rather than from the line's total rate. A ratio::Float64 is returned, and it is NaN wherever no gauge ratio exists – which is the point of the function.
**A GAUGE RATIO BELONGS TO ONE ELECTRIC MULTIPOLE, AND UNTIL 09-Nov-2026 THIS QUANTITY WAS TAKEN FROM THE LINE'S TOTAL RATE.**
That is wrong in two ways at once and both were visible in the approved reference: of its 78 MAGNETIC-multipole rows, **52
carried a ratio other than 1.0000** -- a magnetic multipole has a single form and cannot have a gauge ratio at all -- and on a
mixed M1+E2 line the "ratio" mixed a gauge-INVARIANT contribution into both of its own terms, so it measured neither gauge
agreement nor anything else.
**AND IT IS `NaN`, NOT A LARGE NUMBER, WHERE THE VELOCITY FORM IS STRUCTURALLY ZERO.** For two orbitals of the SAME subshell
the Coulomb branch of an electric multipole vanishes identically -- see `InteractionStrength.MabEmission`, which derives it:
the prefactor (kapa-kapb) and I^-(a,a) die together, while the length form keeps J_L and stays finite. A transition INSIDE one
configuration is built from such diagonal pairs, so its electric amplitude is carried by the length form alone and there is
nothing to compare. Measured on C I 1s^2 2s^2 2p^2 at omega = 0.0583 Ha: the diagonal 2p_3/2 E2 element is Coulomb -0.0 exactly
against Babushkin -3.6180e-08, and the one surviving OFF-diagonal pair 2p_1/2-2p_3/2 is itself suppressed by 181 in amplitude
(-1.9977e-10 against -3.6148e-08) -- 181^2 = 3.3e+04, which is the whole of the 4.4e+04 rate "disagreement" that
`examples/example-An.jl` branch c reported as a gauge failure. Reporting that as an alarm sends a reader hunting a defect in
E2 that is not there; the sound indicator on such a line is the CANCELLATION FACTOR, and on that same line it is 0.0008.JenaAtomicCalculator.PhotoEmission.qualityVerdict — Method
PhotoEmission.qualityVerdict(cf::Float64, ratio::Float64) ... turns a cancellation factor and a Babushkin/Coulomb rate ratio into the one-word verdict used in the quality table; a verdict::String is returned. It exists so that the printed table and the value handed back by PhotoEmission.lastQualityFlags() cannot drift apart – the thresholds live here and nowhere else.
**THE TIERS ABOVE A FACTOR OF TWO ARE SEPARATE, added 09-Nov-2026, because a single top class made the indicator
useless exactly where it matters most.** Until then every deviation above 1.0 read `gauges x2+`, so a ratio of 2
and a ratio of 138 -- both present in the approved reference, 16 rows of it -- were reported in the same words,
on a near-neutral system where this module's own `lineQualitySummary` records that the gauge ratio IS evidence.
A `NaN` ratio now reads `gauge n/a` rather than `no rate`: it means the question does not apply to this row, which
is the case for every magnetic multipole and for an electric one whose velocity form is structurally zero
(`PhotoEmission.multipoleGaugeRatio`).Photoexcitation
JenaAtomicCalculator.PhotoExcitation.Line — Type
struct PhotoExcitation.Line ... defines a type for a photo-excitation line that may include the definition of sublines and their corresponding amplitudes.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega ::Float64 ... Transition frequency of this line; can be shifted w.r.t. the level energies.
+ oscStrength ::EmProperty ... Absorption oscillator strength
+ crossSection ::EmProperty ... Total cross section of this line.
+ staTensor ::Array{TensorComp,1} ... Array of statistical tensor components rho_kq
+ hasSublines ::Bool ... Determines whether the individual sublines are defined in terms of their
multipolarity, amplitude, or not
+ channels ::Array{MultipoleAmplitude,1} ... one entry per multipole, each carrying BOTH gaugesJenaAtomicCalculator.PhotoExcitation.Line — Method
PhotoExcitation.Line(initialLevel::Level, finalLevel::Level, omega::Float64, crossSection::EmProperty) ... constructor an photo-excitation line between a specified initial and final level. A line::PhotoExcitation.Line is returned.
JenaAtomicCalculator.PhotoExcitation.Settings — Type
struct PhotoExcitation.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing photo-excitation lines.
+ multipoles ::Array{EmMultipole,1} ... Specifies the multipoles of the radiation field that are to be included.
+ gauges ::Array{UseGauge,1} ... Specifies the gauges to be included into the computations.
+ calcForStokes ::Bool ... True, if the excitation cross sections are to be calculated (and false
otherwise)
for given Stokes parameter of the incident plane-wave photons.
+ calcPhotonDm ::Bool ... True, if the photon density matrix of a subsequently emitted fluorescence photon
is to be calculated and false otherwise.
+ calcTensors ::Bool ... True, if statistical tensors of the excited atom are to be calculated, false
otherwise.
+ calcBiorthogonal ::Bool ... True, if the initial- and final-state multiplets are first
brought into a bi-orthogonal representation
(`BiOrthogonal.computeTransformation`) before the transition
amplitudes are evaluated, and false (the default) if the
two multiplets are used as they are.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ photonEnergyShift ::Float64 ... An overall energy shift for all photon energies.
+ mimimumPhotonEnergy ::Float64 ... minimum transition energy for which (photon) transitions are included into the
computation.
+ maximumPhotonEnergy ::Float64 ... maximum transition energy for which (photon) transitions are included.
+ stokes ::ExpStokes ... Stokes parameters of the incident radiation.JenaAtomicCalculator.PhotoExcitation.Settings — Method
PhotoExcitation.Settings(set::PhotoExcitation.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, calcForStokes::Union{Nothing,Bool}=nothing, calcPhotonDm::Union{Nothing,Bool}=nothing, calcTensors::Union{Nothing,Bool}=nothing, calcBiorthogonal::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing, mimimumPhotonEnergy::Union{Nothing,Float64}=nothing, maximumPhotonEnergy::Union{Nothing,Float64}=nothing, stokes::Union{Nothing,ExpStokes}=nothing)
... constructor for modifying the given PhotoExcitation.Settings by 'overwriting' the previously selected parameters.
A `settings::PhotoExcitation.Settings` is returned.JenaAtomicCalculator.PhotoExcitation.Settings — Method
PhotoExcitation.Settings() ... 'empty' constructor for the default values of photo-excitation line computations A settings::PhotoExcitation.Settings is returned.
JenaAtomicCalculator.PhotoExcitation.computeAmplitudesProperties — Method
PhotoExcitation.computeAmplitudesProperties(line::PhotoExcitation.Line, grid::Radial.Grid, settings::PhotoExcitation.Settings; printout::Bool=true) ... to compute all amplitudes and properties of the given line; a line::PhotoExcitation.Line is returned for which the amplitudes and properties have now been evaluated.
JenaAtomicCalculator.PhotoExcitation.computeCrossSection — Method
PhotoExcitation.computeCrossSection(line::PhotoExcitation.Line, stokes::ExpStokes) ... to compute the excitation cross section for the excitation of unpolarized atoms by plane-wave photons, whose polarization is described by the given (experimental) Stokes parameters. A cs::EmProperty is returned.
JenaAtomicCalculator.PhotoExcitation.computeExcitedLevelTensors — Method
PhotoExcitation.computeExcitedLevelTensors(kmax::Int64, Ji::AngularJ64, fKey::LevelKey, channels::Array{MultipoleAmplitude,1}, stokes::ExpStokes, gauge::Basics.EmGauge; axis::Basics.AbstractQuantizationAxis=Basics.DefaultQuantizationAxis()) ... computes the statistical tensors of a level that has been EXCITED FROM AN UNPOLARIZED LEVEL Ji by plane-wave photons whose polarization is given by the Stokes parameters, with the photon beam as the quantization axis. The sublevel density matrix is formed directly from the Wigner-Eckart decomposition,
rho(M_f,M_f') = 1/(2J_i+1) SUM_(M_i) SUM_(lambda,lambda') rho^gamma_(lambda lambda')
SUM_(L,L') <J_i M_i, L lambda | J_f M_f> <J_i M_i, L' lambda' | J_f M_f'>
i^(L-L'+p-p') lambda^p lambda'^p' A_L conj(A_L')
and passed to `Statistical.computeTensors`, which owns the definition of rho_kq for the whole code. Summing over M_i, M_f and M_f'
explicitly costs nothing at these angular
momenta and avoids a Racah reduction whose 6j phases cannot be checked independently.
THE PHOTON DENSITY MATRIX FOLLOWS THE CONVENTION ALREADY IN USE in `PhotoIonization`: in the helicity basis
rho^gamma_(lambda lambda) = 1 + lambda P3 and rho^gamma_(lambda != lambda') = P1 - i lambda P2, with the factor
lambda^p on each amplitude and p = 1 for an electric multipole. What that means for P1 and P2 was MEASURED,
not assumed: linearly polarized light on J_i = 0 -> J_f = 1 must leave a pure M = 0 state about the
polarization direction, for which A_20 = -sqrt(2), and rotating the computed tensor there reproduces that to
2e-16 at beta = pi/2 with alpha = 0 for P1 and alpha = pi/4 for P2. So P1 is linear along x and P2 linear at
45 degrees. A `tensors::Array{Statistical.Tensor,1}` is returned.
IT LIVES HERE RATHER THAN IN `Statistical` because it is the physics of ONE process: the photon density matrix,
the multipole phase and the Wigner-Eckart decomposition all belong to photoexcitation, while `Statistical`
holds only what any process needs. `PhotoExcitationFluores` reaches for it across the module boundary, which
is the honest arrangement -- excitation followed by fluorescence IS this excitation.JenaAtomicCalculator.PhotoExcitation.computeLines — Method
PhotoExcitation.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::PhotoExcitation.Settings; output=true) ... to compute the photo-excitation amplitudes and all properties as requested by the given settings. A list of lines::Array{PhotoExcitation.Lines} is returned.
JenaAtomicCalculator.PhotoExcitation.computeLinesCascade — Method
PhotoExcitation.computeLinesCascade(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::PhotoExcitation.Settings, initialLevelSelection::LevelSelection; output::Bool=true, printout::Bool=true) ... to compute the excitation (absorption) transition amplitudes and all properties as requested by the given settings. The computations and printout is adapted for larger cascade computations by including only lines with at least one channel and by sending all printout to a summary file only. A list of lines::Array{PhotoExcitation.Lines} is returned.
JenaAtomicCalculator.PhotoExcitation.computeStatisticalTensor — Method
PhotoExcitation.computeStatisticalTensor(k::Int64, q::Int64, line::PhotoExcitation.Line, stokes::ExpStokes) ... computes the statistical tensor component rho_kq of the EXCITED level for the excitation of unpolarized atoms by plane-wave photons whose polarization is given by the (experimental) Stokes parameters; the quantization axis is the photon beam. A rho::EmPropertyC is returned, holding both gauges, and it is COMPLEX: for linearly polarized light the excited ensemble carries coherence between sublevels differing by two units, so the q = +-2 components are genuinely complex whenever P2 does not vanish.
THE WORK IS DONE BY `PhotoExcitation.computeExcitedLevelTensors`, which builds the sublevel density matrix of a
level excited from an unpolarized one and hands it to `Statistical`, so that this module and
`PhotoExcitationFluores` cannot drift apart in either.
THE PHOTON DENSITY MATRIX FOLLOWS THE CONVENTION ALREADY IN USE in `PhotoIonization`: in the helicity basis
rho^gamma_(lambda lambda) = 1 + lambda P3 and rho^gamma_(lambda != lambda') = P1 - i lambda P2, with the factor
lambda^p attached to each amplitude and p = 1 for an electric multipole. Using the same convention as the one
module that already computes this quantity is the point: the two are meant to be comparable.
WHAT THAT CONVENTION MEANS FOR P1 AND P2 was measured rather than assumed. Linearly polarized light exciting
J_i = 0 -> J_f = 1 must leave a PURE M = 0 state about the polarization direction, for which A_20 = -sqrt(2);
rotating the computed tensor there reproduces that number to 2e-16 at beta = pi/2 with alpha = 0 for P1 and
alpha = pi/4 for P2. So P1 is linear polarization along x and P2 linear at 45 degrees, and the geometry
forces the check to fail if the photon density matrix, the multipole phase or the rotation is wrong.JenaAtomicCalculator.PhotoExcitation.determineChannels — Method
PhotoExcitation.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoExcitation.Settings) ... to determine a list of PhotoExcitation.Channel for a transitions from the initial to final level and by taking into account the particular settings of for this computation; an Array{PhotoExcitation.Channel,1} is returned.
JenaAtomicCalculator.PhotoExcitation.determineLines — Method
PhotoExcitation.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoExcitation.Settings) ... to determine a list of photo-excitation Line's for transitions between the levels from the given initial- and final-state multiplets and by taking into account the particular selections and settings for this computation; an Array{PhotoExcitation.Line,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.
JenaAtomicCalculator.PhotoExcitation.displayCrossSections — Method
PhotoExcitation.displayCrossSections(stream::IO, lines::Array{PhotoExcitation.Line,1}, settings::PhotoExcitation.Settings) ... to list all results, energies, cross sections, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoExcitation.displayLineData — Method
PhotoExcitation.displayLineData(stream::IO, lines::Array{PhotoExcitation.Line,1}) ... to display the calculated data, ordered by the initial levels and the photon energies involved. Neat tables of all initial levels and photon energies as well as all associated total cross sections are printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoExcitation.displayLines — Method
PhotoExcitation.displayLines(stream::IO, lines::Array{PhotoExcitation.Line,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoExcitation.estimateCrossSection — Method
PhotoExcitation.estimateCrossSection(lines::Array{PhotoExcitation.Line,1}, omega::Float64, gamma::Float64, initialLevel) ... to estimate from lines the total PE cross section for any omega and for initial level. The procedure assumes a Gaussian line shape for each PhotoExcitation.Line with widths gamma and distributes the (total cross section according to the line shape within [Er - 10*gamma, Er + 10*gamma]. Other line shapes can be readily implemented; a cross section cs::EmProperty is returned.
Photoionization
JenaAtomicCalculator.PhotoIonization.Channel — Type
struct PhotoIonization.Channel ... ONE asymptotic scattering state: the final ion plus a free electron, coupled to a total symmetry.
+ symmetry ::LevelSymmetry ... total J^parity of the scattering state.
+ amplitudes ::Array{MultipoleAmplitude,1} ... one entry per contributing multipole.JenaAtomicCalculator.PhotoIonization.Line — Type
struct PhotoIonization.Line ... defines a type for a photoionization line between an initial and a final level, for one photon energy, and carries the outgoing electron as a list of partial waves; the cross section and the angular parameters of the line are stored alongside them.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ electronEnergy ::Float64 ... Energy of the (outgoing free) electron.
+ photonEnergy ::Float64 ... Energy of the absorbed photon.
+ crossSection ::EmProperty ... Cross section for this photoionization, AVERAGED over
the magnetic sublevels of the initial level, i.e. the
quantity an unpolarized measurement returns and the one
published tables quote.
+ angularBeta ::EmProperty ... beta_2 anisotropy parameter.
+ coherentDelay ::EmProperty ... coherent time delay.
+ incoherentDelay::EmProperty ... incoherent time delay.
+ partialWaves ::Array{PartialWave,1} ... partial waves, each with the channels it serves.JenaAtomicCalculator.PhotoIonization.PartialWave — Type
struct PhotoIonization.PartialWave ... ONE partial wave of the free electron, and the channels it serves.
+ kappa ::Int64 ... partial wave of the free electron.
+ energy ::Float64 ... energy of the free electron.
+ phase ::Float64 ... scattering phase; a property of (energy, kappa).
+ channels ::Array{Channel,1} ... the total symmetries this partial wave serves.
The radial orbital and the phase belong HERE, not to a channel: they do not depend on the total symmetry, which is precisely why one
kappa can serve several of them.JenaAtomicCalculator.PhotoIonization.PlasmaSettings — Type
struct PhotoIonization.PlasmaSettings <: Basics.AbstractLineShiftSettings ... defines a type for the details and parameters of computing photoionization rates with plasma interactions.
+ multipoles ::Array{Basics.EmMultipole} ... Specifies the multipoles of the radiation field that are to be included.
+ gauges ::Array{Basics.UseGauge} ... Specifies the gauges to be included into the computations.
+ photonEnergies ::Array{Float64,1} ... List of photon energies.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.JenaAtomicCalculator.PhotoIonization.PlasmaSettings — Method
PhotoIonization.PlasmaSettings() ... constructor for a standard instance of PhotoIonization.PlasmaSettings. A plasmaSettings::PhotoIonization.PlasmaSettings is returned.
JenaAtomicCalculator.PhotoIonization.Settings — Type
struct PhotoIonization.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing photoionization lines.
+ multipoles ::Array{EmMultipole} ... Specifies the multipoles of the radiation field that are to be included.
+ gauges ::Array{UseGauge} ... Specifies the gauges to be included into the computations.
+ photonEnergies ::Array{Float64,1} ... List of photon energies [in user-selected units].
+ electronEnergies ::Array{Float64,1} ... List of electron energies; usually only one of these lists are utilized.
+ thetas ::Array{Float64,1} ... List of theta-values if angle-differential CS are calculated explicitly.
+ calcAnisotropy ::Bool ... True, if the beta anisotropy parameters are to be calculated and false
otherwise (o/w).
+ calcPartialCs ::Bool ... True, if partial cross sections are to be calculated and false otherwise.
+ calcTimeDelay ::Bool ... True, if time-delays are to be calculated and false otherwise.
+ calcNonE1AngleDifferentialCS ::Bool ... True, if non-E1 angle-differential CS are be calculated and false otherwise.
+ calcTensors ::Bool ... True, if statistical tensors of the excited atom are to be calculated and
false o/w.
+ calcBiorthogonal ::Bool ... True, if the (bound) initial- and final-state multiplets are first brought
into a bi-orthogonal representation (`BiOrthogonal.computeTransformation`)
before the free-electron (continuum) orbital is generated and the transition
amplitudes are evaluated, and false (the default) if the two multiplets are
used as they are. This transforms ONLY the bound spectator orbitals shared
between the N-electron neutral (initial) and (N-1)-electron ionic (final)
multiplets -- i.e. exactly the kind of core relaxation upon ionization the
bi-orthogonal method is designed to correct. The continuum orbital itself is
generated afterward, per line, directly in the field of the (possibly now
bi-orthogonally-transformed) ionic core via
`Continuum.generateOrbitalForLevel`, and is NEVER itself passed through the
bi-orthogonal machinery: applying it any later (after the continuum orbital
and its placeholder counterpart on the initial side already exist) would fail,
since the initial-side placeholder for the free-electron subshell
(`Basics.generateLevelWithExtraSubshell`) is a dummy, all-zero orbital with no
physical overlap to speak of -- the per-kappa overlap matrix used by
`BiOrthogonal.computeTransformationMatrices` would be singular. Although
`BiOrthogonal.computeTransformation`'s own docstring says the two multiplets
"must have the same number of electrons", nothing in its actual implementation
enforces or requires this: `computeTransformationMatrices` only needs matching
per-kappa orbital COUNTS (not matching NoElectrons), and
`generateCounterRotatingCiMatrices` builds its counter-rotation matrix
entirely from one side's OWN CSF list, with no cross-reference to the other
side's electron count at all -- the N-vs-(N-1) case used here appears
mathematically sound on inspection, but (unlike the PhotoEmission/
PhotoExcitation cases) has not yet been checked against an independent
known-answer test; treat quantitative results with appropriate caution until
such a test exists.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ stokes ::ExpStokes ... Stokes parameters of the incident radiation.
+ freeElectronShift ::Float64 ... An overall energy shift of all free-electron energies [user-specified units].
+ lValues ::Array{Int64,1} ... Orbital angular momentum of free-electrons, for which partial waves are
considered.
+ continuumExchange ::Union{Nothing,Bool} ... True/false to force exchange between the photoelectron and the bound
electrons on or off; `nothing` -- the default -- lets `Basics.perform`
decide automatically from the final-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99).JenaAtomicCalculator.PhotoIonization.Settings — Method
PhotoIonization.Settings(set::PhotoIonization.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, photonEnergies::Union{Nothing,Array{Float64,1}}=nothing, electronEnergies::Union{Nothing,Array{Float64,1}}=nothing, thetas::Union{Nothing,Array{Float64,1}}=nothing, calcAnisotropy::Union{Nothing,Bool}=nothing, calcPartialCs::Union{Nothing,Bool}=nothing, calcTimeDelay::Union{Nothing,Bool}=nothing, calcNonE1AngleDifferentialCS::Union{Nothing,Bool}=nothing, calcTensors::Union{Nothing,Bool}=nothing, calcBiorthogonal::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, stokes::Union{Nothing,ExpStokes}=nothing, freeElectronShift::Union{Nothing,Float64}=nothing, lValues::Union{Nothing,Array{Int64,1}}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... constructor for modifying the given PhotoIonization.Settings by 'overwriting' the previously selected parameters.
A `settings::PhotoIonization.Settings` is returned.JenaAtomicCalculator.PhotoIonization.Settings — Method
PhotoIonization.Settings() ... constructor for the default values of photoionization line computations A settings::PhotoIonization.Settings is returned.
JenaAtomicCalculator.PhotoIonization.amplitude — Method
PhotoIonization.amplitude(kind::String, mp::EmMultipole, gauge::EmGauge, kappa::Int64, phase::Float64, omega::Float64, continuumLevel::Level, initialLevel::Level, grid::Radial.Grid) ... to compute the kind = (photoionization) amplitude <(alphaf Jf, epsilon kappa) Jt || O^(photoionization) || alphai J_i> due to the electron-photon interaction for the given final and initial level, the partial wave of the outgoing electron as well as the given multipole and gauge. A value::ComplexF64 is returned.
JenaAtomicCalculator.PhotoIonization.angularFunctionK — Method
PhotoIonization.angularFunctionK(L1::Int64, L2::Int64, X::Int64, Ji::AngularJ64, Jf::AngularJ64, kappa1::Int64, J1::AngularJ64, kappa2::Int64, J2::AngularJ64) ... to compute angular function K(...) as defined for the non-E1 angle-differential cross sections by Nishita Hosea (2025). No tests are made that the triangular conditions of the quantum numbers are fulfilled. A wa::Float64 is returned.
JenaAtomicCalculator.PhotoIonization.angularFunctionW — Method
PhotoIonization.angularFunctionW(theta::Float64, L1::Int64, L2::Int64, X::Int64, lambda1::Int64, lambda2::Int64, kappa1::Int64, mu1::Rational{Int64}, kappa2::Int64, mu2::Rational{Int64}) ... to compute angular function W(theta; ...) as defined for the non-E1 angle-differential cross sections by Nishita Hosea (2025). No tests are made that the triangular conditions of the quantum numbers are fulfilled. A wa::Float64 is returned.
JenaAtomicCalculator.PhotoIonization.computeAmplitudesProperties — Method
PhotoIonization.computeAmplitudesProperties(line::PhotoIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::PhotoIonization.Settings; printout::Bool=false, nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... computes all amplitudes and properties of the given line; a Line is returned in which the amplitudes, the phases and the cross section are filled.
The physics is unchanged: the amplitudes come from the very same PhotoIonization.amplitude as the flat path. Only the ORDER of the
work differs, and that is the point -- the continuum orbital and the initial level carrying the extra continuum subshell are formed
ONCE PER PARTIAL WAVE, because they depend on (energy, kappa) and on nothing else. The flat path had to re-derive them per channel
until a cache was added; here there is nothing to cache.
An electric multipole is evaluated twice, once per gauge, into one EmPropertyC; a magnetic multipole once, into an EmPropertyC with
equal components.JenaAtomicCalculator.PhotoIonization.computeAmplitudesPropertiesPlasma — Method
PhotoIonization.computeAmplitudesPropertiesPlasma(line::PhotoIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonization.PlasmaSettings, plasmaModel::Basics.AbstractPlasmaModel; nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... to compute all amplitudes and properties of the given line but for the given plasma model. The photon-electron multipole operator itself carries no e-e Coulomb interaction to screen (unlike the Auger case), so the plasma dependence enters here through the continuum (photoelectron) orbital only, cf. Continuum.generateOrbitalForLevel(...,plasmaModel). A line::PhotoIonization.Line is returned for which the amplitudes and properties are now evaluated.
JenaAtomicCalculator.PhotoIonization.computeAngularBeta — Method
PhotoIonization.computeAngularBeta(iLevel::Level, fLevel::Level, partialWaves::Array{PhotoIonization.PartialWave,1}) ... computes the beta_2 anisotropy parameter of the photoelectron angular distribution from the given partial waves, valid in the E1 approximation; a beta::EmProperty is returned.
This is the only place in the module where PAIRS of amplitudes are needed rather than one at a time, and therefore the only one
where the two gauges could in principle be mixed. No guard against that is needed: the product `amp * conj(ampp)` of two EmPropertyC
is componentwise, so Coulomb meets Coulomb and Babushkin meets Babushkin by construction.
The partial wave supplies kappa -- one kappa may serve several total symmetries -- and the channel supplies the total symmetry,
which is exactly the pairing this formula needs.JenaAtomicCalculator.PhotoIonization.computeCrossSection — Method
PhotoIonization.computeCrossSection(partialWaves::Array{PhotoIonization.PartialWave,1}, photonEnergy::Float64, initialLevel::Level) ... computes the total photoionization cross section from the given partial waves, AVERAGED over the magnetic sublevels of the initial level; an EmProperty is returned.
THE SUMMATION IS THE SAME AS THE FLAT PATH'S, deliberately: |amplitude|^2 is summed INCOHERENTLY over multipoles as well as over
channels. The new structure would make a coherent multipole sum easy to write, and that would be a change of physics -- a question
to be settled separately against a reference, not as a side effect of restructuring. What the new form buys is that the rule now
lives in ONE named place instead of being spelled out wherever channels are summed.
No gauge appears: abs2(::EmPropertyC) returns an EmProperty, so the two gauges are carried along untouched, and a magnetic multipole
-- whose two components are equal -- reproduces the flat path's rule of adding it to both sums without any special case.JenaAtomicCalculator.PhotoIonization.computeDisplayNonE1AngleDifferentialCS — Method
PhotoIonization.computeDisplayNonE1AngleDifferentialCS(stream::IO, lines::Array{PhotoIonization.Line,1}, settings::PhotoIonization.Settings) ... computes and displays the non-E1 angle-differential photoionization cross sections for all PhotoIonization.Line's and at all angles theta as defined in the settings; the general formula by Nishita Hosea (2025) is applied, exactly as in PhotoIonization.computeDisplayNonE1AngleDifferentialCS. A table is printed for each line but nothing is returned otherwise.
THIS IS THE ONE CONSUMER THAT PAIRS AMPLITUDES ACROSS PARTIAL WAVES. computeAngularBeta and the partial cross section pair only
within one kappa; here kappa and kappa' are independent, and the interference between two DIFFERENT partial waves is the whole
content of the non-dipole terms. The loop therefore runs over the flattened (kappa, symmetry, multipole, amplitude) entries of the
line.
Of the three flat functions that must keep the gauges apart, this is the one that does it correctly: it guards the pair from BOTH
sides (`cha == Coulomb && chb == Babushkin` and the reverse) and then books a pair into the Coulomb sum unless either partner is
Babushkin, and vice versa -- so a magnetic multipole, whose flat gauge label is Basics.Magnetic, enters both sums. Every one of
those three rules is reproduced here by the single product `ma.amplitude * conj(mp.amplitude)`: it is componentwise, so the mixed
pairs cannot form, and a magnetic amplitude has equal components, so it contributes to both. Four lines of bookkeeping become none.
MIRRORED, NOT REPAIRED: `angCS` is filled once per line but never emptied between lines, so the table printed for the second line
repeats the rows of the first. That is a defect of the flat function; it is reproduced here unchanged, so that the two paths can be
compared line for line, and it is to be fixed in the flat function -- where it belongs -- rather than silently here.
NO CALLER, AND NEVER EXECUTED -- treat that as a warning, not a reassurance. It is a user entry point for non-E1
angle-differential cross sections. On 28-Aug-2026 the two OTHER never-executed functions in this module,
`computePartialCrossSectionUnpolarized` and `computeStatisticalTensorUnpolarized`, were run for the first time
and held THREE defects between them: a retired call signature, a Clebsch-Gordan coefficient evaluated where it
had to be skipped, and a normalisation that still does not sum to the total. Expect the same class here until
somebody runs it, and do not quote a number from it before then.JenaAtomicCalculator.PhotoIonization.computeLines — Method
PhotoIonization.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonization.Settings; output::Bool=true) ... computes the photoionization amplitudes and all requested properties for the lines between the levels of the two given multiplets and for every photon energy of the settings; this is the standard entry point of this module. The nuclear potential and the B-spline basis are built once and shared by all lines, which are then computed in parallel. An Array{PhotoIonization.Line,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.PhotoIonization.computeLinesCascade — Method
PhotoIonization.computeLinesCascade(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonization.Settings, initialLevelSelection::LevelSelection; output=true, printout::Bool=true) ... to compute the photoionization transition amplitudes and all properties as requested by the given settings. The computations and printout is adapted for large cascade computations by including only lines with at least one channel and by sending all printout to a summary file only. A list of lines::Array{PhotoIonization.Lines} is returned.
JenaAtomicCalculator.PhotoIonization.computeLinesPlasma — Method
PhotoIonization.computeLinesPlasma(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonization.PlasmaSettings, plasmaModel::Basics.AbstractPlasmaModel; output::Bool=true) ... to compute the photoIonization transition amplitudes and all properties as requested by the given settings and plasma model. A list of lines::Array{PhotoIonization.Lines} is returned.
JenaAtomicCalculator.PhotoIonization.computePartialCrossSectionUnpolarized — Method
PhotoIonization.computePartialCrossSectionUnpolarized(Mf::AngularM64, line::PhotoIonization.Line) ... computes the partial photoionization cross section for a given magnetic quantum number Mf of the final level, for initially unpolarized atoms ionized by unpolarized plane-wave photons; an EmProperty is returned, holding both gauges at once.
THE SUM RULE IS BUILT IN RATHER THAN CHECKED. The partial cross section is the TOTAL times the normalised population of the
sublevel, sigma(M_f) = sigma_total * p(M_f), following Balashov, Grum-Grzhimailo & Kabachnik, *Polarization and Correlation
Phenomena in Atomic Collisions*, Sect. 2.3, Eqs. (2.161)-(2.162). The population is obtained from the statistical tensor by the
standard inversion p(M_f) = SUM_k (-1)^(J_f - M_f) <J_f M_f, J_f -M_f | k 0> rho_k0, and because
SUM_{M_f} (-1)^(J_f - M_f) <J_f M_f, J_f -M_f | k 0> = sqrt(2 J_f + 1) delta_{k0}, summing over M_f returns sigma_total EXACTLY,
for every level and every energy. That identity is the whole reason for writing it this way.
THE NORMALISATION IS THE DIVISION BY rho_00, AND IT IS THE FIX. Eq. (2.161) normalises the tensor by the incoherent sum of squared
reduced amplitudes, (SUM_{ljJ} |M_{ljJ}|^2)^{-1}. rho_00 is proportional to exactly that sum, so dividing by it supplies the
normalisation -- and any common prefactor that `computeStatisticalTensorUnpolarized` happens to carry cancels in the ratio, which
makes this expression independent of that function's own scale convention.
WHAT THIS REPLACED, so that the old behaviour is not re-derived a fifth time. Until 03-Sep-2026 this function evaluated a SECOND,
independent angular expression -- a coherent double sum over channel and multipole pairs with its own 9j -- and multiplied it by a
prefactor `8 pi^3 alpha / (2 omega (2J_i+1))`. It did not sum to the total, and there were two faults. (i) The `alpha` sat in the
NUMERATOR where the validated `computeCrossSection` has it in the DENOMINATOR: JAC's multipole amplitude already carries the
photon-momentum factor from j_L(alpha omega r), and the total's 1/alpha exists to cancel it. (ii) The normalisation above was
missing entirely, which is why the residue was LEVEL-DEPENDENT -- SUM |M|^2 differs from level to level, so omitting it leaves a
level-dependent factor behind. Measured at omega = 80 eV, E1, sum over M_f divided by the total came out as 5.00 alpha^2 for H 1s,
9.00 for Ne, and 3.10 to 5.89 across the levels of Ne+ -- two levels with the SAME J_i and J_f differing (3.8382 against 3.0982),
which no prefactor in J_i can absorb. Do NOT "repair" such a discrepancy by multiplying in the number measured on one system: 9
alpha^2 is the Ne value alone, Ne being the special case J_i = 0, and patching a call site with a compensating factor is the drift
Rule 18 exists to stop.
THE CHANNEL PAIRING WAS NEVER AT FAULT. Balashov states of (2.162) that the partial waves of the electron enter INCOHERENTLY
(l = l', j = j') while J and J' are free, which is what `computeStatisticalTensorUnpolarized` does; the pairing is inherited from
it here rather than written a second time.JenaAtomicCalculator.PhotoIonization.computeStatisticalTensorUnpolarized — Method
PhotoIonization.computeStatisticalTensorUnpolarized(k::Int64, q::Int64, line::PhotoIonization.Line, settings::PhotoIonization.Settings) ... computes the statistical tensor rho_kq of the photoion; an EmPropertyC is returned, holding both gauges. As above, no gauge argument is taken because the gauge is carried by the amplitude.
CARRIES THE SAME CORRECTION as computePartialCrossSectionUnpolarized: the flat version's inner loop tests `cha.gauge` where it means
`chp.gauge`, so it multiplies Coulomb amplitudes with Babushkin ones. That cannot happen here. The two versions therefore differ by
more than rounding, and the difference is the point rather than a defect of this one.
A GREEN SUITE SAYS NOTHING ABOUT THIS FUNCTION UNDER LINEARLY POLARIZED LIGHT, and that is worth knowing before trusting it. The
Clebsch-Gordan coupling the two helicities carried the projection -lambda where it needs -lambdap, so both projections summed to
zero
and every lambda /= lambda' term -- exactly the terms carrying LINEAR polarization -- was deposited at q = 0 rather than at
q = +-2. Under P1 that cancelled the alignment exactly, A_20 coming out 0.000000 instead of 0.128571; under P2 it produced an
imaginary orientation that Hermiticity forbids; and q = +-2 was always zero. For UNPOLARIZED and CIRCULAR light those terms vanish
outright, so the wrong expression was RIGHT there -- which is why every approved case passed throughout. The defect lived precisely
in the configurations nobody had approved, so the next reader should not take a green suite as coverage of this one.JenaAtomicCalculator.PhotoIonization.computeTimeDelays — Method
PhotoIonization.computeTimeDelays(partialWaves::Array{PhotoIonization.PartialWave,1}, xPartialWaves::Array{PhotoIonization.PartialWave,1}, deltaE::Float64, Jf::AngularJ64) ... computes the coherent and incoherent time delays from two sets of partial waves that have been computed at energies differing by deltaE; a tuple (coherentDelay, incoherentDelay)::Tuple{EmProperty,EmProperty} is returned. The phase of each partial wave is taken from the wave itself, which is what it is a property of.
ONLY THE INCOHERENT DELAY IS EVALUATED: it is the amplitude-weighted mean of the partial-wave phases, differenced over deltaE.
The COHERENT delay is NOT evaluated and EmProperty(0.) is returned in its place, so a caller must not read it as a computed zero. No
general expression for it is available here; a formula restricted to a single initial subshell would look general once written into
this return value, and that is why none is given. Completing it is an open task of this function.JenaAtomicCalculator.PhotoIonization.determineChannels — Method
PhotoIonization.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoIonization.Settings) ... determines the partial waves of the outgoing electron and, within each of them, the scattering channels of the given transition, by applying AngularMomentum.allowedMultipoleSymmetries and AngularMomentum.allowedKappaSymmetries. The distinct pairs (kappa, symt) are collected first, and every multipole that reaches such a pair is then attached to it; the gauge is not iterated over at all, since an electric multipole yields one EmPropertyC holding both gauges and a magnetic one an EmPropertyC with equal components. An Array{PhotoIonization.PartialWave,1} is returned, with every amplitude still zero.
JenaAtomicCalculator.PhotoIonization.determineLines — Method
PhotoIonization.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoIonization.Settings) ... selects the photoionization lines to be computed by forming all pairs of an initial and a final level that pass the line selection, once for every photon energy requested in the settings, and assigns the free-electron energy that follows from the transition energy and settings.freeElectronShift. An Array{PhotoIonization.Line,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.PhotoIonization.displayLineData — Method
PhotoIonization.displayLineData(stream::IO, lines::Array{PhotoIonization.Line,1}) ... lists the initial levels of the given lines and, for each of them, the photon energies and the total cross sections that have been obtained, so that the data of a photoionization computation can be inspected in compact form. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoIonization.displayLines — Method
PhotoIonization.displayLines(stream::IO, lines::Array{PhotoIonization.Line,1}) ... lists the photoionization lines that have been selected, together with the free-electron energy and the multipoles and gauges that will be computed for each of them. One row is printed per (multipole, gauge), an expansion made here because a single amplitude holds both gauges: the gauge is a property of this table, not of the partial wave. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoIonization.displayPhases — Method
PhotoIonization.displayPhases(lines::Array{PhotoIonization.Line,1}) ... lists the selected photoionization lines together with the kappa and the phase of every outgoing partial wave. The phase is a property of the partial wave and is taken from it directly, so that each kappa contributes a single value. A neat table is printed to stdout; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoIonization.displayResults — Method
PhotoIonization.displayResults(stream::IO, lines::Array{PhotoIonization.Line,1}, settings::PhotoIonization.Settings) ... lists the total photoionization cross sections for initially unpolarized atoms and unpolarized plane-wave photons, in both gauges, and appends whatever further tables the settings request: the angular beta parameters, the time delays, the partial cross sections and the reduced statistical tensors of the photoion. This is the main result table of the module. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoIonization.displayTotalCrossSections — Method
PhotoIonization.displayTotalCrossSections(stream::IO, lines::Array{PhotoIonization.Line,1}, settings::PhotoIonization.Settings) ... lists the total photoionization cross sections summed over all final levels, i.e. one entry per initial level and photon energy, which is the quantity to be compared with a measured total cross section. Nothing is printed if no line was selected. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoIonization.extractCrossSection — Method
PhotoIonization.extractCrossSection(lines::Array{PhotoIonization.Line,1}, omega::Float64, initialLevel) ... to extract from lines the total PI cross section that refer to the given omega and initial level; a cross section cs::EmProperty is returned.
JenaAtomicCalculator.PhotoIonization.extractCrossSection — Method
PhotoIonization.extractCrossSection(lines::Array{PhotoIonization.Line,1}, omega::Float64, shell::Shell, initialLevel) ... to extract from lines the total PI cross section that refer to the given omega and initial level and to to the ionization of an electron from shell; a cross section cs::EmProperty is returned.
JenaAtomicCalculator.PhotoIonization.extractLines — Method
PhotoIonization.extractLines(lines::Array{PhotoIonization.Line,1}, omega::Float64) ... to extract from lines all those that refer to the given omega; a reduced list rLines::Array{PhotoIonization.Line,1} is returned.
JenaAtomicCalculator.PhotoIonization.extractPhotonEnergies — Method
PhotoIonization.extractPhotonEnergies(lines::Array{PhotoIonization.Line,1}) ... to extract all photon energies for which photoionization data and cross sections are provided by lines; an list of energies::Array{Float64,1} is returned.
JenaAtomicCalculator.PhotoIonization.getLineKappas — Method
PhotoIonization.getLineKappas(line::PhotoIonization.Line) ... returns a list of kappa-values (partial waves) which contribute to the given line, to which one or several channels are assigned. An kappaList::Array{Int64,1} is returned.
JenaAtomicCalculator.PhotoIonization.interpolateCrossSection — Method
PhotoIonization.interpolateCrossSection(lines::Array{PhotoIonization.Line,1}, omega::Float64, initialLevel) ... to interpolate (or extrapolate) from lines the total PI cross section for any given omega and initial level. The procedure applies a linear interpolation/extrapolation by just using the cross sections from the two nearest (given) omega points; a cross section cs::EmProperty is returned.
Photorecombination
JenaAtomicCalculator.PhotoRecombination.Channel — Type
struct PhotoRecombination.Channel ... ONE asymptotic scattering state: the initial ion plus a free electron, coupled to a total symmetry.
+ symmetry ::LevelSymmetry ... total J^parity of the scattering state.
+ amplitudes ::Array{MultipoleAmplitude,1} ... one entry per contributing multipole.JenaAtomicCalculator.PhotoRecombination.Line — Type
struct PhotoRecombination.Line ... defines a type for a photo-recombination line between an initial ion level and a final (recombined) level, for one energy of the incoming electron, and carries that electron as a list of partial waves.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ electronEnergy ::Float64 ... Energy of the (incoming free) electron.
+ photonEnergy ::Float64 ... Energy of the emitted photon.
+ betaGamma2 ::Float64 ... beta^2 * gamma^2.
+ weight ::Float64 ... weight of line in the integration over electron energies.
+ crossSection ::EmProperty ... Cross section for this electron capture.
+ partialWaves ::Array{PartialWave,1} ... partial waves, each with the channels it serves.JenaAtomicCalculator.PhotoRecombination.PartialWave — Type
struct PhotoRecombination.PartialWave ... ONE partial wave of the incoming free electron, and the channels it serves.
+ kappa ::Int64 ... partial wave of the free electron.
+ energy ::Float64 ... energy of the free electron.
+ phase ::Float64 ... scattering phase; a property of (energy, kappa).
+ channels ::Array{Channel,1} ... the total symmetries this partial wave serves.
The radial orbital and the phase belong HERE, not to a channel: they do not depend on the total symmetry, which is precisely why one
kappa can serve several of them. computeAmplitudesProperties needed a per-kappa dictionary to exploit that; here it follows from the
shape.JenaAtomicCalculator.PhotoRecombination.Settings — Type
struct PhotoRecombination.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing photo recombination lines.
+ multipoles ::Array{EmMultipole} ... Multipoles of the radiation field that are to be included.
+ gauges ::Array{UseGauge} ... Gauges to be included into the computations.
+ electronEnergies ::Array{Float64,1} ... List of electron energies [in default units].
+ ionEnergies ::Array{Float64,1} ... List of ion energies [in MeV/u].
+ useIonEnergies ::Bool ... Make use of ion energies in [MeV/u] to obtain the electron energies.
+ calcTotalCs ::Bool ... True, if the total cross sections is to be calculated/displayed for all initial levels.
+ calcAnisotropy ::Bool ... True, if the overall anisotropy is to be calculated.
+ calcTensors ::Bool ... True, if the statistical tensors are to be calculated and false otherwise.
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ maxKappa ::Int64 ... Maximum kappa value of partial waves to be included.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ continuumExchange ::Union{Nothing,Bool} ... True/false to force exchange between the captured electron and the bound
electrons on or off; `nothing` -- the default -- lets `Basics.perform`
decide automatically from the final-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99).JenaAtomicCalculator.PhotoRecombination.Settings — Method
PhotoRecombination.Settings(set::PhotoRecombination.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, electronEnergies::Union{Nothing,Array{Float64,1}}=nothing, ionEnergies::Union{Nothing,Array{Float64,1}}=nothing, useIonEnergies::Union{Nothing,Bool}=nothing, calcTotalCs::Union{Nothing,Bool}=nothing, calcAnisotropy::Union{Nothing,Bool}=nothing, calcTensors::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, maxKappa::Union{Nothing,Int64}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... constructor for modifying the given PhotoRecombination.Settings by 'overwriting' the previously selected parameters.
A `settings::PhotoRecombination.Settings` is returned.JenaAtomicCalculator.PhotoRecombination.Settings — Method
PhotoRecombination.Settings() ... constructor for the default values of photo recombination line computations A settings::PhotoRecombination.Settings is returned.
JenaAtomicCalculator.PhotoRecombination.amplitude — Method
PhotoRecombination.amplitude(kind::String, mp::EmMultipole, gauge::EmGauge, kappa::Int64, phase::Float64, energy::Float64, finalLevel::Level, continuumLevel::Level, grid::Radial.Grid)
... to compute the kind = (photorecombination) amplitude < alpha_f J_f || O^(photorecombination) || (alpha_i J_i, epsilon kappa) J_t>
due to the electron-photon interaction for the given final and continuum level, the partial wave of the outgoing electron as well as
the given multipole and gauge. A value::ComplexF64 is returned.JenaAtomicCalculator.PhotoRecombination.checkConsistentMultiplets — Method
PhotoRecombination.checkConsistentMultiplets(finalMultiplet::Multiplet, initialMultiplet::Multiplet) ... to check that the given initial- and final-state levels and multiplets are consistent with each other, so that later problems in the computation are avoided. An error is raised if an inconsistency occurs, and nothing is returned otherwise.
THE REQUIREMENT IS A PREFIX, AND IT IS NOT THIS FUNCTION'S TO RELAX. Basics.generateLevelWithSymmetryReducedBasis,
which every amplitude below goes through, supports only the ADDITION of subshells: it raises unless the initial
subshells are the opening segment of the final ones AND strictly fewer. Ignoring subshells that are empty in every
initial CSF was tried on 28-Aug-2026 and REVERTED, because it admits exactly the cases that then fail one level
deeper with an unexplained "stop a" -- a permissive guard in front of a strict one helps nobody.
This is why a BARE ion must be written with the empty shell being the very shell captured INTO: Configuration("2s^0")
for capture into 2s. Configuration("1s^0") against a 2s final state compares [1s_1/2] with [2s_1/2] and is refused
here, with the remedy named. Making one spelling serve every channel means changing that shared Basics routine, which
is not a small change and is carried as its own item.JenaAtomicCalculator.PhotoRecombination.checkPartialWavesAreAdmitted — Method
PhotoRecombination.checkPartialWavesAreAdmitted(settings::PhotoRecombination.Settings) ... to check that the given settings admit at least one partial wave of the free electron, so that a computation which cannot produce anything says so instead of reporting zeros. An error is raised if none is admitted, and nothing is returned otherwise.
WHY THIS EXISTS. `PhotoRecombination.Settings()` leaves `maxKappa = 0`, and `determineChannels` discards every
partial wave with `abs(kappa) > settings.maxKappa`. Since `abs(kappa) >= 1` always, `maxKappa = 0` discards ALL of
them: the channel list comes back empty and every amplitude and cross section is exactly 0.0. Measured 30-Aug-2026,
a computation differing from `examples/example-Dd.jl:110` only in omitting `maxKappa` spent 47 minutes on genuine
SCF and continuum work and then reported 0.000000e+00 for both gauges at all fifteen of its (Z, energy) points, with
nothing to say that the run had been empty from the start. A zero cross section is a physically meaningful answer,
which is exactly why it must not be produced by a setting that admits no channel.JenaAtomicCalculator.PhotoRecombination.computeAmplitudesProperties — Method
PhotoRecombination.computeAmplitudesProperties(line::PhotoRecombination.Line, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::PhotoRecombination.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, primitives::Union{Nothing,Bsplines.Primitives}=nothing) ... computes the amplitudes of every partial wave of the given line and, from them, the cross section. The two keywords carry the nuclear potential and the B-spline primitives, which are constant for a whole computation and are therefore passed in rather than rebuilt per line. A newLine::PhotoRecombination.Line with all amplitudes and the cross section evaluated is returned.
ONE continuum orbital and ONE extended final level are generated per PARTIAL WAVE, which the loop nesting expresses directly, so
that no dictionary keyed on the continuum subshell is needed.
An electric multipole is evaluated twice, once per gauge, into one EmPropertyC; a magnetic multipole once, into an EmPropertyC with
equal components.JenaAtomicCalculator.PhotoRecombination.computeAnisotropyParameter — Method
PhotoRecombination.computeAnisotropyParameter(nu::Int64, line::PhotoRecombination.Line) ... computes the anisotropy parameter beta_nu of the emitted photons for an initially unpolarized ion; a value::EmPropertyC is returned, holding BOTH gauges, so that a single call covers what would otherwise be one call per gauge.
No gauge argument is needed and no gauge guard has to be written: the product conj(amp) * ampp of two EmPropertyC is componentwise,
so Coulomb meets Coulomb and Babushkin meets Babushkin, while a magnetic amplitude has equal components and therefore enters both.
Pairs are formed ACROSS partial waves: kappa and kappa' are independent, and that interference is the physical content of the
anisotropy.JenaAtomicCalculator.PhotoRecombination.computeCrossSectionForMultipoles — Method
PhotoRecombination.computeCrossSectionForMultipoles(multipoles::Array{EmMultipole,1}, line::PhotoRecombination.Line) ... computes the photo-recombination cross section from the amplitudes of the given line, restricted to the given multipoles; a cs::EmProperty is returned.
No gauge branching is needed: abs2 of an EmPropertyC is an EmProperty, so the sum stays gauge-paired by construction, and a magnetic
amplitude -- equal components -- enters both gauge sums by itself.
The summation is INCOHERENT over the multipoles as well as over the channels. A coherent multipole sum would be a physics change and
is deliberately not made here.JenaAtomicCalculator.PhotoRecombination.computeLines — Method
PhotoRecombination.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoRecombination.Settings; output::Bool=true) ... computes the photo-recombination amplitudes and all requested properties for the lines between the levels of the two given multiplets and for every electron energy of the settings; this is the standard entry point of this module. A list of lines::Array{PhotoRecombination.Line,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.PhotoRecombination.computeLinesWithContinuumOrbital — Method
PhotoRecombination.computeLinesWithContinuumOrbital(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, cOrbitals::Dict{Subshell, Orbital}, cPhases::Dict{Subshell, Float64}, energyGrid::Radial.GridGL, settings::PhotoRecombination.Settings; output::Bool=true) ... computes the photo-recombination lines from continuum orbitals that have been generated beforehand and are handed over in cOrbitals, which avoids regenerating them per line; this is the driver used by Cascade.computeSteps(::Cascade.RadiativeRecombinationScheme, ...). A list of lines::Array{PhotoRecombination.Line,1} is returned if output=true, and nothing otherwise. The continuum orbital is looked up once per partial wave, so that the energy-grid index search runs once per partial wave as well.
The scattering phase of each partial wave is taken from cPhases, which must be keyed on the same continuum subshells as cOrbitals;
Cascade.computeContinuumOrbitals produces both together. The phase cancels in the cross section, which is an incoherent sum of
abs2, but NOT in the anisotropy parameters, where amplitudes of different kappa interfere.
ONE LIMITATION distinguishes this driver from PhotoRecombination.computeLines: the cross section is summed inline over ALL
multipoles rather than through PhotoRecombination.computeCrossSectionForMultipoles, so that settings.multipoles does NOT restrict
it here.JenaAtomicCalculator.PhotoRecombination.crossSectionBellTotal — Method
PhotoRecombination.crossSectionBellTotal(energy::Float64, Z::Float64) ... to evaluate the (non-relativistic) total Bell & Bell cross section for the RR of a free electron with energy into any shell of initially bare ions with nuclear charge Z; an cs::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.crossSectionKramers — Method
PhotoRecombination.crossSectionKramers(energy::Float64, Z::Float64, nLowUp::Tuple{Int64,Int64}) ... to evaluate the (non-relativistic) Kramers cross section for the RR of a free electron with energy into all shells with n = nLow ... nUp of initially bare ions with nuclear charge Z; an cs::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.crossSectionKramersTotal — Method
PhotoRecombination.crossSectionKramersTotal(energy::Float64, Z::Float64) ... to evaluate the (non-relativistic) Kramers cross section for the RR of a free electron with energy into any shell of initially bare ions with nuclear charge Z; an cs::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.crossSectionStobbe — Method
PhotoRecombination.crossSectionStobbe(energy::Float64, Z::Float64) ... to evaluate the (non-relativistic) Stobbe cross section for the RR of a free electron with energy into the 1s state of initially bare ions with nuclear charge Z; an cs::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.determineChannels — Method
PhotoRecombination.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoRecombination.Settings) ... determines the partial waves of the incoming electron and, within each of them, the scattering channels of the given transition. The total symmetry is reached from the FINAL (recombined) level by AngularMomentum.allowedMultipoleSymmetries(symf, mp), and the free electron is then coupled to the INITIAL ion by allowedKappaSymmetries(symi, symt); every kappa with abs(kappa) > settings.maxKappa is discarded. The distinct pairs (kappa, symt) are collected first and every multipole that reaches such a pair is attached to it, so that the gauge is not iterated over at all. An Array{PhotoRecombination.PartialWave,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.PhotoRecombination.determineLines — Method
PhotoRecombination.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoRecombination.Settings) ... selects the photo-recombination lines to be computed by forming all pairs of an initial and a final level that pass the line selection, once for every electron energy requested in the settings; the photon energy and the kinematic factor beta^2 gamma^2 follow from that energy. An Array{PhotoRecombination.Line,1} is returned, with all amplitudes still zero.
JenaAtomicCalculator.PhotoRecombination.displayLines — Method
PhotoRecombination.displayLines(stream::IO, lines::Array{PhotoRecombination.Line,1}) ... lists the photo-recombination lines that have been selected, together with the electron and photon energies and the multipoles, gauges and partial waves that will be computed for each of them. One row is printed per (multipole, gauge), an expansion made here because a single amplitude holds both gauges: the gauge is a property of this table, not of the partial wave. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoRecombination.displayRateCoefficients — Method
PhotoRecombination.displayRateCoefficients(stream::IO, isym::LevelSymmetry, temperatures::Array{Float64,1}, alphaRR::Array{EmProperty,1}) ... lists the radiative-recombination rate coefficients of the given level symmetry for all selected temperatures, in both gauges. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoRecombination.displayResults — Method
PhotoRecombination.displayResults(stream::IO, lines::Array{PhotoRecombination.Line,1}, settings::PhotoRecombination.Settings) ... lists the photo-recombination cross sections in both gauges and, whenever the settings ask for them, the anisotropy parameters beta_nu of the emitted photons and the total cross sections. Each anisotropy parameter is obtained from a single call to PhotoRecombination.computeAnisotropyParameter, which returns both gauges at once. A neat table is printed to stream; nothing::Nothing is returned.
JenaAtomicCalculator.PhotoRecombination.plasmaRateKotelnikov — Method
PhotoRecombination.plasmaRateKotelnikov(Te::Float64, Z::Float64) ... to evaluate the RR plasma rate coefficient at temperature Te and for a Maxwellian distribution of electron energies and an initially bare ions with nuclear charge Z; an alpha::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.plasmaRateKotelnikov_1s — Method
PhotoRecombination.plasmaRateKotelnikov_1s(Te::Float64, Z::Float64) ... to evaluate the RR plasma rate coefficient at temperature Te and for a Maxwellian distribution of electron energies and an initially bare ions with nuclear charge Z; here only the capture into 1s is taken into account. An alpha::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.plasmaRatePartialSeaton — Method
PhotoRecombination.plasmaRatePartialSeaton(Te::Float64, Z::Float64, n::Int64) ... to evaluate the RR plasma rate coefficient at temperature Te and for a Maxwellian distribution of electron energies and an initially bare ions with nuclear charge Z. An alpha::Float64 is returned.
JenaAtomicCalculator.PhotoRecombination.plasmaRateSeaton — Method
PhotoRecombination.plasmaRateSeaton(Te::Float64, Z::Float64) ... to evaluate the RR plasma rate coefficient at temperature Te and for a Maxwellian distribution of electron energies and an initially bare ions with nuclear charge Z; this formula is valid for 2*Te / Z^2 << 1. An alpha::Float64 is returned.
Two-electron one-photon transitions
JenaAtomicCalculator.TwoElectronOnePhoton.Channel — Type
struct TwoElectronOnePhoton.Channel ... defines a type for a TEOP channel that specifies the multipole, gauge and amplitude. The total angular momentum and parity of the intermediate Green function levels coincides with either the intial or final-level symmetry and, therefore, need not to be marked separately. However, these Green function levels formally occur in the computation of the amplitude.
+ multipole ::EmMultipole ... Multipole of the photon emission/absorption.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ amplitude ::Complex{Float64} ... Amplitude of this multiple channel.JenaAtomicCalculator.TwoElectronOnePhoton.Line — Type
struct TwoElectronOnePhoton.Line ... defines a type for a TEOP line that may include the definition of sublines and their corresponding amplitudes.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega ::Float64 ... Transition frequency of this line; can be shifted w.r.t. the level energies.
+ teopRate ::EmProperty ... Total TEOP rate of this line.
+ channels ::Array{TwoElectronOnePhoton.Channel,1} ... List of TEOP (photon) channelsJenaAtomicCalculator.TwoElectronOnePhoton.Line — Method
TwoElectronOnePhoton.Line() ... constructor an empty TEOP line. A line::TwoElectronOnePhoton.Line is returned.
JenaAtomicCalculator.TwoElectronOnePhoton.Settings — Type
struct TwoElectronOnePhoton.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing radiative lines.
+ multipoles ::Array{EmMultipoles} ... Specifies the (radiat. field) multipoles to be included.
+ gauges ::Array{UseGauge} ... Gauges to be included into the computations.
+ printBefore ::Bool ... True, if all energies and lines are printed before comput.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ photonEnergyShift ::Float64 ... An overall energy shift for all photon energies.
+ eeInteraction ::AbstractEeInteraction ... Type of the electron-electron interaction in the second-order treatment.
+ gMultiplet ::Multiplet ... Mean-field multiplet of intermediate levels in the computations.JenaAtomicCalculator.TwoElectronOnePhoton.Settings — Method
TwoElectronOnePhoton.Settings(set::TwoElectronOnePhoton.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge}}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing, eeInteraction::Union{Nothing,AbstractEeInteraction}=nothing, gMultiplet::Union{Nothing,Multiplet}=nothing)
... constructor for modifying the given TwoElectronOnePhoton.Settings by 'overwriting' the previously selected parameters.
A `settings::TwoElectronOnePhoton.Settings` is returned.JenaAtomicCalculator.TwoElectronOnePhoton.Settings — Method
TwoElectronOnePhoton.Settings() ... constructor for the default values of TEOP line computations A settings::TwoElectronOnePhoton.Settings is returned.
JenaAtomicCalculator.TwoElectronOnePhoton.amplitude — Method
TwoElectronOnePhoton.amplitude(::Emission, Mp::EmMultipole, gauge::EmGauge, omega::Float64, finalLevel::Level, initialLevel::Level, gMultiplet::Multiplet, kind::AbstractEeInteraction, grid::Radial.Grid, nuclearPotential::Radial.Potential; display::Bool=false, printout::Bool=false) ... to compute the TEOP emission amplitude
<alpha_f J_f || O^(Mp, emission) || alpha_n J_i> <alpha_n J_i || H - E || alpha_i J_i>
+ <alpha_f J_f || H - E || alpha_n J_f> <alpha_n J_f || O^(Mp, emission) || alpha_i J_i>
emission amplitude for the interaction with the photon field of multipolarity Mp and for the given transition energy
and gauge. A value::ComplexF64 is returned. The amplitude value is printed to screen if display=true.
THE ELECTRON-ELECTRON FACTOR CARRIES `H - E` AND NOT `V^(e-e)` ALONE, and in this process that is not a refinement
but the difference between a mean field counted once and counted twice. Each of the two paths above is a product of
a ONE-BODY photon operator and ONE electron-electron factor, while the initial and final states differ in TWO
orbitals; the photon operator moves one of them, so the electron-electron factor is ALWAYS a ONE-orbital
transition a -> b. Exactly there `V^(e-e)` returns the whole spectator mean field `<b|U_HF|a>`, which the one-body
part of `H - E` cancels (Brillouin) down to the residual `<b|(U_HF - U)|a>`. A FIRST-order amplitude is exempt,
because it connects states differing in two orbitals where a one-body operator cannot contribute -- which is why
this never surfaced in the validated PhotoEmission and Auger paths. See ManyElectron.matrixElement_HminusE, whose
docstring carries the measurement, and `tools/probeTeaJunctionOperator.jl`.
`kind` MUST BE THE ELECTRON-ELECTRON INTERACTION OF THE HAMILTONIAN THAT PRODUCED THE LEVELS, since the
cancellation is referenced to their energy; it is `settings.eeInteraction`, which until 29-Oct-2026 this function
ignored in favour of a hard-wired `CoulombInteraction()`. `nuclearPotential` must be the nuclear potential on
`grid` and enters the one-body integral of the electron-electron factor.JenaAtomicCalculator.TwoElectronOnePhoton.checkSecondOrderConditions — Method
TwoElectronOnePhoton.checkSecondOrderConditions(finalMultiplet::Multiplet, initialMultiplet::Multiplet, gMultiplet::Multiplet, grid::Radial.Grid) ... tests the TWO conditions under which this module's explicit second-order amplitude means what it says, and NAMES what it finds rather than letting a wrong number through in silence. An array::Array{String,1} of problem descriptions is returned, EMPTY where both conditions hold.
CONDITION (a): THE GREEN SPACE MUST BE DISJOINT FROM THE INITIAL AND FINAL CI SPACES. Second-order perturbation theory
corrects a ZEROTH-order reference state by a sum over intermediates; where that reference state's own CI space already
contains a Green-space configuration, its admixture is counted ONCE by the CI and AGAIN by the sum. The `selfTolerance`
guard inside `amplitude` cannot see this, because it compares ENERGIES and the double-counted level is degenerate with
nothing -- the reference state merely CONTAINS it. Measured 01-Nov-2026 on the He-like Ne case of
`TestFrames.testModule_TwoElectronOnePhoton`, whose Green space `[1s2p, 1s2s]` shared `1s2s` with its final space
`[1s^2, 1s2s, 2p^2]`: a factor 6.1 too large, and on the time ordering that carries 160-400x the other.
CONDITION (b): ALL THREE MULTIPLETS MUST SHARE ONE ORBITAL SET. `ManyElectron.matrixElement_HminusE` drops the overlap
term `-E <r|s>` on a stated orthonormality assumption, and its ONE-BODY part is precisely what cannot survive that
assumption failing: for two nearly-equal orbitals `<b|h_D|a> ~ eps <b|a>`, a large number that only the dropped term
cancels. Measured on the same case with three separate SCF sets: `<1s_green|2s_initial> = -0.0115`, and the one-body
integral came out `+0.1143` where the single-set value must be `-0.1856` -- the WRONG SIGN, so it ANTI-cancels the
two-body term instead of cancelling it. A factor 9. `V^(e-e)` alone carries no one-body part and never felt this,
which is why the condition went unnoticed for as long as that operator was in use.
WITH BOTH CONDITIONS MET the explicit second order reproduces the same rate obtained by full CI to 0.3 % on that case.
These are therefore the conditions under which the module is VALIDATED, not a counsel of perfection, and the two errors
can hide each other: the test above read 3.70 with both violated, 6.10 with only (a), and 0.997 with neither. Build
the three multiplets on one orbital set with `Hamiltonian.performCIwithFrozenOrbitals`.JenaAtomicCalculator.TwoElectronOnePhoton.computeAmplitudesProperties — Method
TwoElectronOnePhoton.computeAmplitudesProperties(line::TwoElectronOnePhoton.Line, nm::Nuclear.Model, grid::Radial.Grid, settings::TwoElectronOnePhoton.Settings; printout::Bool=true, nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... to compute all amplitudes and properties of the given line; a line::TwoElectronOnePhoton.Line is returned for which the amplitudes and properties are now evaluated. nm is needed because the electron-electron factor of the second-order amplitude carries H - E, whose one-body part is the bare Dirac operator in the nuclear potential; nuclearPot lets a caller that builds that potential once for a whole computation pass it in, and omitting it reproduces the same potential from nm here.
JenaAtomicCalculator.TwoElectronOnePhoton.computeLines — Method
TwoElectronOnePhoton.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::TwoElectronOnePhoton.Settings; output=true) ... to compute the TEOP transition amplitudes and rates as requested by the given settings. A list of lines::Array{TwoElectronOnePhoton.Lines} is returned.
JenaAtomicCalculator.TwoElectronOnePhoton.determineChannels — Method
TwoElectronOnePhoton.determineChannels(finalLevel::Level, initialLevel::Level, settings::TwoElectronOnePhoton.Settings) ... to determine a list of TwoElectronOnePhoton.Channel for a transitions from the initial to final level and by taking into account the particular settings of for this computation. The definition of the channels remains the same as in single-photon emission, whereas the amplitudes requires special care. Since the electron-electron interaction is of zero rank, either the initial or final symmetry gives rises to an additional Green-function levels, together with the associated V^(e-e) interaction. An Array{TwoElectronOnePhoton.Channel,1} is returned.
JenaAtomicCalculator.TwoElectronOnePhoton.determineLines — Method
TwoElectronOnePhoton.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::TwoElectronOnePhoton.Settings) ... to determine a list of TwoElectronOnePhoton Line's for transitions between the levels from the given initial- and final-state multiplets and by taking into account the particular selections and settings for this computation; an Array{TwoElectronOnePhoton.Line,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.
JenaAtomicCalculator.TwoElectronOnePhoton.displayLifetimes — Method
TwoElectronOnePhoton.displayLifetimes(stream::IO, lines::Array{TwoElectronOnePhoton.Line,1}, settings::TwoElectronOnePhoton.Settings) ... to list all lifetimes as derived from the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.TwoElectronOnePhoton.displayLines — Method
TwoElectronOnePhoton.displayLines(lines::Array{TwoElectronOnePhoton.Line,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.TwoElectronOnePhoton.displayRates — Method
TwoElectronOnePhoton.displayRates(stream::IO, lines::Array{TwoElectronOnePhoton.Line,1}, settings::TwoElectronOnePhoton.Settings) ... to list all results, energies, rates, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
Multi-photon transitions
JenaAtomicCalculator.MultiPhotonTransition.AbstractMultiPhotonProperty — Type
abstract type MultiPhotonTransition.AbstractMultiPhotonProperty ... defines an abstract type to distinguish the observables that may be requested for a multi-photon process; by far not all of them are meaningful for every scheme. See also the JAC User Guide:
+ struct EnergyDiffCs
... energy-differential cross section / rate for initially unpolarized atoms (emission schemes).
+ struct TotalAlpha0
... the scalar (K = 0) part of the two-photon transition strength (absorption schemes).
+ struct TotalCsLinear
... total cross section for linearly-polarized incident radiation.
+ struct TotalCsRightCircular
... total cross section for right-circularly polarized incident radiation.
+ struct TotalCsUnpolarized
... total cross section for unpolarized incident radiation.
+ struct TotalCsDensityMatrix
... total cross section for incident radiation of arbitrary polarization, given by the 2x2 photon
density matrix, i.e. by the Stokes parameters in `Settings.stokes`.
ONE CALCULATION, EVERY OBSERVABLE. These are not independent computations. The two-photon amplitude is
decomposed into its irreducible parts of rank K, where K couples the two photon multipoles
(K in oplus(J_f, J_i)); every polarization observable is then a fixed algebraic combination of the SAME
|M_K|^2. The amplitudes are therefore evaluated once, and the polarization cases cost nothing extra:
TotalAlpha0 the K = 0 term alone -- the only one surviving for J_i = J_f = 0, i.e. exactly
the classic S -> S two-photon transition
TotalCsLinear Stokes (P1,P2,P3) = (1,0,0)
TotalCsRightCircular Stokes (0,0,1)
TotalCsUnpolarized Stokes (0,0,0)
TotalCsDensityMatrix the general case, of which the three above are special values
Their RATIOS are fixed by angular algebra alone and are therefore a check on the implementation that is
independent of any overall normalization.JenaAtomicCalculator.MultiPhotonTransition.AbstractMultiPhotonScheme — Type
abstract type MultiPhotonTransition.AbstractMultiPhotonScheme ... defines an abstract type to distinguish the different multi-photon processes; see also:
+ struct TwoPhotonEmissionScheme
... two-photon emission (decay) between two bound levels, often for initially-unpolarized atoms.
+ struct TwoPhotonAbsorptionScheme
... two-photon absorption (excitation) with monochromatic and equally-polarized photons, i.e. both
photons from the same beam.
+ struct TwoPhotonAbsorptionBichromaticScheme
... two-photon absorption by photons of two different, well-defined frequencies, usually from two
different (oriented) beams.
+ struct ThreePhotonEmissionScheme
... three-photon emission; NOT yet implemented, see module-MultiPhotonTransition-inc-3p.jl.
+ struct ThreePhotonAbsorptionScheme
... three-photon absorption; NOT yet implemented, see module-MultiPhotonTransition-inc-3p.jl.
Each scheme carries ITS OWN parameters. That is deliberate: the previous design kept `NoEnergySharings` in
Settings while `TwoPhotonEmission` carried its own `noSharings`, so the same quantity had two sources of
truth and nothing said which one won.JenaAtomicCalculator.MultiPhotonTransition.Channel_2pAbsorptionBichromatic — Type
struct MultiPhotonTransition.Channel_2pAbsorptionBichromatic ... defines a type for a two-photon absorption channel for two beams of DIFFERENT frequency and with well-defined multipolarities.
+ K ::AngularJ64 ... Rank K of the channel.
+ omega1 ::Float64 ... Energy of the photon from beam 1.
+ omega2 ::Float64 ... Energy of the photon from beam 2.
+ multipole1 ::EmMultipole ... Multipole of the photon from beam 1.
+ multipole2 ::EmMultipole ... Multipole of the photon from beam 2.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ Jsym ::LevelSymmetry ... Symmetry of the intermediate levels used in the summation.
+ amplitude1 ::Complex{Float64} ... reduced amplitude for the ordering in which the photon of
beam 1 is absorbed FIRST, i.e. with denominator E_i + omega1 - E_nu.
+ amplitude2 ::Complex{Float64} ... reduced amplitude for the ordering in which the photon of
beam 2 is absorbed FIRST, i.e. with denominator E_i + omega2 - E_nu.
TWO AMPLITUDES, NOT ONE. This is the single structural difference from Channel_2pAbsorptionMonochromatic,
and it is deliberate: for two distinguishable beams the two time orderings are different numbers, so storing
them separately is what lets the exchange phase be applied where it belongs and lets the monochromatic limit
be checked term by term rather than only in the total.JenaAtomicCalculator.MultiPhotonTransition.Channel_2pAbsorptionMonochromatic — Type
struct MultiPhotonTransition.Channel_2pAbsorptionMonochromatic ... defines a type for a two-photon absorption channel for the absorption of monochromatic light with well-defined multipolarities.
+ K ::AngularJ64 ... Rank K of the channel.
+ omega ::Float64 ... omega.
+ multipole1 ::EmMultipole ... Multipole M1.
+ multipole2 ::EmMultipole ... Multipole M2.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ Jsym ::LevelSymmetry ... Symmetry of the Green function channel/multiplet used in the summation.
+ amplitude ::Complex{Float64} ... reduced two-photon absorption amplitude U^(K, 2gamma, absorption) (..)
associated with the given channel.JenaAtomicCalculator.MultiPhotonTransition.EnergyDiffCs — Type
struct MultiPhotonTransition.EnergyDiffCs <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the energy-differential cross sections/rates of a multi-photon emission process.
JenaAtomicCalculator.MultiPhotonTransition.Line_2pAbsorptionBichromatic — Type
struct MultiPhotonTransition.Line_2pAbsorptionBichromatic ... defines a type for a two-photon absorption line driven by two beams of different frequency.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega1 ::Float64 ... Energy of the photon from beam 1.
+ omega2 ::Float64 ... Energy of the photon from beam 2.
+ csLinear ::EmProperty ... Total cross section for linearly-polarized incident light.
+ csRightCircular ::EmProperty ... Total cross section for right-circularly polarized incident light.
+ csUnpolarized ::EmProperty ... Total cross section for unpolarized incident light.
+ channels ::Array{MultiPhotonTransition.Channel_2pAbsorptionBichromatic,1}
... List of MultiPhotonTransition.Channel_2pAbsorptionBichromatic's of this line.JenaAtomicCalculator.MultiPhotonTransition.Line_2pAbsorptionMonochromatic — Type
struct MultiPhotonTransition.Line_2pAbsorptionMonochromatic ... defines a type for a two-photon absorption line by monochromatic light that may include the definition of channels.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega ::Float64 ... Energy of the incoming photons.
+ alpha0 ::EmProperty ... Two-photon absorption parameter alpha_0 [often in cm^4 / Ws]
+ csLinear ::EmProperty ... Total cross section for linearly-polarized incident light.
+ csRightCircular ::EmProperty ... Total cross section for right-circularly polarized incident light.
+ csUnpolarized ::EmProperty ... Total cross section for unpolarized incident light.
+ channels ::Array{MultiPhotonTransition.Channel_2pAbsorptionMonochromatic,1}
... List of MultiPhotonTransition.Channel_2pAbsorptionMonochromatic's of this line.JenaAtomicCalculator.MultiPhotonTransition.Line_2pEmission — Type
struct MultiPhotonTransition.Line_2pEmission ... defines a type for a two-photon absorption line by monochromatic light that may include the definition of channels.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ totalRate ::EmProperty ... Total rate for the two-photon transition.
+ sharings ::Array{MultiPhotonTransition.Sharing_2pEmission,1}
... List of MultiPhotonTransition.Sharing_2pEmission's of this line.JenaAtomicCalculator.MultiPhotonTransition.Line_3pAbsorption — Type
struct MultiPhotonTransition.Line_3pAbsorption ... defines a type for a three-photon absorption line driven by three parallel linearly-polarized beams.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ omega1 ::Float64 ... energy of the first photon.
+ omega2 ::Float64 ... energy of the second photon.
+ omega3 ::Float64 ... energy of the third photon.
+ strength ::EmProperty ... three-photon transition strength S^(3) [atomic units]; NOT a cross
section, see the header of this file.JenaAtomicCalculator.MultiPhotonTransition.ReducedChannel_2pEmission — Type
struct MultiPhotonTransition.ReducedChannel_2pEmission ... defines a type for a two-photon emission channel for the emission of photons with well-defined multipolarities.
+ K ::AngularJ64 ... Rank K of the channel.
+ omega1 ::Float64 ... omega1.
+ omega2 ::Float64 ... omega2.
+ multipole1 ::EmMultipole ... Multipole M1.
+ multipole2 ::EmMultipole ... Multipole M2.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ Jsym ::LevelSymmetry ... Symmetry of the Green function channel used in the summation.
+ amplitude ::Complex{Float64} ... reduced two-photon emission amplitude U^(K, 2gamma, emission) (..)
associated with the given channel.JenaAtomicCalculator.MultiPhotonTransition.Settings — Type
struct MultiPhotonTransition.Settings <: AbstractProcessSettings ... defines the settings for computing multi-photon excitation and decay between bound levels.
+ scheme ::MultiPhotonTransition.AbstractMultiPhotonScheme
... the multi-photon process to be computed; carries its own parameters.
+ multipoles ::Array{EmMultipole,1} ... multipoles of the radiation field to be included.
+ gauges ::Array{UseGauge,1} ... gauges to be included into the computations.
+ intermediateStates ::Union{Multiplet, Array{AtomicState.GreenChannel,1}}
... the intermediate states |nu> over which the second-order sum runs; see the note below.
+ selfTolerance ::Float64
... intermediate levels whose energy denominator |E_i + omega - E_nu| falls below this value are
excluded; see the note below.
+ stokes ::ExpStokes
... Stokes parameters of the incident radiation, used by TotalCsDensityMatrix. (0,0,0) is unpolarized.
+ printBefore ::Bool ... print all selected lines before their evaluation.
+ calcOverview ::Bool ... run in overview mode; see the note below.
+ lineSelection ::LineSelection ... selected lines, if any.
+ photonEnergyShift ::Float64 ... overall shift of all initial-to-final transition energies.
THE INTERMEDIATE-STATE SUM accepts BOTH representations JAC offers, dispatched internally:
* a mean-field `Multiplet` -- cheap, and what `TwoElectronOnePhoton` uses for the same kind of
second-order sum; the right choice for surveys across many atoms;
* an `Array{AtomicState.GreenChannel,1}` -- the accurate route, cf. Fritzsche, Approximate Atomic Green
Functions, Molecules 26 (2021).
Until 06-Aug-2026 the absorption path used the first while the emission path referred to `settings.green`, a
field that had been commented out of Settings -- so the emission path could not run at all.
SELF-TOLERANCE is not cosmetic. The denominator (E_i + omega - E_nu) vanishes when an intermediate level is
resonant, which is the physical boundary between NON-RESONANT and RESONANT multi-photon absorption. The
guard removes the exactly-singular term; `calcOverview` shows the merely dangerous ones. The same convention
and default (1.0e-8) is used by `TwoElectronOnePhoton`.
CALCOVERVIEW = true is a cheap first pass that stops BEFORE the expensive part: it builds the multiplets,
prints them with their indices and symmetries, and ranks the intermediate levels by their contribution
| <f|O(mp2)|nu> <nu|O(mp1)|i> / (E_i + omega - E_nu) |
together with each denominator -- then returns without forming any amplitude or property. It answers three
questions that cannot be guessed from a configuration list: which intermediate levels actually matter, which
denominators are near-resonant (so that perturbation theory is in doubt), and whether the intermediate basis
is large enough -- if the largest contributions sit on the highest levels included, the sum is truncated.
UNITS (settled 06-Aug-2026; nothing had been defined or documented before). The generalized two-photon cross
section is given in cm^4 s, defined by W [1/s] = sigma^(2) * F^2 with F the photon flux density in
photons cm^-2 s^-1, and is additionally reported in GM (1 GM = 1e-50 cm^4 s), the unit the two-photon
literature quotes. `alpha_0` is the K = 0 component of the same quantity and carries the same units -- NOT
the `cm^4/Ws` of the previous docstring, which is dimensionally inconsistent with a rate quadratic in the
photon flux. For a SINGLE beam the two photons are indistinguishable, and whether the rate carries an extra
factor 2 relative to the two-beam case is pure convention; it is fixed here by requiring the monochromatic
result to agree with the bichromatic one, W = sigma^(2) * F_1 * F_2, in the limit omega_1 -> omega_2.JenaAtomicCalculator.MultiPhotonTransition.Settings — Method
MultiPhotonTransition.Settings(set::MultiPhotonTransition.Settings; scheme::Union{Nothing,MultiPhotonTransition.AbstractMultiPhotonScheme}=nothing, multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, intermediateStates::Union{Nothing,Multiplet,Array{AtomicState.GreenChannel,1}}=nothing, selfTolerance::Union{Nothing,Float64}=nothing, stokes::Union{Nothing,ExpStokes}=nothing, printBefore::Union{Nothing,Bool}=nothing, calcOverview::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, photonEnergyShift::Union{Nothing,Float64}=nothing)
... the standard JAC keyword copy-constructor, which this Settings previously lacked.
A `settings::MultiPhotonTransition.Settings` is returned.JenaAtomicCalculator.MultiPhotonTransition.Settings — Method
MultiPhotonTransition.Settings() ... constructor for the default values. A settings::MultiPhotonTransition.Settings is returned.
JenaAtomicCalculator.MultiPhotonTransition.Sharing_2pEmission — Type
struct MultiPhotonTransition.Sharing_2pEmission ... defines a type for a 2pEmission sharing to help characterize energy sharing between the two emitted photons.
+ omega1 ::Float64 ... Energy of the emitted photon 1.
+ omega2 ::Float64 ... Energy of the emitted photon 2.
+ weight ::Float64 ... Gauss-Lengendre weight of this sharing for energy-integrated quantities.
+ differentialRate ::EmProperty ... differential rate of this energy sharing.
+ channels ::Array{MultiPhotonTransition.ReducedChannel_2pEmission,1}
... List of 2pEmission channels of this sharing.JenaAtomicCalculator.MultiPhotonTransition.Sharing_3p — Type
struct MultiPhotonTransition.Sharing_3p ... defines a type for one energy sharing of the total transition energy among THREE photons.
+ omega1 ::Float64 ... Energy of photon 1.
+ omega2 ::Float64 ... Energy of photon 2.
+ omega3 ::Float64 ... Energy of photon 3.
+ weight ::Float64 ... Quadrature weight of this sharing for energy-integrated quantities,
i.e. sum_i weight_i f_i approximates the integral of f over the simplex
with respect to domega1 domega2.JenaAtomicCalculator.MultiPhotonTransition.ThreePhotonAbsorptionScheme — Type
struct MultiPhotonTransition.ThreePhotonAbsorptionScheme <: MultiPhotonTransition.AbstractMultiPhotonScheme ... a scheme for three-photon absorption between two bound levels, in an ELEMENTARY formulation; see the header of module-MultiPhotonTransition-inc-3p.jl for what "elementary" means and does not mean here.
+ properties ::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}
... observables to be computed; only TotalCsUnpolarized is served, and it carries the three-photon
transition STRENGTH rather than a cross section -- see the note below.
+ omega1 ::Float64
... energy of the first photon [in user-selected units].
+ omega2 ::Float64
... energy of the second photon [in user-selected units]; the third follows from energy conservation,
omega3 = (E_f - E_i) - omega1 - omega2.
THREE COLOURS RATHER THAN ONE, and deliberately so. The monochromatic case omega1 = omega2 = omega3 is the
common experiment, but it is also the case in which the six time orderings coincide and therefore test
nothing. With three different colours they are six distinct numbers whose sum must still be invariant under
permuting the colours -- a free, exact check on the whole ordering bookkeeping, which is what caught the
corresponding two-photon bug (blocker A1). Setting omega1 = omega2 = 0 selects the monochromatic case, all
three photons carrying (E_f - E_i)/3, and that case is then reached as the LIMIT of the general one rather
than being asserted separately.
WHAT IS REPORTED IS A STRENGTH, NOT A CROSS SECTION. The generalized three-photon cross section would need a
normalisation of order F^3 (units cm^6 s^2), and the two-photon absorption normalisation of this module has
never been derived either -- inventing a three-photon one would add a second undetermined constant wearing
the units of a measured quantity. What is computed is
S^(3) = 1/(2J_i+1) sum_M |A(M)|^2 [atomic units]
which is the quantity the angular structure and the intermediate sum actually determine.JenaAtomicCalculator.MultiPhotonTransition.ThreePhotonAbsorptionScheme — Method
MultiPhotonTransition.ThreePhotonAbsorptionScheme(scheme::MultiPhotonTransition.ThreePhotonAbsorptionScheme; properties::Union{Nothing,Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}}=nothing, omega1::Union{Nothing,Float64}=nothing, omega2::Union{Nothing,Float64}=nothing)
... the standard JAC keyword copy-constructor.
A `threePhotonAbsorptionScheme::MultiPhotonTransition.ThreePhotonAbsorptionScheme` is returned.JenaAtomicCalculator.MultiPhotonTransition.ThreePhotonAbsorptionScheme — Method
MultiPhotonTransition.ThreePhotonAbsorptionScheme() ... constructor for the default values. A threePhotonAbsorptionScheme::MultiPhotonTransition.ThreePhotonAbsorptionScheme is returned.
JenaAtomicCalculator.MultiPhotonTransition.ThreePhotonEmissionScheme — Type
struct MultiPhotonTransition.ThreePhotonEmissionScheme <: MultiPhotonTransition.AbstractMultiPhotonScheme ... a scheme for three-photon emission between two bound levels. NOT YET IMPLEMENTED; the scheme exists so that the hierarchy is complete and so that selecting it fails with a clear message rather than silently.
+ properties ::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}
+ noSharings ::Int64 ... sharings of the total energy among THREE photons (a two-dimensional simplex).JenaAtomicCalculator.MultiPhotonTransition.ThreePhotonEmissionScheme — Method
MultiPhotonTransition.ThreePhotonEmissionScheme() ... constructor for the default values. A threePhotonEmissionScheme::MultiPhotonTransition.ThreePhotonEmissionScheme is returned.
JenaAtomicCalculator.MultiPhotonTransition.TotalAlpha0 — Type
struct MultiPhotonTransition.TotalAlpha0 <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the scalar (K = 0) part of the two-photon transition strength; see the units note at MultiPhotonTransition.Settings.
JenaAtomicCalculator.MultiPhotonTransition.TotalCsDensityMatrix — Type
struct MultiPhotonTransition.TotalCsDensityMatrix <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the total (absorption) cross section for incident radiation of ARBITRARY polarization, as described by the 2x2 photon density matrix.
DEFINED 06-Aug-2026; it had been listed in the docstring of AbstractMultiPhotonProperty since the module
was written but never declared, so requesting it was an UndefVarError. The density matrix of a photon is
fixed by its three Stokes parameters, which are taken from `Settings.stokes` and carried by the existing
`Basics.ExpStokes` type -- the same type `PhotoExcitation.Settings` already uses. Linear, right-circular
and unpolarized light are the special values (1,0,0), (0,0,1) and (0,0,0) of that vector, so this
property is the general case and the other three are conveniences.JenaAtomicCalculator.MultiPhotonTransition.TotalCsLinear — Type
struct MultiPhotonTransition.TotalCsLinear <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the total (absorption) cross section for linearly-polarized incident radiation, i.e. Stokes (1,0,0).
JenaAtomicCalculator.MultiPhotonTransition.TotalCsRightCircular — Type
struct MultiPhotonTransition.TotalCsRightCircular <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the total (absorption) cross section for right-circularly polarized incident radiation, i.e. Stokes (0,0,1).
JenaAtomicCalculator.MultiPhotonTransition.TotalCsUnpolarized — Type
struct MultiPhotonTransition.TotalCsUnpolarized <: MultiPhotonTransition.AbstractMultiPhotonProperty ... to request the total (absorption) cross section for unpolarized incident radiation, i.e. Stokes (0,0,0).
JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme — Type
struct MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme <: MultiPhotonTransition.AbstractMultiPhotonScheme ... a scheme for two-photon absorption by photons of two different frequencies, usually from two different (oriented) beams.
+ properties ::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}
... observables to be computed for this scheme.
+ omegaLess ::Float64
... energy of the photon with the SMALLER frequency [in user-selected units, like the photon energies of
the other process modules]; the larger one follows from energy conservation,
omegaMore = (E_f - E_i) - omegaLess. Which of the two is called the smaller one is immaterial to the
result: the cross section is exactly invariant under omegaLess <-> omegaMore, and that invariance is
one of the checks the scheme carries.
THE BICHROMATIC CASE IS THE UNAMBIGUOUS ONE, and that matters beyond its own physics: with two
distinguishable beams the rate is W = sigma^(2) * F_1 * F_2 with no combinatorial factor to argue about, so
it is the reference against which the single-beam convention of TwoPhotonAbsorptionScheme is fixed.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme — Method
MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme(scheme::MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme; properties::Union{Nothing,Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}}=nothing, omegaLess::Union{Nothing,Float64}=nothing)
... the standard JAC keyword copy-constructor.
A `twoPhotonAbsorptionBichromaticScheme::MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme` is returned.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme — Method
MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme() ... constructor for the default values. A twoPhotonAbsorptionBichromaticScheme::MultiPhotonTransition.TwoPhotonAbsorptionBichromaticScheme is returned.
JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionScheme — Type
struct MultiPhotonTransition.TwoPhotonAbsorptionScheme <: MultiPhotonTransition.AbstractMultiPhotonScheme ... a scheme for two-photon absorption with monochromatic, equally-polarized photons from the SAME beam. Both photons then carry omega = (Ef - Ei)/2.
+ properties ::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}
... observables to be computed for this scheme.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionScheme — Method
MultiPhotonTransition.TwoPhotonAbsorptionScheme(scheme::MultiPhotonTransition.TwoPhotonAbsorptionScheme; properties::Union{Nothing,Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}}=nothing)
... the standard JAC keyword copy-constructor.
A `twoPhotonAbsorptionScheme::MultiPhotonTransition.TwoPhotonAbsorptionScheme` is returned.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonAbsorptionScheme — Method
MultiPhotonTransition.TwoPhotonAbsorptionScheme() ... constructor for the default values. A twoPhotonAbsorptionScheme::MultiPhotonTransition.TwoPhotonAbsorptionScheme is returned.
JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonEmissionScheme — Type
struct MultiPhotonTransition.TwoPhotonEmissionScheme <: MultiPhotonTransition.AbstractMultiPhotonScheme ... a scheme for two-photon emission between two bound levels.
+ properties ::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}
... observables to be computed for this scheme.
+ noSharings ::Int64
... number of energy sharings between the two emitted photons, placed at the zeros of a Gauss-Legendre
quadrature so that the differential rates integrate to the total rate.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonEmissionScheme — Method
MultiPhotonTransition.TwoPhotonEmissionScheme(scheme::MultiPhotonTransition.TwoPhotonEmissionScheme; properties::Union{Nothing,Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}}=nothing, noSharings::Union{Nothing,Int64}=nothing)
... the standard JAC keyword copy-constructor.
A `twoPhotonEmissionScheme::MultiPhotonTransition.TwoPhotonEmissionScheme` is returned.JenaAtomicCalculator.MultiPhotonTransition.TwoPhotonEmissionScheme — Method
MultiPhotonTransition.TwoPhotonEmissionScheme() ... constructor for the default values. A twoPhotonEmissionScheme::MultiPhotonTransition.TwoPhotonEmissionScheme is returned.
JenaAtomicCalculator.MultiPhotonTransition.allIntermediateLevels — Method
MultiPhotonTransition.allIntermediateLevels(mp::Multiplet) or MultiPhotonTransition.allIntermediateLevels(gChannels::Array{AtomicState.GreenChannel,1}) ... to return ALL intermediate levels of the given representation, irrespective of their symmetry; an Array{Level,1} is returned.
The two-photon routines ask for the levels of ONE symmetry, because the coupled form fixes that symmetry
in advance. The m-sum form below does not work with a predetermined symmetry: it lets the 3-j symbols and
the parity rule decide which intermediate levels contribute, so it needs the whole set.JenaAtomicCalculator.MultiPhotonTransition.allIntermediateLevels — Method
MultiPhotonTransition.allIntermediateLevels(gChannels::Array{AtomicState.GreenChannel,1}) ... collects the levels of ALL Green channels, of every symmetry. The unfiltered counterpart of intermediateLevels, needed by the three-photon amplitude, whose two intermediate sums do not share one total symmetry. A levels::Array{Level,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.allowedSymmetries_2pAbsorptionBichromatic — Method
MultiPhotonTransition.allowedSymmetries_2pAbsorptionBichromatic(symf::LevelSymmetry, multipole2::EmMultipole, multipole1::EmMultipole, symi::LevelSymmetry) ... to return those intermediate symmetries that are allowed for EITHER time ordering of the two photons; an Array{LevelSymmetry,1} is returned.
BOTH ORDERINGS, hence the union. `AngularMomentum.allowedTotalSymmetries(symf, mp2, mp1, symi)` describes
the path i -> (mp1) -> nu -> (mp2) -> f only; with two distinguishable photons the reversed path
i -> (mp2) -> nu -> (mp1) -> f is a physically different contribution to the SAME final state and may
admit intermediate symmetries the first does not. For equal multipoles -- the E1E1 case that is all this
module is exercised with today -- the two sets coincide and the union changes nothing; it matters as soon
as mixed multipoles such as E1M1 are requested.JenaAtomicCalculator.MultiPhotonTransition.checkSharings_3p — Method
MultiPhotonTransition.checkSharings_3p(energy::Float64, noSharings::Int64) ... to verify the simplex quadrature against the exact moments of the simplex; an errors::Array{Tuple{String,Float64,Float64,Float64},1} of (moment, exact, quadrature, relative error) is returned.
THIS IS THE SUM RULE, and it is what makes the sharings a finished piece of work rather than plausible
code. The moments of the two-dimensional simplex are known exactly,
Int omega1^a omega2^b omega3^c domega1 domega2 = E^(a+b+c+2) a! b! c! / (a+b+c+2)!
so (0,0,0) -> E^2/2, (1,0,0) -> E^3/6, (1,1,1) -> E^5/120. The three cases probe polynomial degrees 0, 1
and 3, and the last one is the sharp one: it is degree 3 in the collapsed coordinates and would expose a
missing or misplaced Jacobian, which the constant test alone cannot.JenaAtomicCalculator.MultiPhotonTransition.computeAmplitudes_2pEmission — Method
MultiPhotonTransition.computeAmplitudes_2pEmission(line::MultiPhotonTransition.Line_2pEmission, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute all amplitudes of the given line; a line::MultiPhotonTransition.Line_2pEmission is returned for which the amplitudes are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeChannelAmplitudes_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeChannelAmplitudes_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute both ordering amplitudes of every channel of the given line; a line::MultiPhotonTransition.Line_2pAbsorptionBichromatic is returned for which the amplitudes are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeChannelAmplitudes_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.computeChannelAmplitudes_2pAbsorptionMonochromatic( line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute all amplitudes and properties of the given line; a line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic is returned for which the amplitudes and properties are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeCsPerK_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeCsPerK_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the unpolarized cross section RESOLVED BY the rank K; a contributions::Array{Tuple{AngularJ64,Float64},1} is returned.
THIS IS THE ACCEPTANCE TEST OF THE WHOLE SCHEME, not a display convenience. Odd K must be present for two
colours and must vanish as omega1 -> omega2; K-resolving the cross section is the only way to see it
happen, and it is the same technique that exposed the emission exchange-phase bug (blocker A1), where
K = 1 was carrying 48 % of a rate in which it must vanish.JenaAtomicCalculator.MultiPhotonTransition.computeEnergyDiffCs — Method
MultiPhotonTransition.computeEnergyDiffCs(sharing::MultiPhotonTransition.Sharing_2pEmission, line::MultiPhotonTransition.Line_2pEmission, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the energy differential cross section for the given line and the energy sharing omega1. A dcs::Float64 is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeLines — Method
MultiPhotonTransition.computeLines(scheme::ThreePhotonAbsorptionScheme, finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; output=true) ... to compute the three-photon absorption strengths for three parallel linearly-polarized beams; a list of lines::Array{MultiPhotonTransition.Line_3pAbsorption,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeLines — Method
MultiPhotonTransition.computeLines(scheme::ThreePhotonEmissionScheme, finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; output=true) ... to compute three-photon emission lines. The AMPLITUDE is not implemented and an informative error is raised – except under calcOverview, which displays the piece that IS implemented and verified, namely the energy sharings on the simplex and their sum-rule check.
JenaAtomicCalculator.MultiPhotonTransition.computeLines — Method
MultiPhotonTransition.computeLines(scheme::TwoPhotonAbsorptionBichromaticScheme, finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; output=true) ... to compute the two-photon absorption lines for two beams of different frequency; a list of lines::Array{MultiPhotonTransition.Line_2pAbsorptionBichromatic,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeLines — Method
MultiPhotonTransition.computeLines(scheme::TwoPhotonAbsorptionScheme, finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; output=true) ... to compute the multiphoton transition amplitudes and all properties as requested by the given settings. A list of lines::Array{MultiPhotonTransition.Line_2pAbsorptionMonochromatic,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeLines — Method
MultiPhotonTransition.computeLines(scheme::TwoPhotonEmissionScheme, finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; output=true) ... to compute the multiphoton transition amplitudes and all properties as requested by the given settings. A list of lines::Array{MultiPhotonTransition.Line_2pEmission,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeProperties_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeProperties_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute all requested properties of the given line; a line::MultiPhotonTransition.Line_2pAbsorptionBichromatic is returned for which the properties are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeProperties_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.computeProperties_2pAbsorptionMonochromatic( line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute all amplitudes and properties of the given line; a line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic is returned for which the amplitudes and properties are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeProperties_2pEmission — Method
MultiPhotonTransition.computeProperties_2pEmission(line::MultiPhotonTransition.Line_2pEmission, grid::Radial.Grid, settings::MultiPhotonTransition.Settings) ... to compute all properties of the given line; a line::MultiPhotonTransition.Line_2pEmission is returned for which the properties are now evaluated.
JenaAtomicCalculator.MultiPhotonTransition.computeReducedAmplitudeAbsorption — Function
MultiPhotonTransition.computeReducedAmplitudeAbsorption(K::AngularJ64, finalLevel::Level, multipole2::EmMultipole, Jsym::LevelSymmetry, omega::Float64, multipole1::EmMultipole, initialLevel::Level, gauge::EmGauge, grid::Radial.Grid, intermediateStates::Union{Multiplet,Array{AtomicState.GreenChannel,1}}, selfTolerance::Float64=1.0e-8) ... to compute the reduced amplitude U^{K, 2gamma emission} (K, Jf, multipole2, Jsym, omega, multipole1, Ji) by means of the given Green function/multiplet channels. An amplitude::Complex{Float64} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeReducedAmplitudeBichromatic — Function
MultiPhotonTransition.computeReducedAmplitudeBichromatic(K::AngularJ64, finalLevel::Level, omegaB::Float64, multipoleB::EmMultipole, Jsym::LevelSymmetry, omegaA::Float64, multipoleA::EmMultipole, initialLevel::Level, gauge::EmGauge, grid::Radial.Grid, intermediateStates::Union{Multiplet,Array{AtomicState.GreenChannel,1}}, selfTolerance::Float64=1.0e-8) ... to compute ONE time ordering of the reduced two-photon absorption amplitude for two beams of different frequency: the photon (omegaA, multipoleA) is absorbed FIRST and (omegaB, multipoleB) SECOND. An amplitude::Complex{Float64} is returned.
THE ONLY DIFFERENCE from the monochromatic `computeReducedAmplitudeAbsorption` is that the two photons
carry their own energies: the denominator belongs to the photon absorbed FIRST, E_i + omegaA - E_nu,
while each matrix element is evaluated at the energy of ITS OWN photon. Calling this routine twice with
the two roles exchanged gives the two orderings, which for a single beam coincide and here do not.JenaAtomicCalculator.MultiPhotonTransition.computeReducedAmplitudeEmission — Function
MultiPhotonTransition.computeReducedAmplitudeEmission(K::AngularJ64, finalLevel::Level, omega2::Float64, multipole2::EmMultipole, Jsym::LevelSymmetry, omega1::Float64, multipole1::EmMultipole, initialLevel::Level, gauge::EmGauge, grid::Radial.Grid, intermediateStates::Union{Multiplet,Array{AtomicState.GreenChannel,1}}, selfTolerance::Float64=1.0e-8) ... to compute the reduced amplitude U^{K, 2gamma emission} (K, Jf, omega2, multipole2, Jsym, omega1, multipole1, Ji) by means of the given Green function channels. An amplitude::Complex{Float64} is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeStrength_3pAbsorption — Method
MultiPhotonTransition.computeStrength_3pAbsorption(finalLevel::Level, initialLevel::Level, omegas::Array{Float64,1}, gauge::EmGauge, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; noOrderings::Int64=6) ... to compute the three-photon transition strength S^(3) = 1/(2Ji+1) sumM |A(M)|^2 for three parallel linearly-polarized beams of the given energies; a strength::Float64 is returned.
THE AMPLITUDE, for one time ordering (a, b, c) of the three photons and with all polarizations along z,
so that only the q = 0 components contribute and M is conserved:
A(M) = sum_(nu1,nu2) (-1)^(J_f-M) 3j(J_f, L_c, J_nu2; -M, 0, M)
(-1)^(J_nu2-M) 3j(J_nu2, L_b, J_nu1; -M, 0, M)
(-1)^(J_nu1-M) 3j(J_nu1, L_a, J_i; -M, 0, M)
<f||O(L_c,w_c)||nu2> <nu2||O(L_b,w_b)||nu1> <nu1||O(L_a,w_a)||i>
/ [(E_i + w_a - E_nu1) (E_i + w_a + w_b - E_nu2)]
summed coherently over all 3! = 6 orderings. Note the two denominators: the intermediate state after the
first absorption sits at E_i + w_a, the one after the second at E_i + w_a + w_b.
`noOrderings` exists only for the acceptance test: setting it to 1 keeps the single ordering (1,2,3), so
that the monochromatic limit can be checked to give exactly 6 times that amplitude.JenaAtomicCalculator.MultiPhotonTransition.computeTotalAlpha0 — Method
MultiPhotonTransition.computeTotalAlpha0(line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the (total) alpha_0 parameter for the two-photon absorption line. A ta0::Float64 is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsLinear — Method
MultiPhotonTransition.computeTotalCsLinear(line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross sections for linearly-polarized incident light. A tcs::Float64 is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsLinear_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeTotalCsLinear_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross section for two linearly-polarized beams. A tcs::Float64 is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsRightCircular — Method
MultiPhotonTransition.computeTotalCsRightCircular(line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross sections for right-cicularly polarized incident light. A tcs::Float64 is returned.
WRITTEN 08-Aug-2026. Until then the body of this routine was the comment "Need to be filled" followed by
the prefactor, so it returned EXACTLY ZERO for every input -- for every atom, every transition and every
gauge. That matters beyond the missing feature: the observation "right-circular light vanishes
identically", recorded as a parameter-free check for the hydrogen and magnesium branches of
example-Dh.jl, was produced by a routine that computed nothing and was therefore VACUOUS. Both cases
happen to be ones where zero is also the right answer, which is exactly why it went unnoticed.
THE FACTOR 2 IS A NORMALISATION and is derived, not guessed. A photon linearly polarized along x is the
helicity combination c_lambda = -lambda/sqrt(2), while `computeTotalCsLinear` and
`computeTotalCsUnpolarized` write the helicity sum WITHOUT the 1/sqrt(2) -- so both carry a common factor
2 per photon, i.e. 4 in the cross section. Right-circular light is the single term c_(+1) = 1, so it must
be multiplied by sqrt(2) per photon, i.e. by 2 in the amplitude, to be expressed in the same units. Only
then are the three polarization cross sections mutually comparable, which is the whole value of computing
them from one set of amplitudes.
VERIFIED where the answer is NOT zero, since a routine returning zero is what was being replaced: for
H 1s -> 3d, where J_f = 3/2, 5/2 admit K = 2 and two photons of equal helicity can be absorbed, this
gives right-circular/linear = 1.5 exactly, against 0.8/0.5333 = 1.5 from the 3-j weights of a pure K = 2
channel. The same ratio comes out of the independently written bichromatic routine.
ODD K cannot contribute for two photons of EQUAL helicity: with L1 = L2 the 3-j is antisymmetric under
exchanging the two identical helicity labels, so it vanishes identically. The guard below is therefore
redundant here -- it is kept for parity with `computeTotalCsUnpolarized`, where it is NOT redundant, and
removing it must leave every number unchanged.JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsRightCircular_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeTotalCsRightCircular_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross section for two right-circularly polarized beams. A tcs::Float64 is returned.
THE FACTOR 2 IN THE AMPLITUDE IS A NORMALISATION, not a physical factor, and it is derived rather than
guessed. A photon of linear polarization along x is the helicity combination c_lambda = -lambda/sqrt(2),
while the routines above write the coherent helicity sum WITHOUT the 1/sqrt(2) -- so both the linear and
the unpolarized cross sections carry a common factor 2 per photon, i.e. 4 in the cross section. Right
circular light is the single term c_(+1) = 1, so to be expressed in the SAME units it must be multiplied
by sqrt(2) per photon, i.e. by 2 in the amplitude. Only then are the three polarization cross sections
mutually comparable, which is the entire value of computing them together.
VERIFIED, and deliberately not on a case where zero is the answer. For H 1s -> 2s this routine returns
exactly 0, which is correct -- J = 1/2 -> 1/2 admits K <= 1 while two photons of equal helicity require
|q| = 2 and hence K >= 2 -- but it is also what a routine computing nothing would return. The test is
therefore H 1s -> 3d, where K = 2 is open: right-circular comes out NON-ZERO, and the ratio to linear
light is 1.500000 for both J_f = 3/2 and J_f = 5/2, against the value 0.8/0.5333 = 1.5 that the 3-j
weights alone predict for a pure K = 2 channel. That fixes the factor 2 above independently of the
amplitude and of the absolute normalisation.
NOTE that the corresponding MONOCHROMATIC routine, computeTotalCsRightCircular, has never been filled in:
its body is a comment reading "Need to be filled" and it returns zero for every input. Any earlier
observation that right-circular light gives exactly 0.0000 there is therefore vacuous, whatever the
physics of the case; it is left untouched here because this file may change only its own scheme.JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsUnpolarized — Method
MultiPhotonTransition.computeTotalCsUnpolarized(line::MultiPhotonTransition.Line_2pAbsorptionMonochromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross sections for linearly-polarized incident light. A tcs::Float64 is returned.
JenaAtomicCalculator.MultiPhotonTransition.computeTotalCsUnpolarized_2pAbsorptionBichromatic — Method
MultiPhotonTransition.computeTotalCsUnpolarized_2pAbsorptionBichromatic( line::MultiPhotonTransition.Line_2pAbsorptionBichromatic, gauge::EmGauge, settings::MultiPhotonTransition.Settings) ... to compute the total cross section for two unpolarized beams. A tcs::Float64 is returned.
THE PREFACTOR is taken over from the monochromatic routine with the single generalisation
1/omega^2 -> 1/(omega1 * omega2), which is the only replacement consistent with the monochromatic limit.
IT IS NOT DERIVED, and neither is the monochromatic one: the absorption normalisation of this module has
never been established, unlike the emission prefactor whose residual discrepancy is at least localised to
the constant 6.679. The POLARIZATION RATIOS, the odd-K behaviour and the omega1 <-> omega2 invariance are
independent of it and are what this scheme can legitimately claim today.
ON THE SINGLE-BEAM CONVENTION, which this scheme was meant to fix. The limit omega1 -> omega2 gives
exactly FOUR times the monochromatic cross section, and that factor decomposes into two parts that must
not be confused: (i) a factor 4 = 2^2 because the monochromatic routine keeps only ONE of the two time
orderings in its amplitude, which is a genuine amplitude-level deficiency and not a convention; and
(ii) the flux counting, F_1 F_2 versus F^2 or F^2/2 for one beam, which IS a convention and is untouched
by anything computed here. Part (i) is measured and reproducible; part (ii) still needs the normalisation
to be derived. The monochromatic routine is deliberately NOT patched from this observation, because
changing it would move every absorption number in the module on the strength of an argument that has not
been carried through to the absolute scale.
MEASURED, H 1s -> 2s, Babushkin (work/diag-bichromatic.jl):
x = omega1/(E_f-E_i) unpolarized linear/unpol odd-K fraction bichromatic/monochromatic
0.1 1.607734e-09 0.211197 8.944013e-01 145.060
0.25 3.006394e-10 0.436600 7.817002e-01 27.126
0.4 7.474408e-11 1.254942 3.725292e-01 6.744
0.49 4.462238e-11 1.988122 5.938897e-03 4.026
0.499 4.433576e-11 1.999881 5.974393e-05 4.000261
0.4999 4.433290e-11 1.999999 5.974750e-07 4.000003
THREE THINGS ARE VISIBLE AT ONCE, and none of them needs a normalisation. The ratio to the monochromatic
result converges to 4.000003, the derived value. The odd-K fraction falls by exactly 100 for every factor
10 in (0.5 - x), i.e. QUADRATICALLY in omega1 - omega2 -- as it must, since the odd-K amplitude is the
DIFFERENCE of the two orderings and that difference is linear in the detuning. And linear/unpolarized
approaches 2.0000, the value the monochromatic scheme gives, only once odd K has switched off; away from
the merge point it differs precisely because odd K contributes to one of the two and not to the other.JenaAtomicCalculator.MultiPhotonTransition.determineChannels_2pAbsorptionBichromatic — Method
MultiPhotonTransition.determineChannels_2pAbsorptionBichromatic(omega1::Float64, omega2::Float64, finalLevel::Level, initialLevel::Level, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition.Channel2pAbsorptionBichromatic for a transition from the initial to the final level and by taking the particular settings of this computation into account; an Array{MultiPhotonTransition.Channel2pAbsorptionBichromatic,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.determineChannels_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.determineChannels_2pAbsorptionMonochromatic(omega::Float64, finalLevel::Level, initialLevel::Level, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition.Channel2pAbsorptionMonochromatic for a transitions from the initial to final level and by taking into account the particular settings of for this computation; an Array{MultiPhotonTransition.Channel2pAbsorptionMonochromatic,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.determineLines_2pAbsorptionBichromatic — Method
MultiPhotonTransition.determineLines_2pAbsorptionBichromatic(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition.Line2pAbsorptionBichromatic's for transitions between the levels of the given initial- and final-state multiplets and by taking the particular selections and settings of this computation into account; an Array{MultiPhotonTransition.Line2pAbsorptionBichromatic,1} is returned. Apart from the level specification, all physical properties are set to zero during this initialization process.
JenaAtomicCalculator.MultiPhotonTransition.determineLines_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.determineLines_2pAbsorptionMonochromatic(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition.Line2pAbsorptionMonochromatic's for transitions between the levels from the given initial- and final-state multiplets and by taking into account the particular selections and settings for this computation; an Array{MultiPhotonTransition.Line2pAbsorptionMonochromatic,1} is returned. Apart from the level specification, all physical properties are set to zero during this initialization process.
JenaAtomicCalculator.MultiPhotonTransition.determineLines_2pEmission — Method
MultiPhotonTransition.determineLines_2pEmission(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition.Line2pEmission's for transitions between the levels from the given initial- and final-state multiplets and by taking into account the particular selections and settings for this computation; an Array{MultiPhotonTransition.Line2pEmission,1} is returned. Apart from the level specification, all physical properties are set to zero during this initialization process.
JenaAtomicCalculator.MultiPhotonTransition.determineOmegas_3pAbsorption — Method
MultiPhotonTransition.determineOmegas_3pAbsorption(energy::Float64, scheme::ThreePhotonAbsorptionScheme) ... to determine the three photon energies (in atomic units) from the scheme and the transition energy; an omegas::Array{Float64,1} is returned.
omega1 = omega2 = 0 selects the MONOCHROMATIC case, all three photons carrying energy/3. Otherwise the
two given energies are read in the user-selected units, like every other photon energy in JAC, and the
third follows from energy conservation.JenaAtomicCalculator.MultiPhotonTransition.determineSharingsAndChannels — Method
MultiPhotonTransition.determineSharingsAndChannels(finalLevel::Level, initialLevel::Level, energy::Float64, settings::MultiPhotonTransition.Settings) ... to determine a list of MultiPhotonTransition 2pEmission Sharing's and Channel's for a transitions from the initial to final level and by taking into account the particular settings of for this computation; an Array{MultiPhotonTransition.Sharing_2pEmission,1} is returned.
JenaAtomicCalculator.MultiPhotonTransition.determineSharings_3p — Method
MultiPhotonTransition.determineSharings_3p(energy::Float64, noSharings::Int64) ... to determine the energy sharings of the total energy among three photons, placed on a tensor Gauss-Legendre grid over the two-dimensional simplex; an Array{MultiPhotonTransition.Sharing_3p,1} with noSharings^2 entries is returned.
The weights integrate with respect to domega1 domega2 and already contain the Jacobian of the
collapsed-coordinate map; see the header of this file and `checkSharings_3p`, which verifies them
against the exact simplex moments rather than asserting them.JenaAtomicCalculator.MultiPhotonTransition.displayDifferentialRates_2pEmission — Method
MultiPhotonTransition.displayDifferentialRates_2pEmission(stream::IO, lines::Array{MultiPhotonTransition.Line_2pEmission,1}, settings::MultiPhotonTransition.Settings) ... to display all differential rates, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayIntermediateRanking — Method
MultiPhotonTransition.displayIntermediateRanking(stream::IO, lines::Array{MultiPhotonTransition.Line_2pEmission,1}, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; nShow::Int64=15) ... to rank, for every selected line, the intermediate levels |nu> by their contribution to the second-order sum, and to print them together with their energy denominators; nothing is returned.
THIS IS WHAT calcOverview EXISTS FOR. The intermediate sum is both the expensive part of a two-photon
calculation and the delicate one, and three questions about it cannot be answered from a configuration
list -- only from the numbers:
* WHICH intermediate levels actually carry the transition. Usually a handful dominate and the rest are
noise, so `intermediateStates` can be chosen from evidence instead of guessed.
* WHETHER any denominator is near-resonant. A small (E_i + omega1 - E_nu) makes one term dominate and
puts the whole non-resonant perturbative treatment in doubt; that is the physical boundary between
non-resonant and resonant two-photon decay. `selfTolerance` removes the exactly singular term, but a
merely SMALL denominator is far more dangerous, because it produces a large finite number that looks
like a result.
* WHETHER the basis is big enough. If the largest contributions sit on the highest levels included,
the sum is truncated too early and the answer is not converged, however smooth it looks.
Only the first sharing of each line is scanned: the ranking is a diagnostic of the intermediate basis,
which barely changes across sharings, and scanning all of them would defeat the purpose of a cheap pass.JenaAtomicCalculator.MultiPhotonTransition.displayIntermediateRanking_2pAbsorptionBichromatic — Method
MultiPhotonTransition.displayIntermediateRanking_2pAbsorptionBichromatic(stream::IO, lines::Array{MultiPhotonTransition.Line_2pAbsorptionBichromatic,1}, grid::Radial.Grid, settings::MultiPhotonTransition.Settings; nShow::Int64=15) ... to rank, for every selected line, the intermediate levels |nu> by their contribution to the second-order sum and to print them together with BOTH energy denominators; nothing is returned.
TWO DENOMINATORS, ONE PER BEAM, and that is what makes this table more than the emission analogue. With
two colours the near-resonant case is not an accident to be avoided but the regime an experiment actually
works in: one tunes omega1 close to a real intermediate level to gain orders of magnitude. Seeing
E_i + omega1 - E_nu and E_i + omega2 - E_nu side by side is what tells the user how close the chosen
colours already are to that boundary -- and beyond it the non-resonant expression computed here no longer
applies at all.
READ THIS TABLE IN THE LENGTH (BABUSHKIN) GAUGE, and the gauge is printed for that reason. Measured with
work/diag-omega-dependence.jl, for H at fixed levels and omega varied over a factor 40:
<2s| d(omega) |nu> omega = 0.5 2.0 6.0 20.0 eV
nu = 2p, Babushkin 1.884e-4 7.534e-4 2.260e-3 7.533e-3 <- exactly proportional to omega
nu = 2p, Coulomb 5.971e-6 5.970e-6 5.960e-6 5.851e-6 <- independent of omega
nu = 3p, Babushkin 1.337e-4 5.350e-4 1.605e-3 5.347e-3
nu = 3p, Coulomb 4.045e-4 4.045e-4 4.045e-4 4.043e-4
The LENGTH form carries the photon energy it is given. The VELOCITY form does not: by the commutator
identity <f|p|i> = i m (E_f - E_i) <f|r|i> it carries the LEVEL difference instead, which is the same
thing only ON SHELL. In a second-order sum the intermediate step is off shell by construction, and the
consequence here is severe rather than cosmetic: for H 1s -> 2s the NEARLY DEGENERATE 2p intermediate --
physically the dominant one -- is suppressed in the Coulomb ranking by a factor 250, which is precisely
the ratio of the level gaps (2s-3p over 2s-2p = 276). It then ranks BELOW 3p and 4p, which is backwards.
In Babushkin, 2p correctly comes out largest.
THIS IS NOT SPECIFIC TO THE BICHROMATIC SCHEME. Every second-order sum in this module calls the same
PhotoEmission.amplitude, so the observation applies to the emission and monochromatic-absorption paths
as well; it is recorded here because this is where it was found, and it is an independent reason -- with
a mechanism -- for the long-standing observation that Babushkin is the trustworthy gauge in this module.JenaAtomicCalculator.MultiPhotonTransition.displayKContributions_2pAbsorptionBichromatic — Method
MultiPhotonTransition.displayKContributions_2pAbsorptionBichromatic(stream::IO, lines::Array{MultiPhotonTransition.Line_2pAbsorptionBichromatic,1}, settings::MultiPhotonTransition.Settings) ... to display the unpolarized cross section resolved by the rank K, together with the fraction carried by ODD K. Nothing is returned.
THE ODD-K FRACTION IS THE POINT OF THIS TABLE. For a single beam it must be exactly zero (two identical
bosons, blocker A2); here it must be non-zero, and it must fall to zero continuously as omega1 -> omega2.
Printing it with every run makes that the default observation rather than a special diagnostic, since it
is the one statement this scheme can make that no absolute normalisation is needed for.JenaAtomicCalculator.MultiPhotonTransition.displayLines_2pAbsorptionBichromatic — Method
MultiPhotonTransition.displayLines_2pAbsorptionBichromatic( lines::Array{MultiPhotonTransition.Line_2pAbsorptionBichromatic,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayLines_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.displayLines_2pAbsorptionMonochromatic(lines::Array{MultiPhotonTransition.Line_2pAbsorptionMonochromatic,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayLines_2pEmission — Method
MultiPhotonTransition.displayLines_2pEmission(lines::Array{MultiPhotonTransition.Line_2pEmission,1}) ... to display a list of lines, sharings & (reduced) channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayResults_2pAbsorptionBichromatic — Method
MultiPhotonTransition.displayResults_2pAbsorptionBichromatic(stream::IO, properties::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}, lines::Array{MultiPhotonTransition.Line_2pAbsorptionBichromatic,1}) ... to display all results, energies, cross sections, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayResults_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.displayResults_2pAbsorptionMonochromatic(stream::IO, properties::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}, lines::Array{MultiPhotonTransition.Line_2pAbsorptionMonochromatic,1}) ... to display all results, energies, rates, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayResults_3pAbsorption — Method
MultiPhotonTransition.displayResults_3pAbsorption(stream::IO, lines::Array{MultiPhotonTransition.Line_3pAbsorption,1}) ... to display the three-photon absorption strengths of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displaySharings_3p — Method
MultiPhotonTransition.displaySharings_3p(stream::IO, energy::Float64, noSharings::Int64) ... to display the three-photon energy sharings together with the sum-rule check of their weights; nothing is returned.
JenaAtomicCalculator.MultiPhotonTransition.displayTotalAlpha0_2pAbsorptionMonochromatic — Method
MultiPhotonTransition.displayTotalAlpha0_2pAbsorptionMonochromatic(stream::IO, properties::Array{MultiPhotonTransition.AbstractMultiPhotonProperty,1}, lines::Array{MultiPhotonTransition.Line_2pAbsorptionMonochromatic,1}) ... to display all results, energies, rates, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.displayTotalRates_2pEmission — Method
MultiPhotonTransition.displayTotalRates_2pEmission(stream::IO, lines::Array{MultiPhotonTransition.Line_2pEmission,1}, settings::MultiPhotonTransition.Settings) ... to display all total rates, etc. of the selected lines. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.MultiPhotonTransition.getReducedAmplitudeAbsorption — Method
MultiPhotonTransition.getReducedAmplitudeAbsorption(K::AngularJ64, finalLevel::Level, multipole2::EmMultipole, Jsym::LevelSymmetry, omega::Float64, multipole1::EmMultipole, initialLevel::Level, gauge::EmGauge, channels::Array{MultiPhotonTransition.Channel_2pAbsorptionMonochromatic,1}) ... to get/return the reduced amplitude U^{K, 2gamma absorption} (K, Jf, multipole2, Jsym, omega, multipole1, Ji) from the calculated list of channels. An amplitude::Complex{Float64} is returned.
JenaAtomicCalculator.MultiPhotonTransition.getReducedAmplitudeBichromatic — Method
MultiPhotonTransition.getReducedAmplitudeBichromatic(K::AngularJ64, multipole1::EmMultipole, multipole2::EmMultipole, Jsym::LevelSymmetry, gauge::EmGauge, channels::Array{MultiPhotonTransition.Channel_2pAbsorptionBichromatic,1}) ... to get/return the FULL reduced amplitude of the given channel, i.e. the coherent sum of the two time orderings; an amplitude::Complex{Float64} is returned.
THE EXCHANGE PHASE (-1)^(L1+L2-K) is applied to the second ordering. It is not a symmetrization -- the
two photons here are distinguishable -- but the price of writing both orderings in the SAME coupling
order [O(mp2) (x) O(mp1)]^K; interchanging two coupled tensors carries exactly this phase. It is the same
factor that blocker A1 corrected in the emission file, where it appears for the other reason.
THE MONOCHROMATIC LIMIT IS BUILT INTO THIS LINE. As omega1 -> omega2 the two orderings become equal term
by term, so the sum tends to (1 + (-1)^(L1+L2-K)) times one ordering: 2 U for even K (E1E1) and exactly
zero for odd K. The vanishing of odd K for a single beam is therefore not imposed here by a rule, as it
is in the monochromatic routine, but emerges continuously as the two colours merge.JenaAtomicCalculator.MultiPhotonTransition.getReducedAmplitudeEmission — Method
MultiPhotonTransition.getReducedAmplitudeEmission(K::AngularJ64, finalLevel::Level, omega2::Float64, multipole2::EmMultipole, Jsym::LevelSymmetry, omega1::Float64, multipole1::EmMultipole, initialLevel::Level, gauge::EmGauge, sharings::Array{MultiPhotonTransition.Sharing_2pEmission,1}) ... to get/return the reduced amplitude U^{K, 2gamma emission} (K, Jf, omega2, multipole2, Jsym, omega1, multipole1, Ji) from the calculated list of channels. An amplitude::Complex{Float64} is returned.
JenaAtomicCalculator.MultiPhotonTransition.intermediateLevels — Method
MultiPhotonTransition.intermediateLevels(mp::Multiplet, Jsym::LevelSymmetry) or MultiPhotonTransition.intermediateLevels(gChannels::Array{AtomicState.GreenChannel,1}, Jsym::LevelSymmetry) ... to return those intermediate levels |nu> that carry the total symmetry Jsym and hence contribute to the second-order sum for that symmetry; an Array{Level,1} is returned, empty if the basis does not span it.
THIS IS THE ONE PLACE where the two intermediate-state representations differ, and isolating it here is
what lets every amplitude routine in this module be written once rather than twice. A mean-field
Multiplet must be FILTERED by symmetry, whereas a Green expansion is already organised into channels of
definite symmetry and only needs the matching channel selected.JenaAtomicCalculator.MultiPhotonTransition.intermediateLevels — Method
MultiPhotonTransition.intermediateLevels(gChannels::Array{AtomicState.GreenChannel,1}, Jsym::LevelSymmetry) ... collects the levels of those Green channels whose symmetry equals Jsym, i.e. the intermediate states that can contribute to a second-order amplitude of that total symmetry. A levels::Array{Level,1} is returned, empty if no channel matches.
JenaAtomicCalculator.MultiPhotonTransition.isStepAllowed — Method
MultiPhotonTransition.isStepAllowed(symA::LevelSymmetry, mp::EmMultipole, symB::LevelSymmetry) ... to decide whether a one-photon step of multipolarity mp can connect the two level symmetries; a Bool is returned. Both the triangle rule and the parity rule are applied.
THIS GUARD IS NOT OPTIONAL. `AngularMomentum.Wigner_3j` raises a DomainError for arguments that violate
its own domain rather than returning zero, so forbidden steps must be filtered out before they are
reached, not afterwards.JenaAtomicCalculator.MultiPhotonTransition.stringIntermediateStates — Method
MultiPhotonTransition.stringIntermediateStates(mp::Multiplet) or MultiPhotonTransition.stringIntermediateStates(gChannels::Array{AtomicState.GreenChannel,1}) ... to describe the intermediate-state representation in ONE line, without printing every level of it; a String is returned. The previous Base.show printed the whole gMultiplet, which for any realistic intermediate basis buried everything else in the settings.
JenaAtomicCalculator.MultiPhotonTransition.stringIntermediateStates — Method
MultiPhotonTransition.stringIntermediateStates(gChannels::Array{AtomicState.GreenChannel,1}) ... summarises a Green expansion for printing – how many channels it has and how many levels in total. A sa::String is returned; nothing is computed from it.
Particle scattering
JenaAtomicCalculator.ParticleScattering.AbstractInteractionModel — Type
abstract type ParticleScattering.AbstractInteractionModel ... defines an abstract type for how the target is represented to the projectile. This is the axis along which the ELSEPA code is organised, and it is kept separate from the projectile and the beam so that a further model is one new subtype plus one new method of ParticleScattering.scatteringPotential.
+ struct StaticField ... the electrostatic interaction with the target density alone.
+ struct StaticFieldSlaterExchange ... the static field plus JAC's Slater exchange term (not recommended).
+ struct StaticFieldFurnessMcCarthy ... the static field plus the energy-dependent Furness-McCarthy exchange.JenaAtomicCalculator.ParticleScattering.AbstractProjectile — Type
abstract type ParticleScattering.AbstractProjectile ... defines an abstract type to distinguish the (massive) projectiles that are scattered at an atom or ion. Photons are NOT among them: photon scattering is a second-order matrix element over intermediate atomic states and is computed by the RayleighCompton module, which shares no computational core with the potential scattering treated here.
+ struct Electron ... an electron as projectile.
+ struct Positron ... a positron as projectile; the static field changes sign and no exchange term applies.
+ struct Proton ... a proton as projectile.JenaAtomicCalculator.ParticleScattering.AbstractScatteringProcess — Type
abstract type ParticleScattering.AbstractScatteringProcess ... defines an abstract type to distinguish the scattering processes; the process fixes which final levels may be reached and, with it, how many independent amplitudes the scattering matrix requires.
+ struct ElasticScattering ... the target is left in its initial level.
+ struct InelasticScattering ... the target is left excited (not yet implemented).
+ struct Annihilation1Photon ... the projectile POSITRON annihilates with one bound electron under emission of a single photon.
There is deliberately no Annihilation2Photon. The two-photon channel is second order and would need MultiPhotonTransition's
Green-function sum over intermediate states adapted to a positron continuum; see the header of
module-ParticleScattering-inc-annihilation.jl for why it is not placed here.JenaAtomicCalculator.ParticleScattering.AngularObservables — Type
struct ParticleScattering.AngularObservables ... defines a type for the observables of a scattering event at one scattering angle (theta, phi).
+ theta ::Float64 ... polar scattering angle [rad].
+ phi ::Float64 ... azimuthal scattering angle [rad].
+ dcs ::Float64 ... differential cross section d sigma / d Omega [a.u.].
+ sherman ::Float64 ... Sherman function S; defined for elastic scattering from a spinless target and
returned as NaN wherever that projection does not apply.JenaAtomicCalculator.ParticleScattering.AngularObservables — Method
ParticleScattering.AngularObservables() ... constructor for a default ParticleScattering.AngularObservables. A angularObservables::ParticleScattering.AngularObservables is returned.
JenaAtomicCalculator.ParticleScattering.Annihilation1Photon — Type
... one-photon annihilation of the projectile positron with a BOUND electron, leaving the ion with one electron less: e^+ + |i(N)> –> |f(N-1)> + photon. Impossible for a free electron, since a single photon cannot balance energy and momentum at once; it is the nucleus taking up the recoil that opens the channel, which is why the process lives only in a bound system and why its cross section rises steeply with Z.
JenaAtomicCalculator.ParticleScattering.AnnihilationChannel — Type
struct ParticleScattering.AnnihilationChannel ... defines a type for one reduced amplitude of the one-photon annihilation of the projectile positron with a bound electron, i.e. for one partial wave of the incoming positron, one photon multipole and one gauge.
+ kappa ::Int64 ... kappa of the incoming positron partial wave.
+ multipole ::EmMultipole ... multipole of the emitted photon.
+ gauge ::EmGauge ... gauge in which this amplitude was evaluated.
+ totalSymmetry ::LevelSymmetry ... J^pi of the coupled (ion + positron) system; amplitudes sharing it interfere.
+ amplitude ::ComplexF64 ... the reduced amplitude itself.JenaAtomicCalculator.ParticleScattering.AnnihilationChannel — Method
ParticleScattering.AnnihilationChannel() ... constructor for a default ParticleScattering.AnnihilationChannel. A annihilationChannel::ParticleScattering.AnnihilationChannel is returned.
JenaAtomicCalculator.ParticleScattering.AnnihilationLine — Type
struct ParticleScattering.AnnihilationLine ... defines a type for the one-photon annihilation of a positron of one impact energy with the bound electrons of one initial level, leaving one final level of the ion with one electron less.
+ initialLevel ::Level ... initial level of the N-electron target.
+ finalLevel ::Level ... final level of the (N-1)-electron ion.
+ positronEnergy ::Float64 ... kinetic energy of the incoming positron [a.u.].
+ photonEnergy ::Float64 ... energy of the emitted photon [a.u.], fixed by energy conservation, see the file header.
+ crossSection ::EmProperty ... total annihilation cross section, in both gauges.
+ channels ::Array{ParticleScattering.AnnihilationChannel,1} ... the reduced amplitudes; the primary result.JenaAtomicCalculator.ParticleScattering.AnnihilationLine — Method
ParticleScattering.AnnihilationLine() ... constructor for a default ParticleScattering.AnnihilationLine. A annihilationLine::ParticleScattering.AnnihilationLine is returned.
JenaAtomicCalculator.ParticleScattering.ElasticScattering — Type
... elastic scattering, i.e. the target is left in its initial level.
JenaAtomicCalculator.ParticleScattering.Electron — Type
... an electron as projectile; the local exchange term of the interaction model applies to it.
JenaAtomicCalculator.ParticleScattering.Event — Type
struct ParticleScattering.Event ... defines a type to collect the data and results of a single scattering event, i.e. of one projectile of one energy prepared in one beam and scattered from one initial into one final level.
+ projectile ::ParticleScattering.AbstractProjectile ... the scattered particle.
+ process ::ParticleScattering.AbstractScatteringProcess ... elastic or inelastic.
+ interaction ::ParticleScattering.AbstractInteractionModel ... how the target is represented.
+ beamType ::Beam.AbstractBeamType ... how the projectile is prepared.
+ initialLevel ::Level ... initial level of the target.
+ finalLevel ::Level ... final level of the target.
+ impactEnergy ::Float64 ... kinetic energy of the projectile [a.u.].
+ partialWaves ::Array{ParticleScattering.PartialWave,1} ... the phase shifts that were computed.
+ channels ::Array{ParticleScattering.ScatteringChannel,1} ... the reduced amplitudes; the primary result.
+ angular ::Array{ParticleScattering.AngularObservables,1} ... derived, one per requested (theta, phi).
+ integrated ::ParticleScattering.IntegratedObservables ... derived, the angle-integrated cross sections.JenaAtomicCalculator.ParticleScattering.Event — Method
ParticleScattering.Event() ... constructor for a default ParticleScattering.Event. A event::ParticleScattering.Event is returned.
JenaAtomicCalculator.ParticleScattering.InelasticScattering — Type
... inelastic scattering, i.e. the target is left excited; not yet implemented.
JenaAtomicCalculator.ParticleScattering.IntegratedObservables — Type
struct ParticleScattering.IntegratedObservables ... defines a type for the angle-integrated cross sections of a scattering event. The two transport cross sections are the ones that enter transport and Monte-Carlo simulations, and are what ELSEPA reports alongside the elastic total.
+ sigmaElastic ::Float64 ... total elastic cross section, integral of the DCS over all angles [a.u.].
+ sigmaMomentumTransfer ::Float64 ... first transport cross section sigma_1, weighted by (1 - cos theta) [a.u.].
+ sigmaViscosity ::Float64 ... second transport cross section sigma_2, weighted by sin^2 theta [a.u.].JenaAtomicCalculator.ParticleScattering.IntegratedObservables — Method
ParticleScattering.IntegratedObservables() ... constructor for a default ParticleScattering.IntegratedObservables. A integratedObservables::ParticleScattering.IntegratedObservables is returned.
JenaAtomicCalculator.ParticleScattering.PartialWave — Type
struct ParticleScattering.PartialWave ... defines a type for a single scattering partial wave of the projectile.
+ kappa ::Int64 ... relativistic angular-momentum quantum number of the partial wave.
+ energy ::Float64 ... kinetic energy of the projectile [a.u.].
+ phaseShift ::Float64 ... phase shift delta_kappa of this partial wave.
Only kappa is stored: the orbital and total angular momenta follow from it as l = -kappa-1, j = -kappa-1/2 for
kappa < 0 and l = kappa, j = kappa-1/2 for kappa > 0, and are obtained with Basics.subshell_l(Subshell(101, kappa))
and Basics.subshell_j(...). Carrying l alongside kappa would only give the two a chance to disagree.JenaAtomicCalculator.ParticleScattering.PartialWave — Method
ParticleScattering.PartialWave() ... constructor for a default ParticleScattering.PartialWave. A partialWave::ParticleScattering.PartialWave is returned.
JenaAtomicCalculator.ParticleScattering.Positron — Type
... a positron as projectile; the static field enters with the opposite sign and no exchange term applies.
JenaAtomicCalculator.ParticleScattering.Proton — Type
... a proton as projectile.
JenaAtomicCalculator.ParticleScattering.ScatteringChannel — Type
struct ParticleScattering.ScatteringChannel ... defines a type for one reduced scattering amplitude in a total-angular-momentum coupled basis,
< (alpha_f J_f, eps kappa_f) J^pi || T || (alpha_i J_i, eps kappa_i) J^pi > .
This is the GENERAL object of the module and the one that survives a many-electron target: as soon as the target
carries J_i /= 0 or is left excited, the scattering matrix is a matrix in the magnetic sublevels and cannot be
written with two scalar functions. The familiar direct and spin-flip amplitudes f and g are a projection of these
channels, valid for elastic scattering from a spinless target, and are provided as such.
+ initialKappa ::Int64 ... kappa of the incoming partial wave.
+ finalKappa ::Int64 ... kappa of the outgoing partial wave.
+ totalSymmetry ::LevelSymmetry ... J^pi of the coupled (target + projectile) system.
+ amplitude ::ComplexF64 ... the reduced amplitude itself.JenaAtomicCalculator.ParticleScattering.ScatteringChannel — Method
ParticleScattering.ScatteringChannel() ... constructor for a default ParticleScattering.ScatteringChannel. A scatteringChannel::ParticleScattering.ScatteringChannel is returned.
JenaAtomicCalculator.ParticleScattering.Settings — Type
struct ParticleScattering.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing scattering amplitudes and cross sections.
+ projectile ::ParticleScattering.AbstractProjectile ... the scattered particle.
+ process ::ParticleScattering.AbstractScatteringProcess ... elastic or inelastic scattering.
+ interaction ::ParticleScattering.AbstractInteractionModel ... how the target is represented.
+ beamType ::Beam.AbstractBeamType ... how the projectile is prepared.
+ polarization ::Basics.AbstractPolarization ... polarization of the beam.
+ impactEnergies ::Array{Float64,1} ... impact energies of the projectile.
+ polarThetas ::Array{Float64,1} ... polar scattering angles [rad].
+ polarPhis ::Array{Float64,1} ... azimuthal scattering angles [rad].
+ printBefore ::Bool ... True, if all events are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ epsPartialWave ::Float64
... convergence criterion for the partial-wave series; it is ended once the contribution of one l to the elastic
cross section falls below this fraction of the running total, twice in succession.
+ maxL ::Int64
... hard upper bound on the orbital angular momentum, a backstop rather than the normal way of ending the series;
a computation that reaches it says so.
+ multipoles ::Array{EmMultipole,1}
... photon multipoles to be included; read ONLY by process = Annihilation1Photon() and ignored by the elastic and
inelastic processes, which emit no photon. The annihilation photon carries omega ~ 2 m c^2, i.e. q a_0 ~ 274, so
the multipole series is long wherever the electron is not close to the nucleus; see the file
module-ParticleScattering-inc-annihilation.jl for what that costs.
+ gauges ::Array{UseGauge,1}
... gauges in which the annihilation amplitude is evaluated, again read only by Annihilation1Photon(). Two gauges that
disagree are the standard internal check on a photon amplitude, so both are the default.JenaAtomicCalculator.ParticleScattering.Settings — Method
ParticleScattering.Settings(set::ParticleScattering.Settings; projectile::Union{Nothing,ParticleScattering.AbstractProjectile}=nothing, process::Union{Nothing,ParticleScattering.AbstractScatteringProcess}=nothing, interaction::Union{Nothing,ParticleScattering.AbstractInteractionModel}=nothing, beamType::Union{Nothing,Beam.AbstractBeamType}=nothing, polarization::Union{Nothing,Basics.AbstractPolarization}=nothing, impactEnergies::Union{Nothing,Array{Float64,1}}=nothing, polarThetas::Union{Nothing,Array{Float64,1}}=nothing, polarPhis::Union{Nothing,Array{Float64,1}}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, epsPartialWave::Union{Nothing,Float64}=nothing, maxL::Union{Nothing,Int64}=nothing, multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing)
... constructor for modifying the given ParticleScattering.Settings by 'overwriting' the previously selected parameters.
A `settings::ParticleScattering.Settings` is returned.JenaAtomicCalculator.ParticleScattering.Settings — Method
ParticleScattering.Settings() ... constructor for the default ParticleScattering.Settings. A settings::ParticleScattering.Settings is returned.
JenaAtomicCalculator.ParticleScattering.StaticField — Type
... the electrostatic interaction of the projectile with the nuclear and electronic charge density alone.
JenaAtomicCalculator.ParticleScattering.StaticFieldFurnessMcCarthy — Type
... the static field plus the energy-dependent local exchange potential of Furness and McCarthy, J. Phys. B 6, 2280 (1973), which is the term ELSEPA and the NIST database use. This is the recommended model for electrons and the default.
JenaAtomicCalculator.ParticleScattering.StaticFieldSlaterExchange — Type
... the static field plus the SLATER exchange term carried by JAC's DFS field. That term is designed for a BOUND electron and is too strong for a continuum projectile: at 100 eV on He it raises the transport cross section to 1.157 a0^2 against 0.826 without it, where the reference calculations give 0.834 (TFD) and 0.928 (DHF). Kept because it is what the module used before 17-Aug-2026, not because it is recommended.
JenaAtomicCalculator.ParticleScattering.angularObservables — Method
ParticleScattering.angularObservables(pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64, phi::Float64) ... to compute the differential cross section and the Sherman function at one scattering angle, from the direct and spin-flip amplitudes,
dsigma/dOmega = |f|^2 + |g|^2 , S = i (f g* - f* g) / (|f|^2 + |g|^2) .
An obs::ParticleScattering.AngularObservables is returned.JenaAtomicCalculator.ParticleScattering.annihilationCrossSection — Method
ParticleScattering.annihilationCrossSection(channels::Array{ParticleScattering.AnnihilationChannel,1}, positronEnergy::Float64, photonEnergy::Float64, initialLevel::Level) ... to form the total one-photon annihilation cross section from the evaluated channel amplitudes. Amplitudes that feed the SAME total symmetry J^pi interfere and are therefore summed coherently first; the squared moduli are then summed over J^pi, over the gauges being kept apart, and divided by the statistical weight of the initial level and by the positron flux,
sigma = 8 pi^3 alpha omega / (k_+^2 (2 J_i + 1)) * SUM_{J^pi} | SUM_{kappa, multipole} A |^2 ,
with k_+ the relativistic positron momentum. A crossSection::EmProperty [a.u.] is returned.
THE PREFACTOR IS THE ONE PIECE OF THIS FILE NOT INDEPENDENTLY CHECKED, and it is now known to be inconsistent with its
crossing partner, PhotonScattering.pairCreationCrossSection. The channel structure, the coherent sum within a total symmetry
and the k_+^-2 flux factor are standard; the numerical constant multiplying them was written down rather than derived.
DETAILED BALANCE AGAINST THE CROSSING PARTNER FAILS, and the failure is not yet reduced to one cause. Running the
time-reverse -- helium-like against hydrogen-like uranium at omega = 894.556 keV -- detailed balance requires
sigma_ann / sigma_pc = 573.97 and JAC gives 3.1327e+05 (Coulomb) and 3.2065e+05 (Babushkin), i.e. violation factors of
545.8 and 558.6.
WHAT THAT DOES AND DOES NOT SHOW. It was first read here as a constant of about 4c = 548.14; that reading is WITHDRAWN,
having rested on a single energy point. Comparing the two prefactors directly refutes it: were the amplitudes equal in
both directions, the coded prefactors alone would give a violation of c^2/p_+ = 1326 at this point -- energy-DEPENDENT,
going as 1/p_+, and not 548. The observed 546-559 is 0.41 of that, so the amplitudes are not equal in the two directions
either, and BOTH the prefactor and the amplitude are implicated.
THE SECOND-ENERGY TEST HAS NOW BEEN RUN, and it rules out both simple explanations. Doubling p_+ (T_+ = 100 -> 400 a.u.,
p_+ = 14.1610 -> 28.4345) moves the violation from 545.8/558.6 to 448.3/462.0, i.e. by 0.821 and 0.827. A pure prefactor
error would have given 0.498, a constant one 1.000; it is neither, the implied exponent being about p_+^(-0.28).
The useful part is that the energy dependence is the SAME in both gauges to within half a percent, hence GAUGE-INDEPENDENT,
while the gauge disagreement itself is nearly energy-independent (17.5 -> 17.2 across the same factor of four). So there are
TWO separable faults: a gauge-independent, energy-dependent inconsistency between the two directions -- for which a continuum
NORMALIZATION convention, per unit energy against per unit momentum, is the natural suspect, sitting in how each module uses
the orbital from Continuum.generateOrbitalLocalPotential rather than in the prefactor expressions -- and a gauge-dependent,
energy-independent amplitude defect common to both modules, which example-Of.jl already showed is not a truncation. Suspect
the first one first. See example-Pa.jl branch b, which carries both energy points.JenaAtomicCalculator.ParticleScattering.annihilationPhotonEnergy — Method
ParticleScattering.annihilationPhotonEnergy(finalLevel::Level, initialLevel::Level, positronEnergy::Float64) ... to compute the energy of the single annihilation photon from energy conservation, omega = 2 m c^2 + T+ - (Ef - E_i), where the last bracket is the binding energy of the annihilated electron. Nothing here is adjustable; the expression is the whole content of energy conservation for this process. An omega::Float64 [a.u.] is returned, which is negative – and the channel therefore closed – only for a binding energy in excess of 2 m c^2 plus the impact energy.
JenaAtomicCalculator.ParticleScattering.assertSpinlessTarget — Method
ParticleScattering.assertSpinlessTarget(event::ParticleScattering.Event) ... to test whether the f/g projection applies to the given event, i.e. whether the process is elastic and the target level carries Ji = 0. The decomposition M = f + g (sigma . n) rests on both, and for a target with Ji /= 0 the scattering matrix is a matrix in the magnetic sublevels that two scalar functions cannot represent. Nothing is returned; the function raises where the projection would silently give a wrong number.
JenaAtomicCalculator.ParticleScattering.beamObservables — Method
ParticleScattering.beamObservables(beamType::Beam.AbstractBeamType, pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64, phi::Float64) ... a fallback for every beam type without its own method, which says which one was asked for instead of silently falling back on the plane-wave superposition. Nothing is returned; this method always raises.
JenaAtomicCalculator.ParticleScattering.beamObservables — Method
ParticleScattering.beamObservables(beamType::Beam.BesselBeam, pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64, phi::Float64) ... to compute the observables for a Bessel (vortex) projectile beam. NOT IMPLEMENTED: the partial-wave superposition for a twisted beam has to be re-derived over both signs of kappa before it can be combined with Dirac phase shifts. Nothing is returned; this method always raises.
JenaAtomicCalculator.ParticleScattering.beamObservables — Method
ParticleScattering.beamObservables(beamType::Beam.PlaneWave, pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64, phi::Float64) ... to compute the observables for a PLANE-WAVE projectile, for which the partial-wave superposition is the textbook one and the amplitudes are those of ParticleScattering.directAmplitude and .spinFlipAmplitude directly. An obs::ParticleScattering.AngularObservables is returned.
JenaAtomicCalculator.ParticleScattering.chargeConjugateOrbital — Method
ParticleScattering.chargeConjugateOrbital(orbital::Radial.Orbital) ... to form the charge-conjugate of a positron continuum orbital, i.e. the negative-energy electron solution that represents the same physical positron. Charge conjugation C psi = i gamma^2 psi^* reverses the sign of kappa and exchanges the large and the small radial component,
kappa -> -kappa , P(r) -> -Q(r) , Q(r) -> P(r) ,
which is what lets the annihilation matrix element be evaluated with the ordinary photon-emission operator. A
cOrbital::Radial.Orbital is returned, carrying the conjugated subshell.
THE OVERALL SIGN IS A CONVENTION and cannot be settled from within this file: it cancels in |amplitude|^2 for a single
channel, but it does NOT cancel between two multipoles feeding the same total symmetry, where the amplitudes interfere.
Any disagreement with measured multipole ratios should be checked here first.JenaAtomicCalculator.ParticleScattering.computeAmplitudesProperties — Method
ParticleScattering.computeAmplitudesProperties(event::ParticleScattering.Event, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::ParticleScattering.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, printout::Bool=true) ... to compute the partial waves, the reduced scattering channels and all observables of the given event. A new event::ParticleScattering.Event is returned, for which these are now evaluated.
JenaAtomicCalculator.ParticleScattering.computeAnnihilationAmplitudesProperties — Method
ParticleScattering.computeAnnihilationAmplitudesProperties(line::ParticleScattering.AnnihilationLine, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::ParticleScattering.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, printout::Bool=true) ... to compute all channel amplitudes of one annihilation line and, from them, its total cross section. For every channel the positron partial wave is generated in the POSITRON potential – the electrostatic interaction with reversed sign and no exchange, cf. ParticleScattering.scatteringPotential – charge-conjugated, attached to the final level as an extra electron, and handed to PhotoEmission.amplitude, the operator being the ordinary photon-emission operator. A newLine::ParticleScattering.AnnihilationLine is returned with its channels and cross section evaluated.
JenaAtomicCalculator.ParticleScattering.computeAnnihilationLines — Method
ParticleScattering.computeAnnihilationLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::ParticleScattering.Settings; output=true) ... to compute all selected one-photon annihilation lines, together with their channel amplitudes and cross sections, and to display them. An Array{ParticleScattering.AnnihilationLine,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.ParticleScattering.computeEvents — Method
ParticleScattering.computeEvents(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::ParticleScattering.Settings; output=true) ... to compute all selected scattering events, together with their partial waves, reduced channels and observables, and to display them. An Array{ParticleScattering.Event,1} is returned if output=true, and nothing otherwise.
JenaAtomicCalculator.ParticleScattering.computePartialWaves — Method
ParticleScattering.computePartialWaves(projectile::ParticleScattering.AbstractProjectile, interaction::ParticleScattering.AbstractInteractionModel, level::Level, impactEnergy::Float64, nm::Nuclear.Model, grid::Radial.Grid, contSettings::Continuum.Settings, settings::ParticleScattering.Settings; nuclearPot::Union{Nothing,Radial.Potential}=nothing, printout::Bool=true) ... to compute the phase shifts delta_kappa of the projectile in the field of the given target level, for BOTH spin-orbit partners of every orbital angular momentum: kappa = -l-1 (j = l+1/2) and, for l >= 1, kappa = +l (j = l-1/2). The series is extended until the contribution of one l to the elastic cross section falls below settings.epsPartialWave twice in succession, or until settings.maxL is reached; the achieved l is reported so that a truncation is visible rather than silent. An Array{ParticleScattering.PartialWave,1} is returned.
JenaAtomicCalculator.ParticleScattering.determineAnnihilationChannels — Method
ParticleScattering.determineAnnihilationChannels(finalLevel::Level, initialLevel::Level, settings::ParticleScattering.Settings) ... to determine the allowed (kappa, multipole, gauge) channels of one annihilation line. The photon multipole couples the initial symmetry to an intermediate one, and the incoming positron's kappa then couples that to the final symmetry – the same two-step construction as InternalConversion.determineChannels, a rank-L one-particle operator requiring it. Channels with |kappa| beyond settings.maxL + 1 are dropped. An Array{ParticleScattering.AnnihilationChannel,1} is returned with the amplitudes not yet evaluated.
JenaAtomicCalculator.ParticleScattering.determineAnnihilationLines — Method
ParticleScattering.determineAnnihilationLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::ParticleScattering.Settings) ... to determine the list of annihilation lines to be computed, i.e. one line per selected pair of levels and per impact energy of settings.impactEnergies. A line whose photon energy comes out non-positive is dropped, that channel being closed. An Array{ParticleScattering.AnnihilationLine,1} is returned with the amplitudes not yet evaluated.
JenaAtomicCalculator.ParticleScattering.determineEvents — Method
ParticleScattering.determineEvents(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::ParticleScattering.Settings) ... to determine the list of scattering events that are to be computed, i.e. one event per selected pair of levels and per impact energy, with the amplitudes and observables still empty. For elastic scattering the initial and final level must be the same one. An Array{ParticleScattering.Event,1} is returned.
JenaAtomicCalculator.ParticleScattering.directAmplitude — Method
ParticleScattering.directAmplitude(pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64) ... to compute the direct scattering amplitude
f(theta) = 1/(2ik) SUM_l { (l+1) [exp(2i delta_{-l-1}) - 1] + l [exp(2i delta_{l}) - 1] } P_l(cos theta)
from the computed phase shifts. This is the spin-non-flip amplitude of the elastic scattering of a spin-1/2
projectile from a SPINLESS target; see ParticleScattering.assertSpinlessTarget for where the projection applies.
An f::ComplexF64 [a.u.] is returned.JenaAtomicCalculator.ParticleScattering.displayAnnihilationLines — Method
ParticleScattering.displayAnnihilationLines(stream::IO, lines::Array{ParticleScattering.AnnihilationLine,1}) ... to list the selected annihilation lines before their amplitudes are computed, so that a long run can be checked against what was intended. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.displayAnnihilationResults — Method
ParticleScattering.displayAnnihilationResults(stream::IO, lines::Array{ParticleScattering.AnnihilationLine,1}) ... to print the computed one-photon annihilation cross sections, one row per line and with both gauges beside each other so that their agreement can be read off directly. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.displayCrossSections — Method
ParticleScattering.displayCrossSections(stream::IO, events::Array{ParticleScattering.Event,1}) ... to display the differential cross sections and Sherman functions of every event, at each requested scattering angle. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.displayEvents — Method
ParticleScattering.displayEvents(stream::IO, events::Array{ParticleScattering.Event,1}) ... to list the scattering events that have been selected, before the computation starts, so that a mis-specified selection is seen at once rather than after the partial waves have been generated. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.displayIntegratedCrossSections — Method
ParticleScattering.displayIntegratedCrossSections(stream::IO, events::Array{ParticleScattering.Event,1}) ... to display the angle-integrated cross sections of every event: the elastic total together with the first (momentum-transfer) and second (viscosity) transport cross sections. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.displayPhaseShifts — Method
ParticleScattering.displayPhaseShifts(stream::IO, events::Array{ParticleScattering.Event,1}) ... to display the Dirac phase shifts of every event, for both spin-orbit partners of each orbital angular momentum. Showing them side by side makes the spin-orbit splitting of the phase shifts visible, which is the quantity the spin-flip amplitude and hence the Sherman function are built from. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.ParticleScattering.elasticCrossSectionFromPhases — Method
ParticleScattering.elasticCrossSectionFromPhases(pws::Array{ParticleScattering.PartialWave,1}, energy::Float64) ... to compute the total elastic cross section directly from the phase shifts,
sigma_el = 4 pi / k^2 SUM_l [ (l+1) sin^2 delta_{-l-1} + l sin^2 delta_{l} ] ,
i.e. without ever forming the amplitudes. Comparing it with the angular integral of the differential cross section
is an internal consistency check that costs nothing. A sigma::Float64 [a.u.] is returned.JenaAtomicCalculator.ParticleScattering.extractCrossSections — Method
ParticleScattering.extractCrossSections(events::Array{ParticleScattering.Event,1}, energy::Float64, phi::Float64) ... to collect, for the given impact energy and azimuthal angle, the scattering angles together with the differential cross sections and Sherman functions of all events, in a form convenient for plotting. A named tuple (thetas, dcs, sherman)::NamedTuple is returned.
JenaAtomicCalculator.ParticleScattering.integratedObservables — Method
ParticleScattering.integratedObservables(pws::Array{ParticleScattering.PartialWave,1}, energy::Float64; noAngles::Int64=64) ... to compute the angle-integrated cross sections by Gauss-Legendre quadrature over x = cos(theta),
sigma_el = 2 pi INT dcs dx , sigma_1 = 2 pi INT (1-x) dcs dx , sigma_2 = 3 pi INT (1-x^2) dcs dx ,
i.e. the elastic total together with the first (momentum-transfer) and second (viscosity) transport cross sections,
which are the quantities transport and Monte-Carlo codes consume. An obs::ParticleScattering.IntegratedObservables
is returned.JenaAtomicCalculator.ParticleScattering.phaseShift — Method
ParticleScattering.phaseShift(pws::Array{ParticleScattering.PartialWave,1}, kappa::Int64) ... to pick the phase shift of the partial wave with the given kappa out of the list; zero is returned if that partial wave was not computed, which is the correct limit for an l beyond the converged series. A phase::Float64 is returned.
JenaAtomicCalculator.ParticleScattering.projectileMomentum — Method
ParticleScattering.projectileMomentum(energy::Float64) ... to compute the relativistic momentum of a projectile of rest mass one and kinetic energy energy [a.u.], i.e. p = sqrt(E (E + 2c^2)) / c = sqrt(2E + E^2/c^2). A momentum::Float64 [a.u.] is returned.
JenaAtomicCalculator.ParticleScattering.scatteringChannels — Method
ParticleScattering.scatteringChannels(pws::Array{ParticleScattering.PartialWave,1}, level::Level) ... to build the reduced scattering channels from the computed partial waves. For elastic scattering the projectile keeps its kappa, so one channel arises per partial wave, with the reduced amplitude exp(2 i delta_kappa) - 1 and the total symmetry obtained by coupling the partial wave to the target level. An Array{ParticleScattering.ScatteringChannel,1} is returned.
JenaAtomicCalculator.ParticleScattering.scatteringPotential — Method
ParticleScattering.scatteringPotential(projectile::ParticleScattering.AbstractProjectile, interaction::ParticleScattering.AbstractInteractionModel, level::Level, energy::Float64, nm::Nuclear.Model, grid::Radial.Grid; nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... a fallback that raises for every (projectile, interaction) combination which is not implemented above, and says which one was asked for, rather than returning a silently wrong potential. Nothing is returned; this method always raises.
JenaAtomicCalculator.ParticleScattering.scatteringPotential — Method
ParticleScattering.scatteringPotential(projectile::ParticleScattering.Electron, interaction::ParticleScattering.StaticField, level::Level, energy::Float64, nm::Nuclear.Model, grid::Radial.Grid; nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... to build the local potential in which an ELECTRON partial wave is generated, for the pure static field, i.e. the electrostatic interaction with the nuclear and electronic charge density and no exchange term. The nuclear part depends only on (nm, grid) and may be passed in by a caller that has built it once. A pot::Radial.Potential is returned.
JenaAtomicCalculator.ParticleScattering.scatteringPotential — Method
ParticleScattering.scatteringPotential(projectile::ParticleScattering.Electron, interaction::ParticleScattering.StaticFieldFurnessMcCarthy, level::Level, energy::Float64, nm::Nuclear.Model, grid::Radial.Grid; nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... to build the local potential in which an ELECTRON partial wave is generated, for the static field plus the energy-dependent local exchange potential of Furness and McCarthy, J. Phys. B 6, 2280 (1973),
V_ex(r) = 1/2 [E - V_st(r)] - 1/2 sqrt( [E - V_st(r)]^2 + 4 pi rho(r) ) [a.u.]
with rho(r) the electron density of the target. This is the exchange term ELSEPA and the NIST database use
(NSRDS-64, Eq. (10)), and it is the one appropriate to a CONTINUUM projectile: it depends on the impact energy
and weakens as the projectile becomes fast, whereas the Slater term of the DFS field is built for a bound
electron and does not. V_ex is negative everywhere, so it deepens the well. A pot::Radial.Potential is returned.JenaAtomicCalculator.ParticleScattering.scatteringPotential — Method
ParticleScattering.scatteringPotential(projectile::ParticleScattering.Electron, interaction::ParticleScattering.StaticFieldSlaterExchange, level::Level, energy::Float64, nm::Nuclear.Model, grid::Radial.Grid; nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... to build the local potential in which an ELECTRON partial wave is generated, for the static field plus a local exchange term. The exchange is the Slater term carried by Basics.DFSField(1.0), which is the same field the bound-state machinery of JAC uses, so that projectile and target are described consistently. A pot::Radial.Potential is returned.
JenaAtomicCalculator.ParticleScattering.scatteringPotential — Method
ParticleScattering.scatteringPotential(projectile::ParticleScattering.Positron, interaction::ParticleScattering.StaticField, level::Level, energy::Float64, nm::Nuclear.Model, grid::Radial.Grid; nuclearPot::Union{Nothing,Radial.Potential}=nothing) ... to build the local potential in which a POSITRON partial wave is generated. The electrostatic interaction changes sign throughout – the nucleus repels and the electrons attract – so the electron potential is simply negated; no exchange term applies, a positron being distinguishable from the target electrons. A pot::Radial.Potential is returned.
JenaAtomicCalculator.ParticleScattering.spinFlipAmplitude — Method
ParticleScattering.spinFlipAmplitude(pws::Array{ParticleScattering.PartialWave,1}, energy::Float64, theta::Float64) ... to compute the spin-flip scattering amplitude
g(theta) = 1/(2ik) SUM_l { exp(2i delta_{l}) - exp(2i delta_{-l-1}) } P_l^1(cos theta)
from the computed phase shifts. It vanishes identically when the two spin-orbit partners share a phase shift, which
is why a treatment using only kappa = -l-1 can carry no spin dependence at all. A g::ComplexF64 [a.u.] is returned.Rayleigh-Compton scattering
JenaAtomicCalculator.RayleighCompton.Channel — Type
struct RayleighCompton.Channel ... defines a type for a Rayleigh-Compton reduced channel/ U^(K, Compton) amplitude to help characterize the scattering of a single photon with well-defined multipolarities; in JAC, a Rayleigh-Compton channel is characterized by a reduced amplitude U^(K, Compton) (levelf, multipole2, Jnu, omega, multipole1, level_i).
+ isS12 ::Bool ... True, if S_12 is meant, and false for S_21
+ Jsym ::LevelSymmetry ... Symmetry J_nu of the intermediate levels.
+ multipole1 ::EmMultipole ... Multipole of the incoming photon.
+ multipole2 ::EmMultipole ... Multipole of the outgoing, scattered photon.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ omega1 ::Float64 ... Photon frequency of multipole1.
+ omega2 ::Float64 ... Photon frequency of multipole2.
+ amplitude ::Complex{Float64} ... Two-photon reduced amplitude associated with the given channel.JenaAtomicCalculator.RayleighCompton.Channel — Method
RayleighCompton.Channel() ... constructor for an empty instance of RayleighCompton.Channel. A channel::RayleighCompton.Channel is returned.
JenaAtomicCalculator.RayleighCompton.Line — Type
struct RayleighCompton.Line ... defines a type for a Rayleigh-Compton scattering line that may include the definition of channels.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ inOmega ::Float64 ... Energy of the incoming photon.
+ outOmega ::Float64 ... Energy of the outgoing, scattered photon.
+ crossSection ::EmProperty ... Cross section for this photoionization.
+ channels ::Array{RayleighCompton.Channel,1} ... List of (reduced) RayleighCompton.Channels of this line.JenaAtomicCalculator.RayleighCompton.ReducedChannel — Type
struct RayleighCompton.ReducedChannel ... defines a type for a Rayleigh-Compton reduced channel/ U^(K, Compton) amplitude to help characterize the scattering of a single photon with well-defined multipolarities; in JAC, a Rayleigh-Compton channel is characterized by a reduced amplitude U^(K, Compton) (levelf, multipole2, Jnu, omega, multipole1, level_i).
+ K ::AngularJ64 ... Rank K of the channel.
+ multipole1 ::EmMultipole ... Multipole of the incoming photon.
+ multipole2 ::EmMultipole ... Multipole of the outgoing, scattered photon.
+ gauge ::EmGauge ... Gauge for dealing with the (coupled) radiation field.
+ omega1 ::Float64 ... Photon frequency of multipole1.
+ omega2 ::Float64 ... Photon frequency of multipole2.
+ omega ::Float64 ... Photon frequency in denominator.
+ Jsym ::LevelSymmetry ... Symmetry J_nu of the intermediate levels.
+ amplitude ::Complex{Float64} ... Two-photon reduced amplitude associated with the given channel.JenaAtomicCalculator.RayleighCompton.Settings — Type
struct RayleighCompton.Settings <: AbstractProcessSettings ... defines a type for the settings in estimating lastic Rayleigh and inelastic Compton photon scattering cross sections
+ multipoles ::Array{EmMultipole} ... Specifies the multipoles of the radiation field that are to be included.
+ gauges ::Array{UseGauge} ... Specifies the gauges to be included into the computations.
+ photonEnergies ::Array{Float64,1} ... List of photon energies in units defined by the user.
+ green ::Array{GreenChannel,1} ... Precalculated and user-specified Green function of the ion.
+ calcRayleighRaman ::Bool ... Calculate Rayleigh-Raman cross sections and properties (if true).
+ calcAngular ::Bool ... Calculate the angular distribution of the fluorescence photon (if true).
+ calcStokes ::Bool ... Calculate the Stokes parameters of the Rayleigh-scattered photon (if true).
+ printBefore ::Bool ... True, if all energies and lines are printed before their evaluation.
+ incidentStokes ::ExpStokes ... Stokes parameters of the incident radiation.
+ solidAngles ::Array{SolidAngle,1} ... List of solid angles [(theta_1, pho_1), ...].
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.JenaAtomicCalculator.RayleighCompton.Settings — Method
RayleighCompton.Settings(set::RayleighCompton.Settings; multipoles::Union{Nothing,Array{EmMultipole}}=nothing, gauges::Union{Nothing,Array{UseGauge}}=nothing, photonEnergies::Union{Nothing,Array{Float64,1}}=nothing, green::Union{Nothing,Array{AtomicState.GreenChannel,1}}=nothing, calcRayleighRaman::Union{Nothing,Bool}=nothing, calcAngular::Union{Nothing,Bool}=nothing, calcStokes::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, incidentStokes::Union{Nothing,ExpStokes}=nothing, solidAngles::Union{Nothing,Array{SolidAngle,1}}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::RayleighCompton.Settings.
A `settings::RayleighCompton.Settings` is returned.JenaAtomicCalculator.RayleighCompton.Settings — Method
RayleighCompton.Settings() ... constructor for the default values of Rayleigh-Compton photon-scattering estimates. A settings::RayleighCompton.Settings is returned.
JenaAtomicCalculator.RayleighCompton.computeAmplitudesProperties — Method
RayleighCompton.computeAmplitudesProperties(line::RayleighCompton.Line, grid::Radial.Grid, settings::RayleighCompton.Settings) ... to compute all amplitudes and properties of the given line; a line::RayleighCompton.Line is returned for which the amplitudes and properties are now evaluated.
JenaAtomicCalculator.RayleighCompton.computeChannelAmplitude — Method
RayleighCompton.computeChannelAmplitude(channel::RayleighCompton.Channel, finalLevel::Level, initialLevel::Level, grid::Radial.Grid, greenChannels::Array{AtomicState.GreenChannel,1}) ... to compute the channel amplitudes S12^(RC) or S21^(RC); a newChannel::RayleighCompton.Channel is returned.
JenaAtomicCalculator.RayleighCompton.computeLines — Method
RayleighCompton.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::RayleighCompton.Settings; output=true) ... to compute the Rayleigh-Compton transition amplitudes and all properties as requested by the given settings. A list of lines::Array{RayleighCompton.Lines} is returned.
JenaAtomicCalculator.RayleighCompton.determineChannels — Method
RayleighCompton.determineChannels(finalLevel::Level, initialLevel::Level, inOmega::Float64, outOmega::Float64, settings::RayleighCompton.Settings) ... to determine a list of Rayleigh-Compton Channel's for a transitions from the initial to final level and by taking into account the particular settings of for this computation; an Array{RayleighCompton.ChannelChannel,1} is returned.
JenaAtomicCalculator.RayleighCompton.determineLines — Method
RayleighCompton.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::RayleighCompton.Settings) ... to determine a list of RayleighCompton Line's for elastic scattering or Raman-type transitions between the levels from the given initial- and final-state multiplets and by taking into account the particular selections and settings for this computation; an Array{RayleighCompton.Line,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.
JenaAtomicCalculator.RayleighCompton.displayAngular — Method
RayleighCompton.displayAngular(stream::IO, lines::Array{RayleighCompton.Line,1}, settings::RayleighCompton.Settings) ... to display a list of lines and the angle-differential cross sections for the selected solid angles. A neat table of all selected transitions, energies and solid angles is printed but nothing is returned otherwise.
JenaAtomicCalculator.RayleighCompton.displayChannels — Method
RayleighCompton.displayChannels(stream::IO, line::RayleighCompton.Line, settings::RayleighCompton.Settings) ... to display a list of all channels (amplitudes) of the given line as they were selected by the settings. A neat table of all computed channels is printed but nothing is returned otherwise.
JenaAtomicCalculator.RayleighCompton.displayCrossSections — Method
RayleighCompton.displayCrossSections(stream::IO, lines::Array{RayleighCompton.Line,1}, settings::RayleighCompton.Settings) ... to display a list of lines and their cross sections as they were selected by the settings. A neat table of all selected transitions, energies and cross sections is printed but nothing is returned otherwise.
JenaAtomicCalculator.RayleighCompton.displayLines — Method
RayleighCompton.displayLines(stream::IO, lines::Array{RayleighCompton.Line,1}) ... to display a list of lines and channels that have been selected due to the prior settings. A neat table of all selected transitions and energies is printed but nothing is returned otherwise.
JenaAtomicCalculator.RayleighCompton.displayStokesParameters — Method
RayleighCompton.displayStokesParameters(stream::IO, lines::Array{RayleighCompton.Line,1}, settings::RayleighCompton.Settings) ... to display a list of lines and the Stokes parameters at the selected solid angles. A neat table of all selected transitions, energies and solid angles is printed but nothing is returned otherwise.
Electron-impact ionization
JenaAtomicCalculator.ImpactIonization.AbstractModel — Type
abstract type ImpactIonization.AbstractModel ... defines an abstract and a number of singleton types for the computation of empirical EII cross sections in different models.
+ struct BEBmodel
... to apply a generalized BEB model for non-relativistic impact energies due to
Kim et al. PRA (2001) & Wang et al. JPB (2024).
+ struct BEDmodel
... to apply a improved BED model due to Huo PRA (2001) for non-relativistic impact energies.
+ struct RelativisticBEBmodel
... to apply a generalized BEB model for relativistic impact energies due to
Kim et al. PRA (2001) & Wang et al. JPB (2024).
+ struct RelativisticBEDmodel
... to apply a modified relativistic BEB model due to Uddin et al. PRA (2005) for relativistic impact energies.
+ struct FittedBEDmodel
... to apply a modified relativistic BEB model due to Haque et al. AQC (2017) for non-relativistic &
relativistic impact energies, and by using fitting coefficients for K, L, and M subshells
(also known as MUIBED).
+ struct DirectMultipleModel
... to apply a generalized DirectMultiple model for electron-impact multiple ionization
Belenger et al. JPB (1997).
+ struct InDirectDoubleModel
... to apply a generalized InDirectDouble model for electron-impact double ionization
Shevelko et al. JPB (2005).
+ struct DoubleExperimentModel
... to apply a improved InDirectDouble model based on experimental data fitting for electron-impact double ionization
Shevelko et al. JPB (2006).
+ struct LotzMultipleModel
... a generalized LotzMultiple model for electron-impact multiple ionization
Hahn et al. ApJ (2015).JenaAtomicCalculator.ImpactIonization.CrossSection — Type
struct ImpactIonization.CrossSection ... defines a type for dealing with (shell-dependent) partial EII cross sections that are based on empirical computations.
+ subshell ::Subshell ... subshell for which the (differential and partial) cross sections are calculated.
+ impactEnergy ::Float64 ... energy of impact electron [Hartree].
+ partialCS ::Float64 ... partial cross sections for this shell.
+ electronEnergies ::Array{Float64,1} ... energies of the ionized electron.
+ differentialCS ::Array{Float64,1} ... differential cross sections for this shell.JenaAtomicCalculator.ImpactIonization.MultipleCrossSection — Type
struct ImpactIonization.MultipleCrossSection ... defines a type for total EIMI cross sections at a single impact energy.
+ impactEnergy ::Float64 ... energy of the impact electron [eV].
+ totalCS ::Float64 ... total multiple-ionization cross section [barn].JenaAtomicCalculator.ImpactIonization.Settings — Type
struct ImpactIonization.Settings <: AbstractEmpiricalSettings ... defines a type for the settings of empirical electron-impact ionization cross sections.
+ model ::ImpactIonization.AbstractModel
... model for computing empirical EII cross sections.
+ multipleN ::Int64
... ionization order N for multiple ionization.
+ impactEnergies ::Array{Float64,1}
... List of impact-energies of the incoming elecgtrons.
## + electronEnergies ::Array{Float64,1} ... List of continuum-electron energies.
## + calcDifferentialCs ::Bool
## ... True if energy-differential cross sections are to be calculated, and false otherwise.
+ calcPartialCs ::Bool
... True if partial (shell-dependent) cross sections are to be calculated, and false otherwise.
+ calcTotalCs ::Bool
... True if total cross sections are to be calculated, and false otherwise.
+ shellSelection ::ShellSelection ... Describe the selected shells, if any. ...JenaAtomicCalculator.ImpactIonization.Settings — Method
ImpactIonization.Settings(set::ImpactIonization.Settings; model ::Union{Nothing,ImpactIonization.AbstractModel} = nothing, multipleN ::Union{Nothing,Int64} = nothing, impactEnergies ::Union{Nothing,Array{Float64,1}} = nothing, calcPartialCs ::Union{Nothing,Bool} = nothing, calcTotalCs ::Union{Nothing,Bool} = nothing, shellSelection ::Union{Nothing,ShellSelection} = nothing)
... keyword copy-constructor for re-defining selected values of a settings::ImpactIonization.Settings.
A `settings::ImpactIonization.Settings` is returned.JenaAtomicCalculator.ImpactIonization.Settings — Method
ImpactIonization.Settings() ... constructor for the default values of empirical electron-impact ionization cross sections. A settings::ImpactIonization.Settings is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(basis::Basis, grid::Radial.Grid, nm::Nuclear.Model, settings::ImpactIonization.Settings; output::Bool=true) ... to compute the EII cross sections for an atom or ion in chosen model. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a list of crossSections::Array{ImpactIonization.CrossSection,1} is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::BEBmodel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EII cross sections (cs) for an atom or ion in BEBmodel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.CrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::BEDmodel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the EII cross sections (cs) for an atom or ion in BEDmodel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.CrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::DirectMultipleModel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EIMI cross sections (cs) for an atom or ion in DirectMultipleModel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.MultipleCrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::DoubleExperimentModel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EIMI cross sections (cs) for an atom or ion in DoubleExperimentModel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.MultipleCrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::FittedBEDmodel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the EII cross sections (cs) for an atom or ion in FittedBEDmodel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.CrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::InDirectDoubleModel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EIMI cross sections (cs) for an atom or ion in InDirectDoubleModel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.MultipleCrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::LotzMultipleModel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EIMI cross sections (cs) for an atom or ion in LotzMultipleModel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.MultipleCrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::RelativisticBEBmodel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EII cross sections (cs) for an atom or ion in BEBmodel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.CrossSection is returned.
JenaAtomicCalculator.ImpactIonization.computeCrossSections — Method
ImpactIonization.computeCrossSections(model::RelativisticBEDmodel, cs::ImpactIonization.CrossSection, basis::Basis, nm::Nuclear.Model, grid::Radial.Grid, settings::ImpactIonization.Settings) ... to compute the particular EII cross sections (cs) for an atom or ion in BEBmodel. While the basis describes the configuration of the atom, the settings provide access to the selected subshells and energies; a cs::ImpactIonization.CrossSection is returned.
JenaAtomicCalculator.ImpactIonization.determineCrossSections — Method
ImpactIonization.determineCrossSections(basis::Basis, settings::ImpactIonization.Settings) ... to determine an array of EII cross sections for all requested shells of the given multiplett that need to be calculated in these computations; an Array{ImpactIonization.CrossSection,1} is returned.
JenaAtomicCalculator.ImpactIonization.displayCrossSections — Method
ImpactIonization.displayCrossSections(stream::IO, crossSections::Array{ImpactIonization.CrossSection,1}, settings::ImpactIonization.Settings) ... displays the EII cross sections in a neat tabular form; nothing is returned.
JenaAtomicCalculator.ImpactIonization.effectiveCharge — Method
ImpactIonization.effectiveCharge(subshell::Subshell, nm::Nuclear.Model, basis::Basis) ... determined the effective charge that is felt by an electron in the given subshell; a zEff::Float64 is returned.
Coulomb ionization by ion impact
JenaAtomicCalculator.CoulombIonization.Channel — Type
struct CoulombIonization.Channel ... defines a type for one q-, kappa- and symmetry-dependent Coulomb-ionization amplitude.
+ kappa ::Int64 ... partial wave of the ejected electron.
+ m ::AngularM64 ... magnetic quantum number of the ejected electron.
+ symmetry ::LevelSymmetry ... total symmetry J_t of (residual ion + ejected electron).
+ phase ::Float64 ... phase of the continuum partial wave.
+ q ::Float64 ... momentum transfer of this amplitude.
+ w ::Float64 ... Gauss-Legendre weight of this q in the integration.
+ amplitude ::Complex{Float64} ... K^(Coulion) amplitude of this channel.JenaAtomicCalculator.CoulombIonization.Line — Type
struct CoulombIonization.Line ... defines a type for a Coulomb-ionization line, i.e. one initial level, one level of the residual ion, one projectile energy and one energy of the ejected electron.
+ initialLevel ::Level ... initial level, with N electrons.
+ finalLevel ::Level ... level of the residual ion, with N-1 electrons.
+ ionEnergy ::Float64 ... projectile energy [MeV/u].
+ electronEnergy ::Float64 ... energy of the ejected electron [a.u.].
+ q0 ::Float64 ... minimum momentum transfer for this transition and energy.
+ dCs ::Float64 ... d(sigma)/d(epsilon), summed over all magnetic sublevels.
+ alignmentA2 ::Float64 ... alignment A_2 of the residual ion.
+ alignmentA4 ::Float64 ... alignment A_4 of the residual ion.
+ mLines ::Array{MagneticLine,1} ... list of magnetic lines.JenaAtomicCalculator.CoulombIonization.MagneticLine — Type
struct CoulombIonization.MagneticLine ... defines a type for one pair (Mi, Mf) of magnetic quantum numbers of the initial level and the RESIDUAL ION, together with the differential cross section that belongs to it and its channels.
+ Mi ::AngularM64 ... magnetic quantum number of the initial level.
+ Mf ::AngularM64 ... magnetic quantum number of the residual ion.
+ partialCs ::Float64 ... d(sigma)/d(epsilon) for this pair, summed over the ejected
electron's kappa and m.
+ channels ::Array{CoulombIonization.Channel,1} ... channels of this magnetic line.JenaAtomicCalculator.CoulombIonization.Settings — Type
struct CoulombIonization.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing Coulomb-ionization amplitudes and the energy-differential cross sections that follow from them.
+ ionEnergies ::Array{Float64,1} ... List of projectile ion energies [MeV/u].
+ electronEnergies ::Array{Float64,1} ... List of energies of the EJECTED electron, in the currently
selected energy unit.
+ calcAlignment ::Bool ... True, if the alignment of the residual ion is to be computed.
+ printBefore ::Bool ... True, if all energies and lines are printed before evaluation.
+ lineSelection ::LineSelection ... Specifies the selected levels, if any.
+ zerosGL ::Int64 ... Number of Gauss-Legendre zeros in the momentum-transfer integral.
+ lValues ::Array{Int64,1} ... Orbital angular momenta of the ejected electron to be included.
+ continuumExchange ::Union{Nothing,Bool} ... True/false to force exchange between the ejected electron and
the bound electrons on or off; `nothing` -- the default -- lets
`Basics.perform` decide automatically from the final-ion
`AsfSettings.scField` (`Continuum.resolveExchangeDefault`, item 99).JenaAtomicCalculator.CoulombIonization.Settings — Method
CoulombIonization.Settings(set::CoulombIonization.Settings; ionEnergies::Union{Nothing,Array{Float64,1}}=nothing, electronEnergies::Union{Nothing,Array{Float64,1}}=nothing, calcAlignment::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, zerosGL::Union{Nothing,Int64}=nothing, lValues::Union{Nothing,Array{Int64,1}}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... constructor for modifying the given CoulombIonization.Settings by 'overwriting' the previously selected
parameters. A settings::CoulombIonization.Settings is returned.JenaAtomicCalculator.CoulombIonization.Settings — Method
CoulombIonization.Settings() ... constructor for the default values of Coulomb-ionization line computations. A settings::CoulombIonization.Settings is returned.
JenaAtomicCalculator.CoulombIonization.computeAmplitude — Method
CoulombIonization.computeAmplitude(q::Float64, q0::Float64, beta::Float64, Mix::Float64, Mtx::Float64, cLevel::Level, iLevel::Level, grid::Radial.Grid, key::Int64, cache::Dict{Tuple{Symbol,Int64,Int64,Int64},ComplexF64}) ... computes the Coulomb-ionization amplitude K^(Coulion)(vec q; alphai Ji Mi –> (alphaf Jf, eps kappa) Jt M_t) for one momentum transfer q. An amplitude::ComplexF64 is returned.
This is CoulombExcitation.computeAmplitude with the final level replaced by the COUPLED state of the
residual ion and the ejected electron; the angular algebra is untouched, which is the whole point of
building the final state that way.JenaAtomicCalculator.CoulombIonization.computeAmplitudesProperties — Method
CoulombIonization.computeAmplitudesProperties(line::CoulombIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, settings::CoulombIonization.Settings; printout::Bool=true) ... computes all amplitudes, the energy-differential cross section and, if requested, the alignment of the residual ion for the given line. A newLine::CoulombIonization.Line is returned.
JenaAtomicCalculator.CoulombIonization.computeLines — Method
CoulombIonization.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::CoulombIonization.Settings; output=true) ... computes the Coulomb-ionization amplitudes and all requested properties. An Array{CoulombIonization.Line,1} is returned if output is true, and nothing otherwise.
JenaAtomicCalculator.CoulombIonization.determineLines — Method
CoulombIonization.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::CoulombIonization.Settings) ... determines the list of Coulomb-ionization lines for the given multiplets, projectile energies and ejected-electron energies. An Array{CoulombIonization.Line,1} is returned, with all properties still zero.
JenaAtomicCalculator.CoulombIonization.displayCrossSections — Method
CoulombIonization.displayCrossSections(stream::IO, lines::Array{CoulombIonization.Line,1}, settings::CoulombIonization.Settings) ... displays the energy-differential cross sections and, if requested, the alignment of the residual ion. Nothing is returned.
JenaAtomicCalculator.CoulombIonization.displayLines — Method
CoulombIonization.displayLines(stream::IO, lines::Array{CoulombIonization.Line,1}) ... lists the selected lines before their evaluation. Nothing is returned.
JenaAtomicCalculator.CoulombIonization.generateContinuumLevels — Method
CoulombIonization.generateContinuumLevels(line::CoulombIonization.Line, nm::Nuclear.Model, grid::Radial.Grid, settings::CoulombIonization.Settings) ... builds, once per line, the coupled states of the residual ion and the ejected electron. A tuple (iLevel::Level, states::Array{Tuple{Int64,Float64,LevelSymmetry,Level},1}) is returned, whose entries are (kappa, phase, total symmetry, coupled level) and whose iLevel carries the placeholder subshell that makes the two sides of the matrix element share one subshell list.
This is the expensive part of a computation and it is done ONCE, outside the loops over magnetic quantum
numbers and momentum transfers, which reuse the same continuum orbitals.Multi-photon ionization
JenaAtomicCalculator.MultiPhotonIonization.AbstractMultiPhotonIonizationScheme — Type
abstract type MultiPhotonIonization.AbstractMultiPhotonIonizationScheme ... defines an abstract type to distinguish the multi-photon ionization processes.
+ struct TwoPhotonOneElectronScheme ... two photons absorbed, ONE electron ejected.JenaAtomicCalculator.MultiPhotonIonization.Line2pOneElectron — Type
struct MultiPhotonIonization.Line2pOneElectron ... one photon energy of a two-photon one-electron ionization, with the generalized cross sections that belong to it.
+ iSubshell ::Subshell ... the bound subshell that is ionized.
+ omega ::Float64 ... photon energy [a.u.]; both photons carry it.
+ electronEnergy ::Float64 ... energy of the ejected electron, 2*omega + E_i, fixed by conservation.
+ csLinear ::Basics.EmProperty ... generalized cross section for linearly polarized light [a.u.].
+ csUnpolarized ::Basics.EmProperty ... the same for unpolarized light [a.u.].
+ finalSymmetries ::Array{LevelSymmetry,1} ... the final partial waves that contribute.JenaAtomicCalculator.MultiPhotonIonization.Settings — Type
struct MultiPhotonIonization.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of a multi-photon ionization computation. The PROCESS itself is chosen by the scheme, so that a further process is added by adding a scheme rather than by adding fields here.
+ scheme ::MultiPhotonIonization.AbstractMultiPhotonIonizationScheme ... which process is computed.
+ gauges ::Array{UseGauge,1} ... gauges to be included; the agreement between them is the only internal
check a second-order amplitude has, so both are computed by default.
+ printBefore ::Bool ... print all selected lines before the computation starts.
+ lineSelection ::LineSelection ... specifies the selected levels, if any.
+ intermediateStates ::Union{Multiplet, Array{AtomicState.GreenChannel,1}} ... the intermediate states over
which the second-order sum runs. THE SAME CONVENTION AS EVERY OTHER SECOND-ORDER MODULE
IN JAC -- `MultiPhotonTransition`, `PhotoExcitationFluores`, `PhotonScattering` all pass
a gMultiplet or a set of Green channels here -- and it is deliberately not something of
this module's own. A second-order amplitude is a sum over a spectrum; the spectrum is
supplied, not invented, and the caller decides whether it is a mean-field multiplet or a
Green-function expansion.JenaAtomicCalculator.MultiPhotonIonization.Settings — Method
MultiPhotonIonization.Settings(set::MultiPhotonIonization.Settings; scheme::Union{Nothing,MultiPhotonIonization.AbstractMultiPhotonIonizationScheme}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing, intermediateStates::Union{Nothing,Multiplet,Array{AtomicState.GreenChannel,1}}=nothing)
... constructor for modifying the given MultiPhotonIonization.Settings by 'overwriting' the previously selected
parameters; a `settings::MultiPhotonIonization.Settings` is returned.JenaAtomicCalculator.MultiPhotonIonization.Settings — Method
MultiPhotonIonization.Settings() ... constructor for a default set of multi-photon ionization settings; a settings::MultiPhotonIonization.Settings is returned, which selects two-photon one-electron ionization in both gauges.
JenaAtomicCalculator.MultiPhotonIonization.TwoPhotonOneElectronScheme — Type
struct MultiPhotonIonization.TwoPhotonOneElectronScheme <: AbstractMultiPhotonIonizationScheme ... two photons of the same energy are absorbed and one electron is ejected; the electron energy follows from energy conservation, epsilon = 2*omega - I_P, so omega is the variable to scan.
+ omegas ::Array{Float64,1} ... photon energies to be computed [in the selected energy unit].
+ multipoles ::Array{EmMultipole,1} ... multipoles of the radiation field to be included.
+ resonanceTolerance ::Float64 ... a computation is REFUSED if an intermediate state comes this
close to the energy shell; see below.JenaAtomicCalculator.MultiPhotonIonization.TwoPhotonOneElectronScheme — Method
MultiPhotonIonization.TwoPhotonOneElectronScheme() ... constructor for a default TwoPhotonOneElectronScheme. A twoPhotonOneElectronScheme::MultiPhotonIonization.TwoPhotonOneElectronScheme is returned.
JenaAtomicCalculator.MultiPhotonIonization.computeLines — Method
MultiPhotonIonization.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::MultiPhotonIonization.Settings; output::Bool=true) ... the entrance from Atomic.Computation and Basics.perform, so that a multi-photon study is set up exactly like every other process in JAC rather than by calling into this file directly; a lines::Array{Line2pOneElectron,1} is returned, or nothing when output=false.
WHAT THIS DOES AND DOES NOT DO. It is an ADAPTER, not a generalisation. The physics behind it is written
for ONE electron in a central potential -- that is what `-inc-2p-one-electron-hydrogenic` means -- and this
function does not change that. It takes the general (initialMultiplet, finalMultiplet) route, checks that
the system really has a single electron, extracts the occupied subshell, and hands the work to
`computeLines2pOneElectron`. A many-electron system is REFUSED with a message that says why, rather than
being silently reduced to something this module can do.
THE INTERMEDIATE SPECTRUM COMES FROM `settings.intermediateStates`, as in every other second-order module
of JAC. A second-order amplitude is a sum over a spectrum, and the spectrum is the caller's to choose: a
mean-field multiplet, or a Green-function expansion. This function therefore does NOT build one of its
own; if none is supplied it says so instead of quietly summing over whatever orbitals happen to be in the
initial basis, which would make the result depend on how the initial state was generated.JenaAtomicCalculator.MultiPhotonIonization.computeLines2pOneElectron — Method
MultiPhotonIonization.computeLines2pOneElectron(iSubshell::Subshell, omegas::Array{Float64,1}, multipoles::Array{EmMultipole,1}, orbitals::Dict{Subshell,Orbital}, meanPot::Radial.Potential; resonanceTolerance::Float64=1.0e-3, output::Bool=true) ... computes the generalized two-photon ionization cross sections of a one-electron system, for each of the given photon energies and in both gauges. An Array{Line2pOneElectron,1} is returned if output is true.
JenaAtomicCalculator.MultiPhotonIonization.crossSection2pOneElectron — Method
MultiPhotonIonization.crossSection2pOneElectron(polarization::Symbol, iOrbital::Orbital, omega1::Float64, omega2::Float64, multipoles::Array{EmMultipole,1}, gauge::EmGauge, orbitals::Dict{Subshell,Orbital}, meanPot::Radial.Potential; resonanceTolerance::Float64=1.0e-3) ... computes the generalized two-photon ionization cross section of a one-electron system. A tuple (sigma::Float64 in ATOMIC UNITS, finalSymmetries::Array{LevelSymmetry,1}) is returned.
`polarization` is :linear or :unpolarized, and the two differ in exactly the way they do for two-photon
absorption: for LINEAR light the two helicity components are summed COHERENTLY and then squared, while for
UNPOLARIZED light each helicity pair is squared on its own and only odd ranks K are dropped.
THE FINAL CHANNELS ARE SUMMED INCOHERENTLY, which is the one structural difference from the bound-bound
case. There, one final level receives everything; here each final partial wave kappa_f is a distinct
state of the ejected electron, so their cross sections add rather than their amplitudes.JenaAtomicCalculator.MultiPhotonIonization.displayLines2pOneElectron — Method
MultiPhotonIonization.displayLines2pOneElectron(stream::IO, lines::Array{Line2pOneElectron,1}) ... displays the generalized two-photon ionization cross sections, in atomic units and in GM. Nothing is returned.
JenaAtomicCalculator.MultiPhotonIonization.reducedAmplitude2pOneElectron — Method
MultiPhotonIonization.reducedAmplitude2pOneElectron(K::AngularJ64, fOrbital::Orbital, omega2::Float64, mp2::EmMultipole, symx::LevelSymmetry, omega1::Float64, mp1::EmMultipole, iOrbital::Orbital, gauge::EmGauge, orbitals::Dict{Subshell,Orbital}, grid::Radial.Grid; resonanceTolerance::Float64=1.0e-3) ... computes the second-order reduced amplitude U^K for one intermediate symmetry symx, i.e. the inner sum over all intermediate orbitals of that symmetry. A U::ComplexF64 is returned.
The energy denominator is E_i + omega1 - E_v. If any intermediate comes within `resonanceTolerance` of the
energy shell the routine RAISES, naming that state: a resonant denominator means the non-resonant
expression does not describe the process, and returning a number would be worse than returning none.Photoionization with resonance (Fano) interference
JenaAtomicCalculator.PhotoIonizationInterference.Channel — Type
struct PhotoIonizationInterference.Channel ... defines a type for ONE total symmetry J_t of the (ion + photoelectron) scattering state, and carries the direct, the resonant and the summed amplitude separately, so that the three cross sections and hence the interference term can be formed afterwards.
+ symmetry ::LevelSymmetry ... Total J^parity of the scattering state.
+ amplitudesPI ::Array{MultipoleAmplitude,1} ... Direct (photoionization) amplitudes, one entry per multipole,
both gauges.
+ amplitudesResonant ::Array{MultipoleAmplitude,1} ... Resonant amplitudes, one entry per multipole, both gauges.
+ amplitudes ::Array{MultipoleAmplitude,1} ... The COHERENT SUM, one entry per multipole, both gauges.JenaAtomicCalculator.PhotoIonizationInterference.Channel — Method
PhotoIonizationInterference.Channel() ... constructor for an empty instance of PhotoIonizationInterference.Channel; a channel::Channel is returned.
JenaAtomicCalculator.PhotoIonizationInterference.PartialWave — Type
struct PhotoIonizationInterference.PartialWave ... defines a type for ONE partial wave of the outgoing photoelectron together with the total symmetries it serves; it mirrors PhotoIonization.PartialWave, since the radial orbital and the scattering phase belong to (energy, kappa) and not to any one total symmetry.
+ kappa ::Int64 ... Partial wave of the outgoing photoelectron.
+ energy ::Float64 ... Energy of the photoelectron [a.u.].
+ phase ::Float64 ... Scattering phase of this partial wave.
+ channels ::Array{Channel,1} ... The total symmetries that this partial wave serves.JenaAtomicCalculator.PhotoIonizationInterference.PartialWave — Method
PhotoIonizationInterference.PartialWave() ... constructor for an empty instance of PhotoIonizationInterference.PartialWave; a pw::PartialWave is returned.
JenaAtomicCalculator.PhotoIonizationInterference.Pathway — Type
struct PhotoIonizationInterference.Pathway ... defines a type for the coherent photoionization of an initial ion level into a final level plus photoelectron, for ONE photon energy and through a set of intermediate (autoionizing) resonances.
+ initialLevel ::Level ... Initial-(state) level of the atom or ion.
+ finalLevel ::Level ... Final-(state) level of the ion.
+ intermediateLevels ::Array{Level,1} ... The resonances that were actually included in the resonant term.
+ photonEnergy ::Float64 ... Energy of the absorbed photon [a.u.]; ONE value for both terms.
+ electronEnergy ::Float64 ... Energy of the outgoing photoelectron [a.u.].
+ crossSection ::EmProperty ... Cross section from the SUMMED amplitude.
+ crossSectionPI ::EmProperty ... Cross section from the direct term alone.
+ crossSectionResonant ::EmProperty ... Cross section from the resonant term alone.
+ interference ::EmProperty ... crossSection - crossSectionPI - crossSectionResonant.
+ betaNu ::Array{EmProperty,1} ... Anisotropy parameters beta_nu, nu = 2 and 4, from the summed
amplitude (E1 only).
+ partialWaves ::Array{PartialWave,1} ... Partial waves, each with the channels it serves.JenaAtomicCalculator.PhotoIonizationInterference.Pathway — Method
PhotoIonizationInterference.Pathway() ... constructor for an empty instance of PhotoIonizationInterference.Pathway; a pathway::Pathway is returned.
JenaAtomicCalculator.PhotoIonizationInterference.Settings — Type
struct PhotoIonizationInterference.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing the interference of direct photoionization with resonant (autoionization-mediated) photoionization.
+ multipoles ::Array{EmMultipole,1} ... Multipoles of the absorbed photon that are taken into account.
+ gauges ::Array{UseGauge,1} ... Gauges to be included into the computations.
+ photonEnergies ::Array{Float64,1} ... Photon energies, i.e. the scan ACROSS the resonance.
+ lValues ::Array{Int64,1} ... Orbital angular momenta of the outgoing electron that are considered.
+ augerOperator ::AbstractEeInteraction ... Operator for the autoionization-decay amplitude.
+ includePI ::Bool ... True, if the direct (photoionization) term is included.
+ includeResonance ::Bool ... True, if the resonant (excitation + autoionization) term is included.
+ intermediateWidths ::Dict{Int64,Float64} ... Optional per-level override of the total width Gamma_d [a.u.], keyed on
the index of the intermediate level; where an entry exists it wins over
the width that is computed from the configurations named in the
computation.
+ calcAnisotropy ::Bool ... True, if the anisotropy parameters beta_nu of the photoelectron are
computed.
+ printBefore ::Bool ... True, if all selected pathways are printed before their evaluation.
+ pathwaySelection ::PathwaySelection ... Specifies the selected pathways, if any.
+ continuumExchange ::Union{Nothing,Bool} ... True/false to force exchange between the photoelectron and the bound
electrons on or off; `nothing` -- the default -- lets `Basics.perform`
decide automatically from the final-ion `AsfSettings.scField`
(`Continuum.resolveExchangeDefault`, item 99).JenaAtomicCalculator.PhotoIonizationInterference.Settings — Method
PhotoIonizationInterference.Settings(set::PhotoIonizationInterference.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, photonEnergies::Union{Nothing,Array{Float64,1}}=nothing, lValues::Union{Nothing,Array{Int64,1}}=nothing, augerOperator::Union{Nothing,AbstractEeInteraction}=nothing, includePI::Union{Nothing,Bool}=nothing, includeResonance::Union{Nothing,Bool}=nothing, intermediateWidths::Union{Nothing,Dict{Int64,Float64}}=nothing, calcAnisotropy::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, pathwaySelection::Union{Nothing,PathwaySelection}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::PhotoIonizationInterference.Settings; a
settings::Settings is returned.JenaAtomicCalculator.PhotoIonizationInterference.Settings — Method
PhotoIonizationInterference.Settings() ... constructor for an empty instance of PhotoIonizationInterference.Settings; a settings::Settings is returned.
JenaAtomicCalculator.PhotoIonizationInterference.amplitudeResonant — Function
PhotoIonizationInterference.amplitudeResonant(mp::EmMultipole, kappa::Int64, phase::Float64, dLevel::Level, newcLevel::Level, initialLevel::Level, totalEnergy::Float64, gammaD::Float64, grid::Radial.Grid, settings::PhotoIonizationInterference.Settings, exciteCache::Dict{Tuple{EmMultipole,Int64,Int64},EmPropertyC} = Dict{Tuple{EmMultipole,Int64,Int64},EmPropertyC}()) ... to compute the resonant contribution of ONE intermediate level d to the photoionization amplitude of one channel, i.e.
A_excite(i-->d) * A_decay(d-->f,kappa) / (E_i + omega - E_d + i Gamma_d/2) ,
with NO extra normalization constant -- see `PhotoIonizationInterference.photoionizationNormalization`'s own docstring for
why none is needed here, unlike the sqrt((2Jf+1)/(2Ji+1)) factor `PhotoRecombinationInterference.dielectronicNormalization`
derives for the structurally different RR/DR case. A value::EmPropertyC is returned.
The excitation amplitude is a plain bound-bound `PhotoEmission.amplitude(Absorption(),...)` call -- exactly the amplitude
`PhotoExcitation` itself uses -- carrying no continuum-phase ambiguity at all, since both i and d are ordinary bound
levels. The decay amplitude comes from `AutoIonization.amplitudeForPhotoionizationConvention`, which is
`AutoIonization.amplitude` converted to `PhotoIonization`'s own i^(-l) exp(-i phase) convention; using the plain
`AutoIonization.amplitude` here instead would reweight the partial waves against one another by (-1)^l, exactly the
mistake `AutoIonization.captureAmplitude`'s own docstring warns against for the recombination case.
THE EXCITATION AMPLITUDE DOES NOT DEPEND ON kappa, phase OR newcLevel -- only on (mp, dLevel, initialLevel) -- so the SAME
bound-bound radial integral is otherwise recomputed once per partial wave and per channel that shares this d-level, for
every photon energy of the scan. `exciteCache` memoizes it; the caller supplies ONE dict shared across the whole
`computePathways` run (dLevel and initialLevel repeat across the entire photon-energy scan, so this is the dominant
saving), and an isolated call may simply omit it.JenaAtomicCalculator.PhotoIonizationInterference.computeAmplitudesProperties — Function
PhotoIonizationInterference.computeAmplitudesProperties(pathway::PhotoIonizationInterference.Pathway, intermediateMultiplet::Multiplet, widths::Dict{Int64,Float64}, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::PhotoIonizationInterference.Settings, exciteCache::Dict{Tuple{EmMultipole,Int64,Int64},EmPropertyC} = Dict{Tuple{EmMultipole,Int64,Int64},EmPropertyC}()) ... to compute, for the given pathway, the direct and the resonant amplitude of every channel and to add them coherently; the three cross sections, the interference term and the anisotropy parameters follow from them. A newPathway::Pathway is returned.
ONE continuum orbital is generated per partial wave, exactly as in `PhotoIonization.computeAmplitudesProperties`, and the
excitation amplitude of the resonant term is evaluated at the resonance's OWN energy E_d - E_i, not at the photon energy
of the overall process -- the two coincide only exactly at resonance, same distinction
`PhotoRecombinationInterference.amplitudeDR`'s own docstring draws for its stabilizing amplitude.
`exciteCache` is passed straight through to `PhotoIonizationInterference.amplitudeResonant`, which explains what it saves
and why; `computePathways` is the caller that shares ONE dict across every pathway of the scan.JenaAtomicCalculator.PhotoIonizationInterference.computePathways — Method
PhotoIonizationInterference.computePathways(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonizationInterference.Settings; output::Bool=true) ... to compute the coherent photoionization amplitudes and all requested properties for the selected pathways and for every photon energy of the settings; this is the standard entry point of this module. A list of pathways::Array{PhotoIonizationInterference.Pathway,1} is returned if output = true, and nothing otherwise.
JenaAtomicCalculator.PhotoIonizationInterference.computeTotalWidths — Method
PhotoIonizationInterference.computeTotalWidths(intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, finalMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoIonizationInterference.Settings) ... to determine the total width Gamma_d of every intermediate level, as the sum of its Auger rates into the levels of the final multiplet and of its radiative rates into the levels of the initial multiplet. A widths::Dict{Int64,Float64} is returned, keyed on the index of the intermediate level.
This width is built ONLY from the configurations that the computation names, and is therefore a LOWER bound: any decay
channel outside them is missing, which makes the resonance too narrow and its peak too high. The breakdown is printed for
exactly that reason, and `settings.intermediateWidths` overrides the computed value wherever the user supplies one.
THE TWO DECAY DIRECTIONS, named explicitly because they are the reverse of `PhotoRecombinationInterference`'s own
`computeTotalWidths`: there, Gamma_a decays INTO the INITIAL (bare ion) multiplet and Gamma_r INTO the FINAL (recombined)
multiplet, because recombination's bare ion sits on the initial side. Here Gamma_a decays INTO the FINAL (one-electron-
less ion) multiplet and Gamma_r INTO the INITIAL (bound, lower-lying) multiplet, because photoionization's bare ion sits
on the final side.JenaAtomicCalculator.PhotoIonizationInterference.determineChannels — Method
PhotoIonizationInterference.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoIonizationInterference.Settings) ... to determine the partial waves of the outgoing photoelectron and, for each of them, the total symmetries of the (ion + electron) scattering state that contribute; the list is that of PhotoIonization.determineChannels and is obtained from it, so that the direct term is bookkept exactly as in that module. An Array{PhotoIonizationInterference.PartialWave,1} is returned.
JenaAtomicCalculator.PhotoIonizationInterference.determinePathways — Method
PhotoIonizationInterference.determinePathways(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoIonizationInterference.Settings) ... to determine the list of pathways for which the coherent photoionization amplitude is to be computed, one per (initial level, final level, photon energy). Each pathway carries the intermediate levels that SURVIVE the pathway selection for its own (i, f) pair, so that a single resonance – or a chosen subset of them – can be studied in isolation. Which of the surviving levels then actually contributes is decided channel by channel through the symmetry condition Jd = Jt. An Array{PhotoIonizationInterference.Pathway,1} is returned.
JenaAtomicCalculator.PhotoIonizationInterference.displayPathways — Method
PhotoIonizationInterference.displayPathways(stream::IO, pathways::Array{PhotoIonizationInterference.Pathway,1}, widths::Dict{Int64,Float64}) ... to display a list of the pathways that have been selected for the computations, together with the photon and electron energies and the number of partial waves. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoIonizationInterference.displayResults — Method
PhotoIonizationInterference.displayResults(stream::IO, pathways::Array{PhotoIonizationInterference.Pathway,1}, settings::PhotoIonizationInterference.Settings) ... to display the three cross sections, the interference term and – where requested – the anisotropy parameter beta_2, for every pathway and photon energy. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoIonizationInterference.photoionizationNormalization — Method
PhotoIonizationInterference.photoionizationNormalization(initialLevel::Level, dLevel::Level) ... supplies the constant N that would put the resonant amplitude on the same footing as the direct one, analogous to PhotoRecombinationInterference.dielectronicNormalization. STRUCTURAL ARGUMENT FOR N = 1, not assumed: the direct amplitude's bra is the BOUND initial level i and its ket is the (f, kappa) Jt CONTINUUM state; the resonant amplitude's two halves share exactly those same two ends – PhotoEmission.amplitude(Absorption(),...) has bra i and ket d (both bound, d carrying the SAME Jt the channel itself carries), and AutoIonization.amplitudeForPhotoionizationConvention has bra d and ket (f, kappa) Jt – so NEITHER half introduces a continuum electron on the side the direct term does not already carry one. This is the opposite of the RR/DR case, where the capture amplitude's bra (i, kappa) Jt already carries a continuum electron that the direct term's OWN bra does too, while the stabilization amplitude's bra/ket (d, f) are both bound – an asymmetric structure that is exactly what forces dielectronicNormalization's derived factor.
THIS VALUE IS NOT TRUSTED ON THE STRENGTH OF THE ARGUMENT ALONE: example-Dy.jl's own branch measures the ratio of the
integrated resonant-alone cross section (interference and the direct term both switched off) to the independently
computed sum rule `2 pi^2 alpha f_exc BR_auger` -- `f_exc` from `PhotoExcitation.computeAmplitudesProperties` and
`BR_auger` from `AutoIonization.computeLines`/`displayLifetimes`, both already-validated existing functions -- and reports
the measured ratio, exactly the discipline `dielectronicNormalization`'s own docstring describes for its case. A
value::Float64 is returned.JenaAtomicCalculator.PhotoIonizationInterference.toPhotoIonizationWaves — Method
PhotoIonizationInterference.toPhotoIonizationWaves(partialWaves::Array{PhotoIonizationInterference.PartialWave,1}, which::Symbol) ... to package the amplitudes of the given partial waves into Array{PhotoIonization.PartialWave,1}, so that the cross section and the angular-distribution formula can be taken from that module unchanged. which selects which set of amplitudes travels: :total the coherent sum, :pi the direct term alone and :resonant the resonant term alone. An Array{PhotoIonization.PartialWave,1} is returned.
This is what makes the limit includeResonance = false reproduce `PhotoIonization` by CONSTRUCTION: in that limit the very
same numbers are handed to the very same functions.Photorecombination with RR-DR interference
JenaAtomicCalculator.PhotoRecombinationInterference.Channel — Type
struct PhotoRecombinationInterference.Channel ... defines a type for ONE total symmetry J_t of the (ion + free electron) scattering state, and carries the direct, the resonant and the summed amplitude separately, so that the three cross sections and hence the interference term can be formed afterwards.
+ symmetry ::LevelSymmetry ... Total J^parity of the scattering state.
+ amplitudesRR ::Array{MultipoleAmplitude,1} ... Direct (RR) amplitudes, one entry per multipole, both gauges.
+ amplitudesDR ::Array{MultipoleAmplitude,1} ... Resonant (DR) amplitudes, one entry per multipole, both gauges.
+ amplitudes ::Array{MultipoleAmplitude,1} ... The COHERENT SUM, one entry per multipole, both gauges.JenaAtomicCalculator.PhotoRecombinationInterference.Channel — Method
PhotoRecombinationInterference.Channel() ... constructor for an empty instance of PhotoRecombinationInterference.Channel; a channel::Channel is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.PartialWave — Type
struct PhotoRecombinationInterference.PartialWave ... defines a type for ONE partial wave of the incoming free electron together with the total symmetries it serves; it mirrors PhotoRecombination.PartialWave, since the radial orbital and the scattering phase belong to (energy, kappa) and not to any one total symmetry.
+ kappa ::Int64 ... Partial wave of the incoming free electron.
+ energy ::Float64 ... Energy of the free electron [a.u.].
+ phase ::Float64 ... Scattering phase of this partial wave.
+ channels ::Array{Channel,1} ... The total symmetries that this partial wave serves.JenaAtomicCalculator.PhotoRecombinationInterference.PartialWave — Method
PhotoRecombinationInterference.PartialWave() ... constructor for an empty instance of PhotoRecombinationInterference.PartialWave; a pw::PartialWave is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.Pathway — Type
struct PhotoRecombinationInterference.Pathway ... defines a type for the coherent recombination of an electron with an initial ion level into a final level, for ONE energy of the incoming electron and through a set of intermediate resonances.
+ initialLevel ::Level ... Initial-(state) level of the ion.
+ finalLevel ::Level ... Final-(state) level of the recombined ion.
+ intermediateLevels ::Array{Level,1} ... The resonances that were actually included in the resonant term.
+ electronEnergy ::Float64 ... Energy of the incoming electron [a.u.].
+ photonEnergy ::Float64 ... Energy of the emitted photon [a.u.]; ONE value for both terms.
+ betaGamma2 ::Float64 ... beta^2 * gamma^2 of the incoming electron.
+ crossSection ::EmProperty ... Cross section from the SUMMED amplitude.
+ crossSectionRR ::EmProperty ... Cross section from the direct term alone.
+ crossSectionDR ::EmProperty ... Cross section from the resonant term alone.
+ interference ::EmProperty ... crossSection - crossSectionRR - crossSectionDR.
+ betaNu ::Array{EmPropertyC,1} ... Anisotropy parameters beta_nu, nu = 2 and 4, from the summed amplitude.
+ linearPolarization ::EmPropertyC ... Linear polarization of the photon emitted at 90 degrees.
+ partialWaves ::Array{PartialWave,1} ... Partial waves, each with the channels it serves.JenaAtomicCalculator.PhotoRecombinationInterference.Pathway — Method
PhotoRecombinationInterference.Pathway() ... constructor for an empty instance of PhotoRecombinationInterference.Pathway; a pathway::Pathway is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.Settings — Type
struct PhotoRecombinationInterference.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing the interference of radiative and dielectronic recombination.
+ multipoles ::Array{EmMultipole,1} ... Multipoles of the emitted photon that are taken into account.
+ gauges ::Array{UseGauge,1} ... Gauges to be included into the computations.
+ electronEnergies ::Array{Float64,1} ... Energies of the incoming electron, i.e. the scan ACROSS the resonance.
+ maxKappa ::Int64 ... Maximum kappa of the partial waves of the incoming electron.
+ augerOperator ::AbstractEeInteraction ... Operator for the dielectronic-capture amplitudes.
+ includeRR ::Bool ... True, if the direct (radiative-recombination) term is included.
+ includeDR ::Bool ... True, if the resonant (dielectronic-recombination) term is included.
+ intermediateWidths ::Dict{Int64,Float64} ... Optional per-level override of the total width Gamma_d [a.u.], keyed on the
index of the intermediate level; where an entry exists it wins over the width
that is computed from the configurations named in the computation.
+ calcAnisotropy ::Bool ... True, if the anisotropy parameters beta_nu of the photon are computed.
+ calcPolarization ::Bool ... True, if the linear polarization of the photon is computed.
+ printBefore ::Bool ... True, if all selected pathways are printed before their evaluation.
+ pathwaySelection ::PathwaySelection ... Specifies the selected pathways, if any.
+ continuumExchange ::Union{Nothing,Bool} ... True/false to force exchange between the captured electron and the
bound electrons on or off; `nothing` -- the default -- lets
`Basics.perform` decide automatically from the INITIAL-ion
`AsfSettings.scField` (`Continuum.resolveExchangeDefault`, item 99;
the captured electron approaches the initial ion here, as in
`PhotoRecombination`).JenaAtomicCalculator.PhotoRecombinationInterference.Settings — Method
PhotoRecombinationInterference.Settings(set::PhotoRecombinationInterference.Settings; multipoles::Union{Nothing,Array{EmMultipole,1}}=nothing, gauges::Union{Nothing,Array{UseGauge,1}}=nothing, electronEnergies::Union{Nothing,Array{Float64,1}}=nothing, maxKappa::Union{Nothing,Int64}=nothing, augerOperator::Union{Nothing,AbstractEeInteraction}=nothing, includeRR::Union{Nothing,Bool}=nothing, includeDR::Union{Nothing,Bool}=nothing, intermediateWidths::Union{Nothing,Dict{Int64,Float64}}=nothing, calcAnisotropy::Union{Nothing,Bool}=nothing, calcPolarization::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, pathwaySelection::Union{Nothing,PathwaySelection}=nothing, continuumExchange::Union{Nothing,Bool}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::PhotoRecombinationInterference.Settings; a
settings::Settings is returned.JenaAtomicCalculator.PhotoRecombinationInterference.Settings — Method
PhotoRecombinationInterference.Settings() ... constructor for an empty instance of PhotoRecombinationInterference.Settings; a settings::Settings is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.amplitudeDR — Method
PhotoRecombinationInterference.amplitudeDR(mp::EmMultipole, kappa::Int64, phase::Float64, dLevel::Level, newfLevel::Level, newcLevel::Level, redFLevel::Level, totalEnergy::Float64, omega::Float64, gammaD::Float64, grid::Radial.Grid, settings::PhotoRecombinationInterference.Settings) ... to compute the resonant contribution of ONE intermediate level d to the recombination amplitude of one channel, i.e.
A_capture(d) * A_radiative(f <-- d) / (E_total - E_d + i Gamma_d / 2) ,
without the overall normalization, which `dielectronicNormalization` supplies once per pathway. The stabilizing amplitude is
evaluated at the photon energy of the overall process rather than at E_d - E_f. A value::EmPropertyC is returned.
The capture amplitude comes from `AutoIonization.captureAmplitude`, which is the incoming-wave variant of the Auger amplitude and
NOT its complex conjugate; that distinction is a property of the two continuum-state conventions rather than of this module, so it
is documented there. It matters here because a coherent sum does not square the amplitude first.JenaAtomicCalculator.PhotoRecombinationInterference.computeAmplitudesProperties — Method
PhotoRecombinationInterference.computeAmplitudesProperties(pathway::PhotoRecombinationInterference.Pathway, intermediateMultiplet::Multiplet, widths::Dict{Int64,Float64}, nm::Nuclear.Model, grid::Radial.Grid, nrContinuum::Int64, settings::PhotoRecombinationInterference.Settings) ... to compute, for the given pathway, the direct and the resonant amplitude of every channel and to add them coherently; the three cross sections, the interference term, the anisotropy parameters and the linear polarization follow from them. A newPathway::Pathway is returned.
ONE continuum orbital is generated per partial wave, exactly as in `PhotoRecombination.computeAmplitudesProperties`, and the
radiative amplitude of the resonant term is evaluated at the SAME photon energy as the direct term.JenaAtomicCalculator.PhotoRecombinationInterference.computeLinearPolarization — Method
PhotoRecombinationInterference.computeLinearPolarization(line::PhotoRecombination.Line, multipoles::Array{EmMultipole,1}) ... to compute the degree of linear polarization P = (Iparallel - Iperpendicular)/(Iparallel + Iperpendicular) of the photon emitted perpendicular to the electron beam, for an initially unpolarized ion; a value::EmPropertyC is returned that holds both gauges.
For PURE ELECTRIC-DIPOLE radiation the polarization is not an independent quantity: the same alignment of the emitting system fixes
both the angular distribution and the polarization, and at 90 degrees they are related rigorously by
P = -3 beta_2 / (2 - beta_2) ,
which is what is evaluated here from the beta_2 of `PhotoRecombination.computeAnisotropyParameter`, i.e. from the COHERENTLY SUMMED
amplitudes. Nothing is assumed about the relative size of the direct and the resonant term, so the interference enters the
polarization exactly as it enters beta_2, which is the effect reported by Tong (2023).
RESTRICTION, stated rather than hidden: this relation holds for E1 only. Once a magnetic or a higher electric multipole
contributes, the nu,2 component of the photon density matrix stops being proportional to the nu,0 component and a full density-
matrix treatment is needed. Rather than return a number that would silently be wrong, this function returns NaN in that case, and
the display method prints it as such.JenaAtomicCalculator.PhotoRecombinationInterference.computePathways — Method
PhotoRecombinationInterference.computePathways(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoRecombinationInterference.Settings; output::Bool=true) ... to compute the coherent recombination amplitudes and all requested properties for the selected pathways and for every electron energy of the settings; this is the standard entry point of this module. A list of pathways::Array{PhotoRecombinationInterference.Pathway,1} is returned if output = true, and nothing otherwise.
JenaAtomicCalculator.PhotoRecombinationInterference.computeTotalWidths — Method
PhotoRecombinationInterference.computeTotalWidths(intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, finalMultiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::PhotoRecombinationInterference.Settings) ... to determine the total width Gamma_d of every intermediate level, as the sum of its Auger rates into the levels of the initial multiplet and of its radiative rates into the levels of the final multiplet. A widths::Dict{Int64,Float64} is returned, keyed on the index of the intermediate level.
This width is built ONLY from the configurations that the computation names, and is therefore a LOWER bound: any decay channel
outside them is missing, which makes the resonance too narrow and its peak too high. The breakdown is printed for exactly that
reason, and `settings.intermediateWidths` overrides the computed value wherever the user supplies one.JenaAtomicCalculator.PhotoRecombinationInterference.determineChannels — Method
PhotoRecombinationInterference.determineChannels(finalLevel::Level, initialLevel::Level, settings::PhotoRecombinationInterference.Settings) ... to determine the partial waves of the incoming electron and, for each of them, the total symmetries of the (ion + electron) scattering state that contribute; the list is that of PhotoRecombination.determineChannels and is obtained from it, so that the direct term is bookkept exactly as in that module. An Array{PhotoRecombinationInterference.PartialWave,1} is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.determinePathways — Method
PhotoRecombinationInterference.determinePathways(finalMultiplet::Multiplet, intermediateMultiplet::Multiplet, initialMultiplet::Multiplet, settings::PhotoRecombinationInterference.Settings) ... to determine the list of pathways for which the coherent recombination amplitude is to be computed, one per (initial level, final level, electron energy). Each pathway carries the intermediate levels that SURVIVE the pathway selection for its own (i, f) pair, so that a single resonance – or a chosen subset of them – can be studied in isolation, which is what an interference study normally wants. Which of the surviving levels then actually contributes is decided channel by channel through the symmetry condition Jd = Jt. An Array{PhotoRecombinationInterference.Pathway,1} is returned.
JenaAtomicCalculator.PhotoRecombinationInterference.dielectronicNormalization — Method
PhotoRecombinationInterference.dielectronicNormalization(initialLevel::Level, finalLevel::Level) ... to supply the constant N that puts the resonant amplitude on the same footing as the direct one, so that the two may be added.
N is fixed by requiring that the resonant term ALONE, integrated over one isolated resonance, reproduce the standard dielectronic
resonance strength S = (pi^2/E_res) (2J_d+1)/(2(2J_i+1)) Gamma_a A_r / Gamma_d. Carrying JAC's own three normalizations through
that condition -- Gamma_a = 2 pi Sum |A_Auger|^2, A_r = 8 pi alpha omega/(2J_d+1) Sum |A_rad|^2, and
sigma_RR = (1/beta gamma^2) 8 pi^3 alpha^3 omega/(2J_f+1) Sum |A_RR|^2 -- everything cancels except
N = sqrt( (2J_f+1) / (2J_i+1) ) .
This value is DERIVED, and the derivation is not trusted on its own: branch b of example-Dx.jl measures the ratio of the
integrated resonant cross section to the resonance strength of the DielectronicRecombination module and reports it. A
value::Float64 is returned.JenaAtomicCalculator.PhotoRecombinationInterference.displayPathways — Method
PhotoRecombinationInterference.displayPathways(stream::IO, pathways::Array{PhotoRecombinationInterference.Pathway,1}, widths::Dict{Int64,Float64}) ... to display a list of the pathways that have been selected for the computations, together with the electron and photon energies and the number of partial waves. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoRecombinationInterference.displayResults — Method
PhotoRecombinationInterference.displayResults(stream::IO, pathways::Array{PhotoRecombinationInterference.Pathway,1}, settings::PhotoRecombinationInterference.Settings) ... to display the three cross sections, the interference term and – where they were requested – the anisotropy parameter beta_2 and the linear polarization, for every pathway and electron energy. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.PhotoRecombinationInterference.toPhotoRecombinationLine — Method
PhotoRecombinationInterference.toPhotoRecombinationLine(pathway::PhotoRecombinationInterference.Pathway, partialWaves::Array{PhotoRecombinationInterference.PartialWave,1}, which::Symbol) ... to package the amplitudes of the given partial waves into a PhotoRecombination.Line, so that the cross section and the anisotropy parameters can be taken from that module unchanged. which selects which set of amplitudes travels: :total the coherent sum, :rr the direct term alone and :dr the resonant term alone. A line::PhotoRecombination.Line is returned.
This is what makes the limit includeDR = false reproduce `PhotoRecombination` by CONSTRUCTION: in that limit the very same numbers
are handed to the very same functions.Resonant electron-impact ionization
JenaAtomicCalculator.ResonantImpactIonization.SequentialAuger — Type
struct ResonantImpactIonization.SequentialAuger <: Basics.AbstractProcess ... selects resonant-electron-capture-with-sequential-double-autoionization, in which the doubly-excited resonance sheds its two electrons ONE AFTER THE OTHER, through an intermediate level that autoionizes in its turn. Known as REDA in the older literature. It subtypes Basics.AbstractProcess so that it can stand directly in the processes list of a cascade scheme, rather than needing a second set of marker types beside it.
JenaAtomicCalculator.ResonantImpactIonization.SimultaneousAuger — Type
struct ResonantImpactIonization.SimultaneousAuger <: Basics.AbstractProcess ... selects resonant-electron-capture-with-simultaneous-double-autoionization, in which the doubly-excited resonance sheds both electrons TOGETHER, in a single double-Auger transition. Known as READI in the older literature. Its rate is ESTIMATED from shake-off, see the module docstring and ResonantImpactIonization.shakeProbability; it is not computed from amplitudes.
JenaAtomicCalculator.ResonantImpactIonization.doubleAugerProbability — Method
ResonantImpactIonization.doubleAugerProbability(passiveOrbitals::Array{Radial.Orbital,1}, occupations::Array{Int64,1}, finalOrbitals::Array{Radial.Orbital,1}, grid::Radial.Grid) ... to estimate the probability that a SECOND electron is emitted together with the Auger electron, i.e. the branching fraction of the double-Auger route, by combining the one-electron shake probabilities of all passive subshells; a value::Float64 in [0,1] is returned.
With P(a) the shake probability of subshell a and N(a) its occupation, the probability that NO electron is shaken is the
product of (1 - P(a))^N(a) over the passive subshells, so that
P(double Auger) = 1 - PROD_a (1 - P(a))^N(a)
This treats the passive electrons as shaking INDEPENDENTLY of one another, which is the usual sudden-approximation counting
and is the third approximation stacked on top of the two carried by `shakeProbability` itself. Read that function's
docstring before using the number: the estimate is wrong in both directions and is not a bound.
PASSIVE MEANS PASSIVE, and it is the easiest thing to get wrong here. The two electrons that PARTICIPATE in the Auger
transition -- the one that fills the hole and the one that is ejected -- must NOT appear in `passiveOrbitals`, or they are
counted twice: once as the Auger itself and once as a shake. For a KLL transition the passive set is everything except the
two L electrons involved.
Measured behaviour, for orientation rather than as a claim: with 2s and 2p passive, neon between its neutral and
singly-ionized orbitals gives 6.2 %, and the one-electron probabilities are 1.0 % for 2p in Ne, 0.77 % for 3p in Ar and
0.76 % for 4p in Kr, while the 1s is unaffected to five decimals -- a deeply bound orbital hardly notices the loss of an
outer electron. Those are the right order for light elements. Note that a change of NUCLEAR charge is NOT the right
comparison and gives numbers several times larger; an Auger raises the IONIC charge at fixed Z.JenaAtomicCalculator.ResonantImpactIonization.resonanceStrength — Method
ResonantImpactIonization.resonanceStrength(energy::Float64, captureRate::Float64, twiceJd::Int64, twiceJi::Int64) ... to compute the energy-integrated strength of ONE resonance for its FORMATION alone, i.e. before any decay branching is applied; a value::Float64 in atomic units is returned.
S_0 = pi^2 / k^2 * A(capture) * (2J_d + 1) / (2J_i + 1)
with k the wave number of the incident electron at the resonance energy. The capture rate follows from the Auger rate of
the time-reversed transition by detailed balance, so no separate capture calculation enters. The wave number is taken from
`Defaults.convertUnits("kinetic energy to wave number: atomic units", ...)`, i.e. relativistically and by exactly the same
route as `Cascade.simulateDrRateCoefficients` uses for the dielectronic-recombination strength -- which is what allows the
recombination and ionization strengths of the SAME resonance to be compared without a conversion between them.JenaAtomicCalculator.ResonantImpactIonization.sequentialStrength — Method
ResonantImpactIonization.sequentialStrength(energy::Float64, captureRate::Float64, twiceJd::Int64, twiceJi::Int64, augerRateToIntermediate::Float64, totalWidthResonance::Float64, augerRateIntermediate::Float64, totalWidthIntermediate::Float64) ... to compute the energy-integrated strength of ONE resonance for the sequential double-autoionization route, i.e. the formation strength multiplied by the two decay branchings it must pass through; a value::Float64 in atomic units is returned.
S = S_0 * [ A(d -> n) / Gamma(d) ] * [ A(n, total Auger) / Gamma(n) ]
The first bracket is the branching of the resonance d into the autoionizing intermediate n, the second is the branching of
n to autoionize rather than to radiate; Gamma is the TOTAL width, Auger plus radiative, of the level in question. Zero is
returned if either total width vanishes, which happens for a level whose decays were not generated.
The two steps are treated as INDEPENDENT, with no interference between the time orderings; see the module docstring.JenaAtomicCalculator.ResonantImpactIonization.shakeProbability — Method
ResonantImpactIonization.shakeProbability(initialOrbital::Radial.Orbital, finalOrbitals::Array{Radial.Orbital,1}, grid::Radial.Grid) ... to estimate, in the SUDDEN APPROXIMATION, the probability that a passive electron in initialOrbital fails to remain in any bound orbital of the ion left behind once the Auger electron has gone; a value::Float64 in [0,1] is returned.
P = 1 - SUM_(n' bound, same kappa) |< phi(n' kappa) | phi(initial) >|^2
The sudden change of the potential is spherically symmetric, so it cannot change kappa: only final orbitals of the SAME
kappa are summed, and `RadialIntegrals.overlap` supplies each overlap. `finalOrbitals` must be the orbitals of the ion
AFTER the Auger transition, i.e. one charge state higher than those of `initialOrbital`.
THE ESTIMATE IS WRONG IN BOTH DIRECTIONS AND IS NOT A BOUND, which is the single most important thing about it:
+ a finite bound set INFLATES it
... the sum runs over the bound orbitals that were actually computed. What the projection loses to bound orbitals
outside that set is counted here as if the electron had been ejected, so shake-UP leaks in as shake-off.
+ the missing knockout DEFLATES it
... shake-off is only one of the two mechanisms of double Auger. The other, KNOCKOUT -- the departing electron
striking a second on its way out -- is a collision and cannot be reached from overlaps at all. It is comparable
to, and often larger than, shake-off.
The two errors do not cancel in any controlled way. A negative value from numerical noise, which an over-complete bound
set can produce, is clipped to zero.JenaAtomicCalculator.ResonantImpactIonization.simultaneousStrength — Method
ResonantImpactIonization.simultaneousStrength(energy::Float64, captureRate::Float64, twiceJd::Int64, twiceJi::Int64, doubleAugerRate::Float64, totalWidthResonance::Float64) ... to compute the energy-integrated strength of ONE resonance for the simultaneous double-autoionization route, i.e. the formation strength multiplied by the branching into the double-Auger channel; a value::Float64 in atomic units is returned.
S = S_0 * A(double Auger) / Gamma(d)
with Gamma(d) the total width of the resonance. Zero is returned if that width vanishes. The double-Auger rate is
normally `ResonantImpactIonization.doubleAugerProbability(...)` times the resonance's total Auger rate, and is therefore an
ESTIMATE whose error has both signs; a strength from this function is an order of magnitude, not a value to quote.Generalized oscillator strengths
JenaAtomicCalculator.GeneralizedOscillatorStrength.Channel — Method
GeneralizedOscillatorStrength.Channel() ... constructor for an empty instance of GeneralizedOscillatorStrength.Channel; a channel::Channel is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.Channel — Type
struct GeneralizedOscillatorStrength.Channel ... defines a type for a single (momentum transfer, multipole rank) component of a generalized oscillator strength.
+ q ::Float64 ... Momentum transfer K [a.u.] of this component.
+ L ::Int64 ... Rank of the tensor operator j_L(Kr) C^L.
+ amplitude ::ComplexF64 ... Reduced matrix element <alpha_f J_f || Sum_j j_L(K r_j) C^L(j) || alpha_i J_i>.JenaAtomicCalculator.GeneralizedOscillatorStrength.Line — Method
GeneralizedOscillatorStrength.Line(initialLevel::Level, finalLevel::Level, deltaEnergy::Float64, qValues::Array{Float64,1}) ... constructor for a generalized-oscillator-strength line between a specified initial and final level, and for which no amplitude has yet been evaluated; a line::Line is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.Line — Method
GeneralizedOscillatorStrength.Line() ... constructor for an empty instance of GeneralizedOscillatorStrength.Line; a line::Line is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.Line — Type
struct GeneralizedOscillatorStrength.Line ... defines a type for a generalized oscillator strength, i.e. for one pair of an initial and a final level, together with the GOS values on the whole grid of momentum transfers.
+ initialLevel ::Level ... initial-(state) level
+ finalLevel ::Level ... final-(state) level
+ deltaEnergy ::Float64 ... Transition energy E_f - E_i [a.u.] of this line.
+ qValues ::Array{Float64,1} ... Momentum transfers K [a.u.] at which the GOS has been evaluated.
+ gosValues ::Array{Float64,1} ... Generalized oscillator strengths f_n(K), parallel to qValues.
+ opticalLimit ::Float64 ... Optical oscillator strength f_n, i.e. the limit of f_n(K) for K --> 0.
+ channels ::Array{GeneralizedOscillatorStrength.Channel,1} ... List of all (q, L) components of this line.JenaAtomicCalculator.GeneralizedOscillatorStrength.Settings — Method
GeneralizedOscillatorStrength.Settings(set::GeneralizedOscillatorStrength.Settings; qValues::Union{Nothing,Array{Float64,1}}=nothing, calcOpticalLimit::Union{Nothing,Bool}=nothing, calcBiorthogonal::Union{Nothing,Bool}=nothing, printBefore::Union{Nothing,Bool}=nothing, lineSelection::Union{Nothing,LineSelection}=nothing)
... keyword copy-constructor for re-defining selected values of a settings::GeneralizedOscillatorStrength.Settings;
a settings::Settings is returned.JenaAtomicCalculator.GeneralizedOscillatorStrength.Settings — Method
GeneralizedOscillatorStrength.Settings() ... constructor for an empty instance of GeneralizedOscillatorStrength.Settings; a settings::Settings is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.Settings — Type
struct GeneralizedOscillatorStrength.Settings <: AbstractProcessSettings ... defines a type for the details and parameters of computing generalized oscillator strengths.
+ qValues ::Array{Float64,1} ... List of momentum transfers K [a.u.] for which the GOS is computed.
+ calcOpticalLimit ::Bool ... True, if the optical limit f_n (K --> 0) is evaluated in addition; this
value must agree with the (length-form) oscillator strength of the same
transition and is the natural calibration of the whole computation.
+ calcBiorthogonal ::Bool ... True, if the initial- and final-state multiplets are first brought into a
bi-orthogonal representation (`BiOrthogonal.computeTransformation`) before
the amplitudes are evaluated, and false if they are used as they are.
+ printBefore ::Bool ... True, if all selected lines are printed before their evaluation.
+ lineSelection ::LineSelection ... Specifies the selected level pairs, if any.JenaAtomicCalculator.GeneralizedOscillatorStrength.amplitude — Method
GeneralizedOscillatorStrength.amplitude(L::Int64, q::Float64, finalLevel::Level, initialLevel::Level, grid::Radial.Grid; display::Bool=false)
... to compute the (many-electron) reduced matrix element <alpha_f J_f || Sum_j j_L(q r_j) C^L(j) || alpha_i J_i> of the L-th
multipole component of the plane wave exp(i K.r), for the given final and initial level. The single-electron kernel is
the Grant reduced matrix element <kappa_a || C^L || kappa_b> -- which is the same for the large and the small components,
both requiring l_a + l_b + L to be even -- times the radial integral int dr j_L(qr) [P_a P_b + Q_a Q_b]. The operator
carries the parity (-1)^L, so that the matrix element vanishes unless (-1)^L = pi_i pi_f. A value::ComplexF64 is returned.JenaAtomicCalculator.GeneralizedOscillatorStrength.computeAmplitudesProperties — Method
GeneralizedOscillatorStrength.computeAmplitudesProperties(line::GeneralizedOscillatorStrength.Line, grid::Radial.Grid, settings::GeneralizedOscillatorStrength.Settings; printout::Bool=true) ... to compute all reduced matrix elements and the generalized oscillator strengths of the given line, for every momentum transfer of the line and every contributing multipole rank L. A newLine::GeneralizedOscillatorStrength.Line is returned for which the channels, the GOS values and the optical limit have now been evaluated.
JenaAtomicCalculator.GeneralizedOscillatorStrength.computeGos — Method
GeneralizedOscillatorStrength.computeGos(q::Float64, deltaEnergy::Float64, initialLevel::Level, channels::Array{GeneralizedOscillatorStrength.Channel,1}) ... to combine the reduced matrix elements of all multipole ranks L, evaluated at one and the same momentum transfer q, into the generalized oscillator strength fn(q) = 2 dE/q^2 * 1/(2Ji+1) * SumL (2L+1) |<f|| jL(qr) C^L ||i>|^2, with all quantities in atomic units. A value::Float64 is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.computeLines — Method
GeneralizedOscillatorStrength.computeLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, grid::Radial.Grid, settings::GeneralizedOscillatorStrength.Settings; output=true) ... to compute the generalized oscillator strengths for all selected pairs of levels of the given initial- and final-state multiplet, and as specified by the given settings. A list of lines::Array{GeneralizedOscillatorStrength.Line,1} is returned, and the results are printed in neat tables to screen and to the summary file.
JenaAtomicCalculator.GeneralizedOscillatorStrength.determineLines — Method
GeneralizedOscillatorStrength.determineLines(finalMultiplet::Multiplet, initialMultiplet::Multiplet, settings::GeneralizedOscillatorStrength.Settings) ... to determine a list of lines for the computation of the generalized oscillator strengths between the levels of the given initial- and final-state multiplet. A pair of levels is kept only if it is selected by the line selection and if at least one multipole rank L contributes. An Array{GeneralizedOscillatorStrength.Line,1} is returned.
JenaAtomicCalculator.GeneralizedOscillatorStrength.determineRanks — Method
GeneralizedOscillatorStrength.determineRanks(finalLevel::Level, initialLevel::Level) ... to determine all multipole ranks L that contribute to the generalized oscillator strength between the given initial and final level. Two rules apply and, together, make the list finite and complete: the triangular rule |Jf - Ji| <= L <= Jf + Ji, and the parity of the operator jL(Kr) C^L, which requires (-1)^L = pii pi_f. No truncation and no convergence parameter is involved. An Array{Int64,1} is returned.
The monopole term L = 0 is INCLUDED and is not a trivial one: j_0(Kr) = sin(Kr)/(Kr) is a genuine operator that connects
two different levels of the same J and parity, and it is what carries, for instance, the whole 1s --> 2s generalized
oscillator strength of atomic hydrogen. Only in the limit K --> 0 does j_0(Kr) approach unity, whereupon the matrix
element collapses to the overlap of two orthogonal states -- which is precisely why f_n(K --> 0) vanishes for a
monopole-only transition.JenaAtomicCalculator.GeneralizedOscillatorStrength.displayLines — Method
GeneralizedOscillatorStrength.displayLines(stream::IO, lines::Array{GeneralizedOscillatorStrength.Line,1}) ... to display a list of the level pairs that have been selected for the computations, together with their transition energy and the multipole ranks L that will contribute. A neat table is printed but nothing is returned otherwise.
JenaAtomicCalculator.GeneralizedOscillatorStrength.displayResults — Method
GeneralizedOscillatorStrength.displayResults(stream::IO, lines::Array{GeneralizedOscillatorStrength.Line,1}, settings::GeneralizedOscillatorStrength.Settings) ... to display the generalized oscillator strengths of all lines, one block per line: the momentum transfer both as K and as the variable (Ka0)^2 in which the Bethe theory is usually plotted, the total fn(K), and the separate contribution of each multipole rank L. The optical limit is appended if it has been computed. A neat table is printed but nothing is returned otherwise.