rexafs 0.2.5

Rust-powered X-ray absorption spectroscopy analysis and EXAFS fitting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Historical parameter-container prototype, retained for serialization compatibility.
//! This type is not wired into the current [`crate::Spectrum`] processing pipeline.
//! Configure [`crate::PrePostEdge`], [`crate::AUTOBK`], [`crate::XrayFFTF`] and
//! [`crate::XrayFFTR`] directly through spectrum setters for new applications.

#![allow(dead_code)]
#![allow(unused_imports)]

#[cfg_attr(debug_assertions, allow(dead_code, unused_imports))]
// Standard library dependencies
use std::error::Error;

// External dependencies
use serde::{Deserialize, Serialize};

// load dependencies
use super::background;
use super::io;
use super::lmutils;
use super::mathutils;
use super::normalization;
use super::nshare;
use super::xafsutils;
use super::xrayfft;

// Load local traits
use background::{BackgroundMethod, ILPBkg, AUTOBK};
use mathutils::MathUtils;
use normalization::Normalization;
use normalization::{MBack, NormalizationMethod, PrePostEdge};
use xafsutils::FTWindow;

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Default)]
#[serde(default)]
/// Legacy collection of optional private settings; default fields are unset.
/// No public operation applies this container to a spectrum.
pub struct XASParameters<'a> {
    e0: Option<f64>,
    normalization_method: Option<NormalizationMethod>,
    pre_edge_start: Option<f64>,
    pre_edge_end: Option<f64>,
    norm_start: Option<f64>,
    norm_end: Option<f64>,
    norm_polyorder: Option<i32>,
    n_victoreen: Option<i32>,
    edge_step: Option<f64>,
    background_method: Option<BackgroundMethod>,
    ek0: Option<f64>,
    rbkg: Option<f64>,
    bkg_nknots: Option<i32>,
    bkg_kmin: Option<f64>,
    bkg_kmax: Option<f64>,
    bkg_kstep: Option<f64>,
    bkg_nclamp: Option<i32>,
    bkg_clamp_lo: Option<i32>,
    bkg_clamp_hi: Option<i32>,
    bkg_nfft: Option<i32>,
    bkg_window: Option<&'a str>,
    bkg_dk: Option<f64>,
    fft_rmax_out: Option<f64>,
    fft_window: Option<FTWindow>,
    fft_dk: Option<f64>,
    fft_dk2: Option<f64>,
    fft_kmin: Option<f64>,
    fft_kmax: Option<f64>,
    fft_kweight: Option<f64>,
    fft_nfft: Option<i32>,
    fft_kstep: Option<f64>,
    ifft_qmax_out: Option<f64>,
    ifft_window: Option<FTWindow>,
    ifft_dr: Option<f64>,
    ifft_dr2: Option<f64>,
    ifft_rmin: Option<f64>,
    ifft_rmax: Option<f64>,
    ifft_rweight: Option<f64>,
    ifft_nfft: Option<i32>,
    ifft_kstep: Option<f64>,
}

impl<'a> XASParameters<'a> {
    /// Create a legacy parameter container with unset fields.
    pub fn new() -> Self {
        XASParameters {
            ..XASParameters::default()
        }
    }

    /// Legacy string selector: a name starting with `m` selects the MBack
    /// placeholder; every other name selects pre/post-edge normalization.
    /// This does not configure or process a spectrum.
    pub fn set_normalization_method(
        &mut self,
        normalization_method: &str,
    ) -> Result<&mut Self, Box<dyn Error>> {
        match normalization_method {
            x if x.to_lowercase().starts_with('p') => {
                self.normalization_method =
                    Some(NormalizationMethod::PrePostEdge(PrePostEdge::new()));
            }
            x if x.to_lowercase().starts_with('m') => {
                self.normalization_method = Some(NormalizationMethod::MBack(MBack::new()))
            }
            _ => {
                self.normalization_method =
                    Some(NormalizationMethod::PrePostEdge(PrePostEdge::new()));
            }
        };

        Ok(self)
    }

    /// Legacy string selector: a name starting with `i` selects the ILPBkg
    /// placeholder; every other name selects AUTOBK. No calculation runs.
    pub fn set_background_method(
        &mut self,
        background_method: &str,
    ) -> Result<&mut Self, Box<dyn Error>> {
        match background_method {
            x if x.to_lowercase().starts_with('a') => {
                self.background_method = Some(BackgroundMethod::AUTOBK(AUTOBK::new()));
            }
            x if x.to_lowercase().starts_with('i') => {
                self.background_method = Some(BackgroundMethod::ILPBkg(ILPBkg::new()));
            }
            _ => {
                self.background_method = Some(BackgroundMethod::AUTOBK(AUTOBK::new()));
            }
        };
        Ok(self)
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_initialize_xas_parameters() {
        let _xas_params = XASParameters::new();
    }
}