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.

abstract type Cascade.AbstractCascadeApproach ... defines an abstract and a number of singleton types for the computational approach/model that is applied in order to generate and evaluate all many-electron amplitudes of a given cascade.

+ struct AverageSCA         
... all levels in the cascade are described in single-configuration and single-CSF approximation; this (rather crude) approach 
    neglects all configuration-interactions and also applies just a single set of one-electron orbitals (from the least-ionized charge
    state) for all considered charge states.
    
+ struct SCA                
... all levels in the cascade are described in single-configuration approximation but with 'mixtures' within the configuration;
    an individual mean-field is generated for each charge state and all continuum orbitals are generated for the correct transition
    energy in the field of the remaining ion. Moreover, all the fine-structure transitions are calculated individually.

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.

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

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

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 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 MeanRelaxationTime         ... simulate the mean relaxation times in which 70%, 80%, of the occupied levels
                                        decay 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).

Cascade.Block() ... constructor for an 'empty' instance of a Cascade.Block.

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.

Cascade.Computation(comp::Cascade.Computation;

        name=..,               nuclearModel=..,             grid=..,              asfSettings=..,     
        scheme=..,             approach=..,                 initialConfigs=..,    initialMultiplets=..)
        
... constructor for re-defining the computation::Cascade.Computation.

Cascade.Computation() ... constructor for an 'default' instance of a Cascade.Computation.

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.

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.

Cascade.DielectronicCaptureScheme() ... constructor for an 'default' instance of a Cascade.DielectronicCaptureScheme.

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

Cascade.DielectronicRecombinationScheme() ... constructor for an 'default' instance of a Cascade.DielectronicRecombinationScheme.

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

Cascade.DrRateCoefficients() ... (simple) constructor for cascade DrRateCoefficients.

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

Cascade.ElectronExcitationScheme() ... constructor for an 'default' instance of a Cascade.ElectronExcitationScheme.

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.
+ electronEnergies      ::Array{Float64,1}                
    ... List of electron energies for which this electron-impact excitation scheme is to be calculated.

Cascade.ElectronIntensities() ... (simple) constructor for cascade ElectronIntensities.

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.

Cascade.ElectronIonizationScheme() ... constructor for an 'default' instance of a Cascade.ElectronIonizationScheme.

struct Cascade.ElectronIonizationScheme <: Cascade.AbstractCascadeScheme ... to compute electron ionization spectra including the direct (EII) and resonant contributions, i.e. the dielectronic capture with subsequent double-autoionization. For this double autoionization, a branching factor is estimated. Typical electron-ionization properties are energy-dependent EII cross sections, effective collision strengths, EII plasma rate coefficients, and others (not yet).

+ 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 electron-impact excitation scheme is to be calculated.

Cascade.ExpansionOpacities() ... (simple) constructor for expansion opacity simulations.

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.

+ levelPopulation        ::Basics.AbstractLevelPopulation  
    ... to specify the kind of level population that is considered for the given opacity calculations.
+ opacityDependence      ::Cascade.AbstractOpacityDependence    
    ... to specify the dependence of the opacities [omega, lambda, (temperature-normalized) u]
+ ionDensity             ::Float64       ... ion density [in g/cm^3]
+ 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}
    ... values [in a.u.] for which the expansion opacity is to be calculated.

Cascade.ExpansionOpacityScheme() ... constructor for an 'default' instance of a Cascade.ExpansionOpacityScheme.

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.
+ meanEnergyShift       ::Float64                 
    ... Energy shift for all excited configurations [in a.u.]; this allows to correct for missing correlation 
        contributions.
+ 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 transition data for comparison, if true.

Cascade.FinalLevelDistribution() ... (simple) constructor for cascade FinalLevelDistribution.

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.

struct Cascade.FrequencyOpacityDependence <: Cascade.AbstractOpacityDependence ... to deal with omega-dependence opacities [omega] and a binning that need to be given in Hartree.

Cascade.HollowIonScheme() ... constructor for an 'default' instance of a Cascade.HollowIonScheme.

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

Cascade.ImpactExcitationScheme() ... constructor for an 'default' instance of a Cascade.ImpactExcitationScheme.

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

+ processes              ::Array{Basics.AbstractProcess,1} 
    ... List of the atomic processes that are supported and should be included into the cascade.
+ 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.
+ 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.
        
Either a list of electronEnergies or the NoFreeElectronEnergies can be specified; the program terminates, if "non-zero"
entries appears for these two subfields.

Cascade.ImpactIonizationScheme() ... constructor for an 'default' instance of a Cascade.ImpactIonizationScheme.

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

+ 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 electron-impact excitation scheme is to be calculated.

Cascade.IonDistribution() ... (simple) constructor for cascade IonDistribution data.

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

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.LineIndex,1}  ... list of parent lines that (may) populate the level.     
+ daugthers    ::Array{Cascade.LineIndex,1}  ... list of daugther lines that (may) de-populate the level.

struct Cascade.LineIndex{T} ... defines a line index with regard to the various lineLists of data::Cascade.LineIndex.

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

Cascade.MeanRelaxationTime() ... (simple) constructor for cascade MeanRelaxationTime.

struct Cascade.MeanRelaxationTime <: 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.

Cascade.PhotoAbsorptionScheme() ... constructor for an 'default' instance of a Cascade.PhotoAbsorptionScheme.

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.

Cascade.PhotoAbsorptionSpectrum() ... (simple) constructor for cascade PhotoAbsorptionSpectrum.

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

Cascade.PhotoExcitationScheme() ... constructor for an 'default' instance of a Cascade.PhotoExcitationScheme.

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.

Cascade.PhotoIonizationScheme() ... constructor for an 'default' instance of a Cascade.PhotoIonizationScheme.

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

Cascade.PhotonIntensities() ... (simple) constructor for cascade PhotonIntensities.

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

Cascade.PiRateCoefficients() ... (simple) constructor for cascade PiRateCoefficients.

struct Cascade.PiRateCoefficients <: Cascade.AbstractSimulationProperty ... defines a type for simulating the PI plasma rate coefficients as function of the (free) photon energy distribution and the plasma temperature. These coefficients included a convolution of the direct photoionization cross sections over the Maxwell distribution of electron and (if requested) add the pre-evaluated resonant parts afterwards.

    For the implementation: (1) Perform GL integration over free-electron contributions analog to the photoabsorption;
    (2) for the resonant part, simply add convoluted summation terms for all final states (to be worked out in detail);
    (3) use a electronEnergies grid ... instead of the photonEnergies grid.
    (4) in the direct part, sum over the final states before convolution

+ includeResonantPart ::Bool        ... True, if the resonant contributions are to be included.
+ 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 photoionization processes.
+ finalConfigurations ::Array{Configuration,1}

Cascade.RadiativeRecombinationScheme() ... constructor for an 'default' instance of a Cascade.RadiativeRecombinationScheme.

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

struct Cascade.RosselandOpacities <: Cascade.AbstractSimulationProperty ... defines a type for simulating the Rosseland 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.

+ levelPopulation        ::Basics.AbstractLevelPopulation  
    ... to specify the kind of level population that is considered for the given opacity calculations.
+ opacityDependence      ::Cascade.TemperatureOpacityDependence    
    ... to specify the dependence of the opacities in terms of (the temperature-normalized) u]
+ ionDensities           ::Array{Float64,1}      ... list of ion densities [in g/cm^3]
+ 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.

Cascade.RrRateCoefficients() ... (simple) constructor for cascade RrRateCoefficients.

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}

Cascade.Simulation(sim::Cascade.Simulation;

        name=..,               property=..,             method=..,              settings=..,     computationData=.. )
        
... constructor for re-defining the computation::Cascade.Simulation.

Cascade.Simulation() ... constructor for an 'default' instance of a Cascade.Simulation.

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

Cascade.SimulationSettings() ... constructor for an 'empty' instance of a Cascade.Block.

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.

Cascade.Step() ... constructor for an 'empty' instance of a Cascade.Step.

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.

Cascade.StepwiseDecayScheme() ... constructor for an 'default' instance of a Cascade.StepwiseDecayScheme.

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.

struct Cascade.TemperatureOpacityDependence <: Cascade.AbstractOpacityDependence ... to deal with temperature-normalized dependent opacities [u] and a binning that need to be given Hartree.

struct Cascade.WavelengthOpacityDependence <: Cascade.AbstractOpacityDependence ... to deal with wavelength-dependence opacities [lambda] and a binning that need always to be given in nm.

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

Basics.extractLeadingConfiguration(cLevel::Cascade.Level) ... extract the leading configuration of the given level; a conf::Configuration is returned.

Basics.isSimilar() ... 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.

Basics.perform(comp::Cascade.Computation) ... to set-up and perform a cascade computation that starts from a given set of initial configurations and proceeds via various steps until a given number of electrons has been removed or the decay stops at some stable levels with regard to the given atomic processes. The results of all individual steps are printed to screen but nothing is returned otherwise.

Basics.perform(comp::Cascade.Computation; output::Bool=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary; the particular output depends on the type and specifications of the cascade but can easily accessed by the keys of this dictionary.

Basics.perform(comp::Cascade.Simulation) ... to set-up and perform a cascade computation that starts from a given set of initial configurations and proceeds via various steps until a given number of electrons has been removed or the decay stops at some stable levels with regard to the given atomic processes. The results of all individual steps are printed to screen but nothing is returned otherwise.

Basics.perform(comp::Cascade.Simulation; output=true) ... to perform the same but to return the complete output in a dictionary; the particular output depends on the type and specifications of the cascade but can easily accessed by the keys of this dictionary.

Cascade.RosselandOpacities() ... (simple) constructor for RosselandOpacities opacity simulations.

Cascade.addLevels(levelsA::Array{Cascade.Level,1}, levelsB::Array{Cascade.Level,1}) ... adds two sets of levels so that each levels occurs only 'once' in the list; in practice, however, this 'addition' requires also that the parent and daughter processes are added properly so that all information is later available for the simulations. It is assumed here that all daugther and parent (processes) appear only once if levels from different data sets (Cascade.DecayData, Cascade.PhotoIonData) are added to each other. A message is issued about the number of levels before and after this 'addition', and how many of the levels have been modified by this method. Note that all relative occucations are set to zero in this addition; a newlevels::Array{Cascade.Level,1} is returned.

Cascade.assignOccupation!(levels::Array{Cascade.Level,1}, property::AbstractSimulationProperty) ... assigns the occupation due to the given property

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.

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 set of orbitals cOrbitals::Dict{Subshell, Orbital} is returned.

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.

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.

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.

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.

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::Cascade.DecayData is returned.

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.

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.

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.

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.

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.

Cascade.computeTotalAugerRate(level::Cascade.Level) ... computes the total Auger rate of level as given by its daugther levels; a rate::Float64 is returned.

Cascade.computeTotalPhotonRate(level::Cascade.Level) ... computes the total photon (radiative) rate of level as given by its daugther levels; a rate::EmProperty is returned.

Cascade.determineSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, captureList::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.

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.

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.

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.

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.

Cascade.determineSteps(scheme::Cascade.PhotoIonizationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, ionizedList::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 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.

Cascade.determineSteps(scheme::Cascade.RadiativeRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, captureList::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.

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.

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.

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.

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.

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.

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

Cascade.displayIonDistribution(stream::IO, sc::String, levels::Array{Cascade.Level,1}) ... displays the (current or final) ion distribution in a neat table. Nothing is returned.

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 daugther levels. This enables one to recognize (and perhaps later add) missing parent and daughter levels. Nothing is returned.

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.

Cascade.displayPhotoAbsorptionSpectrum(stream::IO, pEnergies::Array{Float64,1}, crossSections::Array{EmProperty,1}, property::Cascade.PhotoAbsorptionSpectrum) ... displays the photoabsorption cross sections a neat table. Nothing is returned.

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.

Cascade.displayRelativeOccupation(stream::IO, levels::Array{Cascade.Level,1}) ... displays the (initial) relative occupation of the levels in a neat table. Nothing is returned.

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

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.

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.

Cascade.dumpGeant4Index(subsh::Subshell) ... returns the (integer) index of subshell in the Geant4 convention; an i::Int64 is returned

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 daugther lines (to which the pobability may decay). A levelList::Array{Cascade.Level,1} is returned.

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.

Cascade.extractPhotoExcitationData(dataDicts::Array{Dict{String,Any},1}) ... returns the available photoexcitation data.

Cascade.extractPhotoIonizationData(dataDicts::Array{Dict{String,Any},1}) ... returns the available photoionization data.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Cascade.generateConfigurationsForDielectronicCapture(multiplets::Array{Multiplet,1}, scheme::DielectronicRecombinationScheme, nm::Nuclear.Model, grid::Radial.Grid) ... generates all possible doubly-excited configurations due to (dielectronic) electron capture into the given multiplets. The number and type of such doubly-generated configurations depend on (1) the maximum (electron) energy for capturing an electron that is closely related to the (maximum) temperature of the plasma; (2) the fromShells from which (and how many displacements) are accepted as well as (3) the maximum principle and orbital angular quantum number of the additional (to-) shellsthe fromShells into which electrons excited and/or captured. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

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.

Cascade.generateConfigurationsForHollowIons(initialConfigs::Array{Configurations,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.

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.

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.

Cascade.generateConfigurationsForPhotoionization(multiplets::Array{Multiplet,1}, scheme::PhotoIonizationScheme, nm::Nuclear.Model) ... generates all possible (photo-absorption) configurations with a single displacements of an electron from scheme.excitationFromShells to either scheme.excitationToShells or into partial waves with scheme.lValues. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

Cascade.generateConfigurationsForRadiativeRecombination(multiplets::Array{Multiplet,1}, scheme::RadiativeRecombinationScheme, nm::Nuclear.Model, grid::Radial.Grid) ... generates all possible configurations due to radiative recombination into the given multiplets. The number and type of such (singly-excited) configurations depend on the maximum principle and orbital angular quantum number of the additional intoShells, into which electrons are captured. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

Cascade.generateConfigurationsForStepwiseDecay(scheme::Cascade.StepwiseDecayScheme, initialConfigs::Array{Configurations,1}) ... generates all possible configurations as obtained by a stepwise loss of maxElectronLoss electrons and by considering NoShakeDisplacements displacements. A confList::Array{Configuration,1} is returned.

Cascade.generateConfigurationsWith1OuterHole(conf, holeShell) ... generates all possible (decay) configurations where the hole in holeShell is moved 'outwards'. A confList::Array{Configuration,1} is returned.

Cascade.generateConfigurationsWith1OuterHole(configs::Array{Configuration,1}, holeShells::Array{Shell,1}) ... generates all possible (decay) configurations where one hole from holeShells is moved 'outwards'. A confList::Array{Configuration,1} is returned.

Cascade.generateConfigurationsWith2OuterHoles(conf, holeShell) ... generates all possible (decay) configurations where the hole in holeShell is moved 'outwards'. A confList::Array{Configuration,1} is returned.

Cascade.generateConfigurationsWith2OuterHoles(configs::Array{Configuration,1}, holeShells::Array{Shell,1}) ... generates all possible (decay) configurations where two holes from holeShells are moved 'outwards'. A confList::Array{Configuration,1} is returned.

Cascade.groupDisplayConfigurationList(Z::Float64, confs::Array{Configuration,1}; sa::String="") ... group & display the configuration list into sublists with the same No. of electrons; this lists are displayed together with an estimated total energy. An ordered confList::Array{Configuration,1} is returned with configurations of decreasing number of electrons.

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.

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.

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation) ... to set-up and perform a dielectronic-recombination (DR) plasma rate coefficient computation that combines the electron capture and the subsequent radiative stabilization steps. Such a computation 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 given parameters of the scheme::DielectronicRecombinationScheme. The results of these DR plasma rate computation are comprised into (output) data::ExcitationData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::ElectronExcitationScheme, comp::Cascade.Computation) ... to set-up and perform an electron-excitation cascade computation that accounts for the direct and resonant part. Apart from the direct electron-impact excitation of the atom, it enables one to treat the (resonant) dielectronic capture with subsequent electron emission (re-autoionization) in the cascade. Typical electron-excitation properties are energy-dependent collision strengths, impact-excitation cross sections, effective collision strengths, and several others.

Cascade.perform(scheme::ElectronExcitationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::ExpansionOpacityScheme, comp::Cascade.Computation) ... 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. The results of these expansion opacity computations are comprised into (output) data::ExcitationData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::ExpansionOpacityScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::HollowIonScheme, comp::Cascade.Computation) ... to set-up and perform a dielectronic-recombination (DR) plasma rate coefficient computation that combines the electron capture and the subsequent radiative stabilization steps. Such a computation 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 given parameters of the scheme::HollowIonScheme. The results of these DR plasma rate computation are comprised into (output) data::ExcitationData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::HollowIonScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::ImpactExcitationScheme, comp::Cascade.Computation) ... to set-up and perform a electron-impact excitation computation that starts from a given set of initial configurations xor initial multiplets and comprises the impact-excitation of different fromShells to the toShells. All configurations are constructed with regard to the initial configurations. The results of these impact-excitation computations are comprised into (output) data::??? but nothing is returned as default.

Cascade.perform(scheme::ImpactExcitationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::PhotoAbsorptionScheme, comp::Cascade.Computation) ... to set-up and perform a photoabsorption cascade computation that that accounts for the direct and resonant of photoabsorption. Apart from the direct photoionization of the atom, it enables one to treat the photoexcitation and 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 results of a photoabsorption cascade computation are comprised into (output) data::ExcitationData, while nothing is returned otherwise.

Cascade.perform(scheme::PhotoAbsorptionScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::PhotoExcitationScheme, comp::Cascade.Computation) ... to set-up and perform a photo-excitation computation that starts from a given set of initial configurations xor initial multiplets and comprises (various) photoexcitation processes into configurations with up-to NoExcitations single-electron excitations with regard to the initial multiplets. The results of these excitation are comprised into (output) data::PhotoExcData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::PhotoExcitationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::PhotoIonizationScheme, comp::Cascade.Computation) ... to set-up and perform a photo-excitation computation that starts from a given set of initial configurations xor initial multiplets and comprises (various) photoexcitation processes into configurations with up-to NoExcitations single-electron excitations with regard to the initial multiplets. The results of these excitation are comprised into (output) data::PhotoExcData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::PhotoIonizationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(scheme::RadiativeRecombinationScheme, comp::Cascade.Computation) ... to set-up and perform a radiative-recombination (RR) plasma rate coefficient computation basedm on all selected electron capture steps. Such a computation 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; (2) selects all steps for radiative recombination due to given parameters of the scheme::RadiativeRecombinationScheme. The results of these RR plasma rate computation are comprised into (output) data::DecayData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::RadiativeRecombinationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

Cascade.perform(simulation::Cascade.Simulation ... 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 final-level distribution can be derived and displayed from these simulations. Of course, the details of these simulations strongly depend on the atomic processes and data that have been generated before by performing a computation::Cascade.Computation. The results of all individual steps are printed to screen but nothing is returned otherwise.

Cascade.perform(simulation::Cascade.Simulation; output=true) ... to perform the same but to return the complete output in a dictionary; the particular output depends on the method and specifications of the cascade but can easily accessed by the keys of this dictionary.

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation) ... to set-up and perform a cascade computation that starts from a given set of initial configurations and proceeds via various steps until a given number of electrons has been removed or the decay stops at some stable levels with regard to the given atomic processes. The results of all individual steps are printed to screen but nothing is returned otherwise.

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary; the particular output depends on the type and specifications of the cascade but can easily accessed by the keys of this dictionary.

Cascade.propagateOccupationInTime!(levels::Array{Cascade.Level,1}, dt::Float64) ... propagates the occupation of the levels by dt in time.

Cascade.propagateProbability!(levels::Array{Cascade.Level,1}; collectPhotonIntensities::Bool=false, collectElectronIntensities::Bool=false) ... propagates the relative level occupation through the levels of the cascade until no further change occur in the relative level occupation. The argument levels is modified during the propagation, but nothing is returned otherwise.

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 daugther lines of this level otherwise. The argument levels::Array{Cascade.Level,1} is modified and nothing is returned otherwise.

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.

Cascade.simulateDrRateCoefficients(levels::Array{Cascade.Level,1}, simulation::Cascade.Simulation) ... Determines and prints the DR resonance strength and (plasma) rate coefficients for all resonance levels. Nothing is returned.

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. Nothing is returned.

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.

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.

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.

Cascade.simulateMeanRelaxationTime(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. An relaxTimes::Array{Float64,1} is returned that contains the mean relaxation times for 70%, 80%, 90%, ...

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.

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.

Cascade.simulateRosselandOpacities(photoexcitationData::Array{Cascade.Data,1}, simulation::Cascade.Simulation) ... runs through all excitation lines, sums up their contributions and form a (list of) Rosseland opacities, based on the expansion opacities, for the given parameters. Nothing is returned.

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.

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

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.

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.

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.

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.

Cascade.determineSteps(scheme::Cascade.DielectronicRecombinationScheme, comp::Cascade.Computation, initialList::Array{Cascade.Block,1}, captureList::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.

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.

Cascade.generateConfigurationsForDielectronicCapture(multiplets::Array{Multiplet,1}, scheme::DielectronicRecombinationScheme, nm::Nuclear.Model, grid::Radial.Grid) ... generates all possible doubly-excited configurations due to (dielectronic) electron capture into the given multiplets. The number and type of such doubly-generated configurations depend on (1) the maximum (electron) energy for capturing an electron that is closely related to the (maximum) temperature of the plasma; (2) the fromShells from which (and how many displacements) are accepted as well as (3) the maximum principle and orbital angular quantum number of the additional (to-) shellsthe fromShells into which electrons excited and/or captured. A Tuple(initialConfList::Array{Configuration,1}, confList::Array{Configuration,1}) is returned.

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation) ... to set-up and perform a dielectronic-recombination (DR) plasma rate coefficient computation that combines the electron capture and the subsequent radiative stabilization steps. Such a computation 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 given parameters of the scheme::DielectronicRecombinationScheme. The results of these DR plasma rate computation are comprised into (output) data::ExcitationData, while these data are only printed during the generation and nothing is returned.

Cascade.perform(scheme::DielectronicRecombinationScheme, comp::Cascade.Computation; output=true, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary that is written to disk and can be used in subsequent cascade simulation. The particular output depends on the specifications of the cascade.

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.

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.

Cascade.generateConfigurationsForStepwiseDecay(scheme::Cascade.StepwiseDecayScheme, initialConfigs::Array{Configurations,1}) ... generates all possible configurations as obtained by a stepwise loss of maxElectronLoss electrons and by considering NoShakeDisplacements displacements. A confList::Array{Configuration,1} is returned.

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation) ... to set-up and perform a cascade computation that starts from a given set of initial configurations and proceeds via various steps until a given number of electrons has been removed or the decay stops at some stable levels with regard to the given atomic processes. The results of all individual steps are printed to screen but nothing is returned otherwise.

Cascade.perform(scheme::StepwiseDecayScheme, comp::Cascade.Computation; output::Bool=false, outputToFile::Bool=true) ... to perform the same but to return the complete output in a dictionary; the particular output depends on the type and specifications of the cascade but can easily accessed by the keys of this dictionary.