Cascade computations

JenaAtomicCalculator.Cascade.AbsorptionCrossSection — Type

struct Cascade.AbsorptionCrossSection ... defines the absorption cross section for a particular (incident) photon energy in terms of its discrete and (direct photoionization) contributions. Of course, this absorption cross section depends on the relative population of the initial levels.

+ photonEnergy ::Float64              ... incident photon energy/photon-energy dependence of the absorption spectrum.
+ excitationCS ::Basics.EmProperty    ... contribution due to discrete excitation processes.
+ ionizationCS ::Basics.EmProperty    ... contribution due to contineous ionization processes.
source
JenaAtomicCalculator.Cascade.AbstractBoundOrbitals — Type

abstract type Cascade.AbstractBoundOrbitals ... specifies which set of bound one-electron orbitals the cascade blocks are built from.

+ struct GlobalOrbitals       ... ONE set for the whole cascade, from the mean field of the initial ion.
                                  The decayed states are then described with orbitals that never relax
                                  after the hole has been filled.
+ struct ChargeStateOrbitals  ... one self-consistent field per charge state, shared by all blocks with
                                  the same number of electrons.
+ struct MultipletOrbitals    ... one self-consistent field per multiplet, i.e. per block; every block's
                                  levels relax on their own orbitals.
source
JenaAtomicCalculator.Cascade.AbstractCascadeScheme — Type

abstract type Cascade.AbstractCascadeScheme ... defines an abstract type to distinguish different excitation, ionization and decay schemes of an atomic cascade; see also:

+ struct DielectronicCaptureScheme  
    ... to model just the (dielectronic) capture and the formation of doubly-excited levels up to a maximum excitation 
        energy and for a given list of subshells; the excitation energy refers to the lowest level of the reference 
        configurations, and the cascade blocks are built only by means of the given subshells.
        NOTE: The original DielectronicCaptureScheme --> DielectronicRecombinationScheme has been renamed in 
        August 2023 in order to enlarge the consistency of the notations and code !!
+ struct DielectronicRecombinationScheme  
    ... to model the (dielectronic) recombination of an electron up to a maximum excitation energy and for a given 
        list of subshells; the excitation energy refers to the lowest level of the reference configurations, and 
        cascade blocks are built only by means of the given subshells.
+ struct ElectronExcitationScheme  
    ... to model the electron excitation spectra in terms of the direct (EIE) and resonant contributions, i.e. the 
        dielectronic capture of an electron with subsequent re-autoionization. Typical electron-excitation properties are 
        energy-dependent EIE cross sections, effective collision strengths, EIE plasma rate coefficients, and several
        others (not yet).
+ struct ElectronIonizationScheme  
    ... to model the electron ionization spectra including the direct (EII) and resonant contributions, i.e. the 
        dielectronic capture of an electron with subsequent double-autoionization. For this double autoionization, a 
        branching factor will just be estimated. Typical electron-ionization properties are energy-dependent EII cross 
        sections, effective collision strengths for impact-ionization, EII plasma rate coefficients, and several others 
        (not yet).
+ struct ExpansionOpacityScheme  
    ... to model the expansion opacity of an ion in its ground or some low-lying state; this scheme takes a maximum photon
        (transition) energy and the excitation from the fromShells to the toShells in order to select the relevant 
        configurations. These shell lists refer to the given set of reference configurations.
+ struct HollowIonScheme    
    ... to model the capture of one or several electrons into a list of subshells; various distributions of the
        electron among these shells are supported. For the subsequent decay, the list of decay shells need to be specified
        as well.
+ struct ImpactExcitationScheme    
    ... to model the (direct) electron-impact excitation  (collision strength) of atoms from some initial to final 
        fine-structure level, and for a list of impact energies (not yet).
+ struct ImpactIonizationScheme    
    ... to model the (direct) electron-impact ionization  (collision strength) of atoms from some initial to final 
        fine-structure level, and for a list of impact energies. It typically applies some empirical cross sections 
        (not yet).
+ struct PhotoAbsorptionScheme    
    ... to model photoabsortion spectra, including the direct and resonant contributions, i.e. the photoexcitation
        of an inner-shell electron with subsequent electron emission. Typical photoabsorption properties are the
        energy-dependent photoionization cross sections, photoabsorption spectra, PI plasma rate coefficients, and 
        several others.
+ struct PhotoExcitationScheme    
    ... to model the (prior) photo-excitation part of an overall photoabsorption process; it considers a set of 
        inner-shell excitations with regard to the list of reference configurations. This cascade scheme is mainly
        used to compute the resonant contributions to photoabsorption or the initial excitations for a subsequent
        decay cascade.
+ struct PhotoIonizationScheme    
    ... to model the photoionization a basic part of photoabsortion. Typical photoionization properties are the 
        energy-dependent partial and total photoionization cross sections for a range of photon energies
        and several others.
+ struct RadiativeRecombinationScheme  
    ... to model the radiative recombination (capture) of an electron up to a maximum free-electron energy as well as
        for a given list of shells (intoShells), into which the capture is considered; the energy of the emitted photons then
        refer to the levels of the reference configurations, and all cascade blocks are built only with the given intoShells.
+ struct StepwiseDecayScheme       
    ... to model a standard decay scheme in terms of radiative and non-radiative transitions by starting from 
        the levels of one or several initial multiplets. Typical decay properties are ion distributions as well as
        photon and electron spectra from such cascades.
source
JenaAtomicCalculator.Cascade.AbstractCoincidenceGate — Type

abstract type Cascade.AbstractCoincidenceGate ... specifies one condition that an emitted particle (or the resulting ion) has to satisfy for a cascade event to be counted in a coincidence measurement. The gates are named after the PARTICLE that has to be detected, since that is what distinguishes them; ElectronGate and PhotonGate then differ only in which of the two an experiment's analyser accepted.

+ struct ElectronGate     ... an emitted electron within [minEnergy, maxEnergy].
+ struct PhotonGate       ... an emitted photon within [minEnergy, maxEnergy].
+ struct ChargeStateGate  ... the ion left with exactly NoElectrons electrons at the end of the cascade;
                              the odd one out, since it gates on the ion rather than on an emitted
                              particle, and therefore carries a different field.
source
JenaAtomicCalculator.Cascade.AbstractContinuumOrbitals — Type

abstract type Cascade.AbstractContinuumOrbitals ... specifies at which energy the orbital of the emitted (Auger) electron is generated.

+ struct StepAveragedContinuum       ... ONE set per cascade step, at that step's mean transition energy,
                                         shared by all fine-structure transitions of the step.
+ struct TransitionResolvedContinuum ... one orbital per fine-structure transition, at that transition's
                                         own energy.
source
JenaAtomicCalculator.Cascade.AbstractContinuumPotential — Type

abstract type Cascade.AbstractContinuumPotential ... specifies the potential in which the continuum orbital is generated.

+ struct LocalPotential   ... a local (Dirac-Fock-Slater) potential; no exchange with the bound electrons.
+ struct WithExchange     ... exchange between the free and the bound electrons included. NOT available:
                              JAC generates continuum orbitals in a local potential only, and lifting that
                              needs a non-local (Hartree-Fock) continuum solver. Selecting it is reported
                              as a warning rather than an error, so that an approach which merely ASKS for
                              exchange stays usable for everything else it offers.
source
JenaAtomicCalculator.Cascade.AbstractLevelRepresentation — Type

abstract type Cascade.AbstractLevelRepresentation ... specifies how the atomic levels of a cascade block are represented.

+ struct SingleCSF        ... every level is a single CSF; no configuration mixing of any kind.
+ struct BlockCI          ... configuration mixing WITHIN each block (intermediate coupling); one
                              configuration per block, so no mixing between configurations.
+ struct GroupedBlockCI   ... as BlockCI, but a block may comprise SEVERAL configurations as grouped by
                              the user, which admits correlation between those configurations.
source
JenaAtomicCalculator.Cascade.AbstractOpacityContribution — Type

abstract type Cascade.AbstractOpacityContribution ... defines an abstract and a number of singleton types for the CONTRIBUTIONS that build up a spectral opacity. Contributions are ADDITIVE, kappa_nu = sum over contributions, and each carries its own physical assumptions in its docstring, so that a user reading the type sees what is being computed. All contributions are mass opacities in [cm^2/g].

+ struct BoundBoundOpacity   ... lines, in the Sobolev/expansion treatment.
+ struct BoundFreeOpacity    ... photoionization of the bound shells; a true continuum.
+ struct ScatteringOpacity   ... Thomson scattering off free electrons; frequency-independent.

    NOT provided, deliberately rather than as a stub: free-free (bremsstrahlung). See
    Cascade.RosselandMean for why a continuum contribution is needed at all.
source
JenaAtomicCalculator.Cascade.AbstractOpacityDependence — Type

abstract type Cascade.AbstractOpacityDependence` ... defines an abstract type to distinguish different dependencies for the opacity; see also:

+ struct FrequencyOpacityDependence     ... to deal with omega-dependence opacities [omega].
+ struct WavelengthOpacityDependence    ... to deal with wavelength-dependence opacities [lambda].
+ struct TemperatureOpacityDependence   ... to deal with temperature-normalized dependent opacities [u].
source
JenaAtomicCalculator.Cascade.AbstractOpacityMean — Type

abstract type Cascade.AbstractOpacityMean ... defines an abstract and a number of singleton types for the MEAN that is taken over a spectral opacity kappanu. A mean is a FUNCTIONAL of kappanu and is applied after the spectral opacity has been assembled; it is therefore kept separate from both the contributions that build kappa_nu and the dependence (binning) axis on which it is reported.

    Both means below carry the same units as kappa_nu itself, [cm^2/g].

+ struct RosselandMean   ... the HARMONIC mean weighted by dB_nu/dT; use in the optically thick,
                             diffusion regime.
+ struct PlanckMean      ... the ARITHMETIC mean weighted by B_nu; use in the optically thin,
                             emission regime.
source
JenaAtomicCalculator.Cascade.AbstractSimulationMethod — Type

abstract type Cascade.AbstractSimulationMethod` ... defines a abstract and a list of singleton data types for the properties that can be 'simulated' from a given list of lines.

+ struct ProbPropagation     ... to propagate the (occupation) probabilites of the levels until no further changes occur.
+ struct MonteCarlo          ... to simulate the cascade decay by a Monte-Carlo approach of possible pathes (not yet considered).
+ struct RateEquations       ... to solve the cascade by a set of rate equations (not yet considered).
source
JenaAtomicCalculator.Cascade.AbstractSimulationProperty — Type

abstract type Cascade.AbstractSimulationProperty ... defines an abstract and various singleton types for the different properties that can be obtained from the simulation of cascade data.

+ struct DecayPathes                ... determine the major 'decay pathes' of the cascade.
+ struct DrRateCoefficients         ... simulate the DR (plasma) rate coefficients for given plasma temperatures. 
+ struct EiiRateCoefficients        ... simulate the electron-impact ionization (plasma) rate coefficients,
                                        summed over the resonant and excitation-autoionization channels.
+ struct ElectronCoincidence        ... simulate electron-coincidence spectra (not yet).
+ struct FinalLevelDistribution     ... simulate the 'final-level distribution' as it is found after all cascade 
                                        processes are completed.
+ struct IonDistribution            ... simulate the 'ion distribution' as it is found after all cascade processes are completed.
+ struct MeanLineWidths             ... simulate the mean line widths of a line near to a given energy (not yet). 
+ struct RelaxationCurve            ... simulate the relaxation CURVE, i.e. the times by which 70%, 80%, 90%
                                        of the initially occupied levels have decayed to the ground
                                        configuration.        
+ struct ElectronIntensities        ... simulate the electron-line intensities as function of electron energy.
+ struct PhotoAbsorptionCS          ... simulate the (total) photoabsorption cross sections for a given set of photo-excitation 
                                        and ionization processes.
+ struct PhotoResonances            ... simulate the position and strength of photo-resonances for a given set of photo-excitation 
                                        amplitudes & cross sections (not yet).
+ struct PhotonIntensities          ... simulate the photon-line intensities as function of electron energy. 
+ struct PiRateCoefficients         ... simulate the PI (plasma) rate coefficients for given plasma temperatures (not yet). 
+ struct TimeBinnedPhotonIntensity  ... simulate the photon-line intensities as function of electron energy 
                                        in a given time interval (not yet).
source
JenaAtomicCalculator.Cascade.Block — Type

struct Cascade.Block ... defines a type for an individual block of configurations that are treatet together within the cascade. Such an block is given by a list of configurations that may occur as initial- and/or final-state configurations in some step of the canscade and that give rise to a common multiplet in order to allow for configuration interactions but to avoid 'double counting' of individual levels in the cascade.

+ NoElectrons     ::Int64                     ... Number of electrons in this block.
+ confs           ::Array{Configuration,1}    ... List of one or several configurations that define the multiplet.
+ hasMultiplet    ::Bool                      
    ... true if the (level representation in the) multiplet has already been computed and false otherwise.
+ multiplet       ::Multiplet                 ... Multiplet of the this block.
source
JenaAtomicCalculator.Cascade.BoundBoundOpacity — Type

struct Cascade.BoundBoundOpacity <: Cascade.AbstractOpacityContribution ... the bound-bound (line) contribution in the Sobolev/expansion treatment of Eastman & Pinto,

        kappa_nu^bb = 1/(rho c t_exp) * sum_lines (lambda_l/Delta-lambda) (1 - exp(-tau_l))

    with the Sobolev optical depth tau_l = pi alpha n_l lambda_l t_exp f_l.

    ASSUMPTIONS: a homologously expanding medium in which each line is a sharp resonance swept through
    by the velocity gradient (Sobolev); LTE level populations; and a line list that is complete enough
    for the chosen binning. The last is not a formality -- an empty bin means "no line in this bin", NOT
    "no opacity", and it is what makes a Rosseland mean of lines alone vanish.

+ levelPopulation  ::Basics.AbstractLevelPopulation
    ... the level population used to obtain n_l; BoltzmannLevelPopulation() gives the LTE population of
        the lower level, normalised by the partition function over the levels of the given line list.
source
JenaAtomicCalculator.Cascade.BoundFreeOpacity — Type

struct Cascade.BoundFreeOpacity <: Cascade.AbstractOpacityContribution ... the bound-free (photoionization) contribution,

        kappa_nu^bf = n_ion * sum_shells sigma^PI_shell(omega) / rho ,

    with the cross sections taken from Empirical.photoionizationCrossSection in the ScaledHydrogenic
    approximation: Kramers' (1923) formula scaled by the tabulated binding energy of the ionized shell
    and corrected by a bound-free Gaunt factor, which for H 1s turns the Kramers 7.91 Mb at threshold
    into the exact 6.30 Mb and steepens the tail from omega^-3 to the exact omega^-7/2.

    UNLIKE the bound-bound contribution this is a genuine CONTINUUM: it is evaluated at each node
    directly and carries no lambda/Delta-lambda bin factor, since there is no line to be smeared over a
    bin. Each shell contributes only above its own threshold, so the bound-free opacity has edges.

    ASSUMPTIONS: an independent-particle, hydrogenic-scaled description of a single active electron per
    shell; tabulated binding energies; and every ion in the configuration given, i.e. no ionization
    balance is solved here -- the caller states which ion stage is present through the configurations.

    KNOW THIS BEFORE USING IT ON AN ION. Empirical.scaledBindingEnergy draws on X-ray tables compiled for
    NEUTRAL atoms, so the threshold is the neutral binding energy whatever ion stage the configurations
    describe. Measured 14-Aug-2026: for Sr it returns 5.573 eV, essentially the neutral Sr I -> Sr II
    potential of 5.695 eV, where the true edge of Sr^+ is the Sr II -> Sr III potential of 11.030 eV --
    low by a factor of about two. The edge is therefore placed at too LOW a photon energy for any ion,
    which lets bound-free opacity appear in a band where the ion cannot in fact be ionized. For neutral
    species the tables are exactly what is wanted.

    AND THE OBVIOUS ESCAPE DOES NOT WORK. Empirical.photoionizationCrossSection has a second
    approximation, UsingJAC, which computes the cross section ab initio from mean-field orbitals and E1
    amplitudes -- but its own docstring records that ITS thresholds are the DFS orbital energies and
    likewise lie below the true ionization potentials (Ne 2p at 12.0 eV against the true 21.6 eV). Both
    routes therefore open their edge too early, for different reasons: a table that ignores the ion
    stage, and a Koopmans-like eigenvalue that is not an ionization energy. A threshold that is right
    for an ion needs the DIFFERENCE of two total energies, E(ion^q+1) - E(ion^q), which JAC can compute
    but neither cross-section route uses. Until then, treat the position of a bound-free edge here as
    approximate and the opacity within one edge-width of it as unreliable.

+ nuclearCharge          ::Float64
    ... the nuclear charge Z. THIS IS CARRIED EXPLICITLY ON PURPOSE. Empirical.photoionizationCrossSection
        reads Z from the global Defaults, whose GBL_NUCLEAR_CHARGE is 1.0 unless something sets it, and
        no JAC computation does. A contribution relying on that global would silently return HYDROGEN
        cross sections for every element; here Z is taken from this field, set around the call and
        restored afterwards.
+ ionizationPairs        ::Array{Tuple{Configuration,Configuration},1}
    ... the (initial, final) configuration pairs whose photoionization is to be summed; the two must
        differ by exactly one electron in one shell, which is the shell that is ionized.
source
JenaAtomicCalculator.Cascade.CascadeApproachConditions — Type

struct Cascade.CascadeApproachConditions ... the four conditions that together define a cascade approach.

+ levels             ::Cascade.AbstractLevelRepresentation  ... representation of the levels of a block.
+ bound              ::Cascade.AbstractBoundOrbitals        ... origin of the bound one-electron orbitals.
+ continuum          ::Cascade.AbstractContinuumOrbitals    ... energy at which free-electron orbitals are
                                                                generated.
+ continuumPotential ::Cascade.AbstractContinuumPotential   ... potential in which they are generated.
source
JenaAtomicCalculator.Cascade.Computation — Method

Cascade.Computation(comp::Cascade.Computation; name::Union{Nothing,String}=nothing, nuclearModel::Union{Nothing,Nuclear.Model}=nothing, grid::Union{Nothing,Radial.Grid}=nothing, asfSettings::Union{Nothing,AsfSettings}=nothing, scheme::Union{Nothing,Cascade.AbstractCascadeScheme}=nothing, approach::Union{Nothing,Cascade.AbstractCascadeApproach}=nothing, initialConfigs::Union{Nothing,Array{Configuration,1}}=nothing, initialMultiplets::Union{Nothing,Array{Multiplet,1}}=nothing)

... constructor for re-defining the computation::Cascade.Computation.
    A `computation::Cascade.Computation` is returned.
source
JenaAtomicCalculator.Cascade.Computation — Type

struct Cascade.Computation ... defines a type for a cascade computation, i.e. for the computation of a whole photon excitation, photon ionization and/or decay cascade. The – input and control – data from this computation can be modified, adapted and refined to the practical needs, and before the actual computations are carried out explictly. Initially, this struct just contains the physical meta-data about the cascade, that is to be calculated, but a new instance of the same Cascade.Computation gets later enlarged in course of the computation in order to keep also wave functions, level multiplets, etc.

+ name               ::String                          ... A name for the cascade
+ nuclearModel       ::Nuclear.Model                   ... Model, charge and parameters of the nucleus.
+ grid               ::Radial.Grid                     ... The radial grid to be used for the computation.
+ asfSettings        ::AsfSettings                     ... Provides the settings for the SCF process.
+ scheme             ::Cascade.AbstractCascadeScheme   ... Scheme of the atomic cascade (photoionization, decay, ...)
+ approach           ::Cascade.AbstractCascadeApproach 
    ... Computational approach/model that is applied to generate and evaluate the cascade; possible approaches are: 
        {AverageSCA(), SCA(), ...}
+ initialConfs       ::Array{Configuration,1}          
    ... List of one or several configurations that contain the level(s) from which the cascade starts.
+ initialMultiplets  ::Array{Multiplet,1}              
    ... List of one or several (initial) multiplets; either initialConfs 'xor' initialMultiplets can  be specified 
        for a given cascade computation.
source
JenaAtomicCalculator.Cascade.Data — Type

struct Cascade.Data{T} ... defines a type for communicating different line lists to the cascade simulations

+ lines    ::Array{T,1}       ... List of lines to type T.
source
JenaAtomicCalculator.Cascade.DielectronicCaptureScheme — Type

struct Cascade.DielectronicCaptureScheme <: Cascade.AbstractCascadeScheme ... to model just the (dielectronic) capture and the formation of doubly-excited levels up to a maximum excitation energy and for a given list of subshells; the excitation energy refers to the lowest level of the reference configurations, and the cascade blocks are built only by means of the given subshells. NOTE: The original DielectronicCaptureScheme –> DielectronicRecombinationScheme has been renamed in August 2023 in order to enlarge the consistency of the notations and code !!

+ maxExcitationEnergy   ::Float64                 
    ... Maximum excitation energy [in a.u.] with regard to the reference configurations/levels that restrict the number 
        of excited configurations to be taken into accout. This maximum excitation energy has to be derived from the maximum 
        temperature for which DR coefficients need to be derived and is typically set to 5x T_e,max.
+ electronEnergyShift   ::Float64                 
    ... Energy shift for all resonance energies; this is realized by shifting the initial level energies by the negative amount.
        The shift is taken in the user-defined units.
+ NoExcitations         ::Int64                 
    ... (Maximum) Number of electron replacements in the doubly-excited configuration with regard to the initial 
        configurations/multiplets, apart from one additional electron due to the electron capture itself.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which excitations are to be considered.
+ excitationToShells  ::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).
source
JenaAtomicCalculator.Cascade.DielectronicRecombinationScheme — Type

struct Cascade.DielectronicRecombinationScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe the dielectronic recombination of electrons for an atom in some initial state/configuration; for such a scheme, the doubly-excited configurations due to the electron capture are generated automatically due to given maximal numbers of the (into-) shells (nl) as well as the maximum displacement with regard to the initial configuration. An additional maximum excitation energy need to be provided due to the maximum temperatures for which DR plasma rate coefficients are to be determined, cf. Basics.convert().

+ multipoles            ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the radiative stabilization processes.
+ calcWithoutIntoShells ::Bool
    ... If true, the intoShells are not considered explicitly but deterined automatically from the given 
        initial configurations, the from shells as well as the total excitation energy. This features 
        should be set to true, whenever the intoShells are dificult to determine in advance.
+ maxIntoShell          ::Shell   
    ... maximum shell into which an electron is captured, if no intoShells are given explicitly (calcWithoutIntoShells=true).
        From this maxIntoShell, the maximum n_max and l_max is derived for generating the doubly-excited configurations
+ maxExcitationEnergy   ::Float64                 
    ... Maximum excitation energy [in a.u.] with regard to the reference configurations/levels that restrict the number 
        of excited configurations to be taken into accout. This maximum excitation energy has to be derived from the maximum 
        temperature for which DR coefficients need to be derived and is typically set to 5x T_e,max.
+ electronEnergyShift   ::Float64                 
    ... Energy shift for all resonance energies; this is realized by shifting the initial level energies by the negative amount.
        The shift is taken in the user-defined units.
+ minPhotonEnergy       ::Float64                 
    ... Minimum (mean) photon energy [in a.u.] in the radiative stabilization of the doubly-excited configurations; 
        If cascade blocks are separated be less than this energy, the radiative stabilization is neglected.
+ NoExcitations         ::Int64                 
    ... (Maximum) Number of electron replacements in the doubly-excited configuration with regard to the initial 
        configurations/multiplets, apart from one additional electron due to the electron capture itself.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which excitations are to be considered.
+ excitationToShells  ::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).
+ decayShells           ::Array{Shell,1}
    ... List of shells into which electrons the electrons can decay (apart from the core shells).
source
JenaAtomicCalculator.Cascade.DrRateCoefficients — Type

struct Cascade.DrRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for simulating the DR plasma rate coefficients as function of the (free) electron energy and plasma temperature.

+ initialLevelNo      ::Int64       ... Level No of initial level for which rate coefficients are to be computed.
+ electronEnergyShift ::Float64     
    ... (total) energy shifts that apply to all resonances when alpha^(DR) is computed.
+ temperatures        ::Array{Float64,1}
    ... temperatures [K] for which the DR plasma rate coefficieints to be calculated.
+ nDetailed           ::Int64       
    ... principal quantum of the `last' shell for which Auger and radiatiative amplitudes have been calculated
        by the Cascade.Computation; all contributions of this shell are scaled for nDetailed < n <= nMax
        also for higher shells by a simple scaling rule.
+ nMax                ::Int64 
    ... Maximum n (principal quantum number), for which contributions are scaled; NO scaling is taken
        into account for nMax <= nDetailed.
+ resonanceSelection  ::DielectronicRecombination.ResonanceSelection
source
JenaAtomicCalculator.Cascade.EaCrossSections — Type

struct Cascade.EaCrossSections <: Cascade.AbstractSimulationProperty ... defines a type for simulating the excitation-autoionization (EA) contribution to the electron-impact ionization cross section from the lines of a previous Cascade.ElectronIonizationScheme computation.

    The EA cross section at a given impact energy is

        sigma^EA(E; i) = SUM_e  sigma^exc(E; i -> e) * B_a(e)

    i.e. the electron-impact excitation cross section into each autoionizing level e, weighted by the
    branching ratio B_a(e) = A_a / (A_a + A_r) with which that level decays by autoionization rather than
    radiatively.  The ElectronIonizationScheme computes no radiative rates, so A_r = 0 and B_a = 1 for every
    level that carries at least one Auger line; the sum then runs over exactly those levels, which is what
    the autoionization lines of the computation identify.  That is an upper bound on the EA cross section,
    and a good one for inner-shell excited levels of light ions, where autoionization dominates radiative
    decay by orders of magnitude -- but it IS an upper bound and should be read as such.

+ initialLevelNo      ::Int64             ... Level No of the initial level; 0 selects all initial levels.
+ electronEnergies    ::Array{Float64,1}  ... Impact energies at which sigma^EA is reported; these must be
                                              among the energies of the underlying computation.
source
JenaAtomicCalculator.Cascade.EieRateCoefficients — Type

struct Cascade.EieRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for simulating electron-impact excitation (EIE) plasma rate coefficients and effective collision strengths from the ImpactExcitation.Line's of a previous cascade computation.

    This is the simulation counterpart of Cascade.ImpactExcitationScheme.  The computation produces LINES --
    one per (initial level, final level, incident electron energy), each carrying a cross section and a
    collision strength; forming the effective collision strength Upsilon(T) and the rate coefficient
    alpha(T) from them requires an interpolation over energy and an integration against a Maxwellian, and
    that is simulation work.  Compare Cascade.DrRateCoefficients and Cascade.RrRateCoefficients.

+ initialLevelNo      ::Int64             ... Level No of the initial level; 0 selects all initial levels.
+ temperatures        ::Array{Float64,1}  ... Temperatures [K] at which the rate coefficients are formed.
+ finalLevelSelection ::LevelSelection    ... Specifies the selected final levels, if any.
source
JenaAtomicCalculator.Cascade.EiiRateCoefficients — Method

Cascade.EiiRateCoefficients(initialLevelNo::Int64, temperatures::Array{Float64,1}, electronEnergyShift::Float64, dblAugerProbability::Float64) ... convenience constructor that omits the direct channel, i.e. sets directCharge = 0.; it keeps the four-argument calls that predate the direct estimate working unchanged. An EiiRateCoefficients is returned.

source
JenaAtomicCalculator.Cascade.EiiRateCoefficients — Type

struct Cascade.EiiRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for simulating the electron-impact IONIZATION (EII) plasma rate coefficient alpha^EII (T) from the lines of a previous Cascade.ElectronIonizationScheme computation. It is the rate-coefficient counterpart of Cascade.ResonantIonizationStrengths, which reports the same physics as energy-integrated strengths, and it is what an ionization balance actually needs.

    THE POINT OF THIS PROPERTY IS THAT IT ADDS THE CHANNELS UP.  Electron-impact ionization proceeds by three
    routes, and a cascade computation may carry the data for any subset of them:

    + resonant   ... capture into a doubly-excited resonance, which then sheds two electrons either one after the
                     other (sequential) or together (simultaneous).  Taken from the resonances in the cascade data
                     exactly as Cascade.ResonantIonizationStrengths forms them.
    + excitation-autoionization
                 ... impact excitation into a level above the ionization threshold, which then autoionizes.  Taken
                     from the same impact-excitation lines that Cascade.EaCrossSections uses.
    + direct     ... the incident electron knocks a bound electron out in one step.  NOT AVAILABLE: there is no
                     Cascade.perform for ImpactIonizationScheme, so no cascade produces these lines.  The channel is
                     REPORTED AS ABSENT in the table rather than silently omitted, because a total that quietly
                     leaves out the largest contribution is worse than no total at all.

    BOTH AVAILABLE HALVES USE THE SAME MAXWELLIAN PREFACTOR, which is what makes adding them legitimate.  The
    resonant half is a sum over isolated resonances,

        alpha^res(T)  =  4/sqrt(2pi) * T^(-3/2) * SUM_d  E_d * exp(-E_d/T) * S_d

    identical to DielectronicRecombination.computeRateCoefficient, so the ionization and recombination rate
    coefficients of the SAME resonances are directly comparable.  The excitation-autoionization half is an integral
    over the computed cross sections,

        alpha^EA(T)   =  sqrt(8/pi) * T^(-3/2) * INT sigma^EA(E) * E * exp(-E/T) dE

    and sqrt(8/pi) = 4/sqrt(2pi) identically, so the second reduces to the first when sigma is a delta function.
    Everything is in atomic units until the final conversion to cm^3/s.

    THE TEMPERATURE DEPENDENCE IS ITS OWN CHECK, within limits worth stating.  alpha^res ~ T^(-3/2) E exp(-E/T)
    has its maximum at kT = 2E/3 exactly, and the printout tests that the tabulated maximum is one of the two grid
    points bracketing it.  That is falsifiable against a mistake in the FOLD -- a wrong exponent, a wrong sign, a
    wrong temperature conversion -- and not against a mistake in the RESONANCES, since the prediction and the curve
    are formed from the same energies.  The mean resonance energy is therefore printed in eV beside the grid, for a
    reader who knows what threshold to expect.

    WHAT LIMITS THE ACCURACY, in the order that matters.  The excitation-autoionization integral is evaluated by the
    trapezoidal rule over the impact energies the cascade happened to compute -- usually a handful -- and the cross
    section is TRUNCATED above the largest of them.  The share of the Maxwellian weight lying above that last energy
    is therefore printed at every temperature: where it is not small, alpha^EA is a lower bound and the answer is to
    compute more energies, not to trust the number.  Beyond that, every approximation of
    ResonantImpactIonization applies to the resonant half unchanged.

+ initialLevelNo        ::Int64             ... Level No of the initial level from which the ionization starts.
+ temperatures          ::Array{Float64,1}  ... Temperatures [K] at which the rate coefficients are formed.
+ electronEnergyShift   ::Float64           ... Shift applied to every resonance energy, in the user-selected units.
+ dblAugerProbability   ::Float64           ... Probability that a resonance sheds BOTH electrons at once rather than
                                                 one at a time; 0. omits the simultaneous channel.
+ directCharge          ::Float64           ... Nuclear charge Z for the SEMI-EMPIRICAL estimate of the direct channel;
                                                 0. omits that channel and reports it as absent.
+ directConfig          ::Configuration     ... Configuration of the ion being ionized, for that same estimate; it is
                                                 asked for rather than derived from the cascade data, because which ion
                                                 a mixed data set belongs to is precisely the kind of thing that is
                                                 easy to infer wrongly and impossible to notice afterwards.
source
JenaAtomicCalculator.Cascade.ElectronExcitationScheme — Type

struct Cascade.ElectronExcitationScheme <: Cascade.AbstractCascadeScheme ... to compute electron excitation spectra including the direct (EIE) and resonant contributions, i.e. the dielectronic capture with subsequent re-autoionization. Typical electron-excitation properties are energy-dependent EIE cross sections, effective collision strengths, EIE plasma rate coefficients, and others.

+ processes             ::Array{Basics.AbstractProcess,1} 
    ... List of the atomic processes that are supported and should be included into the cascade; Basics.ImpactExc()
        selects the DIRECT channel and Basics.ImpactExcAuto() the RESONANT one.
+ fromShells            ::Array{Shell,1}
    ... List of shells from which the impact excitation proceeds.
+ toShells              ::Array{Shell,1}
    ... List of shells into which the impact excitation proceeds.
+ electronEnergies      ::Array{Float64,1}                
    ... List of electron energies for which this electron-impact excitation scheme is to be calculated.
+ lValues               ::Array{Int64,1}
    ... Orbital angular momenta of the incoming/outgoing free electron to be included.
+ NoFreeElectronEnergies ::Int64
    ... Number of free-electron energies of the internal (Gauss-Legendre) grid.
+ maxFreeElectronEnergy ::Float64
    ... Maximum free-electron energy [in a.u.] of that grid.
+ electronEnergyShift   ::Float64
    ... Energy shift of all electron energies, in the user-selected units.

    These are the same configuration data that a Cascade.ImpactExcitationScheme carries, because the direct channel IS
    an impact excitation and delegates to that scheme. Until 16-Aug-2026 this struct held only `processes` and
    `electronEnergies`, which left the direct channel with no shells to excite between and therefore unusable.
source
JenaAtomicCalculator.Cascade.ElectronIntensities — Type

struct Cascade.ElectronIntensities <: Cascade.AbstractSimulationProperty ... defines a type for simulating the electron-line intensities as function of electron energy.

+ minElectronEnergy   ::Float64     ... Minimum electron energy for the simulation of electron spectra.
+ maxElectronEnergy   ::Float64     ... Maximum electron energy for the simulation of electron spectra.
+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population.
source
JenaAtomicCalculator.Cascade.ElectronIonizationScheme — Method

Cascade.ElectronIonizationScheme(electronEnergies::Array{Float64,1}, excitationFromShells::Array{Shell,1}, excitationToShells::Array{Shell,1}, lValues::Array{Int64,1}, NoExcitations::Int64, electronEnergyShift::Float64) ... constructor for the impact-excitation channel alone, i.e. the six arguments this scheme had before the two resonant channels were added; processes defaults to [Basics.ImpactExcAuto()], intoShells to empty and dblAugerOverride to 0. It exists so that computations written against the earlier six-field struct – such as the dated branches of example-Fi.jl – keep running unchanged. A electronIonizationScheme::Cascade.ElectronIonizationScheme is returned.

source
JenaAtomicCalculator.Cascade.ElectronIonizationScheme — Type

struct Cascade.ElectronIonizationScheme <: Cascade.AbstractCascadeScheme ... to compute the INDIRECT contribution to electron-impact ionization, i.e. excitation-autoionization (EA): a free electron excites an inner-shell electron into a level that lies above the ionization threshold of the ion, and that level then autoionizes. The net effect is ionization, and for many ions – notably along the Li-, Na- and Mg-like sequences – EA rivals or exceeds the direct channel.

        The scheme is built exactly like Cascade.DielectronicRecombinationScheme, with which it is the mirror
        image: DR captures an electron and stabilizes radiatively, EA excites an electron and stabilizes by
        emitting one.  Both therefore generate two kinds of Cascade.Step,

            DR :  Auger (capture, by detailed balance)   +  Radiative (stabilization)
            EA :  ImpactExc (excitation)                 +  Auger (autoionization)

        A cascade computation returns the ImpactExcitation.Line's and AutoIonization.Line's; combining them
        into an EA cross section or plasma rate coefficient is the task of a Cascade.Simulation.

        NOT INCLUDED, and deliberately so:
          + the DIRECT electron-impact ionization channel.  Cascade.ImpactIonizationScheme is reserved for it
            and is not implemented; see the note there.
          + the two RESONANT-ELECTRON-CAPTURE channels, in which the incident electron is CAPTURED into a
            doubly-excited resonance which then sheds two electrons, either one after the other
            (resonant-electron-capture-with-sequential-double-autoionization, the REDA of the older
            literature) or both at once (...-with-simultaneous-double-autoionization, READI).  Together with
            the impact-excitation channel above they make up the resonant part of the ionization; only the
            impact-excitation one is available here.

            THE OLD NOTE HERE SAID THESE "require the electron-capture scheme that is still outstanding".
            That has not been true since 16-Aug-2026: Cascade.perform(::DielectronicCaptureScheme) exists and
            runs, and Cascade.perform(::ElectronExcitationScheme) already delegates to it for its own resonant
            channel.  What is still missing is the second Auger generation and the strengths, not the capture.

+ electronEnergies      ::Array{Float64,1}                
    ... List of impact energies of the incoming electron, in the user-selected units.  The collision strengths
        are computed AT these energies, so three or more well-spread values are needed if a rate coefficient
        is to be formed from them afterwards.
+ excitationFromShells  ::Array{Shell,1}
    ... List of (inner) shells out of which the electron is excited.
+ excitationToShells    ::Array{Shell,1}
    ... List of shells into which it is excited.  Only those excited configurations are kept whose mean energy
        lies ABOVE the ionization threshold of the ion, since only those can autoionize.
+ lValues               ::Array{Int64,1}
    ... Orbital angular momenta of the free electron, i.e. the partial waves summed over in the excitation.
        maxKappa is taken as maximum(lValues)+1.  A truncated sum does not merely lower the cross section, it
        can invert its energy dependence, and it does so silently; read the `convergence` column.
+ NoExcitations         ::Int64
    ... Number of displaced electrons for the generation of the excited configurations; 1 in nearly all cases.
+ electronEnergyShift   ::Float64
    ... Energy shift for all bound-state energies relative to the levels of the reference configuration, taken
        in the user-defined units.
+ processes             ::Array{Basics.AbstractProcess,1}
    ... The channels to be computed, selected exactly as Cascade.ElectronExcitationScheme selects its own.  Any
        combination may be given, and the cost of the selection varies by three orders of magnitude:

          Basics.ImpactExcAuto()                            impact-excitation with subsequent autoionization
              ... the inner-shell excitation channel described above.  EXPENSIVE: it needs a partial-wave sum
                  over the free electron at every impact energy; ~2800 s for the Li-like carbon of example-Fi.jl.
          ResonantImpactIonization.SequentialAuger()        resonant-electron-capture-with-sequential-
                                                            double-autoionization  (REDA in older literature)
              ... CHEAP, seconds rather than hours: a capture is the time reverse of an Auger and needs no
                  partial-wave sum over impact energies at all.
          ResonantImpactIonization.SimultaneousAuger()      resonant-electron-capture-with-simultaneous-
                                                            double-autoionization  (READI)
              ... rides on the resonances of the sequential channel and adds almost nothing to the cost.

+ intoShells            ::Array{Shell,1}
    ... Shells into which the incident electron is CAPTURED, for the two resonant channels only; ignored by the
        impact-excitation channel.  The doubly-excited resonances are built by capturing into these shells while
        exciting from excitationFromShells into excitationToShells.
+ dblAugerOverride      ::Float64
    ... Optional replacement for the computed double-Auger probability of the simultaneous channel.  0. means
        "not set", in which case the shake-off estimate of ResonantImpactIonization is used; a positive value
        replaces it and is reported as having done so.

APPROXIMATIONS, so that it is clear what a computation of this scheme actually delivers:

+ the DIRECT channel is absent
    ... Cascade.ImpactIonizationScheme is reserved for it and is not implemented, so a total ionization cross
        section CANNOT be obtained from this scheme alone.  What it gives is the indirect and resonant parts.
+ single-CSF blocks, no configuration mixing
    ... in Cascade.AverageSCA() every block is generated from single-CSF levels with orbitals from a
        Dirac-Fock-Slater potential, computed independently per block.  Level energies are therefore of
        cascade quality, not of spectroscopic quality.
+ only the Coulomb interaction in the autoionization
    ... the Breit interaction is not included in any Auger rate here.
+ a partial-wave truncation that is silent
    ... lValues fixes maxKappa for BOTH the impact excitation and the Auger rates.  Too small a value does not
        merely lower a cross section, it can invert its energy dependence; example-Fi.jl branch b measures that
        crossover explicitly.  The capture rates of the resonant channels inherit the same truncation.
+ isolated resonances, for the resonant channels
    ... resonance strengths are ADDED, with no interference between resonances and no overlap of their widths.
        Sound while the resonances are narrow against their spacing; it degrades for high capture shells.
+ branchings that sum to one BY CONSTRUCTION
    ... every branching ratio is formed from the total rates of the decay steps the cascade actually generated.
        A decay route left out of the configuration lists is absent from the denominator too, so the branchings
        still sum to one.  That sum checks the arithmetic; it can never reveal a missing channel.
+ the simultaneous channel is an ESTIMATE, not a computed rate
    ... its double-Auger width comes from shake-off in the sudden approximation, whose error has BOTH SIGNS.
        See ResonantImpactIonization.shakeProbability before quoting anything from it.
source
JenaAtomicCalculator.Cascade.ExpansionOpacities — Type

struct Cascade.ExpansionOpacities <: Cascade.AbstractSimulationProperty ... defines a type for simulating the expansion opacity as function of the wavelength as well as (parametrically) the density and expansion time.

    The expansion opacity is formed in the line-binned Sobolev picture of Eastman & Pinto (1993),

        kappa_exp(lambda) = 1/(c * t_exp * rho) * SUM_l (lambda_l/Delta-lambda) * (1 - exp(-tau_l))

    with the Sobolev optical depth of each bound-bound line l

        tau_l = pi * alpha * n_l * lambda_l * t_exp * f_l         (atomic units; n_l = LOWER level)

    NOTE THAT TWO DIFFERENT DENSITIES ENTER, and they are given as two separate fields on purpose:
    a MASS density rho fixes the prefactor and hence the unit of kappa [cm^2/g], while a NUMBER density
    of the absorbing level enters the optical depth.  A single "ionDensity" field previously served as
    the first while the second was hard-wired to 1.0 in the code, which made the absolute scale of every
    opacity meaningless.  Stating both explicitly keeps an inconsistent pair visible in the printout
    rather than silent.

+ levelPopulation        ::Basics.AbstractLevelPopulation  
    ... the level population used to obtain n_l from ionNumberDensity; BoltzmannLevelPopulation() gives
        the LTE population of the lower level, normalised by the partition function over the levels that
        occur in the given line list.
+ opacityDependence      ::Cascade.AbstractOpacityDependence    
    ... to specify the dependence of the opacities [omega, lambda, (temperature-normalized) u]
+ ionNumberDensity       ::Float64       ... number density n of the ions [in 1/cm^3]; enters tau_l
+ massDensity            ::Float64       ... mass density rho [in g/cm^3]; enters the 1/(rho c t) prefactor
+ temperature            ::Float64       ... temperature [in K]
+ expansionTime          ::Float64       ... (expansion/observation) time [in sec]
+ transitionEnergyShift  ::Float64     
    ... (total) energy shifts that apply to all transition energies; the amplitudes are re-scaled accordingly.
+ dependencyValues       ::Array{Float64,1}
    ... the bin CENTRES [in a.u.] at which the expansion opacity is reported; the bin width is taken from
        opacityDependence.binning.
source
JenaAtomicCalculator.Cascade.ExpansionOpacityScheme — Type

struct Cascade.ExpansionOpacityScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe the expansion opacity of ions in some initial state/configuration; for this scheme, the excited (even- and odd-parity) configurations due to the photoabsorption and emission in a plasma are generated automatically in terms of the chosen excitation scheme and a maximum photon (transition) energy that is taken into account.

+ multipoles            ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included for the radiative transitions in the plasma.
+ minPhotonEnergy       ::Float64                 
    ... Minimum photon (transition) energy [in a.u.] that are taken into account for all absorption lines; 
        this transition energy refers to the longest wavelength for which transition amplitudes are calculated.
+ maxPhotonEnergy       ::Float64                 
    ... Maximum photon (transition) energy [in a.u.] that are taken into account for all absorption lines; 
        this transition energy refers to the shortest wavelength for which the opacity is needed.
+ NoExcitations         ::Int64                 
    ... (Maximum) Number of electron replacements in the excited configuration with regard to the initial configurations/multiplets.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which excitations are to be considered.
+ excitationToShells    ::Array{Shell,1}    
    ... List of shells to which excitations are to be considered.
+ printTransitions      ::Bool      
    ... Print the bound-bound line list that the opacity is built from -- wavelength, oscillator strength in
        both gauges and the lower-level energy -- so that one can see which lines dominate a given bin.

    NB an energy shift is deliberately NOT a field of this scheme.  It adjusts how the computed lines are
    INTERPRETED, not which lines are computed, and therefore belongs to the simulation side, where
    Cascade.ExpansionOpacities.transitionEnergyShift provides it.  The former meanEnergyShift here was read
    nowhere and merely duplicated that field, inviting the two to disagree.
source
JenaAtomicCalculator.Cascade.FinalLevelDistribution — Type

struct Cascade.FinalLevelDistribution <: Cascade.AbstractSimulationProperty ... defines a type for simulating the 'final-level distribution' as it is found after all cascade processes are completed.

+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population.
+ leadingConfigs      ::Array{Configuration,1}   
    ... List of leading configurations whose levels are equally populated, either initially or ....
+ finalConfigs        ::Array{Configuration,1}   
    ... List of final configurations whose level population are to be "listed" finally; these configuration
        only determine the printout but not the propagation of the probabilities. If this list is empty, all 
        the levels are shown.
source
JenaAtomicCalculator.Cascade.HollowIonScheme — Type

struct Cascade.HollowIonScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe the formation and decay of a hollow ion, e.g. an electronic core configuration into which one or several additional electrons are captured into (high) nl shells. Both the shell (lists) for the initial capture (intoShells) and the subsequent decay (decayShells) need to be specified explicitly to readily control the size of the computations.

+ processes             ::Array{Basics.AbstractProcess,1} 
    ... List of the atomic processes that are supported and should be included into the decay scheme.  
+ multipoles            ::Array{EmMultipole,1}           
    ... Multipoles of the radiation field that are to be included into the radiative stabilization processes.
+ NoCapturedElectrons   ::Int64   
    ... Number of captured electrons, e.g. placed in the intoShells.
+ intoShells            ::Array{Shell,1}
    ... List of shells into which electrons are initially placed (captured).
+ decayShells           ::Array{Shell,1}
    ... List of shells into which electrons the electrons can decay (apart from the core shells).
source
JenaAtomicCalculator.Cascade.ImpactExcitationScheme — Type

struct Cascade.ImpactExcitationScheme <: Cascade.AbstractCascadeScheme ... to compute the (direct) electron-impact excitation spectrum for a list of impact energies (not yet).

    This scheme always computes the DIRECT electron-impact excitation ImpactExc() and carries no list of
    processes: there is nothing to choose from.  The resonant channel -- capture into a doubly-excited state
    with subsequent re-autoionization into an excited level of the same ion, which yields the same final
    state -- belongs to Cascade.ElectronExcitationScheme.

+ fromShells             ::Array{Shell,1}    
    ... List of shells from which impact-excitations are to be considered.
+ toShells               ::Array{Shell,1}    
    ... List of shells into which impact-excitations are to be considered, including possibly already occupied shells.
+ electronEnergies       ::Array{Float64,1}                
    ... List of electron energies for which this electron-impact excitation scheme is to be calculated.  The
        collision strengths are computed AT these energies; a Cascade.EieRateCoefficients simulation later
        interpolates over them, so three or more well-spread values are needed for any rate coefficient.
+ lValues                ::Array{Int64,1}
    ... Orbital angular momentum values of the free electron, i.e. the partial waves that are summed over.
        maxKappa is taken as maximum(lValues)+1.  NOTE that a truncated sum does not merely lower the collision
        strength, it can invert its energy dependence, and it does so silently; read the `convergence` column.
+ NoFreeElectronEnergies ::Int64             
    ... Number of free-electron energies that a chosen for a Gauss-Laguerre integration.
+ maxFreeElectronEnergy  ::Float64             
    ... Maximum free-electron energies [in a.u.] that restrict the energy of free-electron orbitals; this maximum energy has to 
        be derived from the maximum temperature for which RR plasma coefficients need to be obtained and is typically set to 
        about 5x T_e,max.
+ electronEnergyShift    ::Float64                 
    ... Energy shift for all bound-state energies relative to the levels from the reference configuration; this is realized by 
        shifting the initial level energies by the negative amount. The shift is taken in the user-defined units.
        
Either a list of electronEnergies or the NoFreeElectronEnergies can be specified; the program terminates, if "non-zero"
entries appears for these two subfields.
source
JenaAtomicCalculator.Cascade.ImpactIonizationScheme — Type

struct Cascade.ImpactIonizationScheme <: Cascade.AbstractCascadeScheme ... RESERVED FOR THE DIRECT electron-impact ionization channel; NOT IMPLEMENTED, and there is no Cascade.perform for it. Recorded here so that the gap is visible rather than surprising.

        The obstacle is not effort but shape.  JAC's ImpactIonization module is semi-empirical, not
        amplitude-based: its Settings are an AbstractEmpiricalSettings, it is driven from an
        Empirical.Computation rather than an Atomic.Computation, it takes a Basis rather than two multiplets,
        and it has no Line type at all.  Its elementary datum is an ImpactIonization.CrossSection per
        (subshell, impact energy), obtained from a BEB, BED or relativistic model.  A cascade built on it
        would therefore store cross sections rather than lines, and the cascade approaches (AverageSCA, SCA)
        would influence only the SCF basis behind the binding energies -- not what they mean elsewhere.

        That is a workable design, but it is a different one, and it should be settled deliberately rather
        than by analogy.  The INDIRECT channel, excitation-autoionization, is implemented and lives in
        Cascade.ElectronIonizationScheme.

+ processes             ::Array{Basics.AbstractProcess,1} 
    ... List of the atomic processes that are supported and should be included into the cascade.
+ electronEnergies      ::Array{Float64,1}                
    ... List of electron energies for which this scheme is to be calculated.
source
JenaAtomicCalculator.Cascade.IonDistribution — Type

struct Cascade.IonDistribution <: Cascade.AbstractSimulationProperty ... defines a type for simulating the 'ion distribution' as it is found after all cascade processes are completed.

+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population.
+ leadingConfigs      ::Array{Configuration,1}   
    ... List of leading configurations whose levels are equally populated, either initially or ....
source
JenaAtomicCalculator.Cascade.IonizingResonance — Type

struct Cascade.IonizingResonance ... carries everything that one doubly-excited resonance contributes to electron-impact ionization, so that the two properties which need it – Cascade.ResonantIonizationStrengths, which reports energy-integrated strengths, and Cascade.EiiRateCoefficients, which folds them with a Maxwellian – read the SAME numbers from the SAME place instead of each forming them for itself. Two implementations of one formula drift apart silently; one does not.

    The strengths are energy-integrated and in atomic units.  Each is an EmProperty because the branching ratios
    carry a radiative width in their denominator, and each gauge uses its own, following the correction made to
    Cascade.simulateDrRateCoefficients on 05-Aug-2026.

+ level             ::Cascade.Level     ... the resonance itself.
+ electronEnergy    ::Float64           ... resonance position, i.e. the energy of the captured electron [a.u.].
+ captureRate       ::Float64           ... capture rate, from the Auger rate of the time-reversed transition.
+ augerRate         ::Float64           ... total Auger width of the resonance.
+ photonRate        ::Basics.EmProperty ... total radiative width of the resonance.
+ sequential        ::Basics.EmProperty ... strength of the sequential double-autoionization route.
+ simultaneous      ::Basics.EmProperty ... strength of the simultaneous route; zero unless a double-Auger
                                             probability was supplied.
+ recombination     ::Basics.EmProperty ... dielectronic-recombination strength of the SAME resonance, so that the
                                             competition between the two fates can be read off directly.
source
JenaAtomicCalculator.Cascade.Level — Type

mutable struct Cascade.Level ... defines a level specification for dealing with cascade transitions.

+ energy       ::Float64                     ... energy of the level.
+ J            ::AngularJ64                  ... total angular momentum of the level
+ parity       ::Basics.Parity               ... total parity of the level
+ NoElectrons  ::Int64                       ... total number of electrons of the ion to which this level belongs.
+ majorConfig  ::Configuration               ... major (dominant) configuration of this level.
+ relativeOcc  ::Float64                     ... relative occupation  
+ parents      ::Array{Cascade.LineReference,1}  ... list of parent lines that (may) populate the level.     
+ daughters    ::Array{Cascade.LineReference,1}  ... list of daughter lines that (may) de-populate the level.
source
JenaAtomicCalculator.Cascade.LineFlux — Type

struct Cascade.LineFlux ... records how much probability has flowed through ONE line during a cascade propagation, together with everything needed to interpret it afterwards. This is what separates the propagation from the extraction of observables: Cascade.propagateProbability! records a LineFlux for every line it passes probability through, and each simulation property then derives what it needs from that record.

+ process       ::Basics.AbstractProcess  ... the process of the line (Radiative(), Auger(), Photo()).
+ energy        ::Float64                 ... energy carried away by the emitted particle, i.e. the
                                              difference of the initial and final level energies.
+ flux          ::Float64                 ... probability that has flowed through this line.
+ initialIndex  ::Int64                   ... index of the initial level within the propagated level list.
+ finalIndex    ::Int64                   ... index of the final level within the propagated level list.

    Before 05-Aug-2026 the propagation collected observables itself, through the keywords
    collectPhotonIntensities and collectElectronIntensities, and refused to collect both at once
    (error("stop a")). That made a photon-electron coincidence inexpressible and forced a second full
    propagation whenever a different observable was wanted. Recording the flux once, and keeping the level
    indices with it, removes both restrictions -- and the indices are what a later coincidence simulation
    needs in order to chain individual emissions into pathways.
source
JenaAtomicCalculator.Cascade.LineReference — Type

struct Cascade.LineReference{T} ... refers to one line within one of the line lists of a Cascade.Data set: it keeps the list itself, the atomic process it belongs to, and the position of the line within that list. Renamed from LineIndex (05-Aug-2026), which suggested a bare integer index rather than the reference it is.

+ lines        ::Array{T,1}              ... refers to the line list for which this index is defined.
+ process      ::Basics.AbstractProcess  ... refers to the particular lineList of cascade (data).
+ index        ::Int64                   ... index of the corresponding line.
source
JenaAtomicCalculator.Cascade.MeanOpacities — Type

struct Cascade.MeanOpacities <: Cascade.AbstractSimulationProperty ... defines a type for simulating a MEAN opacity as function of the temperature or density as well as (parametrically) the expansion time. Usually, different values are given for either the temperature or density. A value::EmProperty in [cm^2/g] is reported for each (rho, T) pair.

    This type replaces the former `RosselandOpacities` (14-Aug-2026), which had never been run: it took
    only ONE density list, documented as a mass density, and derived a number density from it as
    rho/1.6605e-24 -- i.e. one ion per nucleon mass, A = 1 for every element, wrong by roughly A. Both
    densities are now carried explicitly, exactly as Cascade.ExpansionOpacities already does and for the
    same reason. It also fixed the mean to a single formula that was in fact the arithmetic one; the
    mean is now named, and is a field.

+ opacityMean            ::Cascade.AbstractOpacityMean
    ... the mean to be taken over the spectral opacity: RosselandMean() or PlanckMean().
+ contributions          ::Array{Cascade.AbstractOpacityContribution,1}
    ... what the spectral opacity is made of; the contributions are summed bin by bin. A list holding
        only BoundBoundOpacity reproduces the pre-14-Aug-2026 behaviour, and cannot support a Rosseland
        mean; adding ScatteringOpacity supplies the continuum floor that can.
+ opacityDependence      ::Cascade.TemperatureOpacityDependence
    ... to specify the dependence of the opacities in terms of (the temperature-normalized) u
+ ionNumberDensities     ::Array{Float64,1}      ... list of ion NUMBER densities [in 1/cm^3]; enters tau_l
+ massDensities          ::Array{Float64,1}      ... list of MASS densities [in g/cm^3]; enters 1/(rho c t)
+ temperatures           ::Array{Float64,1}      ... list of temperatures [in K]
+ expansionTime          ::Float64               ... (expansion/observation) time [in sec]
+ transitionEnergyShift  ::Float64
    ... (total) energy shifts that apply to all transition energies; the amplitudes are re-scaled accordingly.
source
JenaAtomicCalculator.Cascade.ParticleCoincidences — Type

struct Cascade.ParticleCoincidences <: Cascade.AbstractSimulationProperty ... defines a type for simulating a coincidence measurement on a cascade: the spectrum of one emitted particle, recorded only for those cascade events in which a set of further conditions was met.

+ gates               ::Array{Cascade.AbstractCoincidenceGate,1}
    ... the coincidence conditions. They are matched IN EMISSION ORDER along each decay pathway: gates[1]
        against the first emission of the pathway, gates[2] against the second, and so on. Ordered
        matching is chosen because a cascade pathway is intrinsically ordered and the rule is then
        unambiguous; for the usual cases it makes no difference, since the gated groups are separated far
        beyond any analyser window (a Mg KLL electron near 1100 eV against an LMM electron of a few tens
        of eV).
+ observed            ::Cascade.AbstractCoincidenceGate
    ... the particle whose spectrum is reported, together with the window it is observed in. It is matched
        against the emission FOLLOWING the last gate. Giving a ChargeStateGate here is meaningless -- that
        is an ion distribution, not a spectrum -- and is rejected.
+ initialOccupations  ::Array{Tuple{Int64,Float64},1}
    ... levels of the cascade tree together with their initial relative population.

    One type covers every two- and multi-fold combination, because the gates and the observed particle are
    described in the same way:

        Auger-Auger      gates = [ElectronGate(1050., 1200.)]     observed = ElectronGate(0., 100.)
        photon-photon    gates = [PhotonGate(...)]                observed = PhotonGate(...)
        electron-photon  gates = [ElectronGate(...)]              observed = PhotonGate(...)
        electron-ion     gates = [ChargeStateGate(9)]             observed = ElectronGate(0., 2000.)
        triple           gates = [ElectronGate(...), ElectronGate(...)]  observed = ElectronGate(...)
        singles          gates = []                               observed = ElectronGate(0., 1.0e6)

    The last line reproduces Cascade.ElectronIntensities and is worth running as a check on the machinery.
    Cascade.PhotonIntensities and Cascade.ElectronIntensities are deliberately kept as the simple ungated
    cases: they are the common request, and having both lets each verify the other.

    LIMITATION, and it is a physical one rather than an implementation gap. The intensities computed here
    are an INCOHERENT sum over decay pathways, so they are energy correlations only. They are not angular
    correlations between the emitted particles, and they do not describe interference between pathways
    that reach the same final state by different routes. Fritzsche et al., Symmetry 13, 520 (2021),
    Sect. 2.3 makes the point explicitly: once the fine-structure splitting of intermediate levels becomes
    comparable to their natural widths, "the angular emission of the emitted Auger electrons can no longer
    be described by an incoherent summation over individual pathways". Coincidence experiments are often
    precisely where that matters.
source
JenaAtomicCalculator.Cascade.PhotoAbsorptionScheme — Type

struct Cascade.PhotoAbsorptionScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe a photo-absorption calculation for an atom in some initial state/configuration and for a given range of photon energies, processes and multipoles, etc.

+ multipoles            ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the excitation/ionization processes.
+ photonEnergies        ::Array{Float64,1}
    ... List of photon energies (in user-selected units) for which absorption cross sections/spectra are to be
        calculated; this describes the list, distribution and resolution of energies. It is checked that either
        photonEnergies or electronEnergies are given only
+ electronEnergies       ::Array{Float64,1}
    ... List of electron energies (in user-selected units) for which absorption cross sections/spectra are to be
        calculated; this describes the list, distribution and resolution of energies.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which photo-excitations are to be considered.
+ excitationToShells    ::Array{Shell,1}    
    ... List of shells into which photo-excitations are to be considered, including possibly already occupied shells.
+ initialLevelSelection ::LevelSelection    
    ... Specifies the selected initial levels of some given initial-state configurations; these initial level numbers/
        symmetries always refer to the set of initial configurations.
+ lValues               ::Array{Int64,1}
    ... Orbital angular momentum values of the free-electrons, for which partial waves are considered for the PI.
+ calcDirect            ::Bool      ... True, if the direct contributions need to be calculated.                
+ calcResonant          ::Bool      ... True, if the resonant contributions need to be calculated.                
+ electronEnergyShift   ::Float64                 
    ... Energy shift for all bound-state energies relative to the levels from the reference configuration; this is realized by 
        shifting the initial level energies by the negative amount. The shift is taken in the user-defined units.
+ minCrossSection       ::Float64                 
    ... minimum cross section (in user-selected units) for which contributions are accounted for in the list of
        photoionization lines.
source
JenaAtomicCalculator.Cascade.PhotoAbsorptionSpectrum — Type

struct Cascade.PhotoAbsorptionSpectrum <: Cascade.AbstractSimulationProperty ... defines a type for simulating the total photo-absorption cross sections in a given interval of photon energies as well as for a given set of photo-ionization and photo-excitation cross sections

+ includeIonization   ::Bool             ... True, if photo-ionization cross sections are to be considered.
+ includeExcitation   ::Bool             ... True, if photo-excitation lines are to be considered.
+ resonanceWidth      ::Float64          ... Widths of the resonances (user-defined units)
+ csScaling           ::Float64          ... Scaling factor do enhance the strengths of resonances (default=1.0)
+ photonEnergies      ::Array{Float64,1} ... Photon energies (in user-selected units) for the simulation of photon spectra
                                                to describe the interval and resolution of the absorption cross sections.
+ shells              ::Array{Shell,1}   
    ... Shells that should be included for a partial absorption cross sections; a cross section contribution is considered,
        if the occupation of one of these shells is lowered in the leading configurations.
+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population;
        at least one of these tuples must be given.
+ leadingConfigs      ::Array{Configuration,1}   
    ... List of leading configurations whose levels are equally populated, either initially or ....
source
JenaAtomicCalculator.Cascade.PhotoExcitationScheme — Type

struct Cascade.PhotoExcitationScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe a photo-excitation calculation for an atom in some initial state/configuration and for a given set of shell-excitations

+ multipoles            ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the excitation processes.
+ minPhotonEnergy       ::Float64                 
    ... Minimum photon energy [in a.u.] that restrict the number of excited configurations to be taken into accout.
+ maxPhotonEnergy       ::Float64                 
    ... Maximum photon energy [in a.u.] that restrict the number of excited configurations to be taken into accout.
+ NoExcitations         ::Int64                 
    ... (Maximum) Number of electron replacements with regard to the initial configurations/multiplets.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which photo-excitations are to be considered.
+ excitationToShells    ::Array{Shell,1}    
    ... List of shells into which photo-excitations are to be considered, including possibly already occupied shells.
+ initialLevelSelection ::LevelSelection    
    ... Specifies the selected initial levels of some given initial-state configurations; these initial level numbers/
        symmetries always refer to the set of initial configurations.
+ lValues               ::Array{Int64,1}
    ... Orbital angular momentum values of the free-electrons, for which partial waves are considered for the PI.
+ electronEnergyShift   ::Float64                 
    ... Energy shift for all bound-state energies relative to the levels from the reference configuration; this is realized by 
        shifting the initial level energies by the negative amount. The shift is taken in the user-defined units.
+ minCrossSection       ::Float64                 
    ... minimum cross section (in user-selected units) for which contributions are accounted for in the list of
        photoionization lines. This may seriously restrict the amount of data that is prepared for the subsequent simulation 
        of photoabsorption spectra.
source
JenaAtomicCalculator.Cascade.PhotoIonizationScheme — Type

struct Cascade.PhotoIonizationScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe a photo-absorption calculation for an atom in some initial state/configuration and for a given range of photon energies and multipoles, etc.

+ multipoles            ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the excitation/ionization processes.
+ photonEnergies        ::Array{Float64,1}
    ... List of photon energies (in user-selected units) for which absorption cross sections/spectra are to be
        calculated; this describes the list, distribution and resolution of energies. It is checked that either
        photonEnergies or electronEnergies are given only.
+ electronEnergies       ::Array{Float64,1}
    ... List of electron energies (in user-selected units) for which absorption cross sections/spectra are to be
        calculated; this describes the list, distribution and resolution of energies.
+ excitationFromShells  ::Array{Shell,1}    
    ... List of shells from which photo-excitations are to be considered.
+ excitationToShells    ::Array{Shell,1}    
    ... List of shells into which photo-excitations are to be considered, including possibly already occupied
        shells.  NOT USED BY THIS SCHEME, which computes the DIRECT photoionization channel only;  a non-empty
        list is reported by a warning at the start of the run.  The field is carried because
        PhotoAbsorptionScheme builds both this scheme and a PhotoExcitationScheme from one shared set of fields,
        and the bound-bound channel belongs to the latter -- generating it here as well would count it twice.
        Use PhotoExcitationScheme for that channel, or PhotoAbsorptionScheme for both together.
+ initialLevelSelection ::LevelSelection    
    ... Specifies the selected initial levels of some given initial-state configurations; these initial level numbers/
        symmetries always refer to the set of initial configurations.
+ lValues               ::Array{Int64,1}
    ... Orbital angular momentum values of the free-electrons, for which partial waves are considered for the PI.
        This one IS honoured:  it is passed on to PhotoIonization.Settings, which then drops every partial wave
        whose l is not in the list.
+ electronEnergyShift   ::Float64                 
    ... Energy shift for all bound-state energies relative to the levels from the reference configuration; this is realized by 
        shifting the initial level energies by the negative amount. The shift is taken in the user-defined units.
+ minCrossSection       ::Float64                 
    ... minimum cross section (in user-selected units) for which contributions are accounted for in the list of
        photoionization lines.
source
JenaAtomicCalculator.Cascade.PhotonIntensities — Type

struct Cascade.PhotonIntensities <: Cascade.AbstractSimulationProperty ... defines a type for simulating the photon-line intensities as function of photon energy.

+ minPhotonEnergy     ::Float64     ... Minimum photon energy for the simulation of photon spectra.
+ maxPhotonEnergy     ::Float64     ... Maximum photon energy for the simulation of photon spectra.
+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population.
+ leadingConfigs      ::Array{Configuration,1}   
    ... List of leading configurations whose levels are equally populated, either initially or ....
source
JenaAtomicCalculator.Cascade.PiRateCoefficients — Type

struct Cascade.PiRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for folding the PHOTOIONIZATION cross sections of a previous Cascade.PhotoIonizationScheme computation with a photon field, giving the photoionization rate per ion

        R^PI (per ion)  =  INT d(omega)  n(omega) * c * sigma^PI(omega)

    for each of the given photon distributions.  The convention follows
    Empirical.photoionizationPlasmaRatePerIon exactly, and the distinction it draws is the one to keep in mind:
    THIS IS A RATE [1/s] AND NOT A RATE COEFFICIENT.  The convolution already contains the photon number density
    of the field, so it needs no further multiplication by a density; multiply by the ION number density for a
    volumetric rate.  The free-electron density does not enter photoionization at all.

    AN APPETIZER, AND DELIBERATELY SO.  What it does is fold the cross sections the cascade actually computed,
    by the trapezoidal rule, over the photon energies the cascade actually used -- and nothing else.  In
    particular sigma^PI is taken as ZERO outside that range, there is no extrapolation to threshold and none to
    high energy, and the share of the result contributed by the outermost intervals is printed so that a range
    too narrow for the chosen field announces itself.  Widening the range means recomputing the cascade with
    more photonEnergies; it cannot be repaired here.  The resonant contributions to photoabsorption are NOT
    included: Cascade.PhotoAbsorptionSpectrum is the property for those.

+ initialLevelNo      ::Int64    ... Level No of the initial level whose photoionization is folded; 0 sums over
                                      every initial level present in the data.
+ photonDistributions ::Array{Distribution.AbstractPhotonDistribution,1}
    ... the photon fields to fold with, e.g. Distribution.PhotonPlanck(T), PhotonDilute, PhotonPowerLaw or
        PhotonBremsstrahlungThin; one rate is reported per field.
source
JenaAtomicCalculator.Cascade.PlanckMean — Type

struct Cascade.PlanckMean <: Cascade.AbstractOpacityMean ... the Planck (emission) mean opacity, defined by the ARITHMETIC average

        kappa_P  =  int kappa_nu B_nu dnu  /  int B_nu dnu

    Being arithmetic it is dominated by the most OPAQUE frequencies, i.e. by the lines, and it stays
    finite on an incomplete line list. It is the appropriate mean for optically thin emission, and it is
    what was computed -- under the name "Rosseland" and with the Rosseland weight -- by every JAC version
    before 14-Aug-2026.
source
JenaAtomicCalculator.Cascade.RadiativeRecombinationScheme — Type

struct Cascade.RadiativeRecombinationScheme <: Cascade.AbstractCascadeScheme ... a struct to define and describe the radiative recombination of electrons for an atom in some initial state/configuration; for such a scheme, the configurations due to the electron capture are generated automatically due to given maximal numbers of the (into-) shells (nl) as well as the maximum displacement with regard to the initial configuration. An additional maximum excitation energy need to be provided due to the maximum temperatures for which RR plasma rate coefficients are to be determined, cf. Basics.convert().

+ multipoles             ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the radiative stabilization processes.
+ lValues                ::Array{Int64,1}
    ... Orbital angular momentum values of the free-electrons, for which partial waves are considered for the RR.
+ NoFreeElectronEnergies ::Int64             
    ... Number of free-electron energies that a chosen for a Gauss-Laguerre integration.
+ maxFreeElectronEnergy  ::Float64             
    ... Maximum free-electron energies [in a.u.] that restrict the energy of free-electron orbitals; this maximum energy has to 
        be derived from the maximum temperature for which RR plasma coefficients need to be obtained and is typically set to 
        about 5x T_e,max.
+ electronEnergyShift    ::Float64                 
    ... Energy shift for all bound-state energies relative to the levels from the reference configuration; this is realized by 
        shifting the initial level energies by the negative amount. The shift is taken in the user-defined units.
+ minPhotonEnergy       ::Float64                 
    ... Minimum (mean) photon energy [in a.u.] for which the radiative decay is taken into account.
+ intoShells            ::Array{Shell,1}
    ... List of shells into which electrons are initially placed (captured).
source
JenaAtomicCalculator.Cascade.RefinedSCA — Type

struct Cascade.RefinedSCA <: Basics.AbstractCascadeApproach ... a cascade approach that refines SCA by relaxing the bound orbitals per multiplet and by resolving the continuum orbitals per fine-structure transition; see Cascade.conditions.

    Declared here rather than in Basics: only the abstract supertype Basics.AbstractCascadeApproach has to
    live in Basics, because DecayYield.Settings needs it as a compile-time field type and
    module-DecayYield.jl is included before module-Cascade.jl. Subtypes may be declared where they belong.
source
JenaAtomicCalculator.Cascade.RelaxationCurve — Type

struct Cascade.RelaxationCurve <: Cascade.AbstractSimulationProperty ... defines a type for simulating the mean relaxation times in which 70%, 80%, of the occupied levels decay to the ground configuration.

+ timeStep            ::Float64     ... Time-step for following the decay of levels [a.u.]
+ initialOccupations  ::Array{Tuple{Int64,Float64},1}   
    ... List of one or several (tupels of) levels in the overall cascade tree together with their relative population.
+ leadingConfigs      ::Array{Configuration,1}   
    ... List of leading configurations whose levels are equally populated, either initially or ....
+ groundConfigs       ::Array{Configuration,1}   
    ... List of ground configurations into which the decay is considered.
source
JenaAtomicCalculator.Cascade.ResonantIonizationStrengths — Type

struct Cascade.ResonantIonizationStrengths <: Cascade.AbstractSimulationProperty ... defines a type for simulating the RESONANT contribution to electron-impact ionization from the lines of a previous Cascade.ElectronIonizationScheme computation that requested one or both of the resonant capture channels.

    An incident electron is CAPTURED into a doubly-excited resonance d, which then sheds two electrons, so that
    the ion ends one charge state HIGHER than it began.  What is reported is the energy-integrated RESONANCE
    STRENGTH of each resonance, the natural quantity for an isolated resonance, together with its sum:

        S_0(d)   = pi^2/k^2 * A(capture) * (2J_d+1)/(2J_i+1)              formation alone
        S_seq(d) = S_0 * SUM_n [A(d->n)/Gamma(d)] * [A_a(n)/Gamma(n)]     sequential, through each autoionizing n
        S_sim(d) = S_0 * [P_dbl * A_a(d)/Gamma(d)]                        simultaneous, one double-Auger step

    with Gamma the total width, Auger plus radiative.  The prefactor and the relativistic wave number are those
    of Cascade.simulateDrRateCoefficients, deliberately and identically, so that the RECOMBINATION and IONIZATION
    strengths of the same resonance may be placed side by side without a conversion between them -- which is the
    main thing this property is good for, since the two are competing decays of one resonance.

APPROXIMATIONS, so that it is clear what these numbers are:

+ isolated resonances
    ... strengths are ADDED over resonances, with no interference and no overlap of widths.  Sound while the
        resonances stay narrow against their spacing; it degrades for high capture shells.
+ branchings from the rates that were generated
    ... every Gamma is a sum over the decay steps the cascade actually built.  A decay route absent from the
        configuration lists is absent from Gamma too, so the branchings still sum to one.  That checks the
        arithmetic, never the completeness.
+ an autoionizing intermediate is one that HAS an Auger line
    ... the sequential route needs the intermediate n to autoionize in its turn, and n is admitted exactly when
        the computation produced at least one Auger line out of it.  A level that would autoionize into a final
        configuration nobody generated therefore does not count, and its route is missing rather than wrong.
+ the simultaneous route is NOT computed here
    ... its double-Auger probability is supplied by the user through `dblAugerProbability`, because the choice of
        which subshells count as PASSIVE is a physics judgement the cascade cannot make for itself: the two
        electrons that participate in the Auger transition must be excluded, and which those are depends on the
        transition.  Use ResonantImpactIonization.doubleAugerProbability to obtain a value, read its docstring on
        the two-sided error first, and leave this at 0. to omit the channel entirely rather than guess.

+ initialLevelNo        ::Int64             ... Level No of the initial level from which the capture starts.
+ electronEnergyShift   ::Float64           ... Shift applied to every resonance energy, in the user-selected
                                                 units; the initial level is shifted by the negative amount.
+ dblAugerProbability   ::Float64           ... Probability that a resonance sheds BOTH electrons at once rather
                                                 than one at a time; 0. omits the simultaneous channel.
source
JenaAtomicCalculator.Cascade.RosselandMean — Type

struct Cascade.RosselandMean <: Cascade.AbstractOpacityMean ... the Rosseland mean opacity, defined by the HARMONIC average

        1 / kappa_R  =  int (1/kappa_nu) (dB_nu/dT) dnu  /  int (dB_nu/dT) dnu

    In the temperature-normalised variable u = omega/kT the normalised weight is
    w(u) = 15/(4 pi^4) u^4 e^-u / (1 - e^-u)^2, whose prefactor is exact because
    int_0^inf u^4 e^u/(e^u-1)^2 du = 4 Gamma(4) zeta(4) = 4 pi^4/15.

    BECAUSE IT IS HARMONIC, THE ROSSELAND MEAN IS DOMINATED BY THE MOST TRANSPARENT FREQUENCIES --
    radiation leaks through the windows between the lines. One consequence must be understood before
    the number is used: if any bin of the spectral opacity is EMPTY, kappa_nu = 0 there and the mean is
    exactly zero. That is physically correct, not a numerical artefact, and it means a Rosseland mean of
    a bound-bound line list ALONE is meaningless -- a continuum floor (electron scattering, bound-free)
    is required. Cascade.simulateMeanOpacities therefore reports the empty bins rather than returning a
    number that merely looks usable.
source
JenaAtomicCalculator.Cascade.RrRateCoefficients — Type

struct Cascade.RrRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for simulating the RR plasma rate coefficients as function of the (free) electron energy and plasma temperature.

+ initialLevelNo      ::Int64       ... Level No of initial level for which rate coefficients are to be computed.
+ temperatures        ::Array{Float64,1}
    ... temperatures [K] for which the DR plasma rate coefficieints to be calculated.
+ multipoles          ::Array{EmMultipole}           
    ... Multipoles of the radiation field that are to be included into the excitation processes.
+ finalLevelSelection ::LevelSelection    
    ... Specifies the selected final levels of some given final-state configurations; these final level numbers/
        symmetries always refer to single configurations.
+ finalConfigurations ::Array{Configuration,1}
source
JenaAtomicCalculator.Cascade.ScatteringOpacity — Type

struct Cascade.ScatteringOpacity <: Cascade.AbstractOpacityContribution ... the Thomson scattering contribution of free electrons,

        kappa^sc = n_e sigma_T / rho ,      sigma_T = 6.6524587321e-25 cm^2

    which is INDEPENDENT of frequency and therefore contributes the same value to every bin. It is small
    beside a strong line, but it is the CONTINUUM FLOOR that makes a Rosseland mean well defined at all:
    without it a single empty bin sends the harmonic mean to zero.

    ASSUMPTIONS: non-relativistic, unpolarised Thomson scattering (kT << m_e c^2, i.e. T << 6e9 K), and
    scattering treated as pure extinction. For a fully ionised hydrogen plasma n_e = rho/m_H and this
    reduces to the textbook kappa_es = 0.20 (1 + X) = 0.40 cm^2/g, which is the cleanest known-answer
    check available for any mean-opacity implementation.

+ electronNumberDensity  ::Float64      ... free-electron number density n_e [in 1/cm^3]
source
JenaAtomicCalculator.Cascade.Simulation — Method

Cascade.Simulation(sim::Cascade.Simulation; name::Union{Nothing,String}=nothing, property::Union{Nothing,Cascade.AbstractSimulationProperty}=nothing, method::Union{Nothing,Cascade.AbstractSimulationMethod}=nothing, settings::Union{Nothing,Cascade.SimulationSettings}=nothing, computationData::Union{Nothing,Array{Dict{String,Any},1}}=nothing )

... constructor for re-defining the computation::Cascade.Simulation.
    A `simulation::Cascade.Simulation` is returned.
source
JenaAtomicCalculator.Cascade.Simulation — Type

struct Cascade.Simulation ... defines a simulation on some given cascade (data).

+ name            ::String                              ... Name of the simulation
+ property        ::Cascade.AbstractSimulationProperty 
    ... Property that is to be considered in this simulation of the cascade (data).
+ method          ::Cascade.AbstractSimulationMethod    
    ... Method that is used in the cascade simulation; cf. Cascade.SimulationMethod.
+ settings        ::Cascade.SimulationSettings          ... Settings for performing these simulations.
+ computationData ::Array{Dict{String,Any},1}           ... Date on which the simulations are performed
source
JenaAtomicCalculator.Cascade.SimulationSettings — Type

struct Cascade.SimulationSettings ... defines settings for performing the simulation of some cascade (data).

+ printTree           ::Bool        ... Print the cascade tree in a short form
+ printLongTree       ::Bool        ... Print the cascade tree in a long form
+ initialPhotonEnergy ::Float64     ... Photon energy for which photoionization data are considered.
source
JenaAtomicCalculator.Cascade.Step — Type

struct Cascade.Step ... defines a type for an individual step of an excitation and/or decay cascade. Such a step is determined by the two lists of initial- and final-state configuration as well as by the atomic process, such as Auger, PhotoEmission, or others, which related the initial- and final-state levels to each other. Since the (lists of) initial- and final-state configurations treated (each) by a single multiplet (for parities and total angular momenta), a cascade step supports full configuration interaction within the multiplet but also help avoid 'double counting' of individual levels. Indeed, each electron configuration may occur only in one cascade block. In contrast, each list of initial- and final-state multiplets (cascade blocks) can occur in quite different steps due to the considered processes and parallel decay pathes in a cascade.

+ process          ::JBasics.AbstractProcess   ... Atomic process that 'acts' in this step of the cascade.
+ settings         ::Union{PhotoEmission.Settings, AutoIonization.Settings, PhotoIonization.Settings, PhotoExcitation.Settings,
                            DielectronicCapture.Settings}        
                                                ... Settings for this step of the cascade.
+ initialConfigs   ::Array{Configuration,1}    ... List of one or several configurations that define the initial-state multiplet.
+ finalConfigs     ::Array{Configuration,1}    ... List of one or several configurations that define the final-state multiplet.
+ initialMultiplet ::Multiplet                 ... Multiplet of the initial-state levels of this step of the cascade.
+ finalMultiplet   ::Multiplet                 ... Multiplet of the final-state levels of this step of the cascade.
source
JenaAtomicCalculator.Cascade.StepwiseDecayScheme — Type

struct Cascade.StepwiseDecayScheme <: Cascade.AbstractCascadeScheme ... a struct to represent (and generate) a mean-field orbital basis.

+ processes             ::Array{Basics.AbstractProcess,1} 
    ... List of the atomic processes that are supported and should be included into the cascade.
+ maxElectronLoss       ::Int64             
    ... (Maximum) Number of electrons in which the initial- and final-state configurations can differ from each other; 
        this also determines the maximal steps of any particular decay path.
+ chargeStateShifts     ::Dict{Int64,Float64} 
    ... (N => en) total energy shifts of all levels with N electrons; these shifts [in a.u.] help open/close decay 
        channels by simply shifting the total energies of all levels.
+ NoShakeDisplacements  ::Int64             
    ... Maximum number of electron displacements due to shake-up  or shake-down processes in any individual step of cascade.
+ decayShells           ::Array{Shell,1}        ... List of shells that may occur during the decay.
+ shakeFromShells       ::Array{Shell,1}        ... List of shells from which shake transitions may occur.
+ shakeToShells         ::Array{Shell,1}        ... List of shells into which shake transitions may occur.
source
Base.:(==) — Method

Base.:(==)(leva::Cascade.Level, levb::Cascade.Level) ... returns true if both levels are equal and false otherwise.

source
JenaAtomicCalculator.Basics.isSimilar — Method

Basics.isSimilar(keya::LevelKey, keyb::LevelKey, relAcc::Float64) ... returns true if two instances are similar to each other, and false otherwise.

  • (keya::LevelKey, keyb::LevelKey, relAcc::Float64) ... returns true if two level keys refer to the same level, i.e. level with the same symmetry and if the relative energy abs( (Ea - Eb)/E_a ) < relAcc. It returns false otherwise.
source
JenaAtomicCalculator.Basics.perform — Method

Basics.perform(comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform the cascade computation prescribed by comp. The method first rejects an unrealizable cascade approach, before any orbital or amplitude work is done, and then dispatches on comp.scheme and hands all three keywords to Cascade.perform(comp.scheme, comp; ...), so that what it returns is what that scheme's method returns: with output = false nothing, and with output = true a results::Basics.PerformResults whose key "cascade data:" is what a subsequent Cascade.Simulation reads. The results of all individual steps are printed to screen.

source
JenaAtomicCalculator.Basics.perform — Method

Basics.perform(comp::Cascade.Simulation; output::Bool=false) ... to set-up and perform the cascade simulation prescribed by comp, i.e. to propagate an initial level population through the line data of a previous cascade computation. The method only dispatches to Cascade.perform(comp::Cascade.Simulation; output=output), so that what it returns is what that method returns: with output = false nothing, and with output = true a results::Dict{String,Any} whose keys give access to the individual simulation steps. The results of all individual steps are printed to screen.

source
JenaAtomicCalculator.Cascade.addLevels — Method

Cascade.addLevels(levelsA::Array{Cascade.Level,1}, levelsB::Array{Cascade.Level,1}) ... merges two lists of cascade levels into one. A level that occurs in both keeps its identity and gains the parents and daughters of its counterpart, so that the decay paths recorded in the two lists are UNIONED rather than one overwriting the other; a level occurring in only one list is carried over unchanged. Every relative occupation is set to ZERO in the merged list, so a caller that needs them must set them again. A levels::Array{Cascade.Level,1} is returned, and the counts of modified and newly appended levels are printed. It is assumed that each parent and each daughter process appears only once when levels from different data sets – a Cascade.DecayData and a Cascade.PhotoIonData – are added to each other.

source
JenaAtomicCalculator.Cascade.applyOpacityMean — Method

Cascade.applyOpacityMean(mean::Cascade.PlanckMean, kappas::Array{Basics.EmProperty,1}, weights::Array{Float64,1}) ... forms the ARITHMETIC, weight-normalised mean sumi wi kappa_i of the given spectral opacities. A tuple (value::Basics.EmProperty, note::String) is returned; note is empty for this mean, which is finite whatever the spectral opacity looks like.

source
JenaAtomicCalculator.Cascade.applyOpacityMean — Method

Cascade.applyOpacityMean(mean::Cascade.RosselandMean, kappas::Array{Basics.EmProperty,1}, weights::Array{Float64,1}) ... forms the HARMONIC, weight-normalised mean 1 / sumi (wi / kappa_i) of the given spectral opacities. A tuple (value::Basics.EmProperty, note::String) is returned.

    An EMPTY BIN (kappa_i = 0) makes the harmonic mean vanish identically, and that is physics rather
    than a numerical accident: the Rosseland mean is dominated by the most transparent frequencies, so a
    single perfectly transparent window short-circuits it. Rather than silently returning zero -- or,
    worse, substituting an arithmetic mean, as JAC did before 14-Aug-2026 -- the vanishing case is
    reported through `note`, naming how many bins are empty and what is missing: a continuum
    contribution (electron scattering, bound-free) that a bound-bound line list alone cannot supply.
source
JenaAtomicCalculator.Cascade.asResults — Method

Cascade.asResults(x) ... presents a stored cascade result as a Basics.PerformResults, whichever form it arrived in; a results::Basics.PerformResults is returned.

    WHY THIS EXISTS.  `Cascade.asResults(simulation.computationData[i]["results"])` can be EITHER -- a `PerformResults` when the
    caller handed the return of `perform` straight in, or a plain `Dict{String,Any}` when the cascade was
    restored from a JLD2 file.  Typed result keys work on the first and not on the second, and a typed key
    cannot be taught to index a plain `Dict` without type piracy on Base.  Normalising here lets this module
    use the typed keys like every other, and is why its reads did not have to stay on the deprecated strings.
source
JenaAtomicCalculator.Cascade.asfSettingsForApproach — Method

Cascade.asfSettingsForApproach(approach::Basics.AbstractCascadeApproach, settings::AsfSettings) ... returns the AsfSettings with which the cascade blocks must be represented for the given approach. The approach decides ONLY whether the Hamiltonian matrix is taken diagonal or is fully diagonalized; the e-e interaction itself (Coulomb, Gaunt, Breit) stays the caller's choice through AsfSettings.

    JAC packs both questions into the single field eeInteractionCI, whose values are DiagonalCoulomb,
    CoulombInteraction, CoulombGaunt, BreitInteraction and CoulombBreit -- there is no "DiagonalBreit".
    Consequently SingleCSF can only be realized as DiagonalCoulomb, and a Breit request cannot be honoured
    together with AverageSCA; that is a limitation of the type, not a choice made here. From SCA upwards
    the caller's setting is passed through untouched, and is only promoted when it says DiagonalCoulomb,
    which would contradict the configuration mixing the approach asks for. An  AsfSettings  is returned.
source
JenaAtomicCalculator.Cascade.assignOccupation! — Method

Cascade.assignOccupation!(levels::Array{Cascade.Level,1}, property::AbstractSimulationProperty) ... assigns the occupation due to the given property Nothing is returned; the levels are modified in place.

source
JenaAtomicCalculator.Cascade.binningUnit — Method

Cascade.binningUnit(dependence::Cascade.AbstractOpacityDependence) ... returns the unit in which the binning of the given opacity dependence is specified; a String is returned. The binning is in nm for a wavelength dependence and in Hartree otherwise, a mixture that is easily mistaken and that was previously printed as [Hartree] in all three cases.

source
JenaAtomicCalculator.Cascade.checkDataFile — Method

Cascade.checkDataFile(filename::String; stream::IO=stdout) ... reports what a stored cascade .jld file contains and whether THIS JAC can read it; true is returned if the file loaded, false otherwise. Nothing is thrown: a file that cannot be read is the normal case this function exists for, and it prints which JAC wrote it and which type failed, instead of leaving a JLD2 internal error.

    NO CALLER IN `src/`, AND THAT IS CORRECT: it is a REPL tool for a user holding a stored cascade `.jld` file of
    uncertain provenance, who wants to know what is in it and whether this JAC can read it BEFORE loading it into a
    computation. Nothing in a run should call it, because a run already knows what it wrote.
source
JenaAtomicCalculator.Cascade.combineEnergiesIntensities — Method

Cascade.combineEnergiesIntensities(w1::Float64, w1enInts::Array{Tuple{Float64,Float64},1}, w2::Float64, w2enInts::Array{Tuple{Float64,Float64},1}) ... combines w1 * w1enInts + w2 * w2enInts; a newEnergiesInts::Array{Tuple{Float64,Float64},1} is returned.

    NO CALLER IN `src/`: it is offered to a USER combining two simulations by hand -- two cascades under different
    conditions, weighted and added. The simulation drivers build their own lists and do not need it.
source
JenaAtomicCalculator.Cascade.computeContinuumOrbitals — Method

Cascade.computeContinuumOrbitals(scheme::Cascade.RadiativeRecombinationScheme, comp::Cascade.Computation, level::ManyElectron.Level) ... computes in turn all the necessary continuum orbitals for the given energy grid and maxKappa value; a tuple (cOrbitals, cPhases)::Tuple{Dict{Subshell, Orbital}, Dict{Subshell, Float64}} is returned. The scattering phase is kept alongside each orbital because it is needed by the amplitudes: it cancels in a cross section but not in an angular parameter.

source
JenaAtomicCalculator.Cascade.computeDecayProbabilities — Method

Cascade.computeDecayProbabilities(outcome::DecayYield.Outcome, linesR::Array{PhotoEmission.Line,1}, linesA::Array{AutoIonization.Line,1}, settings::DecayYield.Settings) ... to compute the decay probabilities for all pairs and triples of subshells; these probabilities only depend on the holes in different subshells and are sumed over all final levels that share the same subshell occupation. The results are printed in neat tables to screen but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.computeDecayYieldOutcome — Method

Cascade.computeDecayYieldOutcome(outcome::DecayYield.Outcome, linesR::Array{PhotoEmission.Line,1}, linesA::Array{AutoIonization.Line,1}, settings::DecayYield.Settings) ... to compute the flourescence and Auger yields for a single decay yield outcome as specified by the corresponding level; an outcome::DecayYield.Outcome is returned in which all physical parameters are now specified for the given decay-yield.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested capture & transition amplitudes as well as DielectronicCapture.Line's, AutoIonization.Line's, etc. for all pre-specified decay steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.CaptureData is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.ElectronIonizationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes for all pre-specified steps of the cascade, i.e. the ImpactExcitation.Line's of an impact excitation, the AutoIonization.Line's of an autoionization or a capture, and the PhotoEmission.Line's of a radiative stabilization. As for the other cascade schemes, the amount of printout is reduced and sent to the summary file. A set of data::Array{Cascade.Data,1} is returned, always of length three and always in the order (impact-excitation, autoionization, radiative), so that a caller may index it without first asking which channels were requested; an unrequested channel contributes an empty list.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.ExpansionOpacityScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested photon excitation/absorption amplitudes as well as PhotoExcitation.Line's for all pre-specified decay steps of the cascade. When compared with standard computations of photoexcitation, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.ExcitationData is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.HollowIonScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested (decay) transition amplitudes as well as AutoIonization.Line's, etc. for all pre-specified decay steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Array{Cascade.Data,1} is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.ImpactExcitationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes as well as ImpactExcitation.Line's, etc. for all pre-specified excitation steps of the cascade. When compared with standard excitation computations, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.Data is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.PhotoExcitationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes as well as PhotoExcitation.Line's, etc. for all pre-specified excitation steps of the cascade. When compared with standard excitation computations, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.ExcitationData is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.PhotoIonizationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes as well as PhotoExcitation.Line's, etc. for all pre-specified excitation steps of the cascade. When compared with standard excitation computations, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.ExcitationData is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.RadiativeRecombinationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested capture amplitudes as well as PhotoRecombination.Line's, etc. for all pre-specified radiative recombination steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.CaptureData is returned.

source
JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.StepwiseDecayScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes as well as PhotoEmission.Line's, AutoIonization.Line's, etc. for all pre-specified decay steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.DecayData is returned.

source
JenaAtomicCalculator.Cascade.conditions — Method

Cascade.conditions(approach::Basics.AbstractCascadeApproach) ... returns the Cascade.CascadeApproachConditions that define the given cascade approach. Each approach changes exactly TWO conditions with respect to the one below it:

    AverageSCA   SingleCSF      / GlobalOrbitals      / StepAveraged       / LocalPotential
    SCA          BlockCI        / ChargeStateOrbitals / StepAveraged       / LocalPotential
    RefinedSCA   BlockCI        / MultipletOrbitals   / TransitionResolved / LocalPotential
    UserMCA      GroupedBlockCI / MultipletOrbitals   / TransitionResolved / WithExchange

    An  conditions::Cascade.CascadeApproachConditions  is returned.
source
JenaAtomicCalculator.Cascade.dataFormatStamp — Method

Cascade.dataFormatStamp() ... returns a Dict{String,Any} identifying the writer of a cascade .jld file; it is merged into results by Cascade.writeDataFile below, under the key "data format:".

source
JenaAtomicCalculator.Cascade.determineResonantSteps — Method

Cascade.determineResonantSteps(scheme::Cascade.ElectronIonizationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, capturedList::Array{Cascade.Block,1}, excitedList::Array{Cascade.Block,1}, ionizedList::Array{Cascade.Block,1}, decayList::Array{Cascade.Block,1}; withSecondAuger::Bool=true) ... determines all step::Cascade.Step's of the resonant channels of an electron-ionization cascade; a stepList::Array{Cascade.Step,1} is returned.

    FOUR FAMILIES OF STEP are set up, and each is needed for a different reason:

    + Auger, captured(N+1) -> initial(N)
        ... the resonance decaying back whence it came.  Its rate is what gives the CAPTURE rate, by detailed
            balance, and it is also the largest single term in the resonance's total width.
    + Auger, captured(N+1) -> excited(N)
        ... the first of the two sequential steps, into an intermediate that lies above the ionization threshold
            and can therefore autoionize again.
    + Auger, excited(N) -> ionized(N-1)
        ... the second sequential step, which completes the ionization.  The impact-excitation channel sets up the
            VERY SAME family for its own autoionization, so `withSecondAuger=false` suppresses it here whenever both
            channels are requested together.  (`Cascade.modifySteps` does NOT deduplicate -- it is a placeholder that
            copies every step through -- so this has to be handled at the point where the steps are built.)
    + Radiative, captured(N+1) -> decay(N+1)
        ... radiative stabilization of the resonance.  This is NOT an ionization route -- it is dielectronic
            recombination -- but it belongs in the resonance's TOTAL WIDTH, and leaving it out would make every
            ionization branching too large.  It is the reason a resonant-ionization computation also yields the
            recombination branching of the same resonances.

    Each step is set up only where it is energetically possible at all, i.e. where the mean energy of the upper
    block exceeds that of the lower one.

+ withSecondAuger  ::Bool
    ... whether family (3) is emitted.  Pass false when the impact-excitation channel runs alongside, since it emits
        the identical family and the amplitudes would otherwise be computed twice.
source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, capturedList::Array{Cascade.Block,1}, decayList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this dielectronic cascade. It considers the autoionization between the blocks from the captureList and initialList as well as the radiative stabilization between the blocks from the captureList and decayList. It checks that at least on pair of levels supports either an electron-capture' orradiative stabilization' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.ElectronIonizationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, excitedList::Array{Cascade.Block,1}, ionizedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's of this excitation-autoionization cascade. It pairs the initial blocks with the excited ones for the electron-impact excitation, and the excited blocks with the ionized ones for the subsequent autoionization. An Auger step is only set up if it is energetically possible at all, i.e. if the excited block lies above the ionized one; that test is what restricts the cascade to the AUTOIONIZING excited levels, which are the only ones that contribute to ionization. A stepList::Array{Cascade.Step,1} is returned.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.ExpansionOpacityScheme, comp::Cascade.Computation, blockList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this expansion opacity cascade. It considers the pairwise photoexcitation between all blocks and checks that at least one transition is allowed for these blocks. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and oscillator strengths are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.HollowIonScheme, comp::Cascade.Computation, capturedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all decay processes of the given scheme and selects all pairs of blocks due to the selected cascade approach. It checks that at least on pair of levels supports a decay within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.ImpactExcitationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, excitedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all processes of the given decay scheme and selects all pairs of blocks due to the selected cascade approach. It checks that at least on pair of levels supports a `electron-impact excitation' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.PhotoExcitationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, excitedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all processes of the given decay scheme and selects all pairs of blocks due to the selected cascade approach. It checks that at least on pair of levels supports a `photo-excitation' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.PhotoIonizationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, ionizedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all processes of the given decay scheme and selects all pairs of blocks due to the selected processes and cascade approach. It checks that at least on pair of levels supports either a photo-ionization' orphoto-excitation' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.RadiativeRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, capturedList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this radiative recombination cascade. It considers the radiative recombination between the blocks from the initialList and captureList. It checks that at least on pair of levels supports such a `radiative stabilization' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required capture amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.StepwiseDecayScheme, comp::Cascade.Computation, blockList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all processes of the given decay scheme and selects all pairs of blocks due to the selected cascade approach. It is checked that the (averaged) energies each block or level supports a `decay' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates are computed.

source
JenaAtomicCalculator.Cascade.directIonizationAlpha — Method

Cascade.directIonizationAlpha(Z::Float64, conf::Configuration, temperatures::Array{Float64,1}) ... estimates the DIRECT electron-impact ionization rate coefficient semi-empirically, by summing the Lotz rate of Empirical.impactIonizationPlasmaAlpha over every occupied subshell of conf. A tuple (alphas::Array{Float64,1} in cm^3/s, skipped::Array{String,1}) is returned, where skipped names any subshell the empirical binding-energy tables could not supply, together with the reason – those subshells contribute nothing and the caller must be able to say which, since a silently dropped inner shell would lower the total without any sign of it.

    THIS IS NOT A CASCADE COMPUTATION and is not of the same kind as the other channels.  It is a fit: Lotz (1967),
    folded with a Maxwellian, using tabulated binding energies.  Its accuracy is tens of per cent at best and worse
    near threshold and for near-neutral ions.  It is here because the alternative is worse -- without it a total
    that omits the direct channel is wrong by ORDERS OF MAGNITUDE for a light ion, where direct ionization carries
    98% or more of the rate, and a number wrong by 100 is more misleading than one wrong by 30%.
source
JenaAtomicCalculator.Cascade.displayApproach — Method

Cascade.displayApproach(stream::IO, approach::Basics.AbstractCascadeApproach, settings::AsfSettings) ... writes the six lines that state, absolutely and always in the same order, what the given approach actually does. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayBlocks — Method

Cascade.displayBlocks(stream::IO, blockList::Array{Cascade.Block,1}; sa::String="") ... group & display the blocks of the cascade with same No. of electrons; this blocks are displayed with the minimum and maximum energy of each multiplet. The optional sa::String can be used to display some details about the given blocks. nothing is returned.

source
JenaAtomicCalculator.Cascade.displayCoincidences — Method

Cascade.displayCoincidences(stream::IO, property::Cascade.ParticleCoincidences, energiesIntensities::Array{Tuple{Float64,Float64},1}) ... displays the coincidence spectrum in a neat table. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayDecayProbabilities — Method

Cascade.displayDecayProbabilities(stream::IO, outcome::DecayYield.Outcome, rProbabilities::Dict{Subshell,Float64}, aProbabilities::Dict{Tuple{Subshell,Subshell},Float64}, settings::DecayYield.Settings) ... displays the – radiative and Auger – decay probabilities in a neat table and a format close to the geant4 input files. However, here the subshells are still displayed in the standard form. If suitable output files are selected, these – radiative and Auger – decay probabilities are also dumped independently into two ASCII files by using a format very similar to GEANT4. Overall this procedure is rather specific in that the level of each outcome is given by a single relativistic configuration and with just a single core hole (subshell). The many-electron rates are then brought back to a single-particle subshell notation. A neat table is printed to the given stream but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.displayEaCrossSections — Method

Cascade.displayEaCrossSections(stream::IO, results::Array{Basics.ScalarProperty{Float64},1}, property::Cascade.EaCrossSections) ... displays the excitation-autoionization cross sections in a neat table; nothing is returned.

source
JenaAtomicCalculator.Cascade.displayEiiRateCoefficients — Method

Cascade.displayEiiRateCoefficients(stream::IO, temperatures::Array{Float64,1}, alphaRes::Array{Basics.EmProperty,1}, alphaEa::Array{Float64,1}, alphaDir::Array{Float64,1}, skipped::Array{String,1}, alphaDr::Array{Basics.EmProperty,1}, total::Array{Basics.EmProperty,1}, weightAbove::Array{Float64,1}, resonances::Array{Cascade.IonizingResonance,1}, csEnergies::Array{Float64,1}, property::Cascade.EiiRateCoefficients) ... displays the electron-impact ionization rate coefficients channel by channel, together with the two diagnostics that say whether the numbers may be used: the position of the maximum of alpha^res(T), which is fixed analytically by the resonance energies, and the share of the Maxwellian weight lying above the last computed impact energy. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayExpansionOpacities — Method

Cascade.displayExpansionOpacities(stream::IO, sc::String, property::Cascade.ExpansionOpacities, energyInterval::Tuple{Float64, Float64}, kappas::Array{Basics.EmProperty,1}) ... displays the expansion opacities in a neat table. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayExpansionOpacityTransitions — Method

Cascade.displayExpansionOpacityTransitions(stream::IO, lines::Array{PhotoExcitation.Line,1}) ... displays the bound-bound transitions from which the expansion opacity is built, sorted by wavelength. For each line, the wavelength, the transition energy, the absorption oscillator strength in both gauges and the excitation energy of the LOWER level are shown; the latter decides, together with the temperature, how strongly the line is populated. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayFinalLevelDistribution — Method

Cascade.displayFinalLevelDistribution(stream::IO, sc::String, levels::Array{Cascade.Level,1}, finalConfigs::Array{Configuration,1}) ... displays the (current or final) level distribution in a neat table. Only those levels with a non-zero occupation are displayed here. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayIntensities — Method

Cascade.displayIntensities(stream::IO, property::ElectronIntensities, energiesIntensities::Array{Tuple{Float64,Float64},1}) ... displays the (tuples of) energiesIntensities of the emitted electrons in a neat table. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayIntensities — Method

Cascade.displayIntensities(stream::IO, property::PhotonIntensities, energiesIntensities::Array{Tuple{Float64,Float64},1}) ... displays the (tuples of) energiesIntensities in a neat table. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayLevelTree — Method

Cascade.displayLevelTree(stream::IO, levels::Array{Cascade.Level,1}; extended::Bool=false) ... displays all defined levels in a neat table, together with their No. of electrons, symmetry, level energy, current (relative) population as well as analogue information about their parents and daughter levels. This enables one to recognize (and perhaps later add) missing parent and daughter levels. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayLevels — Method

Cascade.displayLevels(stream::IO, multiplets::Array{Multiplet,1}; sa::String="") ... display on stream the initial configurations as well as the calculated levels for all initial multiplets. A neat table is printed but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.displayPiRateCoefficients — Method

Cascade.displayPiRateCoefficients(stream::IO, energies::Array{Float64,1}, rates::Array{Basics.EmProperty,1}, edges::Array{Float64,1}, property::Cascade.PiRateCoefficients) ... displays the photoionization rate per ion for each photon field, with the range folded over and the share of the integral carried by the outermost intervals. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayRelativeOccupation — Method

Cascade.displayRelativeOccupation(stream::IO, levels::Array{Cascade.Level,1}, settings::Cascade.SimulationSettings) ... displays the (initial) relative occupation of the levels in a neat table; an error message is issued if the population is given for those levels in the settings, which do not exist in the present simulation. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displayRelaxationCurve — Method

Cascade.displayRelaxationCurve(stream::IO, relaxPercentage::Array{Float64,1}, relaxTimes::Array{Float64,1}, times::Array{Float64,1}, occupations::Array{Float64,1}) ... displays the relaxation curve, i.e. the fraction of the initial population that has reached the ground configurations as a function of time, together with the times at which the requested percentiles are crossed. Nothing is returned.

source
JenaAtomicCalculator.Cascade.displaySteps — Method

Cascade.displaySteps(stream::IO, steps::Array{Cascade.Step,1}; sa::String="") ... displays all predefined steps in a neat table and supports to delete individual steps from the list. sa::String can be used to display details about the given steps A neat table is printed but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.dumpDecayProbabilities — Method

Cascade.dumpDecayProbabilities(stream::IO, outcome::DecayYield.Outcome, subshEnergies::Dict{Subshell,Float64}, rProbabilities::Dict{Subshell,Float64},settings::DecayYield.Settings) ... dumps the radiative decay probabilities to a selected data file in geant4 form; this is caused by the geant4 boolean of the DecayYield.Settings; this procedure is rather specific in that a single relativistic configuration with a single core hole (subshell) is assumed and that the many-electron rates have been brought back to a single-particle subshell notation. A neat table is printed to the given stream but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.dumpDecayProbabilities — Method

Cascade.dumpDecayProbabilities(stream::IO, outcome::DecayYield.Outcome, subshEnergies::Dict{Subshell,Float64}, aProbabilities::Dict{Tuple{Subshell,Subshell},Float64},settings::DecayYield.Settings) ... dumps the Auger decay probabilities to a selected data file in geant4 form; this is caused by the geant4 boolean of the DecayYield.Settings; this procedure is rather specific in that a single relativistic configuration with a single core hole (subshell) is assumed and that the many-electron rates have been brought back to a single-particle subshell notation. A neat table is printed to the given stream but nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.extractEaCrossSections — Method

Cascade.extractEaCrossSections(simulation::Cascade.Simulation) ... collects the excitation-autoionization cross section sigma^EA(E) from the impact-excitation and autoionization lines of the cascade data, summing over those excited levels that actually autoionize. A tuple (energies::Array{Float64,1}, values::Array{Float64,1}) in ATOMIC UNITS is returned, sorted by energy and empty if the data carry no impact-excitation lines at all – which is the normal case for a purely resonant computation and is not an error.

source
JenaAtomicCalculator.Cascade.extractIntensities — Method

Cascade.extractIntensities(fluxes::Array{Cascade.LineFlux,1}, process::Basics.AbstractProcess) ... extracts, from the flux records of a cascade propagation, the (energy, intensity) tuples of all emissions belonging to the given process – Basics.Radiative() for the photon spectrum, Basics.Auger() for the electron spectrum. An Array{Tuple{Float64,Float64},1} is returned.

source
JenaAtomicCalculator.Cascade.extractIonizingResonances — Method

Cascade.extractIonizingResonances(levels::Array{Cascade.Level,1}, property::Cascade.AbstractSimulationProperty; strict::Bool=true) ... determines and prints the resonance strengths of the two resonant electron-capture channels of electron-impact ionization, together with the recombination strength of the SAME resonances so that the competition between the two is visible. Nothing is returned.

    A resonance is any level with one electron MORE than the initial one that has an Auger line back to the initial
    level; that Auger rate is the capture rate, by detailed balance.  An intermediate of the sequential route is
    admitted when it has the initial electron number AND carries at least one Auger line of its own, i.e. when the
    computation itself found it to be autoionizing.
source
JenaAtomicCalculator.Cascade.extractLevels — Method

Cascade.extractLevels(data::Array{Cascade.Data,1}, settings::Cascade.SimulationSettings) ... extracts and sorts all levels from the given cascade data into a new levelList::Array{Cascade.Level,1} to simplify the propagation of the probabilities. In this list, every level of the overall cascade just occurs just once, together with its parent lines (which may populate the level) and the daughter lines (to which the pobability may decay). A levelList::Array{Cascade.Level,1} is returned.

source
JenaAtomicCalculator.Cascade.extractOccupation — Method

Cascade.extractOccupation(levels::Array{Cascade.Level,1}, groundConfigs::Array{Configuration,1}) ... determines the total occupation of the levels in (one of) the groundConfigs. A occ::Float64 is returned.

source
JenaAtomicCalculator.Cascade.findCascadeLevel — Method

Cascade.findCascadeLevel(levels::Array{Cascade.Level,1}, mLevel::ManyElectron.Level, NoElectrons::Int64) ... finds, among levels, the cascade level that corresponds to the many-electron level mLevel of an ion with NoElectrons electrons; a level::Union{Cascade.Level,Nothing} is returned, and nothing if there is no match.

    The match is on the electron number together with the energy, J and parity, since a Cascade.Level carries no
    reference back to the ManyElectron.Level it was built from.  The energy tolerance is relative and loose
    (1e-10), because both sides come from the same computation and differ only by round-trip through the data file.
source
JenaAtomicCalculator.Cascade.findLevelIndex — Method

Cascade.findLevelIndex(level::Cascade.Level, levels::Array{Cascade.Level,1}) ... find the index of the given level within the given list of levels; an idx::Int64 is returned and an error message is issued if the level is not found in the list.

source
JenaAtomicCalculator.Cascade.foldWithMaxwellian — Method

Cascade.foldWithMaxwellian(energies::Array{Float64,1}, values::Array{Float64,1}, temperatures::Array{Float64,1}) ... folds a tabulated cross section sigma(E) with a Maxwellian electron distribution at each temperature,

        alpha(T)  =  4/sqrt(2pi) * T^(-3/2) * INT sigma(E) * E * exp(-E/T) dE ,

    the SAME prefactor that DielectronicRecombination.computeRateCoefficient carries, since sqrt(8/pi) and
    4/sqrt(2pi) are identically equal; a delta-like sigma therefore reproduces the isolated-resonance formula
    exactly.  The integral is a trapezoidal sum over the tabulated energies and is TRUNCATED above the largest of
    them.  A tuple (alphas::Array{Float64,1} in cm^3/s, weightAbove::Array{Float64,1}) is returned, where
    weightAbove[i] = (1 + x) exp(-x) with x = E_max/T_i is the exact share of the Maxwellian weight lying beyond
    the last tabulated energy -- the number that says whether the truncation matters at that temperature.
source
JenaAtomicCalculator.Cascade.foldWithPhotonField — Method

Cascade.foldWithPhotonField(energies::Array{Float64,1}, values::Array{Float64,1}, dist::Distribution.AbstractPhotonDistribution) ... folds a tabulated cross section with a photon field, R = INT d(omega) n(omega) c sigma(omega), by the trapezoidal rule over the tabulated energies and with sigma taken as ZERO outside them. A tuple (rate::Float64 in 1/s, edgeShare::Float64) is returned, where edgeShare is the fraction of the integral contributed by the two OUTERMOST intervals together. That fraction is the diagnostic: if the integrand is still large at the ends of the computed range, the range is too narrow for this field and the rate is a lower bound. It makes no assumption about the shape of the field, which a closed-form tail estimate would.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(comp::Cascade.Computation, confs::Array{Configuration,1}, initalOrbitals::Dict{Subshell, Orbital}; sa::String="", printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this cascade, and compute also the corresponding multiplets. The different cascade approches enables one to realized follow different strategies how these block are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this electron-capture and subsequent stabilization (DR) cascade, and compute also the corresponding multiplets. The different cascade approches realized different strategies how these blocks are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.ElectronIonizationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generates all block::Cascade.Block's of this excitation-autoionization cascade and computes the corresponding multiplets. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.ExpansionOpacityScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this expansion opacity cascade, and compute also the corresponding multiplets. The different cascade approches realizes different strategies how these blocks are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.HollowIonScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this electron-capture and subsequent stabilization (DR) cascade, and compute also the corresponding multiplets. The different cascade approches realized different strategies how these block are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.ImpactExcitationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this impact-excitation cascade, and compute also the corresponding multiplets. The different cascade approches realized different strategies how these block are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.PhotoExcitationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this excitation cascade, and compute also the corresponding multiplets. The different cascade approches realized different strategies how these block are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.PhotoIonizationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this excitation cascade, and compute also the corresponding multiplets. The different cascade approaches realizes different strategies how these block are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.RadiativeRecombinationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this radiative recombination cascade, and compute also the corresponding multiplets. The different cascade approaches help realize different strategies how these blocks are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateBoundOrbitals — Method

Cascade.generateBoundOrbitals(approach::Basics.AbstractCascadeApproach, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generates the bound one-electron orbitals prescribed by the approach, as a dictionary that maps the number of electrons onto the orbital set to be used for every configuration with that many electrons. An empty dictionary is returned for MultipletOrbitals, where the orbitals cannot be prepared in advance because each block generates its own; the caller then runs the self-consistent field itself. A Dict{Int64, Dict{Subshell, Orbital}} is returned.

    For GlobalOrbitals the single set is generated from a mean-field basis spanning ALL of the cascade's
    configurations at once. Seeding it from the initial configurations alone -- the literal wording of the
    published AverageSCA -- is not sufficient in general: an excitation or ionization cascade reaches
    configurations with subshells the initial one never had, and the frozen-orbital CI would then fail on a
    missing subshell. Spanning all configurations keeps one common set while guaranteeing that every
    subshell the cascade can reach is present.
source
JenaAtomicCalculator.Cascade.generateCaptureConfigurations — Method

Cascade.generateCaptureConfigurations(multiplets::Array{Multiplet,1}, coreConfList::Array{Configuration,1}, scheme::DielectronicRecombinationScheme, nm::Nuclear.Model, grid::Radial.Grid) ... checks and compiles are doubly-excited configurations due to an (dielectronic) electron capture into the given multiplets, for which the total energy is expected to be in the interval Einitial < ECaptured < E_initial + maxExcitationEnergy. A ConfList::Array{Configuration,1} is returned that contains all the doubly-excited configurations. Moreover, a neat table of all configurations is printed to check and control for the correct input.

    In practice, the generation of useful doubly-excited configurations is not simple as long as no SCF computations
    are performed explicitly. We here apply the following strategy to keep the computations feasible:
    (1) Compute a mean-field basis for the coreConfList to obtain a proper set of orbitals.
    (2) Generate a set of hydrogenic orbitals for all (n,l) shells with n <= nMax and l <= lMax; the orbitals
        are generated for the nuclear charge Zeff = Z - NoElectrons(core) + 1
    (3) Set-up and diagonalize a multiplet for each doubly-excited configuration; determine eLowest, eHighest
        as the lowest and highest level energies.
    (4) Take the energy conditions in the sloppy form:
            eMin - 1. <= eLowest <= eMax + 1. || eMin - 1. <= eHighest <= eMax + 1.
        to make sure that no relevant configurations are missing
    (5) Report about energies   eMin, eLowest, eHighest eMax  
        to modify the energy condition if appropriate
source
JenaAtomicCalculator.Cascade.generateConfigurationList — Method

Cascade.generateConfigurationList(multiplets::Array{Multiplet,1}, further::Int64, NoShake::Int64) ... generates all possible (decay) configurations with up to further holes and with NoShake displacements with regard to the given multiplets. First, all configuratons are generated for which the hole is either moved 'outwards' or is moved and a second 'outer' hole is created; this step is repated further + 2 times to make sure that all relevant configurations are met. From the generated list, however, only those configurations are kept eventually with up to further holes, when compared to the configurations of the given multiplets. A confList::Array{Configuration,1} is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForElectronIonization — Method

Cascade.generateConfigurationsForElectronIonization(multiplets::Array{Multiplet,1}, scheme::ElectronIonizationScheme, nm::Nuclear.Model) ... generates the three sets of configurations of an excitation-autoionization cascade: the initial ones, the (inner-shell) excited ones with the same number of electrons, and the ionized ones with one electron less. A Tuple(initialConfList, excitedConfList, ionizedConfList) is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForExpansionOpacity — Method

Cascade.generateConfigurationsForExpansionOpacity(initialConfigs::Array{Configuration,1}, scheme::ExpansionOpacityScheme, nm::Nuclear.Model, grid::Radial.Grid) ... generates all excited configurations for the expansion opacity computations due the given fromShells, toShells and number of excited electrons. A confList::Array{Configurations,1} is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForHollowIons — Method

Cascade.generateConfigurationsForHollowIons(initialConfigs::Array{Configuration,1}, intoShells::Array{Shell,1}, decayShells::Array{Shell,1}, noElectrons::Int64) ... generates all possible configurations as obtained by the capture of noElectrons into the intoShells. A confList::Array{Configuration,1} is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForImpactExcitation — Method

Cascade.generateConfigurationsForImpactExcitation(multiplets::Array{Multiplet,1}, scheme::ImpactExcitationScheme, nm::Nuclear.Model) ... generates all possible (electron-impact excited) configurations due to the single excitation scheme.fromShells to scheme.toShells with regard to the given mutiplets. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForPhotoexcitation — Method

Cascade.generateConfigurationsForPhotoexcitation(multiplets::Array{Multiplet,1}, scheme::PhotoExcitationScheme, nm::Nuclear.Model) ... generates all possible (photo-excited) configurations with upto scheme.NoExcitations of displacements of electron from scheme.excitationFromShells to scheme.excitationToShells with regard to the given mutiplets. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForPhotoionization — Method

Cascade.generateConfigurationsForPhotoionization(multiplets::Array{Multiplet,1}, scheme::PhotoIonizationScheme, nm::Nuclear.Model) ... generates the configurations reached by removing ONE electron from each of scheme.excitationFromShells, which is what a photoionization cascade needs; no bound-bound excitation is generated here, so neither scheme.excitationToShells nor scheme.lValues is read by this method. A Tuple(initialConfList::Array{Configuration,1}, ionConfList::Array{Configuration,1}) is returned, the first holding the reference configurations of the given multiplets and the second the photo-ionized ones.

source
JenaAtomicCalculator.Cascade.generateConfigurationsForResonantIonization — Method

Cascade.generateConfigurationsForResonantIonization(multiplets::Array{Multiplet,1}, scheme::Cascade.ElectronIonizationScheme, nm::Nuclear.Model) ... generates the DOUBLY-EXCITED configurations of the resonant channels, i.e. those reached by capturing the incident electron into one of scheme.intoShells while exciting a further electron from scheme.excitationFromShells into scheme.excitationToShells, each carrying one electron MORE than the initial configurations.

    A Tuple(capturedConfList, decayConfList) is returned: the doubly-excited resonances themselves, and the
    (N+1)-electron configurations they can radiate INTO, which are needed for the resonance's radiative width.

    The generation is delegated to `Basics.ForDielectronicRecombination`, the same configuration theme that
    `Cascade.DielectronicRecombinationScheme` uses -- these resonances ARE dielectronic-capture resonances, and only
    their subsequent decay distinguishes the two schemes, so building them by a second route would be an invitation
    for the two to drift apart.

    The intermediate and final configurations of these channels are NOT generated here: they are the very same
    inner-shell excited and ionized lists that the impact-excitation channel already builds, which is what lets the
    two channels share one scheme at all.

    An explanatory error is raised if no intoShells were given -- a resonant channel without a capture shell has
    nothing to capture into, and would otherwise fail later and less clearly.
source
JenaAtomicCalculator.Cascade.generateMeanFieldOrbitals — Method

Cascade.generateMeanFieldOrbitals(comp::Cascade.Computation, confs::Array{Configuration,1}) ... generates one common set of bound orbitals from a mean-field basis spanning the given configurations. A Dict{Subshell, Orbital} is returned.

source
JenaAtomicCalculator.Cascade.interpolateIonizationCS — Method

Cascade.interpolateIonizationCS(photonEnergy::Float64, ionizationCS::Array{Basics.ScalarProperty{EmProperty},1}) ... interpolates (or extrapolates) the ionization cross sections as defined by ionizationCS for the given photonEnergy. If photonEnergy is outside the photon energies from ionizationCS, simply the cross section from the nearest energy is returned; if photonEnergy lays between two photon energies from ionizationCS, a simple linear interpolation rules is applied here. A cs::Basics.EmProperty is returned.

source
JenaAtomicCalculator.Cascade.jacVersion — Method

Cascade.jacVersion() ... returns the version of the JenaAtomicCalculator package as a String, or "unknown" if it cannot be determined; used only to stamp stored cascade data.

source
JenaAtomicCalculator.Cascade.matchesGate — Method

Cascade.matchesGate(gate::Cascade.ElectronGate, emission::Tuple{Basics.AbstractProcess,Float64}) ... true if the emission is an electron within the gate's energy window. A Bool is returned.

source
JenaAtomicCalculator.Cascade.matchesGate — Method

Cascade.matchesGate(gate::Cascade.PhotonGate, emission::Tuple{Basics.AbstractProcess,Float64}) ... true if the emission is a photon within the gate's energy window. A Bool is returned.

source
JenaAtomicCalculator.Cascade.modifySteps — Method

Cascade.modifySteps(stepList::Array{Cascade.Step,1}) ... allows the user to modify the steps, for instance, by deleting selected steps of the cascade or by modifying the settings of one or several steps. A newStepList::Array{Cascade.Step,1} for which the transition data are eventually computed.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::Cascade.DielectronicCaptureScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... sets up and performs a dielectronic-CAPTURE cascade: the capture of a free electron into doubly-excited levels, together with the autoionization of those levels back into the target – both into its GROUND state, which is the capture channel itself, and into its EXCITED states, which is what turns a capture into a contribution to electron-impact EXCITATION. No radiative stabilization is computed; that path is dielectronic recombination and belongs to Cascade.DielectronicRecombinationScheme. A results::Dict{String,Any} is returned if output=true, and nothing otherwise.

    THREE GROUPS OF CONFIGURATIONS are built, and the third is what distinguishes this from a plain capture calculation:
      * the initial target, N electrons, from comp.initialConfigs;
      * the EXCITED target, also N electrons, by exciting one electron from scheme.excitationFromShells into
        scheme.excitationToShells.  These are the exit channels of a resonant excitation;
      * the doubly-excited resonances, N+1 electrons, from Basics.ForDielectronicRecombination.
    Auger steps are then generated from every resonance block to every N-electron block, ground and excited alike, so that each
    resonance carries both its capture width (the channel back to the ground state) and its excitation widths. A TOTAL
    impact-excitation cross section still has to be assembled from these: the resonant contribution is the capture strength times the
    branching ratio into the excited exit channel, and it adds to the direct cross section of Cascade.ImpactExcitationScheme.

    WHICH RESONANCES CONTRIBUTE TO EXCITATION, and this is easy to get wrong. A resonance can only autoionize into a target state that
    lies BELOW it, and the 1s 2l nl' series converges to the 1s2l threshold FROM BELOW however large n is taken. Capturing into ever
    higher n therefore never opens the 1s->2l excitation channel. What opens it is a resonance built on the SAME core excitation as the
    capture: 1s 3l 3l' lies above 1s2l and autoionizes into it. In practice scheme.intoShells must reach the same principal quantum
    number as scheme.excitationToShells.

    Measured for He-like carbon, which is the case to reason from. With excitationToShells = 2l and intoShells = 2l, all 16 K-LL
    resonances (229-255 eV) autoionize ONLY to 1s^2: pure dielectronic capture, no excitation. With excitationToShells = {2l,3l} and
    intoShells = 3l, the 507 lines split into 129 back to 1s^2 (268-335 eV) and 378 into 1s2s and 1s2p, the latter ejecting electrons
    of 12-37 eV. The 1s2s and 1s2p ejection energies differ by the 2s-2p separation of the target, which is a free consistency check.

    The capture and excitation lines are AutoIonization.Line's -- a capture is the time reverse of an Auger transition -- and are
    returned under "dielectronic-capture lines:" as well as in a Cascade.Data{AutoIonization.Line}.
source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a dielectronic-recombination (DR) plasma rate coefficient computation that combines the electron capture and the subsequent radiative stabilization steps. It starts from a given set of initial configurations xor initial multiplets and (1) generates all doubly-excited configurations due to the capture of an electron with a given maximum electron energy; (2) selects all electron capture (inverse Auger) and re-autoionization (Auger) steps and (3) selects all steps for radiative stabilization due to the given parameters of the scheme::DielectronicRecombinationScheme. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{PhotoEmission.Line} and Cascade.Data{AutoIonization.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-dr-rate-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::ElectronExcitationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... sets up and performs an electron-excitation cascade computation. The scheme covers two channels and selects them by its own processes list: Basics.ImpactExc() requests the DIRECT electron-impact excitation, and Basics.ImpactExcAuto() the RESONANT part, i.e. dielectronic capture followed by re-autoionization. Typical properties are energy-dependent collision strengths, impact-excitation cross sections and effective collision strengths. A results::Dict{String,Any} is returned if output=true, and nothing otherwise; with outputToFile=true the same dictionary is written to a .jld file for use in a subsequent cascade simulation.

    The direct channel hands the scheme's own configuration -- shells, l-values, free-electron grid and energy shift -- to a
    Cascade.ImpactExcitationScheme, and raises if the shell lists are empty rather than failing further in.

    BOTH CHANNELS RUN since 16-Aug-2026. The resonant one delegates to Cascade.perform(::DielectronicCaptureScheme) and collects
    AutoIonization.Line's, a capture being the time reverse of an Auger transition. Until that date this function could not run at all:
    it read scheme.calcDirect, scheme.calcResonant and scheme.multipoles, none of which are fields of
    Cascade.ElectronExcitationScheme, so it raised on the first line that touched the scheme.
source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::ElectronIonizationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform an electron-impact ionization cascade computation for the given initial configurations xor initial multiplets. The method first rejects a scheme that requests no channel at all, and then generates the three sets of configurations – impact excitation, autoionization and radiative stabilization – groups each into cascade blocks and computes the lines of every step. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data of ImpactExcitation.Line, AutoIonization.Line and PhotoEmission.Line that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-electron-ionization-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::ExpansionOpacityScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform an expansion opacity computation. It starts from a given set of initial configurations xor initial multiplets and (1) generates all excited configurations with regard to the initial configuration, (2) selects all radiative photoabsorption steps and (3) computes the corresponding transition amplitudes. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{PhotoExcitation.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-expansion-opacity-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::HollowIonScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a hollow-ion cascade computation, i.e. the decay of an ion whose inner shells are empty. It starts from the initial configurations of comp and generates the configurations that the capture into scheme.intoShells and the subsequent decay within scheme.decayShells give rise to; it then groups them into cascade blocks and computes the radiative and the autoionization lines of every step. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data of PhotoEmission.Line and AutoIonization.Line that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-hollow-ion-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise. The same data is additionally stored under the key "hollow-ion line data:".

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::ImpactExcitationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform an electron-impact excitation computation that starts from a given set of initial configurations xor initial multiplets and comprises the impact excitation from the scheme's fromShells into its toShells. All configurations are constructed with regard to the initial configurations. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{ImpactExcitation.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-impact-excitation-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::PhotoAbsorptionScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a photoabsorption cascade computation that accounts for both the direct and the resonant part of photoabsorption. Apart from the direct photoionization of the atom, it enables one to treat the photoexcitation and the subsequent electron emission (autoionization) in the cascade. Typical photoabsorption properties are energy-dependent photoionization cross sections, photoabsorption spectra, PI plasma rate coefficients and others. The method runs the photoionization and the photoexcitation part in turn and merges their results. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data of the two parts that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-photoabsorption-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::PhotoExcitationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a photoexcitation cascade computation that starts from a given set of initial configurations xor initial multiplets and comprises the photoexcitation processes into configurations with up to NoExcitations single-electron excitations with regard to the initial multiplets. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{PhotoExcitation.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-photoexcitation-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::PhotoIonizationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a photoionization cascade computation. It starts either from comp.initialConfigs, for which an SCF and CI computation is carried out first, xor from the given comp.initialMultiplets; it then generates the configurations that the removal of one electron from each of scheme.excitationFromShells gives rise to, groups them into cascade blocks, determines the individual steps and computes the PhotoIonization.Line's of every step for the photon energies in scheme.photonEnergies. All intermediate and final results are printed to screen and to the summary file. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the photoionization lines, and the Cascade.Data{PhotoIonization.Line} under the key "cascade data:", which is the key a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-photoionization-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::RadiativeRecombinationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a radiative-recombination (RR) plasma rate coefficient computation, based on all selected electron capture steps. It starts from a given set of initial configurations xor initial multiplets and (1) generates all singly-excited configurations due to the capture of an electron with a given maximum electron energy and (2) selects all steps for radiative recombination due to the given parameters of the scheme::RadiativeRecombinationScheme. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{PhotoRecombination.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-rr-rate-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(simulation::Cascade.Simulation; output::Bool=false) ... to simulate a cascade decay (and excitation) from the given data. Different computational methods and different properties of the ionic system, such as the ion distribution or the final-level distribution, can be derived and displayed from these simulations. The details of course depend strongly on the atomic processes and data generated beforehand by performing a computation::Cascade.Computation. The results of all individual steps are printed to screen. With output = false, nothing is returned otherwise; with output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – whose keys depend on the method and the specifications of the cascade.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a stepwise-decay cascade computation that starts from a given set of initial configurations and proceeds via the radiative and non-radiative steps of the scheme until a given number of electrons has been removed or the decay stops at some stable levels. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data of PhotoEmission.Line and AutoIonization.Line that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-decay-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.propagateProbability! — Method

Cascade.propagateProbability!(levels::Array{Cascade.Level,1}) ... propagates the relative level occupation through the levels of the cascade until no further change occurs. The argument levels is modified during the propagation.

    A  fluxes::Array{Cascade.LineFlux,1}  is returned: one record per line that probability has flowed
    through, carrying the process, the energy of the emitted particle, the flux itself, and the indices of
    the initial and final level. Observables are NOT collected here -- each simulation property derives
    what it needs afterwards, see Cascade.extractIntensities. Until 05-Aug-2026 this function took
    collectPhotonIntensities/collectElectronIntensities keywords, could honour only one at a time
    (error("stop a")), and so had to be re-run in full for a second observable; a photon-electron
    coincidence could not be expressed at all.
source
JenaAtomicCalculator.Cascade.pushLevels! — Method

Cascade.pushLevels!(levels::Array{Cascade.Level,1}, newLevel::Cascade.Level) ... push's the information of newLevel of levels. This is the standard 'push!(levels, newLevel)' if newLevel is not yet including in levels, and the proper modification of the parent and daughter lines of this level otherwise. The argument levels::Array{Cascade.Level,1} is modified and nothing is returned otherwise.

source
JenaAtomicCalculator.Cascade.resonantExcitationRateCoefficient — Method

Cascade.resonantExcitationRateCoefficient(strengths::Array{<:NamedTuple,1}, temp::Float64) ... converts the resonance strengths of Cascade.resonantExcitationStrengths into a plasma rate coefficient at the electron temperature temp [K], in the isolated-resonance (delta-like) approximation and with the same prefactor that DielectronicRecombination.computeRateCoefficient uses,

        alpha(T) = 4/sqrt(2 pi) * T^(-3/2) * sum_d E_d * exp(-E_d/T) * S_d

    An alpha::Float64 is returned in cm^3/s. Summing over all entries gives the total resonant contribution; filter the vector by
    finalLevel first to obtain the contribution to one excitation channel.
source
JenaAtomicCalculator.Cascade.resonantExcitationStrengths — Method

Cascade.resonantExcitationStrengths(lines::Array{AutoIonization.Line,1}; totalPhotonRates::Dict{Int64,Float64}=Dict{Int64,Float64}()) ... assembles the RESONANT contribution to electron-impact excitation from the autoionization lines of a dielectronic-capture cascade, i.e. from the output of Cascade.perform(::Cascade.DielectronicCaptureScheme). Each doubly-excited resonance m is formed by capture from the ground level i and then decays; the part that ends on an EXCITED target level f is an excitation that went through a resonance. Its integrated cross section (resonance strength) follows JAC's dielectronic-recombination convention,

        C(i,m) = pi^2 / k^2 * A_a(m->i) * (2J_m+1)/(2J_i+1),      k^2 = 2 E_res
        S(i->m->f) = C(i,m) * A_a(m->f) / (Gamma_a + Gamma_r),    Gamma_a = sum_k A_a(m->k)

    which is the same expression the DR strength uses with the radiative width Gamma_r in the numerator replaced by the Auger width
    into the excited channel. A vector of named tuples (resonance, finalLevel, energy, strength) is returned, with the energy in atomic
    units and the strength in a_0^2 * Hartree.

    Gamma_r DEFAULTS TO ZERO, because a capture cascade computes no radiative rates. Neglecting it OVERESTIMATES every branching ratio,
    and the error grows with the nuclear charge, where radiative stabilization competes with autoionization. Pass totalPhotonRates,
    keyed on the resonance level index, whenever those rates are available.

    The ground level is identified as the target level of LOWEST energy among the lines, so the capture channel is the line that ends
    on it; every other final level is treated as an excitation channel.
source
JenaAtomicCalculator.Cascade.reviewData — Method

Cascade.reviewData(simulation::Cascade.Simulation; ascendingOrder::Bool=false) ... reviews and displays the (computation) data for the given simulation; these data contains the name of the data set, its initial and generated multiplets for the various blocks of (some part of the ionization and/or decay) cascade as well as all the line data [lineR, linesA, lineP, ...]. From these data, this function also generates and returns the level tree that is to be used in the subsequent simulations, and where levels are odered in `ascending' order if selected.

source
JenaAtomicCalculator.Cascade.rosselandWeights — Method

Cascade.rosselandWeights(noNodes::Int64) ... returns the Gauss-Laguerre nodes u_i of the temperature-normalised variable u = omega/kT together with the NORMALISED Rosseland weights

        w(u) = 15/(4 pi^4) u^4 e^-u / (1 - e^-u)^2 ,        int_0^inf w(u) du = 1 .

    Gauss-Laguerre supplies the factor e^-u, so only 15/(4 pi^4) u^4 / (1 - e^-u)^2 is evaluated against
    its weights. The prefactor is EXACT rather than fitted, because
    int_0^inf u^4 e^u/(e^u-1)^2 du = 4 int_0^inf u^3/(e^u-1) du = 4 Gamma(4) zeta(4) = 4 pi^4/15.
    Measured 14-Aug-2026: eight nodes give sum_i w_i = 1 to 2.8e-6, sixteen to 1.8e-11. Eight is ample
    here, and that residue is the accuracy floor of every mean built on these weights -- the grey and
    Thomson known-answer checks in TestFrames.testMethod_Opacities reproduce their exact values to
    precisely this 2.8e-6 and to nothing better, which is how one knows the deviation is the quadrature
    and not the physics.

    A tuple (nodes::Array{Float64,1}, weights::Array{Float64,1}) is returned.
source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.AbstractSimulationProperty, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... carries out the simulation that the given property asks for, by the given method. A method is defined for every supported (property, method) combination; this fallback catches the rest and names what is missing, rather than letting the request pass silently. NOTHING is returned because this method RAISES: it is the fallback for a property and method combination that is not implemented.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.DrRateCoefficients, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates dielectronic-recombination rate coefficients. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.EaCrossSections, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates the excitation-autoionization contribution to the electron-impact ionization cross section from the ImpactExcitation.Line's and AutoIonization.Line's of a previous ElectronIonizationScheme computation. Only those excited levels that carry at least one Auger line contribute, i.e. exactly the autoionizing ones. An Array{Basics.ScalarProperty{Float64},1} of (impact energy, sigma^EA) is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.EieRateCoefficients, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates electron-impact excitation rate coefficients and effective collision strengths from the ImpactExcitation.Line's of a previous cascade computation. The lines carry a cross section and a collision strength for each incident energy; this method interpolates the collision strengths over energy and integrates them against a Maxwellian at the requested temperatures. An Array{ImpactExcitation.RateCoefficients,1} is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.EiiRateCoefficients, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates the electron-impact ionization plasma rate coefficients, summed over whichever of the resonant and excitation-autoionization channels the cascade data contain. An Array{Basics.EmProperty,1} in cm^3/s is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.ElectronIntensities, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates the emitted electron (Auger) spectrum. An energiesInts::Array{Tuple{Float64,Float64},1} of (energy, relative intensity) is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.ExpansionOpacities, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates expansion opacities. An Array{Basics.EmProperty,1} in [cm^2/g], one entry per property.dependencyValues, is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.FinalLevelDistribution, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates the final level distribution. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.IonDistribution, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates the final ion (charge-state) distribution. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.MeanOpacities, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates mean (Rosseland or Planck) opacities. An Array{Basics.EmProperty,1} carrying the mean opacities, in the order they are printed, is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.ParticleCoincidences, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates a coincidence spectrum. An Array{Tuple{Float64,Float64},1} of (energy, intensity) is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.PhotoAbsorptionSpectrum, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates the photo-absorption spectrum. The absorption cross sections are returned as lists, as Cascade.simulatePhotoAbsorptionSpectrum gives them.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.PhotonIntensities, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates the emitted photon (fluorescence) spectrum. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.PiRateCoefficients, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates the photoionization rate per ion by folding the cascade's cross sections with the given photon fields. An Array{Basics.EmProperty,1} in 1/s is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.RelaxationCurve, method::Cascade.ProbPropagation, simulation::Cascade.Simulation) ... simulates the mean relaxation time of the cascade. A tuple of two Array{Float64,1} – the relaxation percentages and the mean relaxation times belonging to them – is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.ResonantIonizationStrengths, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates the resonant contribution to electron-impact ionization. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulate — Method

Cascade.simulate(property::Cascade.RrRateCoefficients, method::Cascade.AbstractSimulationMethod, simulation::Cascade.Simulation) ... simulates radiative-recombination rate coefficients. An Array{Basics.EmProperty,1} of RR plasma rate coefficients is returned.

source
JenaAtomicCalculator.Cascade.simulateEiiRateCoefficients — Method

Cascade.simulateEiiRateCoefficients(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... forms the electron-impact ionization plasma rate coefficient alpha^EII (T) by adding whichever of its channels the given cascade data contain, and reports the breakdown rather than only the sum. An Array{Basics.EmProperty,1} of length length(property.temperatures) is returned, in cm^3/s.

source
JenaAtomicCalculator.Cascade.simulateElectronIntensities — Method

Cascade.simulateElectronIntensities(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... simulates the (relative) intensities of the ELECTRONS emitted during the cascade, i.e. the Auger spectrum, as a function of the electron energy. This is the exact counterpart of Cascade.simulatePhotonIntensities: the same probability propagation is run through the cascade tree, but the emitted energy is collected at the Auger rather than at the radiative steps. For a K-shell hole in a light element the electron spectrum carries most of the decay, since the fluorescence yield is small, so this is usually the more informative of the two.

    The propagation machinery for this already existed -- Cascade.propagateProbability! had taken a
    collectElectronIntensities keyword all along, and collected (energy, intensity) at every
    Basics.Auger() daughter -- but nothing ever called it: Cascade.perform(simulation) had no branch for
    ElectronIntensities and there was no simulate function to reach. Only the wiring was missing. Since
    05-Aug-2026 the propagation records the flux through every line instead, and the Auger emissions are
    selected from those records by Cascade.extractIntensities.

    An  energiesInts::Array{Tuple{Float64,Float64},1}  of (energy, relative intensity) is returned.
source
JenaAtomicCalculator.Cascade.simulateExpansionOpacities — Method

Cascade.simulateExpansionOpacities(photoexcitationData::Array{Cascade.Data,1}, name::String, property::Cascade.ExpansionOpacities; printout::Bool=true) ... runs through all excitation lines, sums up their contributions and form a (list of) expansion opacities for the given parameters; printout decides whether the result is also displayed, but never whether it is returned. An Array{Basics.EmProperty,1} in [cm^2/g], one entry per property.dependencyValues, is returned.

source
JenaAtomicCalculator.Cascade.simulateFinalLevelDistribution — Method

Cascade.simulateFinalLevelDistribution(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... sorts all levels as given by data and propagates their (occupation) probability until no further changes occur. For this propagation, it runs through all levels and propagates the probability until no level probability changes anymore. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulateIonDistribution — Method

Cascade.simulateIonDistribution(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... sorts all levels as given by data and propagates their (occupation) probability until no further changes occur. For this propagation, it runs through all levels and propagates the probabilty until no level probability changes anymore. The final level distribution is then used to derive the ion distribution or the level distribution, if appropriate. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulateLevelDistribution — Method

Cascade.simulateLevelDistribution(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... sorts all levels as given by data and propagates their (occupation) probability until no further changes occur. For this propagation, it runs through all levels and propagates the probabilty until no level probability changes anymore. The final level distribution is then used to derive the ion distribution or the level distribution, if appropriate. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulateMeanOpacities — Method

Cascade.simulateMeanOpacities(photoexcitationData::Array{Cascade.Data,1}, simulation::Cascade.Simulation) ... runs through all excitation lines, assembles the spectral opacity kappa(u_i) on the eight Gauss-Laguerre nodes of the temperature-normalised variable u = omega/kT, and reduces it to the MEAN named by simulation.property.opacityMean – RosselandMean() or PlanckMean(). One value in [cm^2/g] is printed for each (rho, T) pair, in both gauges. An Array{Basics.EmProperty,1} carrying those means, in the order printed – mass densities outermost, temperatures innermost – is returned.

source
JenaAtomicCalculator.Cascade.simulateParticleCoincidences — Method

Cascade.simulateParticleCoincidences(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... simulates a coincidence measurement: the spectrum of the observed particle, restricted to those decay pathways in which every gate is satisfied. Gates are matched in emission order, and the observed particle is the emission FOLLOWING the last gate; a Cascade.ChargeStateGate among the gates is instead applied to the charge state that the pathway ends in. All energies are in ATOMIC UNITS, as everywhere else in these properties. An Array{Tuple{Float64,Float64},1} of (energy, intensity) is returned.

source
JenaAtomicCalculator.Cascade.simulatePhotoAbsorptionSpectrum — Method

Cascade.simulatePhotoAbsorptionSpectrum(simulation::Cascade.Simulation, linesP::Array{PhotoIonization.Line,1}, linesE::Array{PhotoExcitation.Line,1}) ... cycle through all lines and (incident photon) energies to derive the overall photo-absorption spectrum. The procedure interpolates the photoionization and 'adds' the photoexcitation cross sections to obtain the total photoabsorption CS. A linear interpolation is used inside of the energy interval, for which photoionization lines and cross sections have been calculated before. No extrapolation of cross sections is done here. It is also assumed that the same initial levels (indices) appear in the photoionization and photoexcitation lines. Moreover, energy units must be one of "eV", "Kayser", "Hartree"]. All absorption cross sections are displayed in a neat table and are returned as lists.

source
JenaAtomicCalculator.Cascade.simulatePhotonIntensities — Method

Cascade.simulatePhotonIntensities(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... sorts all levels as given by data and propagates their (occupation) probability until no further changes occur. For this propagation, it runs through all levels and propagates the probabilty until no level probability changes anymore. The final level distribution is then used to derive the ion distribution or the level distribution, if appropriate. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulatePiRateCoefficients — Method

Cascade.simulatePiRateCoefficients(simulation::Cascade.Simulation) ... folds the photoionization cross sections of the cascade data with each of the given photon fields and reports the photoionization rate per ion. An Array{Basics.EmProperty,1} in 1/s, one entry per field, is returned.

source
JenaAtomicCalculator.Cascade.simulateRelaxationCurve — Method

Cascade.simulateRelaxationCurve(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... determine the mean relaxation time until 70%, 80%, 90% of the initially occupied levels decay down to the ground configurations. A TUPLE of two Array{Float64,1} is returned: the relaxation percentages [0.7, 0.8, 0.9] and the mean relaxation times belonging to them. Until 07-Nov-2026 this said an relaxTimes::Array{Float64,1} alone, which the code has never returned – return( relaxPercentage, relaxTimes ) – so a caller taking the value as one array got the percentages and silently lost the times.

source
JenaAtomicCalculator.Cascade.simulateResonantIonizationStrengths — Method

Cascade.simulateResonantIonizationStrengths(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... displays the resonance strengths of the resonant electron-capture channels of electron-impact ionization, beside the dielectronic-recombination strength of the same resonances. Nothing is returned.

source
JenaAtomicCalculator.Cascade.simulateRrRateCoefficients — Method

Cascade.simulateRrRateCoefficients(lines::Array{PhotoRecombination.Line,1}, simulation) ... Integrates over all selected cross sections in order to determine the RR plasma rate coefficients for a Maxwellian distribution. An alphaRR::Array{Basics.EmProperty,1} of RR plasma rate coefficients is returned.

source
JenaAtomicCalculator.Cascade.sortByEnergy — Method

Cascade.sortByEnergy(levels::Array{Cascade.Level,1}; ascendingOrder::Bool=false) ... sorts all levels by energy and assigns the occupation as given by the simulation An Array{Cascade.Level,1}, sorted by energy, is returned.

source
JenaAtomicCalculator.Cascade.specifyInitialOccupation! — Method

Cascade.specifyInitialOccupation!(levels::Array{Cascade.Level,1}, leadingConfigs::Array{Configuration,1}) ... specifies the initial occupation of levels for the given leadingConfigs; it modifies the occupation but returns nothing otherwise.

source
JenaAtomicCalculator.Cascade.specifyInitialOccupation! — Method

Cascade.specifyInitialOccupation!(levels::Array{Cascade.Level,1}, initialOccupations::Array{Tuple{Int64,Float64},1}) ... specifies the initial occupation of levels for the given relOccupation; it modifies the occupation but returns nothing otherwise.

source
JenaAtomicCalculator.Cascade.spectralOpacityContribution — Method

Cascade.spectralOpacityContribution(contribution::Cascade.BoundBoundOpacity, photoexcitationData::Array{Cascade.Data,1}, property::Cascade.MeanOpacities, nion::Float64, rho::Float64, T::Float64, ulist::Array{Float64,1}) ... returns the bound-bound (line) contribution to the spectral opacity at the given nodes, by handing the work to Cascade.simulateExpansionOpacities. An Array{Basics.EmProperty,1} in [cm^2/g] is returned.

source
JenaAtomicCalculator.Cascade.spectralOpacityContribution — Method

Cascade.spectralOpacityContribution(contribution::Cascade.BoundFreeOpacity, photoexcitationData::Array{Cascade.Data,1}, property::Cascade.MeanOpacities, nion::Float64, rho::Float64, T::Float64, ulist::Array{Float64,1}) ... returns the bound-free contribution kappanu^bf = nion sumshells sigma^PI(omega) / rho at the given nodes, with the cross sections from Empirical.photoionizationCrossSection in the ScaledHydrogenic approximation. The nodes ui are converted to photon energies omegai = ui kT, and the cross sections from atomic units (a_0^2) to cm^2. Being a continuum, this contribution carries NO lambda/Delta-lambda bin factor. An Array{Basics.EmProperty,1} in [cm^2/g] is returned; the estimate is gauge-independent, so both components carry the same value.

    Empirical.photoionizationCrossSection reads the nuclear charge from the GLOBAL Defaults, which is
    1.0 unless set. It is therefore set here from contribution.nuclearCharge and restored afterwards,
    so that a forgotten setDefaults cannot silently produce hydrogen cross sections for another element.
source
JenaAtomicCalculator.Cascade.spectralOpacityContribution — Method

Cascade.spectralOpacityContribution(contribution::Cascade.ScatteringOpacity, photoexcitationData::Array{Cascade.Data,1}, property::Cascade.MeanOpacities, nion::Float64, rho::Float64, T::Float64, ulist::Array{Float64,1}) ... returns the Thomson-scattering contribution kappa^sc = ne sigmaT / rho, which is INDEPENDENT of frequency and therefore identical in every bin, and gauge-independent so that both components of the EmProperty carry the same value. An Array{Basics.EmProperty,1} in [cm^2/g] is returned.

source
JenaAtomicCalculator.Cascade.truncateEnergiesIntensities — Method

Cascade.truncateEnergiesIntensities(energiesInts::Array{Tuple{Float64,Float64},1}, minPhotonEnergy::Float64, maxPhotonEnergy::Float64) ... reduces and truncates the energies & intensities energiesInts; 'reduce' hereby refer to omit all intensity < 1.0e-8, while 'truncate' omits all energies outside of the interval [minPhotonEnergy, miaxPhotonEnergy]. An newEnergiesInts::Array{Tuple{Float64,Float64},1} is returned.

source
JenaAtomicCalculator.Cascade.validateConditions — Method

Cascade.validateConditions(approach::Basics.AbstractCascadeApproach) ... checks, at cascade set-up time, that the requested approach can actually be realized. Conditions that are not implemented raise an error here, before any orbital or amplitude work is done, so that a cascade which cannot succeed fails in the first second rather than in the middle of some step. The one exception is the continuum exchange, which only warns: an approach that merely ASKS for exchange stays usable for everything else it offers. Nothing is returned.

source
JenaAtomicCalculator.Cascade.walkPathways! — Method

Cascade.walkPathways!(levels::Array{Cascade.Level,1}, index::Int64, prob::Float64, emissions::Array{Tuple{Basics.AbstractProcess,Float64},1}, cutoff::Float64, pathways::Array) ... walks the cascade tree from the level with the given index, follows every branch while accumulating the probability along it, and records one entry per completed PATHWAY: the ordered list of emissions (process and energy of each emitted particle), the index of the level the pathway ends in, and the probability of the pathway as a whole. Nothing is returned; pathways is appended to.

    This is deliberately not what Cascade.propagateProbability! does. The propagation yields the total flux
    through each line, which is all a singles spectrum needs, but it forgets by which route the probability
    arrived. A coincidence is a statement about routes -- the JOINT probability that one particle was
    emitted AND then another -- so pathways have to be kept intact. Cascade.Level's `daughters` links are
    what make this possible at all.

    Branches whose probability falls below `cutoff` are terminated: pathway counts multiply with cascade
    depth, and a deep cascade is not otherwise enumerable.
source
JenaAtomicCalculator.Cascade.writeDataFile — Method

Cascade.writeDataFile(filename::String, results::Dict{String,Any}) ... stamps results with Cascade.dataFormatStamp() and writes it to filename with JLD2; nothing is returned. Every cascade that stores its results goes through here, so that the stamp cannot be forgotten at one of the fourteen call sites.

source

Dielectronic recombination scheme

JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested capture & transition amplitudes as well as DielectronicCapture.Line's, AutoIonization.Line's, etc. for all pre-specified decay steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.CaptureData is returned.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, capturedList::Array{Cascade.Block,1}, decayList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this dielectronic cascade. It considers the autoionization between the blocks from the captureList and initialList as well as the radiative stabilization between the blocks from the captureList and decayList. It checks that at least on pair of levels supports either an electron-capture' orradiative stabilization' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates/cross sections are computed.

source
JenaAtomicCalculator.Cascade.generateBlocks — Method

Cascade.generateBlocks(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, confs::Array{Configuration,1}; printout::Bool=true) ... generate all block::Cascade.Block's, that need to be computed for this electron-capture and subsequent stabilization (DR) cascade, and compute also the corresponding multiplets. The different cascade approches realized different strategies how these blocks are selected and computed. A blockList::Array{Cascade.Block,1} is returned.

source
JenaAtomicCalculator.Cascade.generateCaptureConfigurations — Method

Cascade.generateCaptureConfigurations(multiplets::Array{Multiplet,1}, coreConfList::Array{Configuration,1}, scheme::DielectronicRecombinationScheme, nm::Nuclear.Model, grid::Radial.Grid) ... checks and compiles are doubly-excited configurations due to an (dielectronic) electron capture into the given multiplets, for which the total energy is expected to be in the interval Einitial < ECaptured < E_initial + maxExcitationEnergy. A ConfList::Array{Configuration,1} is returned that contains all the doubly-excited configurations. Moreover, a neat table of all configurations is printed to check and control for the correct input.

    In practice, the generation of useful doubly-excited configurations is not simple as long as no SCF computations
    are performed explicitly. We here apply the following strategy to keep the computations feasible:
    (1) Compute a mean-field basis for the coreConfList to obtain a proper set of orbitals.
    (2) Generate a set of hydrogenic orbitals for all (n,l) shells with n <= nMax and l <= lMax; the orbitals
        are generated for the nuclear charge Zeff = Z - NoElectrons(core) + 1
    (3) Set-up and diagonalize a multiplet for each doubly-excited configuration; determine eLowest, eHighest
        as the lowest and highest level energies.
    (4) Take the energy conditions in the sloppy form:
            eMin - 1. <= eLowest <= eMax + 1. || eMin - 1. <= eHighest <= eMax + 1.
        to make sure that no relevant configurations are missing
    (5) Report about energies   eMin, eLowest, eHighest eMax  
        to modify the energy condition if appropriate
source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::Cascade.DielectronicCaptureScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... sets up and performs a dielectronic-CAPTURE cascade: the capture of a free electron into doubly-excited levels, together with the autoionization of those levels back into the target – both into its GROUND state, which is the capture channel itself, and into its EXCITED states, which is what turns a capture into a contribution to electron-impact EXCITATION. No radiative stabilization is computed; that path is dielectronic recombination and belongs to Cascade.DielectronicRecombinationScheme. A results::Dict{String,Any} is returned if output=true, and nothing otherwise.

    THREE GROUPS OF CONFIGURATIONS are built, and the third is what distinguishes this from a plain capture calculation:
      * the initial target, N electrons, from comp.initialConfigs;
      * the EXCITED target, also N electrons, by exciting one electron from scheme.excitationFromShells into
        scheme.excitationToShells.  These are the exit channels of a resonant excitation;
      * the doubly-excited resonances, N+1 electrons, from Basics.ForDielectronicRecombination.
    Auger steps are then generated from every resonance block to every N-electron block, ground and excited alike, so that each
    resonance carries both its capture width (the channel back to the ground state) and its excitation widths. A TOTAL
    impact-excitation cross section still has to be assembled from these: the resonant contribution is the capture strength times the
    branching ratio into the excited exit channel, and it adds to the direct cross section of Cascade.ImpactExcitationScheme.

    WHICH RESONANCES CONTRIBUTE TO EXCITATION, and this is easy to get wrong. A resonance can only autoionize into a target state that
    lies BELOW it, and the 1s 2l nl' series converges to the 1s2l threshold FROM BELOW however large n is taken. Capturing into ever
    higher n therefore never opens the 1s->2l excitation channel. What opens it is a resonance built on the SAME core excitation as the
    capture: 1s 3l 3l' lies above 1s2l and autoionizes into it. In practice scheme.intoShells must reach the same principal quantum
    number as scheme.excitationToShells.

    Measured for He-like carbon, which is the case to reason from. With excitationToShells = 2l and intoShells = 2l, all 16 K-LL
    resonances (229-255 eV) autoionize ONLY to 1s^2: pure dielectronic capture, no excitation. With excitationToShells = {2l,3l} and
    intoShells = 3l, the 507 lines split into 129 back to 1s^2 (268-335 eV) and 378 into 1s2s and 1s2p, the latter ejecting electrons
    of 12-37 eV. The 1s2s and 1s2p ejection energies differ by the 2s-2p separation of the target, which is a free consistency check.

    The capture and excitation lines are AutoIonization.Line's -- a capture is the time reverse of an Auger transition -- and are
    returned under "dielectronic-capture lines:" as well as in a Cascade.Data{AutoIonization.Line}.
source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a dielectronic-recombination (DR) plasma rate coefficient computation that combines the electron capture and the subsequent radiative stabilization steps. It starts from a given set of initial configurations xor initial multiplets and (1) generates all doubly-excited configurations due to the capture of an electron with a given maximum electron energy; (2) selects all electron capture (inverse Auger) and re-autoionization (Auger) steps and (3) selects all steps for radiative stabilization due to the given parameters of the scheme::DielectronicRecombinationScheme. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data{PhotoEmission.Line} and Cascade.Data{AutoIonization.Line} that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-dr-rate-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source
JenaAtomicCalculator.Cascade.resonantExcitationRateCoefficient — Method

Cascade.resonantExcitationRateCoefficient(strengths::Array{<:NamedTuple,1}, temp::Float64) ... converts the resonance strengths of Cascade.resonantExcitationStrengths into a plasma rate coefficient at the electron temperature temp [K], in the isolated-resonance (delta-like) approximation and with the same prefactor that DielectronicRecombination.computeRateCoefficient uses,

        alpha(T) = 4/sqrt(2 pi) * T^(-3/2) * sum_d E_d * exp(-E_d/T) * S_d

    An alpha::Float64 is returned in cm^3/s. Summing over all entries gives the total resonant contribution; filter the vector by
    finalLevel first to obtain the contribution to one excitation channel.
source
JenaAtomicCalculator.Cascade.resonantExcitationStrengths — Method

Cascade.resonantExcitationStrengths(lines::Array{AutoIonization.Line,1}; totalPhotonRates::Dict{Int64,Float64}=Dict{Int64,Float64}()) ... assembles the RESONANT contribution to electron-impact excitation from the autoionization lines of a dielectronic-capture cascade, i.e. from the output of Cascade.perform(::Cascade.DielectronicCaptureScheme). Each doubly-excited resonance m is formed by capture from the ground level i and then decays; the part that ends on an EXCITED target level f is an excitation that went through a resonance. Its integrated cross section (resonance strength) follows JAC's dielectronic-recombination convention,

        C(i,m) = pi^2 / k^2 * A_a(m->i) * (2J_m+1)/(2J_i+1),      k^2 = 2 E_res
        S(i->m->f) = C(i,m) * A_a(m->f) / (Gamma_a + Gamma_r),    Gamma_a = sum_k A_a(m->k)

    which is the same expression the DR strength uses with the radiative width Gamma_r in the numerator replaced by the Auger width
    into the excited channel. A vector of named tuples (resonance, finalLevel, energy, strength) is returned, with the energy in atomic
    units and the strength in a_0^2 * Hartree.

    Gamma_r DEFAULTS TO ZERO, because a capture cascade computes no radiative rates. Neglecting it OVERESTIMATES every branching ratio,
    and the error grows with the nuclear charge, where radiative stabilization competes with autoionization. Pass totalPhotonRates,
    keyed on the resonance level index, whenever those rates are available.

    The ground level is identified as the target level of LOWEST energy among the lines, so the capture channel is the line that ends
    on it; every other final level is treated as an excitation channel.
source

Stepwise decay scheme

JenaAtomicCalculator.Cascade.computeSteps — Method

Cascade.computeSteps(scheme::Cascade.StepwiseDecayScheme, comp::Cascade.Computation, stepList::Array{Cascade.Step,1}) ... computes in turn all the requested transition amplitudes as well as PhotoEmission.Line's, AutoIonization.Line's, etc. for all pre-specified decay steps of the cascade. When compared with standard computations of these atomic processes, however, the amount of output is largely reduced and often just printed into the summary file. A set of data::Cascade.DecayData is returned.

source
JenaAtomicCalculator.Cascade.determineSteps — Method

Cascade.determineSteps(scheme::Cascade.StepwiseDecayScheme, comp::Cascade.Computation, blockList::Array{Cascade.Block,1}) ... determines all step::Cascade.Step's that need to be computed for this decay cascade. It cycles through all processes of the given decay scheme and selects all pairs of blocks due to the selected cascade approach. It is checked that the (averaged) energies each block or level supports a `decay' within the step. A stepList::Array{Cascade.Step,1} is returned, and for which subsequently all required transition amplitudes and rates are computed.

source
JenaAtomicCalculator.Cascade.perform — Method

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true, outputDirectory::String="") ... to set-up and perform a stepwise-decay cascade computation that starts from a given set of initial configurations and proceeds via the radiative and non-radiative steps of the scheme until a given number of electrons has been removed or the decay stops at some stable levels. With output = false, nothing is returned. With output = true, a results::Basics.PerformResults is returned – an AbstractDict{String,Any} – that carries the initial and the generated multiplets, the individual line lists, and under the key "cascade data:" the Cascade.Data of PhotoEmission.Line and AutoIonization.Line that a subsequent Cascade.Simulation reads. With outputToFile = true the same data is written to a zzz-cascade-decay-computations-<date>.jld file, into outputDirectory when one is named and into the working directory otherwise.

source