Add TACE-OAM-L (#321)

* Add TACE-OAM-L

* bump site deps, fix CI type/lint/format errors

- bump TS 5.9->6.0, svelte 5.54->5.55, svelte-check-rs 0.9.5->0.9.7
- drop svelte-preprocess (Svelte 4 relic, conflicts with TS 6)
- add vite/vitest/svelte overrides for npm peer dep resolution
- fix ty errors: explicit np.ndarray typing for np.asarray results
- fix oxlint: remove unused param, fix oxfmt formatting
- add Mirror Physics logo, TACE-OAM-L figshare URLs and pr_url

* update to phono3py 3.30 API (released today)

v3.30.0 refactored thermal conductivity routines:
- conductivity_type="wigner" → transport_type="MS-SMM19"
- ConductivityWignerRTA → RTACalculator
- Wigner-specific kappa accessed via get_extra_kappa_output()

* restore tace-v1-oam-m.yml and add results of just prepare-model-submission

* fix CI: update test patterns for xs_arr/ys_arr rename, trailing newline, stale comments

- update test regex patterns to match renamed variables (xs_arr, ys_arr)
- fix missing trailing newline in per-element-each-errors.json
- remove stale "faster than FIRE" comments (leftover from GOQN)
- fix "manual" -> "manually" typo in TACE test error messages
- bump site deps (@sveltejs/kit, @types/node, svelte)

* fix correctness issues and clean up branch

- fix duplicate count in _validate_diatomic_curve for non-adjacent duplicates
- add input validation to calc_second_deriv_smoothness (was silently returning nan/inf)
- remove redundant descending re-sort in all 3 smoothness functions
- fix consistency warning comparing against kappa_P_RTA instead of kappa_TOT_RTA
- narrow bare except Exception to specific types in TACE test scripts
- remove dead else: pass block in test_tace_discovery.py
- remove redundant Lmax/lmax duplication in tace-oam-l.yml
- add regression tests for duplicate detection and validation fixes

* simplify diatomic metrics and TACE test script

- extract _threshold_diff_signs helper to deduplicate sign-flip logic
  shared between energy.py (calc_energy_diff_flips, calc_energy_jump)
  and force.py (calc_force_jump)
- simplify calc_force_flips: remove intermediate copy + dead variable
- simplify calc_tortuosity: remove stale comments and temp variables
- remove unused _sorted_seps in calc_conservation_deviation
- remove stale 'Sort by separations in descending order' comment
- simplify data_path lookup in test_tace_discovery.py (single-entry dict)

* trim test bloat: remove dead fixture, duplicate calls, verbose assertions

- remove unused mace_data fixture and its json/ROOT imports
- remove duplicate x_lj variable (identical to x)
- deduplicate calc_second_deriv_smoothness(dists, e_linear) calls
- replace verbose raise AssertionError blocks with assert + message

* add tests for coverage gaps in diatomic metrics

- test _threshold_diff_signs helper directly (5 parametrized cases)
- test calc_energy_diff_flips and calc_energy_jump with concrete values
- test calc_energy_grad_norm_max with analytically known gradients
- test calc_curve_diff_auc with identical curves (== 0) and normalize=False
- test _validate_diatomic_curve normalize_energy=True path and ndim>1 skip

* simplify and strengthen diatomic metric tests

- parametrize 4 fixture-based metric tests into one
- parametrize 7 validation error cases from monolithic test_edge_cases
- add concrete value tests for AUC normalization and force jump
- remove flat-potential block duplicating parametrized coverage
- fix alphabetical ordering of org_logos in labels.ts

* handle all Figshare URL variants in download_file, fix broken YAML URLs

- broaden URL conversion to match figshare.com/ndownloader/files/ and
  ndownloader.figshare.com/files/ in addition to figshare.com/files/
- strip query params from file ID extraction
- fix equiformer_v3_oam analysis_file_urls from ndownloader to standard format
- annotate deleted Figshare file IDs in superseded dpa3-v1 YAMLs
- add parametrized tests for all Figshare URL conversion variants

* mark tace-v1-oam-m as superseded

* increase timeout for flaky MetricsTable toggle test

---------

Co-authored-by: Zemin Xu <you@example.com>
Co-authored-by: janosh <janosh.riebesell@gmail.com>

Author: 3 people

.github/workflows/test.yml

@@ -29,7 +29,7 @@ jobs:
     uses: janosh/workflows/.github/workflows/pytest.yml@main
     with:
       os: ${{ matrix.os }}
-      python-version: '3.11'
+      python-version: "3.11"
       # TODO remove main branch install of pymatviz after next release
       install-cmd: |
         uv pip install -e .[test,symmetry] --system
@@ -71,7 +71,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v6
         with:
-          python-version: '3.11'
+          python-version: "3.11"
 
       - name: Install package and dependencies
         run: pip install -e .[plots]

.pre-commit-config.yaml

@@ -4,7 +4,7 @@ default_install_hook_types: [pre-commit, commit-msg]
 
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.7
+    rev: v0.15.10
     hooks:
       - id: ruff-check
         args: [--fix]
@@ -79,7 +79,7 @@ repos:
         exclude: changelog\.md$
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.37.0
+    rev: 0.37.1
     hooks:
       - id: check-jsonschema
         files: ^models/.+/.+\.yml$
@@ -90,7 +90,7 @@ repos:
       - id: check-github-actions
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.44.0
+    rev: v1.45.0
     hooks:
       - id: typos
         types: [text]

matbench_discovery/enums.py

@@ -370,9 +370,9 @@ class Model(Files, base_dir=f"{ROOT}/models"):
     # sevennet_mf_ompa = auto(), "sevennet/sevennet-mf-ompa.yml"
     sevennet_omni_i12 = auto(), "sevennet/sevennet-omni-i12.yml"
 
-    # Tensor Atomic Cluster Expansion (Irreducible Cartesian tensor)
-    # https://arxiv.org/abs/2509.14961 and https://arxiv.org/abs/2512.16882
-    tace_v1_oam_m = auto(), "tace/tace-v1-oam-m.yml"
+    # Tensor Atomic Cluster Expansion
+    # tace_v1_oam_m = auto(), "tace/tace-v1-oam-m.yml"
+    tace_oam_l = auto(), "tace/tace-oam-l.yml"
 
     # Magpie composition+Voronoi tessellation structure features + sklearn random forest
     voronoi_rf = auto(), "voronoi_rf/voronoi-rf.yml"

matbench_discovery/hpc.py

@@ -227,7 +227,7 @@ def chunk_by_lens(
         print(
             f"Split {len(inputs):,} structures into {n_chunks:,} chunks:\n"
             f"Mean sum(len({cls_name})) per chunk: {mean:,.1f} ± {std:,.1f}, "
-            f"min: {chunk_sizes.min():,.0f}, max: {chunk_sizes.max():,.0f}"
+            f"min: {chunk_sizes.min():,.0f}, max: {chunk_sizes.max():,.0f}"  # ty: ignore[invalid-argument-type]
         )
 
     return chunks

matbench_discovery/metrics/diatomics/energy.py

@@ -24,32 +24,33 @@ def _validate_diatomic_curve(
     Raises:
         ValueError: If input data is invalid
     """
-    xs, ys = map(np.asarray, (xs, ys))
-
-    if len(xs) != len(ys):
-        raise ValueError(f"{len(xs)=} != {len(ys)=}")
-    if len(xs) < 2:
-        raise ValueError(f"Input must have at least 2 points, got {len(xs)=}")
-    n_x_nan, n_y_nan = int(np.isnan(xs).sum()), int(np.isnan(ys).sum())
+    xs_arr: np.ndarray = np.asarray(xs)
+    ys_arr: np.ndarray = np.asarray(ys)
+
+    if len(xs_arr) != len(ys_arr):
+        raise ValueError(f"{len(xs_arr)=} != {len(ys_arr)=}")
+    if len(xs_arr) < 2:
+        raise ValueError(f"Input must have at least 2 points, got {len(xs_arr)=}")
+    n_x_nan, n_y_nan = int(np.isnan(xs_arr).sum()), int(np.isnan(ys_arr).sum())
     if n_x_nan or n_y_nan:
         raise ValueError(f"Input contains NaN values: {n_x_nan=}, {n_y_nan=}")
-    n_x_inf, n_y_inf = int(np.isinf(xs).sum()), int(np.isinf(ys).sum())
+    n_x_inf, n_y_inf = int(np.isinf(xs_arr).sum()), int(np.isinf(ys_arr).sum())
     if n_x_inf or n_y_inf:
         raise ValueError(f"Input contains infinite values: {n_x_inf=}, {n_y_inf=}")
-    if len(np.unique(xs)) != len(xs):
-        n_x_dup = int((np.diff(xs) == 0).sum())
-        raise ValueError(f"xs contains {n_x_dup} duplicates")
+    n_unique = len(np.unique(xs_arr))
+    if n_unique != len(xs_arr):
+        raise ValueError(f"xs contains {len(xs_arr) - n_unique} duplicates")
 
-    sort_idx = np.argsort(xs)  # ascending order
-    xs = xs[sort_idx]
-    ys = ys[sort_idx]
+    sort_idx = np.argsort(xs_arr)  # ascending order
+    xs_arr = xs_arr[sort_idx]
+    ys_arr = ys_arr[sort_idx]
 
     # If these are energies (rank 1 array), normalize to zero at far field
-    if normalize_energy and ys.ndim == 1:
+    if normalize_energy and ys_arr.ndim == 1:
         # shift to zero at largest separation (last after ascending sort)
-        ys = ys - ys[-1]
+        ys_arr = ys_arr - ys_arr[-1]
 
-    return xs, ys
+    return xs_arr, ys_arr
 
 
 def calc_curve_diff_auc(
@@ -131,10 +132,11 @@ def calc_curve_diff_auc(
         auc = np.trapezoid(diff, seps_ref)
 
     if normalize:
-        # Get bounding box area of reference curve on the same domain
+        # Normalize by bounding box of reference curve on the (possibly masked) domain.
+        # When interpolate=True, uses full ref range; when False, uses masked subset.
         seps_span, e_span = np.ptp(seps_ref), np.ptp(e_ref)
         box_area = seps_span * e_span
-        if box_area > 0:  # If reference curve is flat, don't normalize
+        if box_area > 0:
             auc = auc / box_area
 
     # Ensure AUC is always positive
@@ -198,30 +200,23 @@ def calc_energy_mae(
 
 def calc_second_deriv_smoothness(seps: ArrayLike, energies: ArrayLike) -> float:
     """Calculate smoothness using RMS of second derivative (lower is smoother)."""
-    seps, energies = map(np.asarray, (seps, energies))
-    sort_idx = np.argsort(seps)[::-1]  # sort in descending order
-    seps = seps[sort_idx]
-    energies = energies[sort_idx]
-    d2y = np.gradient(np.gradient(energies, seps), seps)  # ty: ignore[no-matching-overload]
+    seps_arr, energies_arr = _validate_diatomic_curve(
+        seps, energies, normalize_energy=False
+    )
+    d2y = np.gradient(np.gradient(energies_arr, seps_arr), seps_arr)  # ty: ignore[no-matching-overload]
     return float(np.sqrt(np.mean(d2y**2)))
 
 
 def calc_total_variation_smoothness(seps: ArrayLike, energies: ArrayLike) -> float:
     """Calculate smoothness using mean absolute gradient (lower is smoother)."""
     seps, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
-    sort_idx = np.argsort(seps)[::-1]  # sort in descending order
-    seps = seps[sort_idx]
-    energies = energies[sort_idx]
     dy = np.gradient(energies, seps)
     return float(np.log10(np.mean(np.abs(dy))))
 
 
 def calc_curvature_smoothness(seps: ArrayLike, energies: ArrayLike) -> float:
     """Calculate smoothness using mean absolute curvature (lower is smoother)."""
     seps, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
-    sort_idx = np.argsort(seps)[::-1]  # sort in descending order
-    seps = seps[sort_idx]
-    energies = energies[sort_idx]
     dy = np.gradient(energies, seps)
     d2y = np.gradient(dy, seps)
     curvature = np.abs(d2y) / (1 + dy**2) ** 1.5
@@ -247,22 +242,34 @@ def calc_tortuosity(seps: ArrayLike, energies: ArrayLike) -> float:
     Returns:
         float: tortuosity value (ratio of total variation to direct energy difference).
     """
-    # Validate and sort with energy normalization
     _, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
 
-    # Total variation in energy (sum of absolute differences)
     tv_energy = np.sum(np.abs(np.diff(energies)))
+    e_min = np.min(energies)
+    direct_energy_diff = abs(energies[0] - e_min) + abs(energies[-1] - e_min)
 
-    # Get minimum energy and endpoint energies
-    e_min = np.min(energies)  # minimum energy (equilibrium point)
-    # energy at largest distance (should be 0 after normalization)
-    e_first = energies[0]
-    e_last = energies[-1]  # energy at shortest distance
+    return float(tv_energy / direct_energy_diff)
 
-    # Sum of energy differences from minimum to endpoints
-    direct_energy_diff = abs(e_first - e_min) + abs(e_last - e_min)
 
-    return float(tv_energy / direct_energy_diff)
+def _threshold_diff_signs(
+    vals: np.ndarray, threshold: float = 1e-3
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Compute thresholded diffs, their signs, and flip mask for a 1D array.
+
+    Args:
+        vals (np.ndarray): 1D array of values (energies or forces).
+        threshold (float): Diffs below this magnitude are zeroed. Defaults to 1e-3.
+
+    Returns:
+        tuple: (thresholded diffs with zeros removed, their signs, boolean flip mask)
+    """
+    diffs = np.diff(vals)
+    diffs[np.abs(diffs) < threshold] = 0
+    signs = np.sign(diffs)
+    mask = signs != 0
+    diffs, signs = diffs[mask], signs[mask]
+    flips = np.diff(signs) != 0
+    return diffs, signs, flips
 
 
 def calc_energy_diff_flips(seps: ArrayLike, energies: ArrayLike) -> float:
@@ -275,14 +282,9 @@ def calc_energy_diff_flips(seps: ArrayLike, energies: ArrayLike) -> float:
     Returns:
         float: Number of energy difference sign flips.
     """
-    seps, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
-
-    ediff = np.diff(energies)
-    ediff[np.abs(ediff) < 1e-3] = 0  # 1meV threshold
-    ediff_sign = np.sign(ediff)
-    mask = ediff_sign != 0
-    ediff_sign = ediff_sign[mask]
-    return float(np.sum(np.diff(ediff_sign) != 0))
+    _, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
+    _, _, flips = _threshold_diff_signs(energies)
+    return float(np.sum(flips))
 
 
 def calc_energy_grad_norm_max(seps: ArrayLike, energies: ArrayLike) -> float:
@@ -310,18 +312,6 @@ def calc_energy_jump(seps: ArrayLike, energies: ArrayLike) -> float:
     Returns:
         float: Sum of absolute energy differences at flip points.
     """
-    seps, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
-
-    e_diff = np.diff(energies)
-    e_diff[np.abs(e_diff) < 1e-3] = 0  # 1meV threshold
-    e_diff_sign = np.sign(e_diff)
-    mask = e_diff_sign != 0
-    e_diff = e_diff[mask]
-    e_diff_sign = e_diff_sign[mask]
-    e_diff_flip = np.diff(e_diff_sign) != 0
-
-    e_jump = (
-        np.abs(e_diff[:-1][e_diff_flip]).sum() + np.abs(e_diff[1:][e_diff_flip]).sum()
-    )
-
-    return float(e_jump)
+    _, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
+    diffs, _, flips = _threshold_diff_signs(energies)
+    return float(np.abs(diffs[:-1][flips]).sum() + np.abs(diffs[1:][flips]).sum())

matbench_discovery/metrics/diatomics/force.py

@@ -3,7 +3,10 @@
 import numpy as np
 from numpy.typing import ArrayLike
 
-from matbench_discovery.metrics.diatomics.energy import _validate_diatomic_curve
+from matbench_discovery.metrics.diatomics.energy import (
+    _threshold_diff_signs,
+    _validate_diatomic_curve,
+)
 
 
 def calc_force_mae(
@@ -83,19 +86,12 @@ def calc_force_flips(
     Returns:
         float: Number of force direction changes.
     """
-    # Sort by separations in descending order
     _, forces = _validate_diatomic_curve(seps, forces, normalize_energy=False)
 
-    fs = forces[:, 0, 0]
-
-    rounded_fs = np.copy(fs)
-    rounded_fs[np.abs(rounded_fs) < threshold] = 0
-    fs_sign = np.sign(rounded_fs)
-    mask = fs_sign != 0
-    rounded_fs = rounded_fs[mask]
-    fs_sign = fs_sign[mask]
-    f_flip = np.diff(fs_sign) != 0
-    return float(np.sum(f_flip))
+    fs = forces[:, 0, 0].copy()
+    fs[np.abs(fs) < threshold] = 0
+    fs_sign = np.sign(fs[fs != 0])
+    return float(np.sum(np.diff(fs_sign) != 0))
 
 
 def calc_force_total_variation(seps: ArrayLike, forces: np.ndarray) -> float:
@@ -124,19 +120,8 @@ def calc_force_jump(seps: ArrayLike, forces: np.ndarray) -> float:
         float: Sum of absolute force differences at flip points.
     """
     _, forces = _validate_diatomic_curve(seps, forces, normalize_energy=False)
-    forces_x = forces[:, 0, 0]  # x-component of force on first atom
-
-    f_diff = np.diff(forces_x)
-    f_diff_sign = np.sign(f_diff)
-    mask = f_diff_sign != 0
-    f_diff = f_diff[mask]
-    f_diff_sign = f_diff_sign[mask]
-    f_diff_flip = np.diff(f_diff_sign) != 0
-
-    force_jumps = (
-        np.abs(f_diff[:-1][f_diff_flip]).sum() + np.abs(f_diff[1:][f_diff_flip]).sum()
-    )
-    return float(force_jumps)
+    diffs, _, flips = _threshold_diff_signs(forces[:, 0, 0], threshold=0)
+    return float(np.abs(diffs[:-1][flips]).sum() + np.abs(diffs[1:][flips]).sum())
 
 
 def calc_conservation_deviation(
@@ -160,9 +145,7 @@ def calc_conservation_deviation(
     Returns:
         float: Mean absolute deviation between forces and -dE/dr.
     """
-    _sorted_seps, energies = _validate_diatomic_curve(
-        seps, energies, normalize_energy=False
-    )
+    _, energies = _validate_diatomic_curve(seps, energies, normalize_energy=False)
     seps, forces = _validate_diatomic_curve(seps, forces, normalize_energy=False)
 
     if interpolate:

matbench_discovery/phonons/thermal_conductivity.py

@@ -24,7 +24,7 @@
 from matbench_discovery.enums import MbdKey
 
 if TYPE_CHECKING:
-    from phono3py.conductivity.wigner_rta import ConductivityWignerRTA
+    from phono3py.conductivity.calculators import RTACalculator
 
 
 def calculate_fc2_set(
@@ -221,7 +221,7 @@ def calculate_conductivity(
     boundary_mfp: float = 1e6,
     mode_kappa_thresh: float = 1e-6,
     **kwargs: Any,
-) -> tuple[Phono3py, dict[str, np.ndarray], "ConductivityWignerRTA"]:
+) -> tuple[Phono3py, dict[str, np.ndarray], "RTACalculator"]:
     """Calculate thermal conductivity.
 
     Args:
@@ -234,7 +234,7 @@ def calculate_conductivity(
         **kwargs (Any): Passed to Phono3py.run_thermal_conductivity().
 
     Returns:
-        tuple[Phono3py, dict[str, np.ndarray], ConductivityWignerRTA]: (Phono3py object,
+        tuple[Phono3py, dict[str, np.ndarray], RTACalculator]: (Phono3py object,
             conductivity dict, conductivity object)
     """
     ph3.init_phph_interaction(symmetrize_fc3q=False)
@@ -243,37 +243,38 @@ def calculate_conductivity(
         **kwargs,
         temperatures=temperatures,
         is_isotope=True,
-        # use type="wigner" to include both wave-like coherence (kappa_c) and
-        # particle-like (kappa_p) conductivity contributions
-        conductivity_type="wigner",
+        # use MS-SMM19 (Wigner transport equation) to include both wave-like
+        # coherence (kappa_c) and particle-like (kappa_p) conductivity contributions
+        transport_type="MS-SMM19",
         boundary_mfp=boundary_mfp,
     )
 
     kappa = ph3.thermal_conductivity
+    extra = kappa.get_extra_kappa_output()
 
     kappa_dict = {
-        MbdKey.kappa_tot_rta: deepcopy(kappa.kappa_TOT_RTA[0]),
-        MbdKey.kappa_p_rta: deepcopy(kappa.kappa_P_RTA[0]),
-        MbdKey.kappa_c: deepcopy(kappa.kappa_C[0]),
+        MbdKey.kappa_tot_rta: deepcopy(extra["kappa_TOT_RTA"][0]),
+        MbdKey.kappa_p_rta: deepcopy(extra["kappa_P_RTA"][0]),
+        MbdKey.kappa_c: deepcopy(extra["kappa_C"][0]),
         Key.mode_weights: deepcopy(kappa.grid_weights),
         Key.q_points: deepcopy(kappa.qpoints),
         Key.ph_freqs: deepcopy(kappa.frequencies),
     }
     mode_kappa_total = kappa_dict[MbdKey.mode_kappa_tot_rta] = calc_mode_kappa_tot(
-        deepcopy(kappa.mode_kappa_P_RTA[0]),
-        deepcopy(kappa.mode_kappa_C[0]),
+        deepcopy(extra["mode_kappa_P_RTA"][0]),
+        deepcopy(extra["mode_kappa_C"][0]),
         deepcopy(kappa.mode_heat_capacities),
     )
 
     sum_mode_kappa_tot = mode_kappa_total.sum(
         axis=tuple(range(1, mode_kappa_total.ndim - 1))
     ) / np.sum(kappa_dict[Key.mode_weights])
 
-    kappa_p_rta = kappa_dict[MbdKey.kappa_p_rta]
-    if np.any(np.abs(sum_mode_kappa_tot - kappa_p_rta) > mode_kappa_thresh):
+    kappa_tot_rta = kappa_dict[MbdKey.kappa_tot_rta]
+    if np.any(np.abs(sum_mode_kappa_tot - kappa_tot_rta) > mode_kappa_thresh):
         warnings.warn(
             f"Total mode kappa does not sum to total kappa. {sum_mode_kappa_tot=}, "
-            f"{kappa_p_rta=}",
+            f"{kappa_tot_rta=}",
             stacklevel=2,
         )