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.HfBasisVector ... defines a type for a hyperfine basis vector that enables one to think and deal with hyperfine levels. These hyperfine levels have representations with regard to (tensor) product states, which are formed from a set of isomeric states as well as a set of electronic ASF level J. Hyperfine basis vectors are need to diagonalize the hyperfine Hamiltonian in a tensor basis of isomeric + ASF states. The different representations have different advantages.

+ F         ::AngularJ64        ... Total angular momentum F
+ parity    ::Parity            ... Total parity of the basis vector = nuclear x electronic parity.
+ isomer    ::Nuclear.Isomer    ... Isomeric state of the nucleus.
+ LevelJ    ::Basis             ... Electronic level that is part of the electronic basis.

There is no need to introduce a type HfBasis since such a hfBasis = Hfs.HfBasisVector[...] can be readily formed at all 
occurrences.

Hfs.HfBasisVector() ... constructor for an empty instance of HfBasisVector`.

struct Hfs.HfLevel ... defines a type for HfLevel with a representation that refers to a product basis of isomeric and ASF states; the HfLevel is the pendant to a (electronic) Level/state, if hyperfine-resolved transitions are considered. Each hyperfine level has a representation mc that refers to the hfBasis, and which contains all information about the representation of the underlying nuclear and electronic basis states. The electronic basis is formed by a selected set of ASF, typically taken from some (electronic) multiplet. In contrast to a pure (electronic) IJF_Basis, the use of ASF simplifies the interpretation of physical findings but cannot reduce the computational effort (perhaps, even slightly increase the computational effort).

+ F              ::AngularJ64               ... Total angular momentum F.
+ M              ::AngularM64               ... Total projection M, only defined if a particular magnetic sublevel is referred to.
+ parity         ::Parity                   ... Parity of the level which corresponds to the electronic system.
+ energy         ::Float64                  ... energy
+ hfBbasis       ::Array{HfBasisVector,1}   ... the product basis nuclear (isomeric) state x selected ASF.
+ mc             ::Vector{Float64}          ... Vector of mixing coefficients w.r.t hfBasis.

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

struct Hfs.HfMultiplet ... defines a type for a multiplet of hyperfine levels (HfLevel's) which are based on a (tensor) product basis of nuclear (isomeric) x ASF states.

+ name     ::String                ... A name associated to the multiplet.
+ hfLevels ::Array{HfLevel,1}      ... List of hyperfine levels (HfLevel's)

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

struct Hfs.IJF_Vector ... defines a type for a IJF-coupled basis vector, here based on an ASF. Following IJF-coupling, an IJF basis vector is always the (tensor) product state of an isomeric state x electronic state. IJF-coupled basis vector are needed and obtained from the diagonalization of the (electronic) HFS Hamiltonian within a given CSF basis.

+ F         ::AngularJ64        ... Total angular momentum F
+ parity    ::Parity            ... Total parity of the basis vector = nuclear x electronic parity.
+ isomer    ::Nuclear.Isomer    ... Isomeric state of the nucleus.
+ csf       ::ManyElectron.CsfR ... Electronic CSF state.
+ basisJ    ::Basis             ... Electronic CSF basis to which the csf refer to.

There is no need to introduce a type IJF_Basis since such a ijfBasis = Hfs.IJF_Vector[...] can be readily formed at all 
occurrences.

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              ::HfMultiplet      ... Multiplet of HfLevel's 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.HfMultiplet) ... to sort all hyperfine levels in the multiplet into a sequence of increasing energy; a (new) multiplet::Hfs.HfMultiplet is returned.

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

• ("multiplet: energies", multiplet::Hfs.HfMultiplet; 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.HfMultiplet; 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 hfMultiplet::hfMultiplet 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(hfBasisVectors::Array{HfBasisVector,1}, 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 hfBasis::HfBasis 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.