From 7f4aacd632a9b941eca53a6e41b32c46f565fb95 Mon Sep 17 00:00:00 2001 From: "Haddad, Lucy (DLSLtd,RAL,CEO)" Date: Tue, 17 Nov 2026 11:08:45 +0000 Subject: [PATCH 1/5] add array types --- src/xas_toolbox/utils/typing.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 src/xas_toolbox/utils/typing.py diff --git a/src/xas_toolbox/utils/typing.py b/src/xas_toolbox/utils/typing.py new file mode 100644 index 0000000..56ba43f --- /dev/null +++ b/src/xas_toolbox/utils/typing.py @@ -0,0 +1,17 @@ +from typing import Any + +from numpy import complex128, dtype, float64, int_, ndarray, uint + +# AliasTypes for 1d and nd arrays of float/ints. + +_Array1dFloat = ndarray[tuple[Any], dtype[float64]] +_Array1dInt = ndarray[tuple[Any], dtype[uint | int_]] +_Array1dComplex = ndarray[tuple[Any], dtype[complex128]] + +_Array1d = _Array1dFloat | _Array1dInt | _Array1dComplex + +_ArrayNdFloat = ndarray[tuple[Any, ...], dtype[float64]] +_ArrayNdInt = ndarray[tuple[Any, ...], dtype[uint | int_]] +_ArrayNdComplex = ndarray[tuple[Any, ...], dtype[complex128]] + +_ArrayNd = _ArrayNdFloat | _ArrayNdInt | _ArrayNdComplex From 9559958743351d9cacabf670848c2c04134d2143 Mon Sep 17 00:00:00 2001 From: "Haddad, Lucy (DLSLtd,RAL,CEO)" Date: Tue, 17 Nov 2026 11:16:17 +0000 Subject: [PATCH 2/5] add new edge metadata routines --- src/xas_toolbox/xas/edges/find_e0.py | 75 ++++++++++++++++++++++++++-- 1 file changed, 70 insertions(+), 5 deletions(-) diff --git a/src/xas_toolbox/xas/edges/find_e0.py b/src/xas_toolbox/xas/edges/find_e0.py index 68383e1..e911281 100644 --- a/src/xas_toolbox/xas/edges/find_e0.py +++ b/src/xas_toolbox/xas/edges/find_e0.py @@ -8,6 +8,7 @@ from xraylib import EdgeEnergy, SymbolToAtomicNumber from xas_toolbox.utils.maths.start_stop import _mean_start_stop +from xas_toolbox.utils.typing import _Array1dFloat, _ArrayNdFloat from xas_toolbox.utils.xray import _edges logger = logging.getLogger(__name__) @@ -58,7 +59,63 @@ def calc_e0(x: np.ndarray, y: np.ndarray, sigma: float = 5): return edge_energy, np.array(edge_coords, dtype=int), edge_number -def edge_from_symbol(x: np.ndarray, y: np.ndarray, symbol: str) -> str: +def get_edge_symbol( + x: _ArrayNdFloat | _Array1dFloat | list[_Array1dFloat], + y: _Array1dFloat | _ArrayNdFloat, + symbol: str | None, +): + """ + Get absorption edge and atom labels for x, y data with optional absorbing atom + input. + + Arguments: + x: Energy array/list + y: Absorption array/list + symbol (Optional): Absorbing atom. + + Returns: + out: List/single value for predicted absorption edge + absorbing atom + (if symbol=`None`). + """ + if symbol is not None: + out = edge_from_symbol(x, y, symbol) + else: + if isinstance(x, np.ndarray) and x.ndim == 1: + e0, _, _ = calc_e0(x, y) + if isinstance(e0, list): + out = guess_edge(e0[0]) + else: + out = guess_edge(e0) + else: + out = [] + for i in range(x.shape[0]): + e0, idx, no = calc_e0(x[i, :], y[i, :]) + if isinstance(e0, list): + out.append(guess_edge(e0[0])) + else: + out.append(guess_edge(e0)) + return out + + +def edge_from_symbol( + x: _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat], + y: _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat], + symbol: str, +) -> str | list[str]: + if x.ndim > 1: + for i in range(x.shape[0]): + edge = edge_from_symbol(x[i, :], y[i, :], symbol=symbol) + else: + edge = edge_from_symbol(x, y, symbol) + edge = list(set(edge)) + if len(edge) == 1: + edge = edge[0] + return edge + + +def edge_from_symbol_1d( + x: _Array1dFloat, y: _Array1dFloat | _ArrayNdFloat, symbol: str +) -> str: """ Get absorption edge label for a sample with unkown edge but known absorbing atom. @@ -73,14 +130,21 @@ def edge_from_symbol(x: np.ndarray, y: np.ndarray, symbol: str) -> str: """ Z = SymbolToAtomicNumber(symbol) # noqa: N806 e0, ec, eno = calc_e0(x, y) - e0s = np.array([EdgeEnergy(Z, e.upper()) for e in _edges]) - diffs = np.abs(e0s - e0) + e0s = np.array([EdgeEnergy(Z, e.upper()) for e in _edges[5:]]) + if isinstance(e0, float): + diffs = np.abs(e0s - e0) + else: + diffs = np.abs(e0s - e0[0]) + edge = _edges[np.where(diffs == diffs.min())[0][0]] return edge def compare_e0s( - x: np.ndarray, y: np.ndarray, symbol: str | None = None, edge: str | None = None + x: _Array1dFloat, + y: _Array1dFloat | _ArrayNdFloat, + symbol: str | None = None, + edge: str | None = None, ): """ Get a tabulated e0 value from either sample metadata for absorbing atom + edge @@ -98,7 +162,8 @@ def compare_e0s( e0_calc (float): Calcuated e0 from `x` and `y`. """ e0_calc, idx, no = calc_e0(x, y) - e0_calc = e0_calc[0] + if isinstance(e0_calc, list): + e0_calc = e0_calc[0] if edge is None: if symbol is None: symbol, edge = guess_edge(e0_calc) From 724d222905d600b8b344c7bb46a841adfb0797c2 Mon Sep 17 00:00:00 2001 From: "Haddad, Lucy (DLSLtd,RAL,CEO)" Date: Tue, 17 Nov 2026 11:21:13 +0000 Subject: [PATCH 3/5] add shift x old routine. --- src/xas_toolbox/xas/alignment/align_stack.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/xas_toolbox/xas/alignment/align_stack.py b/src/xas_toolbox/xas/alignment/align_stack.py index 6c2ac07..0350a37 100644 --- a/src/xas_toolbox/xas/alignment/align_stack.py +++ b/src/xas_toolbox/xas/alignment/align_stack.py @@ -4,6 +4,7 @@ from xas_toolbox.io import XasMeasurement from xas_toolbox.utils.maths.interpolate import interpolate_data +from xas_toolbox.utils.typing import _Array1dFloat, _ArrayNdFloat logger = logging.getLogger(__name__) @@ -105,3 +106,19 @@ def align_stack(scan: XasMeasurement): scan_out.energy = energy_out scan_out.mu = mu_out return scan_out + + +def shift_to_iref( + x: _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat], delta_e: float | np.ndarray +) -> _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat]: + """ + Shift `x` array/list of arrays by `delta_e` values. + """ + if isinstance(x, np.ndarray): + out = np.empty_like(x) + out = x + delta_e + else: + out = [] + for i in range(len(x)): + out.append(x[i] + delta_e[i]) + return out From 244be33c4f14bd1e155302ddfc2d9348a82c4f97 Mon Sep 17 00:00:00 2001 From: "Haddad, Lucy (DLSLtd,RAL,CEO)" Date: Tue, 17 Nov 2026 11:35:32 +0000 Subject: [PATCH 4/5] fix mypy --- src/xas_toolbox/xas/alignment/align_stack.py | 4 +- src/xas_toolbox/xas/edges/find_e0.py | 45 ++++++++++++++------ 2 files changed, 34 insertions(+), 15 deletions(-) diff --git a/src/xas_toolbox/xas/alignment/align_stack.py b/src/xas_toolbox/xas/alignment/align_stack.py index 0350a37..3e30880 100644 --- a/src/xas_toolbox/xas/alignment/align_stack.py +++ b/src/xas_toolbox/xas/alignment/align_stack.py @@ -115,10 +115,10 @@ def shift_to_iref( Shift `x` array/list of arrays by `delta_e` values. """ if isinstance(x, np.ndarray): - out = np.empty_like(x) + out: _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat] = np.empty_like(x) out = x + delta_e else: out = [] for i in range(len(x)): - out.append(x[i] + delta_e[i]) + out.append(x[i] + delta_e[i]) # type: ignore return out diff --git a/src/xas_toolbox/xas/edges/find_e0.py b/src/xas_toolbox/xas/edges/find_e0.py index e911281..f80c02a 100644 --- a/src/xas_toolbox/xas/edges/find_e0.py +++ b/src/xas_toolbox/xas/edges/find_e0.py @@ -88,12 +88,20 @@ def get_edge_symbol( out = guess_edge(e0) else: out = [] - for i in range(x.shape[0]): - e0, idx, no = calc_e0(x[i, :], y[i, :]) - if isinstance(e0, list): - out.append(guess_edge(e0[0])) - else: - out.append(guess_edge(e0)) + if isinstance(x, np.ndarray): + for i in range(x.shape[0]): + e0, idx, no = calc_e0(x[i, :], y[i, :]) + if isinstance(e0, list): + out.append(guess_edge(e0[0])) + else: + out.append(guess_edge(e0)) + if isinstance(x, list): + for i in range(len(x)): + e0, idx, no = calc_e0(x[i], y[i]) + if isinstance(e0, list): + out.append(guess_edge(e0[0])) + else: + out.append(guess_edge(e0)) return out @@ -102,14 +110,23 @@ def edge_from_symbol( y: _Array1dFloat | _ArrayNdFloat | list[_Array1dFloat], symbol: str, ) -> str | list[str]: - if x.ndim > 1: - for i in range(x.shape[0]): - edge = edge_from_symbol(x[i, :], y[i, :], symbol=symbol) + if isinstance(x, np.ndarray): + if x.ndim > 1: + edge = [] + for i in range(x.shape[0]): + tmp = edge_from_symbol_1d(x[i, :], y[i, :], symbol=symbol) # type:ignore + edge.append(tmp) + else: + edge = edge_from_symbol_1d(x, np.array(y), symbol) else: - edge = edge_from_symbol(x, y, symbol) - edge = list(set(edge)) - if len(edge) == 1: - edge = edge[0] + edge = [] + for i in range(len(x)): + tmp = edge_from_symbol_1d(x[i], y[i], symbol=symbol) + edge.append(tmp) + + edge = list(set(edge)) + if len(edge) == 1: + edge = edge[0] return edge @@ -169,6 +186,8 @@ def compare_e0s( symbol, edge = guess_edge(e0_calc) else: edge = edge_from_symbol(x, y, symbol) + if isinstance(edge, list): + edge = edge[0] # compare with xraydb value: # e0_pred = xray_edge(symbol, edge, energy_only=True) e0_pred = EdgeEnergy(SymbolToAtomicNumber(symbol), _edges.index(edge.upper())) * 1e3 From 728f195af4eb5476c95836d25bea6a290a6e1fbe Mon Sep 17 00:00:00 2001 From: "Haddad, Lucy (DLSLtd,RAL,CEO)" Date: Tue, 17 Nov 2026 12:00:01 +0000 Subject: [PATCH 5/5] add tests for new fixes. --- src/xas_toolbox/xas/edges/find_e0.py | 4 +-- tests/test_alignment.py | 13 ++++++++ tests/test_edge_metadata.py | 48 ++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 2 deletions(-) create mode 100644 tests/test_edge_metadata.py diff --git a/src/xas_toolbox/xas/edges/find_e0.py b/src/xas_toolbox/xas/edges/find_e0.py index f80c02a..b8c5b0a 100644 --- a/src/xas_toolbox/xas/edges/find_e0.py +++ b/src/xas_toolbox/xas/edges/find_e0.py @@ -62,7 +62,7 @@ def calc_e0(x: np.ndarray, y: np.ndarray, sigma: float = 5): def get_edge_symbol( x: _ArrayNdFloat | _Array1dFloat | list[_Array1dFloat], y: _Array1dFloat | _ArrayNdFloat, - symbol: str | None, + symbol: str | None = None, ): """ Get absorption edge and atom labels for x, y data with optional absorbing atom @@ -147,7 +147,7 @@ def edge_from_symbol_1d( """ Z = SymbolToAtomicNumber(symbol) # noqa: N806 e0, ec, eno = calc_e0(x, y) - e0s = np.array([EdgeEnergy(Z, e.upper()) for e in _edges[5:]]) + e0s = np.array([EdgeEnergy(Z, i) for i in range(5)]) if isinstance(e0, float): diffs = np.abs(e0s - e0) else: diff --git a/tests/test_alignment.py b/tests/test_alignment.py index 509f8c7..9380466 100644 --- a/tests/test_alignment.py +++ b/tests/test_alignment.py @@ -2,6 +2,7 @@ from xas_toolbox.io import XasMeasurement from xas_toolbox.xas.alignment import align_scan, align_stack +from xas_toolbox.xas.alignment.align_stack import shift_to_iref from xas_toolbox.xas.data_generation import make_fake_spectrum, mix_scans @@ -39,3 +40,15 @@ def get_fn(valname: str): assert stacked.energy.shape[0] == len(as_data_1.energy) assert aligned.energy.ndim == 1 + + def test_iref_shift(self): + data = make_fake_spectrum("AsO2", "As", "K", nscans=1) + x = shift_to_iref(data.energy, delta_e=0.1) + assert len(x) == len(data.energy) + assert isinstance(x, np.ndarray) + assert x.ndim == 1 + + data = make_fake_spectrum("FeSO3", "Fe", "K", nscans=1) + energy = [data.energy] * 100 + x = shift_to_iref(energy, np.random.default_rng(12).choice(10, 100)) + assert isinstance(x, list) diff --git a/tests/test_edge_metadata.py b/tests/test_edge_metadata.py new file mode 100644 index 0000000..3c1eb17 --- /dev/null +++ b/tests/test_edge_metadata.py @@ -0,0 +1,48 @@ +from xas_toolbox.xas.data_generation import make_fake_spectrum +from xas_toolbox.xas.edges.find_e0 import get_edge_symbol + + +def test_detect_1d_no_symbol(): + spectrum = make_fake_spectrum("CuO", "Cu", "K", nscans=1) + edge = get_edge_symbol(spectrum.energy, spectrum.mu, symbol=None) + assert isinstance(edge, tuple) + assert edge[0] == "Cu" + assert edge[1].upper() == "K" + + +def test_detect_1d_symbol(): + spectrum = make_fake_spectrum("HoO2", "Ho", "L1", nscans=1) + edge = get_edge_symbol(spectrum.energy, spectrum.mu, "Tb") + assert isinstance(edge, str) + + +def test_detect_stack(): + s = make_fake_spectrum("PtRu", "Pt", "L3", nscans=30) + edge = get_edge_symbol(s.energy, s.mu, symbol=None) + assert isinstance(edge, tuple) + assert isinstance(edge[0], str) + assert isinstance(edge[1], str) + + s = make_fake_spectrum("AsO5", "As", "K", nscans=10) + edge = get_edge_symbol(s.energy, s.mu, symbol="As") + assert len(list(set(edge))) == 1 + assert list(set(edge)) == ["K"] + + +def test_detect_multi(): + x = [] + y = [] + for _ in range(5): + spectrum = make_fake_spectrum("FeO2", "Fe", "K", nscans=1) + x.append(spectrum.energy) + y.append(spectrum.mu) + edge = get_edge_symbol(x, y) + assert isinstance(edge, list) + for e in edge: + assert isinstance(e[0], str) + assert isinstance(e[1], str) + assert len(edge) == len(x) + + edge = get_edge_symbol(x, y, "Fe") + assert len(list(set(edge))) == 1 + assert list(set(edge)) == ["K"]