Struct PrePostEdge 

pub struct PrePostEdge {

    pub pre_edge_start: Option<f64>,
    pub pre_edge_end: Option<f64>,
    pub norm_start: Option<f64>,
    pub norm_end: Option<f64>,
    pub norm_polyorder: Option<i32>,
    pub n_victoreen: Option<i32>,
    pub e0: Option<f64>,
    pub edge_step: Option<f64>,
    pub pre_edge: Option<DVector<f64>>,
    pub post_edge: Option<DVector<f64>>,
    pub norm: Option<DVector<f64>>,
    pub flat: Option<DVector<f64>>,
    pub pre_coefficients: Option<Vec<f64>>,
    pub norm_coefficients: Option<Vec<f64>>,
}

Pre-edge subtraction, edge-step normalization and post-edge flattening.

Use new() for data-dependent fit ranges and polynomial degree, as in the Python/TypeScript constructors. default() instead uses fixed offsets −200/−30/150/2000 eV and degree 2. Endpoints are offsets from E0, not absolute energies. Results are cached in this object after normalize.

The method fits a line to mu * E.powi(n_victoreen), removes that background, and fits a post-edge polynomial to estimate the edge step. See Newville, Fundamentals of XAFS. The precise automatic ranges and flattening convention are rexafs choices.

For photon energy E in eV and input absorption mu(E), the fitted models are p(E) = (a + b*E) * E^(-v) and a polynomial P(E) fitted to mu(E)-p(E). Here v is n_victoreen; coefficients have the units required to match mu. pre_edge is p(E), and post_edge is p(E)+P(E). If E* is the measured energy nearest E0, the automatic jump is P(E*), in mu units. With the resolved jump D, the dimensionless outputs are

norm(E) = (mu(E) - p(E)) / D
flat(E) = norm(E)                              for E < E*
        = norm(E) - (P(E) - P(E*)) / D          for E >= E*

The jump must be finite and is floored at 1e-12. This numerical floor is not evidence of a usable absorption edge. Flattening is a separate display output; AUTOBK uses the original absorption and resolved edge step. Automatic values filled into this object are retained. Set a field back to None, or construct fresh settings, to request its automatic resolution again.

Fields

pre_edge_start: Option<f64>

Lower pre-edge fit offset from E0 in eV. new() leaves this automatic; default() uses −200. Automatic selection follows the available pre-edge data.

pre_edge_end: Option<f64>

Upper pre-edge fit offset from E0 in eV. new() is automatic; default() uses −30. Choose a range below edge structure with enough points for a line.

norm_start: Option<f64>

Lower post-edge fit offset from E0 in eV. new() is automatic; default() uses 150. Automatic selection depends on the resolved upper endpoint.

norm_end: Option<f64>

Upper post-edge fit offset from E0 in eV. new() uses the available range; default() uses 2000. Fit intervals are evaluated on available samples.

norm_polyorder: Option<i32>

Degree of the post-edge polynomial. Automatic degrees are 0, 1, or 2 for spans below 50 eV, below 350 eV, or at least 350 eV; explicit values are clamped to 0–5. new() is automatic and default() uses 2.

n_victoreen: Option<i32>

Exponent v in the pre-edge model (a + b*E) * E.powi(-v). The line is fitted to mu * E.powi(v); automatic v is 0 (ordinary line).

e0: Option<f64>

Absorption edge energy in eV; None requests automatic detection. When using Spectrum, an explicit E0 must be finite and strictly inside the energy range or normalization returns E0OutOfRange. The lower-level PrePostEdge::fill_parameter instead replaces a nonfinite value or one outside the first through penultimate input energies with a derivative estimate.

edge_step: Option<f64>

Absorption jump in the same units as mu. None uses post-edge minus pre-edge at the energy sample nearest E0. A finite result is floored at 1e-12; inspect nonpositive or tiny jumps rather than trusting that floor.

pre_edge: Option<DVector<f64>>

Fitted pre-edge background on the energy grid, in input mu units. None until normalization runs.

post_edge: Option<DVector<f64>>

Pre-edge background plus the post-edge polynomial, in input mu units. None until normalization runs.

norm: Option<DVector<f64>>

Dimensionless (mu - pre_edge) / edge_step on the energy grid. None until normalization runs.

flat: Option<DVector<f64>>

Dimensionless normalized absorption with the post-edge trend removed above the sample nearest E0. Values below that sample equal norm. This is a separate display output and is not substituted into AUTOBK.

pre_coefficients: Option<Vec<f64>>

Fitted line coefficients [a, b] for mu * E.powi(n_victoreen). Coefficient units depend on the exponent and the use of E in eV.

norm_coefficients: Option<Vec<f64>>

Post-edge polynomial coefficients in increasing powers of absolute E in eV. Their weighted sum has input mu units; they are not powers of E − E0.

Implementations

impl PrePostEdge

pub fn new() -> PrePostEdge

Create automatic normalization settings.

Unlike default(), every configurable field starts as None; the next calculation resolves fit ranges, degree, edge energy and edge step from data.

pub fn fill_parameter( &mut self, energy: &DVector<f64>, mu: &DVector<f64>, ) -> Result<&mut Self, NormalizationError>

Resolve automatic settings from equal-length finite energy/mu arrays.

Requires at least two samples and nondecreasing energy in eV. This mutates settings but does not fit the backgrounds or refresh result arrays. Resolved values remain stored; reset a field to None or create a fresh object to request automatic selection again.

pub fn get_pre_edge_start(&self) -> Option<f64>

Read the stored value without recalculating.

Lower pre-edge fit offset from E0 in eV. new() leaves this automatic; default() uses −200. Automatic selection follows the available pre-edge data.

pub fn get_pre_edge_end(&self) -> Option<f64>

Read the stored value without recalculating.

Upper pre-edge fit offset from E0 in eV. new() is automatic; default() uses −30. Choose a range below edge structure with enough points for a line.

pub fn get_norm_start(&self) -> Option<f64>

Read the stored value without recalculating.

Lower post-edge fit offset from E0 in eV. new() is automatic; default() uses 150. Automatic selection depends on the resolved upper endpoint.

pub fn get_norm_end(&self) -> Option<f64>

Read the stored value without recalculating.

Upper post-edge fit offset from E0 in eV. new() uses the available range; default() uses 2000. Fit intervals are evaluated on available samples.

pub fn get_norm_polyorder(&self) -> Option<i32>

Read the stored value without recalculating.

Degree of the post-edge polynomial. Automatic degrees are 0, 1, or 2 for spans below 50 eV, below 350 eV, or at least 350 eV; explicit values are clamped to 0–5. new() is automatic and default() uses 2.

pub fn get_n_victoreen(&self) -> Option<i32>

Read the stored value without recalculating.

Exponent v in the pre-edge model (a + b*E) * E.powi(-v). The line is fitted to mu * E.powi(v); automatic v is 0 (ordinary line).

pub fn get_pre_edge(&self) -> Option<&DVector<f64>>

Read the stored value without recalculating.

Fitted pre-edge background on the energy grid, in input mu units. None until normalization runs.

pub fn get_post_edge(&self) -> Option<&DVector<f64>>

Read the stored value without recalculating.

Pre-edge background plus the post-edge polynomial, in input mu units. None until normalization runs.

pub fn get_norm_coefficients(&self) -> Option<&Vec<f64>>

Read the stored value without recalculating.

Post-edge polynomial coefficients in increasing powers of absolute E in eV. Their weighted sum has input mu units; they are not powers of E − E0.

pub fn get_pre_coefficients(&self) -> Option<&Vec<f64>>

Read the stored value without recalculating.

Fitted line coefficients [a, b] for mu * E.powi(n_victoreen). Coefficient units depend on the exponent and the use of E in eV.

Trait Implementations

impl Clone for PrePostEdge

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrePostEdge

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PrePostEdge

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PrePostEdge

where PrePostEdge: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<PrePostEdge> for NormalizationMethod

fn from(parameters: PrePostEdge) -> Self

Converts to this type from the input type.

impl From<PrePostEdge> for Option<NormalizationMethod>

fn from(parameters: PrePostEdge) -> Self

Converts to this type from the input type.

impl Normalization for PrePostEdge

fn normalize( &mut self, energy: &DVector<f64>, mu: &DVector<f64>, ) -> Result<&mut Self, NormalizationError>

Normalize absorption using the selected method and refresh cached outputs. Energy is in eV. Use matching finite arrays with sufficient fit points; method-specific failures are returned as NormalizationError. The low-level PrePostEdge implementation zips its inputs and filters nonfinite pairs before fitting: unequal lengths can discard the longer tail, and result arrays then describe only retained pairs. Spectrum validates finite matching arrays before this step; prefer that contract.

fn get_e0(&self) -> Option<f64>

Read edge energy in eV, or None while automatic/unresolved.

fn get_edge_step(&self) -> Option<f64>

Read the absorption jump in input mu units, or None while automatic/unresolved.

fn get_flat(&self) -> Option<&DVector<f64>>

Borrow the flattened normalized absorption, or None before calculation.

fn get_norm(&self) -> Option<&DVector<f64>>

Borrow dimensionless edge-step-normalized absorption, or None before calculation.

fn set_e0(&mut self, e0: Option<f64>) -> &mut Self

Set edge energy in eV or None for automatic detection; recalculate results afterward.

fn set_edge_step(&mut self, edge_step: Option<f64>) -> &mut Self

Set the jump in mu units or None for estimation; recalculate results afterward.

impl PartialEq for PrePostEdge

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for PrePostEdge

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PrePostEdge