struct FormFactor.Outcome ... defines a type to keep the outcome of a form-factor computation, such as the standard form factor as well other results.

+ level                     ::Level              ... Atomic level to which the outcome refers to.
+ qValues                   ::Array{Float64,1}   ... momentum transfer |q|.
+ standardFs                ::Array{Float64,1}   ... standard atomic form factor F(q) for an (assumed) spherical charge distr.
+ modifiedFs                ::Array{Float64,1}   ... modified atomic form factor F(q) for such a charge distribution.

FormFactor.Outcome() ... constructor for an empty instance of FormFactor.Outcome for the computation of atomic form factors.

struct FormFactor.Settings <: AbstractPropertySettings ... defines a type for the details and parameters of computing alpha-variation parameters.

+ qList                    ::Array{Float64,1} ... List of q-values in [a.u.]
+ printBefore              ::Bool             ... True if a list of selected levels is printed before the  
                                                    actual computations start. 
+ levelSelection           ::LevelSelection   ... Specifies the selected levels, if any.

FormFactor.Settings() ... constructor for an empty instance of FormFactor.Settings for the computation of atomic form factors.

FormFactor.amplitude(q::Float64, finalLevel::Level, initialLevel::Level, grid::Radial.Grid; display::Bool=false) ... to compute the momentum transfer amplitude <(alphaf Jf, kappa) Ji || T^(1) || alphai J_i> for the given final and initial level. A value::ComplexF64 is returned.

FormFactor.computeAmplitudesProperties(outcome::FormFactor.Outcome, nm::Nuclear.Model, grid::Radial.Grid, settings::FormFactor.Settings) ... to compute all form factors, etc. for the given outcome; a newOutcome::FormFactor.Outcome is returned.

FormFactor.computeOutcomes(multiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::FormFactor.Settings; output=true) ... to compute (as selected) the alpha-variation parameters for the levels of the given multiplet and as specified by the given settings. The results are printed in neat tables to screen but nothing is returned otherwise.

FormFactor.determineOutcomes(multiplet::Multiplet, settings::FormFactor.Settings) ... to determine a list of Outcomes's for the computation of the alpha-variation parameters for the given multiplet. It takes into account the particular selections and settings. An Array{FormFactor.Outcome,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.

FormFactor.displayOutcomes(stream::IO, outcomes::Array{FormFactor.Outcome,1}) ... to display a list of levels that have been selected for the computations. A small neat table of all selected levels and their energies is printed but nothing is returned otherwise.

FormFactor.displayResults(stream::IO, outcomes::Array{FormFactor.Outcome,1}) ... to display the energies, M_ms and F-parameters, etc. for the selected levels. A neat table is printed but nothing is returned otherwise.

FormFactor.modifiedF(q::Float64, level::Level, grid::Radial.Grid) ... to compute the (real) Fourier transform of the (spherically-symmetric) charge distribution but including a correction due to the local (DFS) potential, relative to the rest mass of the electron. A value::Float64 is returned.

FormFactor.standardF(q::Float64, level::Level, grid::Radial.Grid) ... to compute the (real) Fourier transform of the (spherically-symmetric) charge distribution. A value::Float64 is returned.

struct Hfs.IJF_Basis ... defines a type for a IJF-coupled basis.

+ vectors   ::Array{IJF_Vector,1}   ... List of IJF_Vectors that form the basis.
+ basisJ    ::Basis                 ... Electronic basis that allows access to the electronic orbitals and CSF basis.

Hfs.IJF_Basis() ... constructor for an empty instance of IJF_Basis.

struct Hfs.IJF_Level ... defines a type for a IJF-coupled level.

+ I              ::AngularJ64       ... Nuclear spin I.
+ F              ::AngularJ64       ... Total angular momentum F.
+ M              ::AngularM64       ... Total projection M, only defined if a particular sublevel is referred to.
+ parity         ::Parity           ... Parity of the level which corresponds to the electronic system.
+ energy         ::Float64          ... energy
+ basis          ::IJF_Basis        ... basis for this level
+ mc             ::Vector{Float64}  ... Vector of mixing coefficients w.r.t basis.

Hfs.IJF_Level() ... constructor for an empty instance of IJF_Level.

struct Hfs.IJF_Multiplet ... defines a type for a multiplet of IJF-coupled levels.

+ name     ::String                ... A name associated to the multiplet.
+ levelFs  ::Array{IJF_Level,1}    ... List of IJF-coupled levels.

Hfs.IJF_Multiplet() ... constructor for an empty instance of Hfs.IJF_Multiplet.

struct Hfs.IJF_Vector ... defines a type for a IJF-coupled basis vector, here based on an ASF.

+ I        ::AngularJ64   ... Nuclear spin I.
+ F        ::AngularJ64   ... Total angular momentum F
+ levelJ   ::Level        ... Atomic level with well-defined total (electronic) angular momentum J

Hfs.IJF_Vector() ... constructor for an empty instance of IJF_Vector.

struct Hfs.InteractionMatrix ... defines a type for storing the T^1 and T^2 interaction matrices for a given basis.

+ calcT1   ::Bool               ... true, if the matrixT1 has been calculated and false otherwise.
+ calcT2   ::Bool               ... true, if the matrixT2 has been calculated and false otherwise.
+ matrixT1 ::Array{Float64,2}   ... T1 interaction matrix
+ matrixT2 ::Array{Float64,2}   ... T2 interaction matrix

Hfs.InteractionMatrix() ... constructor for an empty instance of InteractionMatrix.

struct Hfs.Outcome ... defines a type to keep the outcome of a HFS computation, such as the HFS A and B coefficients as well other results.

+ Jlevel                    ::Level            ... Atomic level to which the outcome refers to.
+ AIoverMu                  ::Float64          ... HFS A * I / mu value.
+ BoverQ                    ::Float64          ... HFS B / Q value
+ amplitudeT1               ::Complex{Float64} ... T1 amplitude
+ amplitudeT2               ::Complex{Float64} ... T2 amplitude
+ nuclearI                  ::AngularJ64       ... nuclear spin
+ hfsMultiplet              ::IJF_Multiplet    ... Multiplet of IJF levels as associated with the JLevel.

Hfs.Outcome() ... constructor for an empty instance of Hfs.Outcome for the computation of HFS properties.

struct Settings <: AbstractPropertySettings ... defines a type for the details and parameters of computing HFS A and B coefficients.

+ calcT1                    ::Bool             ... True if T1-amplitudes (HFS A values) need to be calculated, and false otherwise.
+ calcT2                    ::Bool             ... True if T2-amplitudes (HFS B values) need to be calculated, and false otherwise.
+ calcNondiagonal           ::Bool             
    ... True if also (non-)diagonal hyperfine amplitudes are to be calculated and printed, and false otherwise.
+ calcIJFexpansion          ::Bool             
    ... True if the selected atomic levels are to be represented in a IJF-coupled basis, and false otherwise.
+ printBefore               ::Bool             ... True if a list of selected levels is printed before the actual computations start. 
+ levelSelection            ::LevelSelection   ... Specifies the selected levels, if any.

Hfs.Settings(; calcT1::Bool=true, calcT2::Bool=false, calcNondiagonal::Bool=false, calcIJFexpansion::Bool=false, printBefore::Bool=false, levelSelection::LevelSelection=LevelSelection()) ... keyword constructor to overwrite selected value of Einstein line computations.

Basics.sortByEnergy(multiplet::Hfs.IJF_Multiplet) ... to sort all hyperfine levels in the multiplet into a sequence of increasing energy; a (new) multiplet::Hfs.IJF_Multiplet is returned.

Basics.tabulate(sa::String, multiplet::Hfs.IJF_Multiplet; stream::IO=stdout) ... tabulates the energies from the multiplet due to different criteria.

• ("multiplet: energies", multiplet::Hfs.IJF_Multiplet; stream::IO=stdout) ... to tabulate the energies of all hyperfine levels of the given multiplet into a neat format; nothing is returned.
• ("multiplet: energy of each level relative to lowest level", multiplet::Hfs.IJF_Multiplet; stream::IO=stdout) ... to tabulate the energy splitting of all levels with regard to the lowest level of the given multiplet into a neat format; nothing is returned.

Hfs.amplitude(kind::String, rLevel::Level, sLevel::Level, grid::Radial.Grid; printout::Bool=true) ... to compute either the T^(1) or T^(2) hyperfine amplitude <alphar Jr || T^(n)) || alphas Js> for a given pair of levels. A value::ComplexF64 is returned.

`Hfs.computeAmplitudesProperties(outcome::Hfs.Outcome, nm::Nuclear.Model, grid::Radial.Grid, settings::Hfs.Settings, im::Hfs.InteractionMatrix) ... to compute all amplitudes and properties of for a given level; an outcome::Hfs.Outcome is returned for which the amplitudes and properties are now evaluated explicitly.

Hfs.computeHyperfineMultiplet(level::Level, nm::Nuclear.Model, grid::Radial.Grid) ... to compute a hyperfine multiplet, i.e. a representation of hyperfine levels within a hyperfine-coupled basis as defined by the given (electronic) level; a hfsMultiplet::IJF_Multiplet is returned.

Hfs.computeHyperfineMultiplet(multiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::Hfs.Settings; output=true) ... to compute a hyperfine multiplet, i.e. a representation of hyperfine levels within a hyperfine-coupled basis as defined by the given (electronic) multiplet; a hfsMultiplet::IJF_Multiplet is returned.

Hfs.computeHyperfineRepresentation(hfsBasis::IJF_Basis, nm::Nuclear.Model, grid::Radial.Grid) ... to set-up and diagonalized the Hamiltonian matrix of H^(DFB) + H^(hfs) within the atomic hyperfine (IJF-coupled) basis; a hfsMultiplet::IJF_Multiplet is returned.

Hfs.computeInteractionAmplitudeM(mp::EmMultipole, leftIsomer::Nuclear.Isomer, rightIsomer::Nuclear.Isomer) ... to compute the hyperfine interaction amplitude (<leftIsomer || M^(mp)) || rightIsomer>) for the interaction of two nuclear levels; this ME is geometrically fixed if the left and right isomer are the same, and it depends on the nuclear ME otherwise. An amplitude::ComplexF64 is returned.

Hfs.computeInteractionAmplitudeT(mp::EmMultipole, aLevel::Level, bLevel, grid::Radial.Grid) ... to compute the T^(mp) interaction matrices for the given basis, i.e. (<aLevel || T^(mp) || bLevel>). Both levels must refer to the same basis. A me::ComplexF64 is returned.

Hfs.computeInteractionMatrix(basis::Basis, grid::Radial.Grid, settings::Hfs.Settings) ... to compute the T^1 and/or T^2 interaction matrices for the given basis, i.e. (<csfr || T^(n)) || csfs>). An im::Hfs.InteractionMatrix is returned.

Hfs.computeModifiedEinsteinRates(upperOutcome::Outcome, lowerOutcome::Outcome, multipoles::Array{EmMultipole,1}, gauge::EmGauge, grid::Radial.Grid) ... to compute and tabulate the modified Einstein amplitudes and rates for the hyperfine-resolved transitions between the upper and lower outcome. The procedures assumes that the two outcomes provide a proper IJF expansion (multiplet) of the hyperfine levels of interest. A neat table is printed but nothing is returned otherwise

Hfs.computeOutcomes(multiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::Hfs.Settings; output=true) ... to compute (as selected) the HFS A and B parameters as well as hyperfine energy splittings for the levels of the given multiplet and as specified by the given settings. The results are printed in neat tables to screen and, if requested, an arrays{Hfs.Outcome,1} with all the results are returned.

Hfs.defineHyperfineBasis(level::Level, nm::Nuclear.Model) ... to define/set-up an atomic hyperfine (IJF-coupled) basis for the given electronic level; a hfsBasis::IJF_Basis is returned.

Hfs.defineHyperfineBasis(multiplet::Multiplet, nm::Nuclear.Model) ... to define/set-up an atomic hyperfine (IJF-coupled) basis for the given electronic multipet; a hfsBasis::IJF_Basis is returned.

Hfs.determineOutcomes(multiplet::Multiplet, settings::Hfs.Settings) ... to determine a list of Outcomes's for the computation of HFS A- and B-parameters for the given multiplet. It takes into account the particular selections and settings. An Array{Hfs.Outcome,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.

Hfs.displayNondiagonal(stream::IO, multiplet::Multiplet, grid::Radial.Grid, settings::Hfs.Settings) ... to compute and display all non-diagonal hyperfine amplitudes for the selected levels. A small neat table of all (pairwise) hyperfine amplitudes is printed but nothing is returned otherwise.

Hfs.displayOutcomes(outcomes::Array{Hfs.Outcome,1}) ... to display a list of levels that have been selected for the computations A small neat table of all selected levels and their energies is printed but nothing is returned otherwise.

Hfs.displayResults(stream::IO, outcomes::Array{Hfs.Outcome,1}, nm::Nuclear.Model, settings::Hfs.Settings) ... to display the energies, A- and B-values, Delta E_F energy shifts, etc. for the selected levels. All nuclear parameters are taken from the nuclear model. A neat table is printed but nothing is returned otherwise.

struct IsotopeShift.Outcome ... defines a type to keep the outcome of a isotope-shift computation, such as the K and F parameters as well other results.

+ level                     ::Level              ... Atomic level to which the outcome refers to.
+ Knms                      ::Float64            ... K_nms parameter
+ Ksms                      ::Float64            ... K_sms parameter
+ Fme                       ::Float64            ... F parameter from matrix element.
+ Fdensity                  ::Float64            ... F parameter from density.
+ Xboson                    ::Float64            ... X boson-field shift constant.
+ amplitudeKnms             ::Complex{Float64}   ... K_nms amplitude
+ amplitudeKsmsA            ::Complex{Float64}   ... K_sms,A amplitude
+ amplitudeKsmsB            ::Complex{Float64}   ... K_sms,B amplitude
+ amplitudeKsmsC            ::Complex{Float64}   ... K_sms,C amplitude

IsotopeShift.Outcome() ... constructor for an empty instance of Hfs.Outcome for the computation of isotope-shift properties.

struct IsotopeShift.Settings <: AbstractPropertySettings ... defines a type for the details and parameters of computing isotope-shift M and F parameters.

+ calcNMS                  ::Bool             ... True if mass-shift parameters M_nmn need to be calculated, and false otherwise.
+ calcSMS                  ::Bool             ... True if mass-shift parameters M_sms need to be calculated, and false otherwise.
+ calcF                    ::Bool             ... True if the field-shift parameter need to be calculated, and false otherwise.
+ calcBoson                ::Bool             ... True if the boson-field shift parameter need to be calculated, and false otherwise.
+ printBefore              ::Bool             ... True if a list of selected levels is printed before the actual computations start. 
+ bosonMass                ::Float64          ... mass of the scalar boson [e_electron].
+ levelSelection           ::LevelSelection   ... Specifies the selected levels, if any.

IsotopeShift.Settings(; calcNMS::Bool=true, calcSMS::Bool=false, calcF::Bool=false, calcBoson::Bool=false, printBefore::Bool=true, bosonMass::Float64=0., levelSelection::LevelSelection=LevelSelection()) ... keyword constructor to overwrite selected value of isoshift computations.

IsotopeShift.amplitude(kind::String, rLevel::Level, sLevel::Level, nm::Nuclear.Model, grid::Radial.Grid) ... to compute either the H^(NMS), H^(SMS,A), H^(SMS,B) or H^(SMS,C) normal and specific mass-shift amplitudes <alphar Jr || H^(A)) || alphas Js> for a given pair of levels. A value::ComplexF64 is returned.

IsotopeShift.amplitude(kind::String, rLevel::Level, sLevel::Level, potential::Array{Float64,1}, grid::Radial.Grid) ... to compute the H^(field-shift) field-shift amplitude <alphar Jr || H^(field-shift) || alphas Js> or the H^(boson-field) shift amplitude <alphar Jr || H^(boson-field) || alphas Js> for a given pair of levels. The potential has to provide delta V^(nuc) for the field-shift amplitudes and the effective potential for the boson-field shift. A value::ComplexF64 is returned.

`IsotopeShift.computeAmplitudesProperties(outcome::IsotopeShift.Outcome, nm::Nuclear.Model, grid::Radial.Grid, settings::IsotopeShift.Settings) ... to compute all amplitudes and properties for a given level; an outcome::IsotopeShift.Outcome is returned for which the amplitudes and properties are now evaluated explicitly.

IsotopeShift.computeOutcomes(multiplet::Multiplet, nm::Nuclear.Model, grid::Radial.Grid, settings::IsotopeShift.Settings; output=true) ... to compute (as selected) the isotope-shift M and F parameters for the levels of the given multiplet and as specified by the given settings. The results are printed in neat tables to screen but nothing is returned otherwise.

IsotopeShift.determineOutcomes(multiplet::Multiplet, settings::IsotopeShift.Settings) ... to determine a list of Outcomes's for the computation of the isotope-shift M and F parameters for the given multiplet. It takes into account the particular selections and settings. An Array{IsotopeShift.Outcome,1} is returned. Apart from the level specification, all physical properties are set to zero during the initialization process.

IsotopeShift.displayOutcomes(outcomes::Array{IsotopeShift.Outcome,1}) ... to display a list of levels that have been selected for the computations. A small neat table of all selected levels and their energies is printed but nothing is returned otherwise.

IsotopeShift.displayResults(stream::IO, outcomes::Array{Hfs.Outcome,1}, settings::IsotopeShift.Settings) ... to display the energies, M_ms and F-parameters, etc. for the selected levels. A neat table is printed but nothing is returned otherwise.