matterviz 0.3.6 → 0.4.0

package/dist/symmetry/index.js

@@ -0,0 +1,226 @@
+import { ATOMIC_NUMBER_TO_SYMBOL, SYMBOL_TO_ATOMIC_NUMBER } from '../composition/parse';
+import { DEFAULTS } from '../settings';
+import { merge_split_partial_sites } from '../structure/partial-occupancy';
+import init, { analyze_cell } from '@spglib/moyo-wasm';
+import moyo_wasm_url from '@spglib/moyo-wasm/moyo_wasm_bg.wasm?url';
+export * from './cell-transform';
+export * from './spacegroups';
+export { default as SymmetryStats } from './SymmetryStats.svelte';
+export { default as WyckoffTable } from './WyckoffTable.svelte';
+// Keys are standard crystallographic symbols (P, I, F, A, B, C, R)
+export const BRAVAIS_LATTICES = {
+    P: `Primitive`,
+    I: `Body-centered`,
+    F: `Face-centered`,
+    A: `A-face centered`,
+    B: `B-face centered`,
+    C: `C-face centered`,
+    R: `Rhombohedral`,
+};
+export const default_sym_settings = {
+    symprec: DEFAULTS.symmetry.symprec,
+    algo: DEFAULTS.symmetry.algo,
+};
+let initialized = false;
+const OCCUPANCY_EPS = 1e-8;
+const to_unit = (value) => value - Math.floor(value);
+const near_zero = (value) => Math.min(value, 1 - value);
+const near_half = (value) => Math.abs(value - 0.5);
+const symmetry_position_key = (pos) => pos.map((coord) => to_unit(coord).toFixed(8)).join(`,`);
+const periodic_distance = (pos1, pos2) => Math.sqrt(pos1.reduce((sum, coord, idx) => {
+    // Wrap delta into [-0.5, 0.5) using safe modulo
+    const delta = coord - pos2[idx];
+    const wrapped = ((((delta + 0.5) % 1) + 1) % 1) - 0.5;
+    const distance = Math.abs(wrapped);
+    return sum + distance * distance;
+}, 0));
+export async function ensure_moyo_wasm_ready(wasm_url) {
+    if (initialized)
+        return;
+    // Use provided URL (e.g. from VSCode webview data), otherwise use Vite-bundled URL
+    const url = wasm_url ?? moyo_wasm_url;
+    await init({ module_or_path: url });
+    initialized = true;
+}
+function get_site_atomic_number(site, site_idx) {
+    const occupancy_by_element = new Map();
+    for (const { element, occu } of site.species) {
+        if (occu <= OCCUPANCY_EPS)
+            continue;
+        occupancy_by_element.set(element, (occupancy_by_element.get(element) ?? 0) + occu);
+    }
+    let selected_element = site.species[0]?.element;
+    let best_occupancy = -Infinity;
+    occupancy_by_element.forEach((occupancy, element) => {
+        if (occupancy > best_occupancy ||
+            (occupancy === best_occupancy && element.localeCompare(selected_element ?? ``) < 0)) {
+            selected_element = element;
+            best_occupancy = occupancy;
+        }
+    });
+    if (selected_element === undefined) {
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
+    }
+    const atomic_number = SYMBOL_TO_ATOMIC_NUMBER[selected_element];
+    if (atomic_number === undefined) {
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
+    }
+    return atomic_number;
+}
+function build_moyo_input_cell(structure) {
+    const merged_render_sites = merge_split_partial_sites(structure.sites);
+    return {
+        positions: merged_render_sites.map(({ site }) => site.abc),
+        numbers: merged_render_sites.map(({ site, site_idx }) => get_site_atomic_number(site, site_idx)),
+        orig_site_indices_by_input_idx: merged_render_sites.map(({ source_site_indices }) => source_site_indices),
+    };
+}
+function build_moyo_cell(structure, positions, numbers) {
+    // nalgebra Matrix3 deserializes as a flat list in COLUMN-MAJOR of the internal basis B
+    // Internal B = transpose(row-basis RB). column-major(B) == row-major(RB).
+    // So supply row-major of the pymatgen lattice.matrix (RB).
+    const [v_a, v_b, v_c] = structure.lattice.matrix;
+    return {
+        lattice: { basis: [...v_a, ...v_b, ...v_c] },
+        positions,
+        numbers,
+    };
+}
+export function to_cell_json(structure) {
+    const { positions, numbers } = build_moyo_input_cell(structure);
+    return JSON.stringify(build_moyo_cell(structure, positions, numbers));
+}
+const fractional_sq_dist = (pos_1, pos_2) => (pos_1[0] - pos_2[0] - Math.round(pos_1[0] - pos_2[0])) ** 2 +
+    (pos_1[1] - pos_2[1] - Math.round(pos_1[1] - pos_2[1])) ** 2 +
+    (pos_1[2] - pos_2[2] - Math.round(pos_1[2] - pos_2[2])) ** 2;
+export const map_std_to_orig_site_indices = (std_positions, std_numbers, input_positions, input_numbers, orig_site_indices_by_input_idx) => std_positions.map((std_pos, std_idx) => {
+    const std_number = std_numbers[std_idx];
+    let nearest_input_idx = -1;
+    let nearest_sq_dist = Infinity;
+    for (let input_idx = 0; input_idx < input_positions.length; input_idx += 1) {
+        if (input_numbers[input_idx] !== std_number)
+            continue;
+        const sq_dist = fractional_sq_dist(std_pos, input_positions[input_idx]);
+        if (sq_dist < nearest_sq_dist) {
+            nearest_sq_dist = sq_dist;
+            nearest_input_idx = input_idx;
+        }
+    }
+    if (nearest_input_idx === -1)
+        return [];
+    return orig_site_indices_by_input_idx[nearest_input_idx] ?? [];
+});
+export async function analyze_structure_symmetry(struct_or_mol, settings) {
+    await ensure_moyo_wasm_ready();
+    if (!(`lattice` in struct_or_mol)) {
+        throw new Error(`Symmetry analysis requires a periodic structure with a lattice`);
+    }
+    const moyo_input_cell = build_moyo_input_cell(struct_or_mol);
+    const cell_json = JSON.stringify(build_moyo_cell(struct_or_mol, moyo_input_cell.positions, moyo_input_cell.numbers));
+    const { symprec, algo } = { ...default_sym_settings, ...settings };
+    // Map "Moyo" to "Standard" for moyo-wasm
+    const moyo_algo = algo === `Moyo` ? `Standard` : algo;
+    const sym_data = analyze_cell(cell_json, symprec, moyo_algo);
+    const orig_site_indices_by_std_idx = map_std_to_orig_site_indices(sym_data.std_cell.positions, sym_data.std_cell.numbers, moyo_input_cell.positions, moyo_input_cell.numbers, moyo_input_cell.orig_site_indices_by_input_idx);
+    return { ...sym_data, orig_site_indices_by_std_idx };
+}
+// Helper function to score coordinate simplicity for Wyckoff table
+export function simplicity_score(vec) {
+    const [ax, ay, az] = vec?.map(to_unit) ?? [];
+    return (near_zero(ax) +
+        near_zero(ay) +
+        near_zero(az) +
+        0.5 * (near_half(ax) + near_half(ay) + near_half(az)));
+}
+// Generate Wyckoff table rows from symmetry data
+export function wyckoff_positions_from_moyo(sym_data) {
+    if (!sym_data)
+        return [];
+    const { positions, numbers } = sym_data.std_cell;
+    const { wyckoffs, orig_indices, orig_site_indices_by_std_idx } = sym_data;
+    // Group sites by letter-element combination and track all indices
+    const groups = new Map();
+    // Process all atoms in the standardized cell
+    // Note: wyckoffs array may be shorter than std_cell when moyo combines symmetry-equivalent sites
+    for (let idx = 0; idx < numbers.length; idx++) {
+        // Use wyckoff letter if available, otherwise mark as non-symmetric
+        const full = idx < wyckoffs.length ? wyckoffs[idx] : null;
+        const letter = full?.match(/[a-z]+$/)?.[0] ?? full ?? ``;
+        const atomic_num = numbers[idx];
+        const elem = ATOMIC_NUMBER_TO_SYMBOL[atomic_num] ?? `?`;
+        const position = positions[idx];
+        const key = letter ? `${letter}|${elem}` : `nosym|${elem}|${idx}`;
+        const group = groups.get(key) ?? { letter, elem, indices: [], positions: [] };
+        group.indices.push(idx);
+        group.positions.push(position);
+        groups.set(key, group);
+    }
+    const rows = Array.from(groups.values()).map(({ letter, elem, indices, positions: group_positions }) => {
+        // Find the position with the best simplicity score to display
+        const best_pos = group_positions.reduce((best, pos) => {
+            const score = simplicity_score(pos);
+            return score < best.score ? { pos, score } : best;
+        }, { pos: group_positions[0], score: simplicity_score(group_positions[0]) }).pos;
+        // Map standardized cell indices back to original structure indices
+        const orig_site_indices = orig_site_indices_by_std_idx
+            ? indices.flatMap((std_idx) => orig_site_indices_by_std_idx[std_idx] ?? [])
+            : orig_indices
+                ? indices.map((std_idx) => orig_indices[std_idx]).filter((idx) => idx !== undefined)
+                : indices;
+        const wyckoff = letter ? `${indices.length}${letter}` : `1`;
+        return {
+            wyckoff,
+            elem,
+            abc: best_pos,
+            site_indices: [...new Set(orig_site_indices)].sort((idx_a, idx_b) => idx_a - idx_b),
+        };
+    });
+    rows.sort((w1, w2) => {
+        const [w1_mult, w2_mult] = [parseInt(w1.wyckoff, 10), parseInt(w2.wyckoff, 10)];
+        if (w1_mult !== w2_mult)
+            return w1_mult - w2_mult;
+        return w1.wyckoff.localeCompare(w2.wyckoff);
+    });
+    return rows;
+}
+// Apply symmetry operations to find all equivalent positions for a given fractional coordinate
+export function apply_symmetry_operations(position, operations, _tolerance = 1e-6) {
+    const seen = new Set();
+    return operations
+        .map(({ rotation, translation }) => {
+        // new_pos = W·position + t; moyo serializes W COLUMN-major: W[dim][j] = rotation[dim + 3j]
+        const new_pos = [0, 1, 2].map((dim) => rotation[dim] * position[0] +
+            rotation[dim + 3] * position[1] +
+            rotation[dim + 6] * position[2] +
+            translation[dim]);
+        return new_pos.map(to_unit);
+    })
+        .filter((pos) => {
+        const pos_key = symmetry_position_key(pos);
+        if (seen.has(pos_key))
+            return false;
+        seen.add(pos_key);
+        return true;
+    });
+}
+// Map Wyckoff positions to all equivalent atoms in the displayed structure (including image atoms)
+export function map_wyckoff_to_all_atoms(wyckoff_positions, displayed_structure, orig_structure, sym_data, tolerance = 1e-5) {
+    if (!sym_data?.operations || !displayed_structure.sites || !orig_structure.sites) {
+        return wyckoff_positions;
+    }
+    return wyckoff_positions.map((wyckoff_pos) => {
+        const indices = (wyckoff_pos.site_indices ?? [])
+            .filter((idx) => idx < orig_structure.sites.length)
+            .flatMap((orig_idx) => {
+            const { abc: orig_abc, species } = orig_structure.sites[orig_idx];
+            const element = species[0]?.element;
+            const equivalent_positions = apply_symmetry_operations(orig_abc, sym_data.operations, tolerance);
+            return displayed_structure.sites
+                .map((site, display_idx) => ({ site, display_idx }))
+                .filter(({ site }) => site.species[0]?.element === element)
+                .filter(({ site }) => equivalent_positions.some((equiv_pos) => periodic_distance(equiv_pos, site.abc) < tolerance))
+                .map(({ display_idx }) => display_idx);
+        });
+        return { ...wyckoff_pos, site_indices: [...new Set(indices)].sort((a, b) => a - b) };
+    });
+}

package/dist/symmetry/spacegroups.d.ts

@@ -0,0 +1,16 @@
+import type { SunburstNode } from '../plot/core/types';
+export declare const CRYSTAL_SYSTEM_RANGES: Record<CrystalSystem, [number, number]>;
+export declare const CRYSTAL_SYSTEM_COLORS: Record<CrystalSystem, string>;
+export declare const CRYSTAL_SYSTEMS: readonly ["triclinic", "monoclinic", "orthorhombic", "tetragonal", "trigonal", "hexagonal", "cubic"];
+export type CrystalSystem = (typeof CRYSTAL_SYSTEMS)[number];
+export declare function spacegroup_num_to_crystal_sys(spacegroup: number): CrystalSystem | null;
+export declare function spacegroup_to_crystal_sys(spacegroup: number | string): CrystalSystem | null;
+export declare function normalize_spacegroup(spacegroup: number | string): number | null;
+export declare const SPACEGROUP_SYMBOL_TO_NUM: Record<string, number>;
+export declare const SPACEGROUP_NUM_TO_SYMBOL: Record<number, string>;
+export interface SpacegroupSunburstMetadata {
+    spacegroup: number;
+    crystal_system: CrystalSystem;
+    [key: string]: unknown;
+}
+export declare function spacegroup_sunburst_data(spacegroups: readonly (number | string)[]): SunburstNode<SpacegroupSunburstMetadata>[];

package/dist/symmetry/spacegroups.js

@@ -0,0 +1,429 @@
+// Space group to crystal system mappings and utilities
+// Crystal system ranges: [min, max] space group numbers (inclusive)
+export const CRYSTAL_SYSTEM_RANGES = {
+    triclinic: [1, 2],
+    monoclinic: [3, 15],
+    orthorhombic: [16, 74],
+    tetragonal: [75, 142],
+    trigonal: [143, 167],
+    hexagonal: [168, 194],
+    cubic: [195, 230],
+};
+// Colors matching pymatviz's spacegroup_bar
+export const CRYSTAL_SYSTEM_COLORS = {
+    triclinic: `red`,
+    monoclinic: `teal`,
+    orthorhombic: `blue`,
+    tetragonal: `green`,
+    trigonal: `orange`,
+    hexagonal: `purple`,
+    cubic: `darkred`,
+};
+// Ordered list of crystal systems (by space group number range)
+export const CRYSTAL_SYSTEMS = [
+    `triclinic`,
+    `monoclinic`,
+    `orthorhombic`,
+    `tetragonal`,
+    `trigonal`,
+    `hexagonal`,
+    `cubic`,
+];
+// Convert space group number to crystal system
+export function spacegroup_num_to_crystal_sys(spacegroup) {
+    for (const [system, [min, max]] of Object.entries(CRYSTAL_SYSTEM_RANGES)) {
+        if (spacegroup >= min && spacegroup <= max) {
+            return system;
+        }
+    }
+    return null;
+}
+// Convert space group (number or symbol) to crystal system
+export function spacegroup_to_crystal_sys(spacegroup) {
+    const num = normalize_spacegroup(spacegroup);
+    return num == null ? null : spacegroup_num_to_crystal_sys(num);
+}
+// Normalize space group input (number, Hermann-Mauguin symbol, or numeric string
+// like "225") to a space group number in [1, 230], or null if invalid
+export function normalize_spacegroup(spacegroup) {
+    if (typeof spacegroup === `number`) {
+        return spacegroup >= 1 && spacegroup <= 230 ? spacegroup : null;
+    }
+    const from_symbol = SPACEGROUP_SYMBOL_TO_NUM[spacegroup];
+    if (from_symbol !== undefined)
+        return from_symbol;
+    const parsed = parseInt(spacegroup, 10);
+    return isNaN(parsed) ? null : normalize_spacegroup(parsed);
+}
+export const SPACEGROUP_SYMBOL_TO_NUM = {
+    // Triclinic
+    P1: 1,
+    'P-1': 2,
+    // Monoclinic
+    P2: 3,
+    P2_1: 4,
+    C2: 5,
+    Pm: 6,
+    Pc: 7,
+    Cm: 8,
+    Cc: 9,
+    'P2/m': 10,
+    'P2_1/m': 11,
+    'C2/m': 12,
+    'P2/c': 13,
+    'P2_1/c': 14,
+    'C2/c': 15,
+    // Orthorhombic
+    P222: 16,
+    P222_1: 17,
+    P2_12_12: 18,
+    P2_12_12_1: 19,
+    C222_1: 20,
+    C222: 21,
+    F222: 22,
+    I222: 23,
+    I2_12_12_1: 24,
+    Pmm2: 25,
+    Pmc2_1: 26,
+    Pcc2: 27,
+    Pma2: 28,
+    Pca2_1: 29,
+    Pnc2: 30,
+    Pmn2_1: 31,
+    Pba2: 32,
+    Pna2_1: 33,
+    Pnn2: 34,
+    Cmm2: 35,
+    Cmc2_1: 36,
+    Ccc2: 37,
+    Amm2: 38,
+    Aem2: 39,
+    Ama2: 40,
+    Aea2: 41,
+    Fmm2: 42,
+    Fdd2: 43,
+    Imm2: 44,
+    Iba2: 45,
+    Ima2: 46,
+    Pmmm: 47,
+    Pnnn: 48,
+    Pccm: 49,
+    Pban: 50,
+    Pmma: 51,
+    Pnna: 52,
+    Pmna: 53,
+    Pcca: 54,
+    Pbam: 55,
+    Pccn: 56,
+    Pbcm: 57,
+    Pnnm: 58,
+    Pmmn: 59,
+    Pbcn: 60,
+    Pbca: 61,
+    Pnma: 62,
+    Cmcm: 63,
+    Cmce: 64,
+    Cmmm: 65,
+    Cccm: 66,
+    Cmme: 67,
+    Ccce: 68,
+    Fmmm: 69,
+    Fddd: 70,
+    Immm: 71,
+    Ibam: 72,
+    Ibca: 73,
+    Imma: 74,
+    // Tetragonal
+    P4: 75,
+    P4_1: 76,
+    P4_2: 77,
+    P4_3: 78,
+    I4: 79,
+    I4_1: 80,
+    'P-4': 81,
+    'I-4': 82,
+    'P4/m': 83,
+    'P4_2/m': 84,
+    'P4/n': 85,
+    'P4_2/n': 86,
+    'I4/m': 87,
+    'I4_1/a': 88,
+    P422: 89,
+    P42_12: 90,
+    P4_122: 91,
+    P4_12_12: 92,
+    P4_222: 93,
+    P4_22_12: 94,
+    P4_322: 95,
+    P4_32_12: 96,
+    I422: 97,
+    I4_122: 98,
+    P4mm: 99,
+    P4bm: 100,
+    P4_2cm: 101,
+    P4_2nm: 102,
+    P4cc: 103,
+    P4nc: 104,
+    P4_2mc: 105,
+    P4_2bc: 106,
+    I4mm: 107,
+    I4cm: 108,
+    I4_1md: 109,
+    I4_1cd: 110,
+    'P-42m': 111,
+    'P-42c': 112,
+    'P-42_1m': 113,
+    'P-42_1c': 114,
+    'P-4m2': 115,
+    'P-4c2': 116,
+    'P-4b2': 117,
+    'P-4n2': 118,
+    'I-4m2': 119,
+    'I-4c2': 120,
+    'I-42m': 121,
+    'I-42d': 122,
+    'P4/mmm': 123,
+    'P4/mcc': 124,
+    'P4/nbm': 125,
+    'P4/nnc': 126,
+    'P4/mbm': 127,
+    'P4/mnc': 128,
+    'P4/nmm': 129,
+    'P4/ncc': 130,
+    'P4_2/mmc': 131,
+    'P4_2/mcm': 132,
+    'P4_2/nbc': 133,
+    'P4_2/nnm': 134,
+    'P4_2/mbc': 135,
+    'P4_2/mnm': 136,
+    'P4_2/nmc': 137,
+    'P4_2/ncm': 138,
+    'I4/mmm': 139,
+    'I4/mcm': 140,
+    'I4_1/amd': 141,
+    'I4_1/acd': 142,
+    P3: 143,
+    P3_1: 144,
+    P3_2: 145,
+    R3: 146,
+    'P-3': 147,
+    'R-3': 148,
+    // Trigonal
+    P312: 149,
+    P321: 150,
+    P3_112: 151,
+    P3_121: 152,
+    P3_212: 153,
+    P3_221: 154,
+    R32: 155,
+    P3m1: 156,
+    P31m: 157,
+    P3c1: 158,
+    P31c: 159,
+    R3m: 160,
+    R3c: 161,
+    'P-31m': 162,
+    'P-31c': 163,
+    'P-3m1': 164,
+    'P-3c1': 165,
+    'R-3m': 166,
+    'R-3c': 167,
+    // Hexagonal
+    P6: 168,
+    P6_1: 169,
+    P6_5: 170,
+    P6_2: 171,
+    P6_4: 172,
+    P6_3: 173,
+    'P-6': 174,
+    'P6/m': 175,
+    'P6_3/m': 176,
+    P622: 177,
+    P6_122: 178,
+    P6_522: 179,
+    P6_222: 180,
+    P6_422: 181,
+    P6_322: 182,
+    P6mm: 183,
+    P6cc: 184,
+    P6_3cm: 185,
+    P6_3mc: 186,
+    'P-6m2': 187,
+    'P-6c2': 188,
+    'P-62m': 189,
+    'P-62c': 190,
+    'P6/mmm': 191,
+    'P6/mcc': 192,
+    'P6_3/mcm': 193,
+    'P6_3/mmc': 194,
+    // Cubic
+    P23: 195,
+    F23: 196,
+    I23: 197,
+    P2_13: 198,
+    I2_13: 199,
+    'Pm-3': 200,
+    'Pn-3': 201,
+    'Fm-3': 202,
+    'Fd-3': 203,
+    'Im-3': 204,
+    'Pa-3': 205,
+    'Ia-3': 206,
+    P432: 207,
+    P4_232: 208,
+    F432: 209,
+    F4_132: 210,
+    I432: 211,
+    P4_332: 212,
+    P4_132: 213,
+    I4_132: 214,
+    'P-43m': 215,
+    'F-43m': 216,
+    'I-43m': 217,
+    'P-43n': 218,
+    'F-43c': 219,
+    'I-43d': 220,
+    'Pm-3m': 221,
+    'Pn-3n': 222,
+    'Pm-3n': 223,
+    'Pn-3m': 224,
+    'Fm-3m': 225,
+    'Fm-3c': 226,
+    'Fd-3m': 227,
+    'Fd-3c': 228,
+    'Im-3m': 229,
+    'Ia-3d': 230,
+    // Special cases
+    P121: 3,
+    P12_11: 4,
+    C121: 5,
+    P1m1: 6,
+    P1c1: 7,
+    C1m1: 8,
+    C1c1: 9,
+    'P12/m1': 10,
+    'P12_1/m1': 11,
+    'C12/m1': 12,
+    'P12/c1': 13,
+    'P12_1/c1': 14,
+    'C12/c1': 15,
+    'P2/m2/m2/m': 47,
+    'P2/n2/n2/n': 48,
+    'P2/c2/c2/m': 49,
+    'P2/b2/a2/n': 50,
+    'P2_1/m2/m2/a': 51,
+    'P2/n2_1/n2/a': 52,
+    'P2/m2/n2_1/a': 53,
+    'P2_1/c2/c2/a': 54,
+    'P2_1/b2_1/a2/m': 55,
+    'P2_1/c2_1/c2/n': 56,
+    'P2/b2_1/c2_1/m': 57,
+    'P2_1/n2_1/n2/m': 58,
+    'P2_1/m2_1/m2/n': 59,
+    'P2_1/b2/c2_1/n': 60,
+    'P2_1/b2_1/c2_1/a': 61,
+    'P2_1/n2_1/m2_1/a': 62,
+    'C2/m2/c2_1/m': 63,
+    'C2/m2/c2_1/e': 64,
+    'C2/m2/m2/m': 65,
+    'C2/c2/c2/m': 66,
+    'C2/m2/m2/e': 67,
+    'C2/c2/c2/e': 68,
+    'F2/m2/m2/m': 69,
+    'F2/d2/d2/d': 70,
+    'I2/m2/m2/m': 71,
+    'I2/b2/a2/m': 72,
+    'I2/b2/c2/a': 73,
+    'I2/m2/m2/a': 74,
+    'P4/m2/m2/m': 123,
+    'P4/m2/c2/c': 124,
+    'P4/n2/b2/m': 125,
+    'P4/n2/n2/c': 126,
+    'P4/m2_1/bm': 127,
+    'P4/m2_1/nc': 128,
+    'P4/n2_1/mm': 129,
+    'P4/n2_1/cc': 130,
+    'P4_2/m2/m2/c': 131,
+    'P4_2/m2/c2/m': 132,
+    'P4_2/n2/b2/c': 133,
+    'P4_2/n2/n2/m': 134,
+    'P4_2/m2_1/b2/c': 135,
+    'P4_2/m2_1/n2/m': 136,
+    'P4_2/n2_1/m2/c': 137,
+    'P4_2/n2_1/c2/m': 138,
+    'I4/m2/m2/m': 139,
+    'I4/m2/c2/m': 140,
+    'I4_1/a2/m2/d': 141,
+    'I4_1/a2/c2/d': 142,
+    'P-312/m': 162,
+    'P-312/c': 163,
+    'P-32/m1': 164,
+    'P-32/c1': 165,
+    'R-32/m': 166,
+    'R-32/c': 167,
+    'P6/m2/m2/m': 191,
+    'P6/m2/c2/c': 192,
+    'P6_3/m2/c2/m': 193,
+    'P6_3/m2/m2/c': 194,
+    'P2/m-3': 200,
+    'P2/n-3': 201,
+    'F2/m-3': 202,
+    'F2/d-3': 203,
+    'I2/m-3': 204,
+    'P2_1/a-3': 205,
+    'I2_1/a-3': 206,
+    'P4/m-32/m': 221,
+    'P4/n-32/n': 222,
+    'P4_2/m-32/n': 223,
+    'P4_2/n-32/m': 224,
+    'F4/m-32/m': 225,
+    'F4/m-32/c': 226,
+    'F4_1/d-32/m': 227,
+    'F4_1/d-32/c': 228,
+    'I4/m-32/m': 229,
+    'I4_1/a-32/d': 230,
+};
+export const SPACEGROUP_NUM_TO_SYMBOL = Object.entries(SPACEGROUP_SYMBOL_TO_NUM).reduce((acc, [symbol, num]) => {
+    if (!acc[num])
+        acc[num] = symbol;
+    return acc;
+}, {});
+// Build crystal-system -> spacegroup hierarchy data for the Sunburst component from a
+// list of spacegroup numbers or symbols (one entry per occurrence; counts become leaf
+// values). Leaf ids follow the pymatviz spacegroup_sunburst scheme, e.g. "cubic/225".
+export function spacegroup_sunburst_data(spacegroups) {
+    const counts = new Map();
+    let n_invalid = 0;
+    for (const spacegroup of spacegroups) {
+        const num = normalize_spacegroup(spacegroup); // numbers, symbols, numeric strings
+        if (num == null) {
+            n_invalid += 1;
+            continue;
+        }
+        counts.set(num, (counts.get(num) ?? 0) + 1);
+    }
+    if (n_invalid > 0) {
+        console.warn(`spacegroup_sunburst_data: skipped ${n_invalid} invalid spacegroup(s) (expected numbers 1-230 or Hermann-Mauguin symbols)`);
+    }
+    // Emit crystal systems in canonical (space group number) order, only those present
+    return CRYSTAL_SYSTEMS.flatMap((system) => {
+        const nums = [...counts.keys()]
+            .filter((num) => spacegroup_num_to_crystal_sys(num) === system)
+            .sort((num_a, num_b) => num_a - num_b);
+        if (nums.length === 0)
+            return [];
+        return [
+            {
+                id: system,
+                label: system,
+                color: CRYSTAL_SYSTEM_COLORS[system],
+                children: nums.map((num) => ({
+                    id: `${system}/${num}`,
+                    label: SPACEGROUP_NUM_TO_SYMBOL[num] ?? `${num}`,
+                    value: counts.get(num),
+                    metadata: { spacegroup: num, crystal_system: system },
+                })),
+            },
+        ];
+    });
+}