The AllBelowTolerance ConvergenceTest ensures that the difference between measured and computed is below a threshold for each k-ratio.

Coating

Implements a simple multi-layer coating correction.

An abstract type for implementing coating correction algorithms.

NeXLCore.transmission(zaf::CoatingCorrection, xray::CharXRay)

The ConvergenceTest abstract type represents mechanisms to decide when the iteration has converged.

converged(ct::ConvergenceTest, meas::Vector{KRatio}, computed::Dict{Element,Float64})::Bool

An abstract type for implementing secondary-fluorescence corrections.

F(unk::FluorescenceCorrection, xray::CharXRay, θtoa::AbstractFloat)

The IsApproximate ConvergenceTest checks that the k-ratio differences are either below an absolute threshold or a relative tolerance.

Collects the information necessary to define the iteration process including the MatrixCorrection and FLuorescenceCorrection algorithms, the iteration UpdateRule, the ConvergenceTest, and an UnmeasuredElementRule.

IterationResult contains the results of the iteration process including a Label identifying the source of the k-ratios, the resulting Material, the initial and final k-ratios, whether the iteration converged and the number of steps. The results can be output using asa(DataFrame, ir::IterationResult).

KRatioOptimizer

Defines an optimizeks(kro::KRatioOptimizer, krs::Vector{KRatio})::Vector{KRatio} method which takes a vector of k-ratios which may have redundant data (more than one KRatio per element) and trims it down to a vector of k-ratios with one KRatio per element.

MatrixCorrection is an abstract type for computing ϕ(ρz)-type matrix correction algorithms. A sub-class MCA <: MatrixCorrection should implement

# Integral of the area under the ϕ(ρz)-curve
F(mc::MCA)
# Integral of the transmitted area under the ϕ(ρz)-curve
Fχ(mc::MCA, xray::CharXRay, θtoa::Real)
# Area under 0 to τ under the transmitted ϕ(ρz)-curve
Fχp(mc::MCA, xray::CharXRay, θtoa::Real, τ::Real)
# The ϕ(ρz)-curve
ϕ(mc::MCA, ρz)
# A factory method from MCA
matrixcorrection(::Type{MCA}, mat::Material, ashell::AtomicSubShell, e0)::MCA

The algorithm should precompute as much as possible based on the Material, AtomicSubShell and beam energy. The class MCA should define member variables subshell::AtomicSubShell, material::Material and E0::AbstractFloat to store the input values. See XPP for an example.

From these methods, other methods like Z(...), A(...) are implemented.

The MultiZAF structure holds the information necessary to perform matrix correction on a collection of characteristic X-rays that were measured simultaneously from the same element. Use zafcorrection(...) to construct these rather than the internal constructor.

The NaiveUpdateRule implements the 'method of successive approximations' to update the composition between iteration steps.

NullCoating

No coating (100%) transmission.

NullFluorescence

Implements Castaing's First Approximation (i.e. No correction F=1)

The NullUnmeasuredRule adds no additional elements in the iteration process.

The RMSBelowTolerance ConvergenceTest ensures that the root-mean-squared difference between measured and computed is below a threshold.

The RecordingUpdateRule wraps other UpdateRule instances to provide diagnostics which may be tabulated using asa(DataFrame, rur::RecordingUpdateRule) or plotted using Gadfly's plot(rur::RecordingUpdateRule).

The ReedFluorescence structure implements FluorescenceCorrection for the Reed fluorescence model.

The ReedInternal structure optimizes the calculation of the Reed correction algorithm.

@article{riveros1993review, title={Review of ϕ(ρz) curves in electron probe microanalysis}, author={Riveros, Jose and Castellano, Gustavo}, journal={X-Ray Spectrometry}, volume={22}, number={1}, pages={3–10}, year={1993}, publisher={Wiley Online Library} }

The instruction in Packwood1991 in Electron Probe Quantitation is: "For compounds weight averaging is used for all appropriate variables: Z, Z/A, η, and (Z/A)log(1.166(E0-Ec)/2J)"

SimpleKRatioOptimizer

Implements a simple optimizer based on shell first, overvoltage next and brightness last. Once it picks an optimum set of lines for an element, it will not change.

The UnmeasuredElementRule mechanism provides a method to implement rules for adding unmeasured elements to the fitting process. Examples include element-by-stoichiometry or element-by-difference.

The UpdateRule abstract type defines mechanisms to update the best composition estimate between iteration steps.

The WegsteinUpdateRule implements the very effective method of Reed and Mason (S.J.B. Reed and P.K. Mason, Transactions ofthe Second National Conference on Electron Microprobe Analysis, Boston, 1967.) for updating the composition estimate between iteration steps.

ZAFCorrection

Pulls together the ZA, F and coating corrections into a single structure.

range(::Type{XPP}, mat::MaterialLabel, e0, inclDensity=true)
range(ty::Type{<:BetheEnergyLoss}, mat::Material, e0::Float64, inclDensity=true; emin=50.0, mip::Type{<:NeXLMeanIonizationPotential}=Berger1982)

Total trajectory (range) of an electron with initial energy e0 (eV). (Units: inclDensity ? cm : cm/(g/cm³))

J(::Type{XPP}, mat::Material)

Mean ionization potential for the specified material in eV. (PAP1991 Eqn 6)

a(b, ϵ)

XPP ϕ(ρz) model parameter a

NeXLCore.atomicsubshell(mc::MatrixCorrection)

The sub-shell for which this MatrixCorrection has been calculated.

shells(mz::MultiZAF)

A set of all sub-shells supported by this MultiZAF

NeXLCore.characteristic(mz::MultiZAF)

The X-rays associated with this MultiZAF.

NeXLCore.element(mz::MultiZAF)

The element associate with this MultiZAF

NeXLCore.material(itres::IterationResult)::Material

NeXLCore.material(mc::MatrixCorrection) = mc.material

The material for which this MatrixCorrection has been calculated.

NeXLCore.transmission(zaf::Coating, xray::CharXRay, toa)

Calculate the transmission fraction for the specified X-ray through the coating in the direction of the detector.

NeXLCore.transmission(zaf::NullCoating, xray::CharXRay, toa)

Calculate the transmission fraction for the specified X-ray through no coating (1.0).

A(unk::MatrixCorrection, std::MatrixCorrection, xray::CharXRay, χcunk=0.0, tcunk=0.0, χcstd=0.0, tcstd=0.0)

The absorption correction factors.

A(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)

The A (absorption) correction for unk relative to std.

A(B, b, ϕ0, F, ϵ)

XPP ϕ(ρz) model parameter A

A(unk::ZAFCorrection, std::ZAFCorrection, cxr::CharXRay, θunk::AbstractFloat, θstd::AbstractFloat)

Computes the absorption correction.

B(b, F, P, ϕ0, ϵ)

XPP ϕ(ρz) model parameter B

F(mc::MatrixCorrection)

Integral of the ϕ(ρz)-curve from ρz = 0 to ∞.

F(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)

The F (fluoresence) correction for unk relative to std.

F(reed::ReedFluorescence, secondary::CharXRay, toa::Float64)

Compute the enhancement of the secondary characteristic X-ray due to the primaries specified in reed.

F(unk::ZAFCorrection, std::ZAFCorrection, cxr::CharXRay, θunk::AbstractFloat, θstd::AbstractFloat)

Computes the secondary fluorescence correction.

Fχ(mc::MatrixCorrection, xray::CharXRay, θtoa::Real)

Integral of the area under the absorption corrected ϕ(ρz)-curve from ρz = 0 to ∞.

Fχp(mc::NeXLMatrixCorrection, xray::CharXRay, θtoa::Real, τ::Real)

The partial integral of the absorption corrected ϕ(ρz) curve from ρz = 0 to τ #

Fχp(::Type{XPP}, χ, A, a, B, b, ϕ0, τ)

The integral of the ϕ(ρz) exp(-χ ρz) from 0 to τ.

M(mat::Material)

P&P's M from top line in page 35

QlA(U,El,m)

Computes the relative ionization cross-section.

R(mat::Material, u0)

Backscatter factor as a function of material and overvoltage. Compares well to PAP Figure 23.

R0(J, D, P, M, Ekev)

Total trajectory (range) of an electron with initial energy Ekev. (in cm/(g/cm^3))

S(mat, ashell, E)

Computes S, the stopping power at the specified energy (in keV)

Z(unk::MatrixCorrection, std::MatrixCorrection)

The atomic number correction factor.

Z(unk::MultiZAF, std::MultiZAF)

The Z (atomic number) correction for unk relative to std.

Z(unk::ZAFCorrection, std::ZAFCorrection)

Computes the atomic number correction.

ZA(
  unk::MatrixCorrection,
  std::MatrixCorrection,
  xray::CharXRay,
  θunk::AbstractFloat,
  θstd::AbstractFloat
)

The atomic number (Z) and absorption (A) correction factors.

ZA(unk::ZAFCorrection, std::ZAFCorrection, cxr::CharXRay, θunk::AbstractFloat, θstd::AbstractFloat)

Computes the combined atomic number and fluorescence correction.

ZAFc(unk::ZAFCorrection, std::ZAFCorrection, cxr::CharXRay, θunk::AbstractFloat, θstd::AbstractFloat)

Computes the combined correction for atomic number, absorption, secondary fluorescence and generation.

b(Rbar, ϕ0, F)

XPP ϕ(ρz) model parameter b

beamEnergy(mc::MatrixCorrection) = mc.E0

The beam energy (eV) for which this MatrixCorrection has been calculated.

carboncoating(nm)

Constructs a carbon coating of the specified thickness (in nanometers).

coating(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)

The conductive (or other) coating correction factor.

coating(unk::ZAFCorrection, std::ZAFCorrection, cxr::CharXRay, θunk::AbstractFloat, θstd::AbstractFloat)

Computes the coating correction.

compute(::Type{UnmeasuredElementRule}, inp::Dict{Element,Float64})::Dict{Element,Float64}

A null UnmeasuredElementRule. Just returns the inputs.

computeZAFs(
    iter::Iteration,
    est::Material,
    stdZafs::Dict{KRatio,MultiZAF}
)::Dict{Element, Float64}

Given an estimate of the composition compute the corresponding k-ratios.

correctkratios(krs::AbstractVector{KRatio}, coating::Material, θtoa::Real, ρz::Real)::Vector{KRatio}

This function is mainly for pedagogical purposes. It takes a KRatio[], a coating Material on the unknown, and a mass-thickness (g/cm²) and creates a new KRatio[] that accounts for the intensity missing due to absorption by the coating. Favor the coating correction built into ZAFCorrection or MultiZAF.

dEdρs(args::Dict{Label,AbstractFloat}, mat::MaterialLabel, Ekev::AbstractFloat, elms)

The function P&P uses to describe the deceleration of an electron in a material. Output units are (keV/cm)/(g/cm^3) = keV cm^2/g. (PAP eqn 5)

detail(::Type{DataFrame}, mzs::AbstractArray{Tuple{MultiZAF, MultiZAF}})::DataFrame

Tabulate the details of a matrix correction relative to the specified unknown and standard in a DataFrame.

detail(::Type{DataFrame}, unk::MultiZAF, std::MultiZAF)::DataFrame

Tabulate each term in the MultiZAF matrix correction in a DataFrame.

familyfactor(shellA::AtomicSubShell, shellB::AtomicSubShell)::Float64

Accounts for the differences in ionization cross section between K , L and M shells

fluorescencecorrection(::Type{ReedFluorescence}, comp::Material, primary::Vector{CharXRay}, secondary::AtomicSubShell, e0::Float64)

Construct an instance of a ReedFluorescence correction structure to compute the secondary fluorescence due to a primary characteristic X-ray in the specified material and beam energy.

fluorescence(fltype::Type{ReedFluorescence}, comp::Material, secondary::AtomicSubShell, e0::Float64)

Construct an instance of a fltype correction structure to compute the secondary fluorescence in the specified material and beam energy.

gZAFc(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)
gZAFc(kr::KRatio, unkComp::Material; mc::Type{<:MatrixCorrection} = XPP, fc::Type{<:FluorescenceCorrection} = ReedFluorescence, cc::Type{<:CoatingCorrection} = Coating)

The combined generation, atomic number, absorption and generation corrections.

generation(unk::MultiZAF, std::MultiZAF)

The generation correction for unk relative to std. Usually, 1.0 unless the standard and unknown were collected at different beam energies.

generation(unk::ZAFCorrection, std::ZAFCorrection, ass::AtomicSubShell)

Computes a correction factor for differences X-ray generation due to differences in beam energy.

invS(U0, V0, M, D, P, T)

Computes 1/S where S is the stopping power.

ionizationdepthratio(primary::AtomicSubShell, secondary::AtomicSubShell, e0::Float64)

Ionization depth ratio from "Reed S.J.B. (1990) Microbeam Analysis, p.109"

ionizationfraction(shell::AtomicSubShell)

The fraction of the ionizations to attribute to the specified shell. Computed from the jump ratio.

k(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)

The computed k-ratio for the unknown relative to standard.

k(unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)

The computed k-ratio for the unknown relative to standard.

kcoating(ty::Type{<:MatrixCorrection}, subtrate::Material, coating::Material, cxr::CharXRay, e0::Real, toa::Real, τ::Real)

Estimate the k-ratio for a coating of mass-thickness τ (g/cm²) on the specified substrate. The standard for the coating is assumed to be of the same material as the coating.

lenardcoefficient(e0::Float64, ashell::AtomicSubShell)

Computes the Lenard coefficient according to the algorithm of Heinrich. "Heinrich K. F. J. (1967) EPASA 2, paper no. 7"

m(ashell::AtomicSubShell)

Returns the ionization cross-section exponent for QlA(U,El,m(ashell))

" massthickness(ty::Type{<:MatrixCorrection}, subtrate::Material, coating::Material, cxr::CharXRay, e0::Real, toa::Real, k::Real)

Estimate the mass-thickness of a ultra-thin layer of a coating material on a substrate from a measured k-ratio k of a characteristic X-ray cxr. Works for k-ratios of the order of 1 %. The standard for the coating is assumed to be of the same material as the coating.

matrixcorrection(::Type{XPP}, mat::Material, ashell::AtomicSubShell,e0)

Constructs an instance of the XPP algorithm.

quantify(iter::Iteration, label::Label, measured::Vector{KRatio}, maxIter::Int = 100)::IterationResult
quantify(iter::Iteration, name::String, measured::Vector{KRatio})::IterationResult
quantify(ffr::FitResult; strip::AbstractVector{Element} = Element[], mc::Type{<:MatrixCorrection} = XPP, fl::Type{<:FluorescenceCorrection} = ReedFluorescence, cc::Type{<:CoatingCorrection} = Coating)::IterationResult

Perform the iteration procedurer as described in iter using the measured k-ratios to produce the best estimate Material in an IterationResult object. The third form makes it easier to quantify the k-ratios from filter fit spectra.

quantify(ffr::FitResult, strip::AbstractVector{Element} = [], mc::Type{<:MatrixCorrection} = XPP, fl::Type{<:FluorescenceCorrection} = ReedFluorescence)::IterationResult

Facilitates quantifying FilterFitResult or BasicFitResult objects from extracting k-ratios from measured spectra.

reset(weg::WegsteinUpdateRule)

Restart the WegsteinUpdateRule accumulators.

The source of the k-ratio data as a Label (often a CharXRayLabel).

steps1(sample, elms, shell, all)

steps1 requires as data MassFractionLabel, AtomicWeightLabel, JzLabel, E0Label, mLabel in an UncertainValues

steps2(sample, shell, all)

steps2 requires as data μoρLabel, dzLabel in an UncertainValues

steps3(sample, xray, layer, all)

steps3 requires as data tcLabel, μoρLabel for the coating in an UncertainValues

update(
    ::NaiveUpdateRule,
    prevcomp::Material,
    measured::Vector{KRatio},
    zafs::Dict{Element, Float64}
)::Dict{Element,Float64}

Determine the next estimate of the composition that brings the estimate k-ratios closer to measured.

zafcorrection(
  mctype::Type{<:MatrixCorrection},
  fctype::Type{<:FluorescenceCorrection},
  cctype::Type{<:CoatingCorrection},
  mat::Material,
  cxrs,
  e0,
  coating=missing
)

Constructs a MultiZAF around the mctype and fctype algorithms for a collection of CharXRay cxrs.

zafcorrection(
  mctype::Type{<:MatrixCorrection},
  fctype::Type{<:FluorescenceCorrection},
  cctype::Type{<:CoatingCorrection},
  mat::Material,
  ashell::AtomicSubShell,
  e0::Real,
  coating::Union{Film,AbstractVector{Film},Missing}
)

Constructs an ZAFCorrection object using the mctype correction model with the fluorescence model for the specified parameters.

zafcorrection(
  mctype::Type{<:MatrixCorrection},
  fctype::Type{<:FluorescenceCorrection},
  cctype::Type{<:CoatingCorrection},
  unk::Material,
  std::Material,
  cxrs,
  e0;
  unkCoating::Union{Film,AbstractVector{Film},Missing} = missing,
  stdCoating::Union{Film,AbstractVector{Film},Missing} = missing,
)

Constructs a tuple of MultiZAF around the mctype and fctype correction algorithms for the unknown and standard for a collection of CharXRay cxrs.

zafcorrection(
   mctype::Type{<:MatrixCorrection},
   fctype::Type{<:FluorescenceCorrection},
   cctype::Type{<:CoatingCorrection},
   unk::Material,
   std::Material,
   ashell::AtomicSubShell,
   e0::Real;
   unkCoating::Union{Film,AbstractVector{Film},Missing} = missing,
   stdCoating::Union{Film,AbstractVector{Film},Missing} = missing,
)

Creates a matched pair of ZAFCorrection objects using the matrix correction algorithm for the specified unknown and standard.

χ(mat::Material, xray::CharXRay, θtoa)

Angle adjusted mass absorption coefficient.

ϕ(mc::MatrixCorrection, ρz)

The ϕ(ρz)-curve for visualization and other purposes.

ϕ(ρz, xpp::XPP)

Computes the ϕ(ρz) curve according to the XPP algorithm.

ϕ0(U0, ηbar)

The value of the ϕ(ρz) curve at ρz=0.0.

ϕabs(mc::MatrixCorection, ρz, xray::CharXRay, θtoa::AbstractFloat)

Computes the absorbed ϕ(ρz) curve according to the XPP algorithm.

ϕxpp(ρz, A, a, B, b, ϕ0)

Compute the shape of the ϕ(ρz) curve in the XPP model.

asa(::Type{DataFrame}, mzs::AbstractArray{Tuple{MultiZAF,MultiZAF}}, θunk::AbstractFloat, θstd::AbstractFloat)::DataFrame

Tabulate a matrix correction relative to a specified Dict of unknowns and standards in a DataFrame.

asa(::Type{DataFrame}, unk::MultiZAF, std::MultiZAF, θunk::AbstractFloat, θstd::AbstractFloat)::DataFrame

Tabulate a matrix correction relative to the specified unknown and standard in a DataFrame.

NeXLUncertainties.asa(::Type{DataFrame}, rur::RecordingUpdateRule)::DataFrame

Tabulate the iteration steps in a DataFrame.

NeXLUncertainties.asa(::Type{DataFrame}, unk::ZAFCorrection, std::ZAFCorrection, trans::AbstractVector{Transition},
θunk::AbstractFloat, θstd::AbstractFloat)::DataFrame

Tabulate a matrix correction relative to the specified unknown and standard for the iterable of Transition, trans.