rexafs 0.2.3__tar.gz → 0.2.4__tar.gz

{rexafs-0.2.3 → rexafs-0.2.4}/Cargo.lock

@@ -6887,7 +6887,7 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
 
 [[package]]
 name = "py-rexafs"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "ndarray",
  "numpy",
@@ -7484,7 +7484,7 @@ dependencies = [
 
 [[package]]
 name = "rexafs"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "apex-solver",
  "approx",
@@ -7517,13 +7517,13 @@ dependencies = [
  "serde",
  "serde_json",
  "thiserror 2.0.20",
- "ureq 3.4.0",
+ "ureq 3.4.1",
  "version",
 ]
 
 [[package]]
 name = "rexafs-gui"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "accesskit",
  "accesskit_macos",
@@ -7549,7 +7549,7 @@ dependencies = [
  "serde_json",
  "sha2 0.11.0",
  "unicode-segmentation",
- "ureq 3.4.0",
+ "ureq 3.4.1",
  "walkdir",
  "windows 0.62.2",
  "xraydb",
@@ -7557,7 +7557,7 @@ dependencies = [
 
 [[package]]
 name = "rexafs-wasm"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "js-sys",
  "rexafs",
@@ -9730,9 +9730,9 @@ dependencies = [
 
 [[package]]
 name = "ureq"
-version = "3.4.0"
+version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "972d7902c8735f2695410b8aed7df6ed12a47394aa1c8d7af49f0497b731a94d"
+checksum = "af5546be8f5378d5414f83733f5c9a2526f4645829edbc1c41790aeef1b38e8b"
 dependencies = [
  "base64 0.23.1",
  "cookie_store",
@@ -9750,9 +9750,9 @@ dependencies = [
 
 [[package]]
 name = "ureq-proto"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da5f78b09e6941e1a0f2e30e695e4b120377b54d5e0aec11b594bb57b3971613"
+checksum = "fabc3e92916c89c95b20eef7b06b00b066bc217ef9ea3a4ac9bf1a7e35261e10"
 dependencies = [
  "base64 0.23.1",
  "http",

{rexafs-0.2.3 → rexafs-0.2.4}/Cargo.toml

@@ -10,7 +10,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 rust-version = "1.98"
 authors = ["Ameyanagi <contact@ameyanagi.com>"]
@@ -62,7 +62,7 @@ ruviz-gpui = { version = "0.14.1", features = ["gpu", "3d"] }
 refeff = { version = "0.3.0", default-features = false, features = ["exafs"] }
 feff10 = { version = "0.2.3", features = ["prebuilt"] }
 
-rexafs = { version = "0.2.3", path = "crates/rexafs" }
+rexafs = { version = "0.2.4", path = "crates/rexafs" }
 
 [patch.crates-io]
 gpui = { git = "https://github.com/zed-industries/zed", rev = "3060e4170ea5ef0e6886b9ac1853aaead9ddd59f" }

{rexafs-0.2.3 → rexafs-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rexafs
-Version: 0.2.3
+Version: 0.2.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -62,7 +62,7 @@ still unimplemented placeholders; selecting them raises an error.
 
 ## Build
 
-Registry publication is pending. Build from the repository root with CPython
+Build from the repository root with CPython
 3.10–3.14:
 
 ```bash
@@ -80,3 +80,7 @@ is `clamp_lo = 0`, the high-end weight is `clamp_hi = 1`, and `nclamp = 3`.
 The `FixedPenalty` model does not add a separate ridge penalty on coefficients.
 See the [full definition](../doc/autobk-fixed-penalty.md).
 
+`XrayFFTF.grid` defaults to `"Input"`. Set it to `"Larch"` to resample on the
+extended FFT window grid used by XrayLarch. `Spectrum.kwin_k()` and `.kwin()`
+return the matching window axis and values. See [compatibility and migration](../doc/fft-grid-compatibility.md).
+

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/Cargo.toml

@@ -61,9 +61,10 @@ http = ["dep:ureq"]
 materials-project = ["http"]
 cod = ["http"]
 
-[dev-dependencies]
+[target.'cfg(unix)'.dev-dependencies]
 pprof = { version = "0.15", features = ["flamegraph"] }
 
+[dev-dependencies]
 criterion = { version = "0.8.2", features = ["html_reports"] }
 
 [[bench]]

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/benches/autobk_stage_benchmark.rs

@@ -3,6 +3,7 @@ mod perf;
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::hint::black_box;
 
+#[cfg(unix)]
 use perf::FlamegraphProfiler;
 use rexafs::xafs::background::{AUTOBKClampScalePolicy, AUTOBKSolver, AUTOBK};
 use rexafs::xafs::normalization::{NormalizationMethod, PrePostEdge};
@@ -73,13 +74,11 @@ fn criterion_benchmark(c: &mut Criterion) {
 
 fn custom() -> Criterion {
     let base = Criterion::default().sample_size(20);
-    let enable_profiler =
-        std::env::args().any(|arg| arg == "--profile-time" || arg.starts_with("--profile-time="));
-    if enable_profiler {
-        base.with_profiler(FlamegraphProfiler::new(1000))
-    } else {
-        base
+    #[cfg(unix)]
+    if std::env::args().any(|arg| arg == "--profile-time" || arg.starts_with("--profile-time=")) {
+        return base.with_profiler(FlamegraphProfiler::new(1000));
     }
+    base
 }
 
 criterion_group! {

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/benches/feff_fitting_batch_benchmark.rs

@@ -2,6 +2,7 @@ mod perf;
 
 use criterion::{criterion_group, criterion_main, Criterion, Throughput};
 use nalgebra::DVector;
+#[cfg(unix)]
 use perf::FlamegraphProfiler;
 use rexafs::xafs::fitting::{
     feffit_independent, feffit_joint_with_options, feffpath, ff2chi, FeffBatchOptions,
@@ -160,13 +161,11 @@ fn criterion_benchmark(c: &mut Criterion) {
 
 fn custom() -> Criterion {
     let base = Criterion::default().sample_size(10);
-    let enable_profiler =
-        std::env::args().any(|arg| arg == "--profile-time" || arg.starts_with("--profile-time="));
-    if enable_profiler {
-        base.with_profiler(FlamegraphProfiler::new(1000))
-    } else {
-        base
+    #[cfg(unix)]
+    if std::env::args().any(|arg| arg == "--profile-time" || arg.starts_with("--profile-time=")) {
+        return base.with_profiler(FlamegraphProfiler::new(1000));
     }
+    base
 }
 
 criterion_group! {

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/benches/perf.rs

@@ -1,3 +1,5 @@
+#![cfg(unix)]
+
 use std::{fs::File, os::raw::c_int, path::Path};
 
 use criterion::profiler::Profiler;

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/lib.rs

@@ -14,5 +14,5 @@ pub use xafs::background::{BackgroundMethod, AUTOBK};
 pub use xafs::normalization::{NormalizationMethod, PrePostEdge};
 pub use xafs::xasgroup::XASGroup as Group;
 pub use xafs::xasspectrum::XASSpectrum as Spectrum;
-pub use xafs::xrayfft::XrayFFTF;
+pub use xafs::xrayfft::{FFTGrid, XrayFFTF};
 pub use xafs::{analysis, fitting, io, structure, tools, Result, XAFSError as Error};

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/prelude.rs

@@ -20,7 +20,7 @@ pub use crate::xafs::normalization::{Normalization, NormalizationMethod};
 #[cfg(feature = "ndarray-compat")]
 pub use crate::xafs::nshare::{ToNalgebra, ToNdarray1};
 pub use crate::xafs::xafsutils::{FTWindow, XAFSUtils};
-pub use crate::xafs::xrayfft::{FFTUtils, XrayFFTF, XrayFFTR};
+pub use crate::xafs::xrayfft::{FFTGrid, FFTUtils, XrayFFTF, XrayFFTR};
 
 #[cfg(feature = "plotting")]
 pub use crate::plot::{PlotError, PlotXAS, XASPlotBuilder};

rexafs-0.2.4/crates/rexafs/src/xafs/background/legacy_clamp_tests.rs

@@ -0,0 +1,120 @@
+//! Regression for issue #20. This exercises the legacy objective independently
+//! of the fixed-penalty solver, for both array backends.
+use super::*;
+
+fn problem() -> AUTOBKSpline {
+    let x: Vec<f64> = (0..9).map(|i| i as f64 * 1.5).collect();
+    let y: Vec<f64> = x.iter().map(|v| 1.0 + 0.03 * v.cos()).collect();
+    let (knots, coefs) = spline::interpolate(&x, &y, 3).unwrap();
+    let k = DVector::from_iterator(241, (0..241).map(|i| i as f64 * 0.05));
+    AUTOBKSpline {
+        coefs: DVector::from_vec(coefs),
+        knots: DVector::from_vec(knots),
+        kraw: k.clone(),
+        kout: k.clone(),
+        mu: k.map(|v| 1.0 + 0.1 * (2.0 * v).sin()),
+        chi_std: Some(k.map(|v| 0.01 * v.cos())),
+        ftwin: k,
+        nclamp: 3,
+        clamp_lo: 2,
+        clamp_hi: 1,
+        irbkg: 35,
+        ..Default::default()
+    }
+}
+
+fn numerical_jacobian(p: &AUTOBKSpline, scale: Option<f64>) -> DMatrix<f64> {
+    DMatrix::from_columns(
+        &(0..p.coefs.len())
+            .map(|j| {
+                let mut plus = p.coefs.clone();
+                let mut minus = p.coefs.clone();
+                plus[j] += 1e-6;
+                minus[j] -= 1e-6;
+                (p.residual_vec_with_scale(&plus, scale) - p.residual_vec_with_scale(&minus, scale))
+                    / 2e-6
+            })
+            .collect::<Vec<_>>(),
+    )
+}
+
+#[test]
+fn legacy_clamp_jacobian_matches_central_differences() {
+    for nclamp in [0, 1, 3, 500] {
+        for weights in [(0, 0), (0, 1), (2, 0), (2, 3)] {
+            for irbkg in [0, 35] {
+                let mut p = problem();
+                p.nclamp = nclamp;
+                (p.clamp_lo, p.clamp_hi) = weights;
+                p.irbkg = irbkg;
+                #[cfg(not(feature = "ndarray-compat"))]
+                if nclamp == 3 {
+                    p.ensure_precomputed_basis();
+                }
+                for scale in [None, Some(1.7)] {
+                    let analytic = p.residual_jacobian_with_scale(&p.coefs, scale);
+                    let numeric = numerical_jacobian(&p, scale);
+                    let error = (&analytic - &numeric).norm() / numeric.norm().max(1.0);
+                    assert!(
+                        error < 1e-7,
+                        "n={nclamp}, weights={weights:?}, R={irbkg}, scale={scale:?}: {error}"
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+struct NumericProblem(AUTOBKSpline, bool);
+impl LeastSquaresProblem<f64, Dyn, Dyn> for NumericProblem {
+    type ParameterStorage = Owned<f64, Dyn>;
+    type ResidualStorage = Owned<f64, Dyn>;
+    type JacobianStorage = Owned<f64, Dyn, Dyn>;
+    fn set_params(&mut self, p: &DVector<f64>) {
+        self.0.coefs.copy_from(p);
+    }
+    fn params(&self) -> DVector<f64> {
+        self.0.coefs.clone()
+    }
+    fn residuals(&self) -> Option<DVector<f64>> {
+        Some(self.0.residual_vec(&self.0.coefs))
+    }
+    fn jacobian(&self) -> Option<DMatrix<f64>> {
+        if self.1 {
+            Some(self.0.residual_jacobian_with_scale(
+                &self.0.coefs,
+                Some(self.0.clamp_scale(&self.0.coefs)),
+            ))
+        } else {
+            Some(numerical_jacobian(&self.0, None))
+        }
+    }
+}
+
+#[test]
+fn legacy_lm_agrees_with_numerical_derivative_solution() {
+    let solver = LevenbergMarquardt::new()
+        .with_tol(1e-10)
+        .with_patience(1000);
+    let (analytic, report) = solver.minimize(problem());
+    let (numeric, reference) = solver.minimize(NumericProblem(problem(), false));
+    let (old, old_report) = solver.minimize(NumericProblem(problem(), true));
+    let old_chi = old.0.chi_for_coefs(&old.0.coefs);
+    let new_chi = analytic.chi_for_coefs(&analytic.coefs);
+    println!("analytic: {report:?}; numerical: {reference:?}; omitted-chain-rule: {old_report:?}; old/new chi relative L2: {}", (&old_chi - &new_chi).norm()/new_chi.norm());
+    assert!(report.termination.was_successful());
+    assert!(reference.termination.was_successful());
+    let a = analytic.chi_for_coefs(&analytic.coefs);
+    let n = numeric.0.chi_for_coefs(&numeric.0.coefs);
+    let error = (&a - &n).norm() / n.norm();
+    assert!(error < 1e-6, "chi relative L2: {error}");
+    assert!((report.objective_function - reference.objective_function).abs() < 1e-10);
+}
+
+#[test]
+fn legacy_lm_does_not_return_nonfinite_fit_as_success() {
+    let mut invalid = problem();
+    invalid.mu[0] = f64::NAN;
+    assert!(AUTOBK::solve_lm_problem(invalid).is_err());
+}

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/xafs/background.rs

@@ -442,13 +442,20 @@ impl AUTOBK {
     }
 
     fn solve_lm_problem(problem: AUTOBKSpline) -> Result<AUTOBKSpline, BackgroundError> {
-        let (fit_result, _report) = LevenbergMarquardt::new()
+        let (fit_result, report) = LevenbergMarquardt::new()
             .with_gtol(1.0e-5)
             .with_ftol(1.0e-5)
             .with_xtol(1.0e-5)
             .with_stepbound(1.0e-5)
             .minimize(problem);
-
+        if !report.termination.was_successful() || !report.objective_function.is_finite() {
+            return Err(BackgroundError::OptimizationFailed {
+                reason: format!(
+                    "legacy LM terminated with {:?} after {} evaluations",
+                    report.termination, report.number_of_evaluations
+                ),
+            });
+        }
         Ok(fit_result)
     }
 
@@ -1215,11 +1222,24 @@ impl AUTOBKSpline {
         coefs: &DVector<f64>,
         clamp_scale_override: Option<f64>,
     ) -> DMatrix<f64> {
-        let scale = if self.nclamp != 0 {
-            clamp_scale_override.unwrap_or_else(|| self.clamp_scale(coefs))
-        } else {
-            1.0
-        };
+        // For a dynamic clamp s(c) * chi(c), include both terms of the
+        // product rule. A frozen scale is used by the linear solver and has
+        // zero derivative. Compute the shared residual only once per Jacobian.
+        let dynamic =
+            (self.clamp_len(self.kout.len()) > 0 && clamp_scale_override.is_none()).then(|| {
+                let chi = self.chi_for_coefs(coefs);
+                let head = self.fft_residual_head(&chi);
+                (chi, head)
+            });
+        let scale = clamp_scale_override.unwrap_or_else(|| {
+            dynamic.as_ref().map_or(1.0, |(_, head)| {
+                if head.is_empty() {
+                    1.0
+                } else {
+                    1.0 + 100.0 * head.norm_squared() / head.len() as f64
+                }
+            })
+        });
 
         // `splev_jacobian` reads `coefs` only for its length (it sizes the
         // output and bounds-checks the write); every entry comes from
@@ -1262,13 +1282,20 @@ impl AUTOBKSpline {
                     return out;
                 }
 
-                let low_clamp = self.clamp_lo as f64 * scale * chi_der.view((0, 0), (nclamp, 1));
+                let scale_der = dynamic.as_ref().map_or(0.0, |(_, head)| {
+                    if head.is_empty() {
+                        0.0
+                    } else {
+                        200.0 * head.dot(&out) / head.len() as f64
+                    }
+                });
                 let high_start = chi_der.len() - nclamp - 1;
-                let high_clamp =
-                    self.clamp_hi as f64 * scale * chi_der.view((high_start, 0), (nclamp, 1));
-
-                out.extend(low_clamp.data.as_vec().to_owned());
-                out.extend(high_clamp.data.as_vec().to_owned());
+                for (start, weight) in [(0, self.clamp_lo), (high_start, self.clamp_hi)] {
+                    out.extend((start..start + nclamp).map(|i| {
+                        let chi = dynamic.as_ref().map_or(0.0, |(chi, _)| chi[i]);
+                        weight as f64 * (scale * chi_der[i] + scale_der * chi)
+                    }));
+                }
                 out
             })
             .collect::<Vec<DVector<f64>>>();
@@ -2035,3 +2062,7 @@ mod tests {
         Ok(())
     }
 }
+
+#[cfg(test)]
+#[path = "background/legacy_clamp_tests.rs"]
+mod legacy_clamp_tests;

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/xafs/background_ndarray.rs

@@ -446,13 +446,20 @@ impl AUTOBK {
     }
 
     fn solve_lm_problem(problem: AUTOBKSpline) -> Result<AUTOBKSpline, BackgroundError> {
-        let (fit_result, _report) = LevenbergMarquardt::new()
+        let (fit_result, report) = LevenbergMarquardt::new()
             .with_gtol(1.0e-5)
             .with_ftol(1.0e-5)
             .with_xtol(1.0e-5)
             .with_stepbound(1.0e-5)
             .minimize(problem);
-
+        if !report.termination.was_successful() || !report.objective_function.is_finite() {
+            return Err(BackgroundError::OptimizationFailed {
+                reason: format!(
+                    "legacy LM terminated with {:?} after {} evaluations",
+                    report.termination, report.number_of_evaluations
+                ),
+            });
+        }
         Ok(fit_result)
     }
 
@@ -1155,11 +1162,24 @@ impl AUTOBKSpline {
         coefs: &DVector<f64>,
         clamp_scale_override: Option<f64>,
     ) -> DMatrix<f64> {
-        let scale = if self.nclamp != 0 {
-            clamp_scale_override.unwrap_or_else(|| self.clamp_scale(coefs))
-        } else {
-            1.0
-        };
+        // For a dynamic clamp s(c) * chi(c), include both terms of the
+        // product rule. A frozen scale is used by the linear solver and has
+        // zero derivative. Compute the shared residual only once per Jacobian.
+        let dynamic =
+            (self.clamp_len(self.kout.len()) > 0 && clamp_scale_override.is_none()).then(|| {
+                let chi = self.chi_for_coefs(coefs);
+                let head = self.fft_residual_head(&chi);
+                (chi, head)
+            });
+        let scale = clamp_scale_override.unwrap_or_else(|| {
+            dynamic.as_ref().map_or(1.0, |(_, head)| {
+                if head.is_empty() {
+                    1.0
+                } else {
+                    1.0 + 100.0 * head.norm_squared() / head.len() as f64
+                }
+            })
+        });
 
         let spline_jacobian = -splev_jacobian(
             self.knots.data.as_vec().clone(),
@@ -1187,13 +1207,20 @@ impl AUTOBKSpline {
                     return out;
                 }
 
-                let low_clamp = self.clamp_lo as f64 * scale * chi_der.view((0, 0), (nclamp, 1));
+                let scale_der = dynamic.as_ref().map_or(0.0, |(_, head)| {
+                    if head.is_empty() {
+                        0.0
+                    } else {
+                        200.0 * head.dot(&out) / head.len() as f64
+                    }
+                });
                 let high_start = chi_der.len() - nclamp - 1;
-                let high_clamp =
-                    self.clamp_hi as f64 * scale * chi_der.view((high_start, 0), (nclamp, 1));
-
-                out.extend(low_clamp.data.as_vec().to_owned());
-                out.extend(high_clamp.data.as_vec().to_owned());
+                for (start, weight) in [(0, self.clamp_lo), (high_start, self.clamp_hi)] {
+                    out.extend((start..start + nclamp).map(|i| {
+                        let chi = dynamic.as_ref().map_or(0.0, |(chi, _)| chi[i]);
+                        weight as f64 * (scale * chi_der[i] + scale_der * chi)
+                    }));
+                }
                 out
             })
             .collect::<Vec<DVector<f64>>>();
@@ -1907,3 +1934,7 @@ mod tests {
         Ok(())
     }
 }
+
+#[cfg(test)]
+#[path = "background/legacy_clamp_tests.rs"]
+mod legacy_clamp_tests;

rexafs-0.2.4/crates/rexafs/src/xafs/fft_grid.rs

@@ -0,0 +1,13 @@
+use serde::{Deserialize, Serialize};
+
+/// Forward-transform sampling and window domain. The default backend retains
+/// `Input`; the optional ndarray backend retains its extended `Larch` grid.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum FFTGrid {
+    /// Weight/window the supplied grid without resampling (historical default).
+    #[default]
+    Input,
+    /// Resample from k=0, extend the window through kmax+dk2, then truncate
+    /// the weighted chi and window to the measured range, as in Larch.
+    Larch,
+}

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/xafs/mod.rs

@@ -25,6 +25,7 @@ pub mod background;
 pub mod background;
 pub mod bessel_i0;
 pub mod errors;
+mod fft_grid;
 pub mod fitting;
 mod inverse_fft;
 pub mod io;

{rexafs-0.2.3 → rexafs-0.2.4}/crates/rexafs/src/xafs/xasspectrum.rs

@@ -1006,6 +1006,22 @@ impl XASSpectrum {
         }
     }
 
+    /// Wavenumbers for `kwin()`. In Larch mode these follow the resampled
+    /// FFT grid, which can differ from the background's `k()` spacing.
+    pub fn kwin_k(&self) -> Option<DVector<f64>> {
+        let ft = self.xftf.as_ref()?;
+        let len = ft.get_kwin()?.len();
+        if ft.grid == super::xrayfft::FFTGrid::Larch {
+            let step = *ft.get_kstep()?;
+            Some(DVector::from_iterator(
+                len,
+                (0..len).map(|i| i as f64 * step),
+            ))
+        } else {
+            Some(DVector::from_column_slice(self.k()?))
+        }
+    }
+
     pub fn kwin(&self) -> Option<DVector<f64>> {
         #[cfg(feature = "ndarray-compat")]
         {