matterviz 0.3.1 → 0.3.2

package/dist/structure/parse.js

@@ -2,9 +2,8 @@ import { COMPRESSION_EXTENSIONS_REGEX, CONFIG_DIRS_REGEX, STRUCT_KEYWORDS_REGEX,
 import { ELEM_SYMBOLS } from '../labels';
 import * as math from '../math';
 import { wrap_to_unit_cell } from './pbc';
+import { normalize_scientific_notation } from '../utils';
 import { load as yaml_load } from 'js-yaml';
-// Normalize scientific notation in coordinate strings (handles eEdD and *^ notation variants)
-const normalize_scientific_notation = (str) => str.toLowerCase().replace(/d/g, `e`).replace(/\*\^/g, `e`);
 // Parse a coordinate value that might be in various scientific notation formats
 function parse_coordinate(str) {
     const normalized = normalize_scientific_notation(str.trim());
@@ -939,11 +938,10 @@ function find_structure_in_json(obj, visited = new WeakSet()) {
         return null;
     }
     // Check if this object looks like a valid structure
-    const potential_structure = obj;
-    if (is_parsed_structure(potential_structure))
-        return potential_structure;
+    if (is_parsed_structure(obj))
+        return obj;
     // Otherwise, recursively search through all properties
-    for (const value of Object.values(potential_structure)) {
+    for (const value of Object.values(obj)) {
         const result = find_structure_in_json(value, visited);
         if (result)
             return result;
@@ -954,17 +952,19 @@ function find_structure_in_json(obj, visited = new WeakSet()) {
 function is_parsed_structure(obj) {
     if (!obj || typeof obj !== `object`)
         return false;
-    const record = obj;
-    // Must have non-empty sites array
-    if (!Array.isArray(record.sites) || record.sites.length === 0)
+    const parsed_obj = obj;
+    const sites = parsed_obj.sites;
+    if (!Array.isArray(sites) || sites.length === 0)
         return false;
-    // Check if first site looks valid (has species and coordinates)
-    const first_site = record.sites[0];
+    const first_site = sites[0];
     if (!first_site || typeof first_site !== `object`)
         return false;
-    // Must have species (array) and either abc or xyz coordinates
-    const has_species = Array.isArray(first_site.species) && first_site.species.length > 0;
-    const has_coords = Array.isArray(first_site.abc) || Array.isArray(first_site.xyz);
+    const first_site_obj = first_site;
+    const species = first_site_obj.species;
+    const abc = first_site_obj.abc;
+    const xyz = first_site_obj.xyz;
+    const has_species = Array.isArray(species) && species.length > 0;
+    const has_coords = Array.isArray(abc) || Array.isArray(xyz);
     return has_species && has_coords;
 }
 // Normalize structure coordinates: wrap fractional coords to [0,1) and recompute Cartesian
@@ -1268,8 +1268,11 @@ function is_optimade_structure_object(value) {
     if (!value || typeof value !== `object`)
         return false;
     const obj = value;
-    return obj.type === `structures` && typeof obj.id === `string` &&
-        typeof obj.attributes === `object` && obj.attributes !== null;
+    const type = obj.type;
+    const id = obj.id;
+    const attributes = obj.attributes;
+    return type === `structures` && typeof id === `string` &&
+        typeof attributes === `object` && attributes !== null;
 }
 // Convert OPTIMADE structure to Crystal format
 export function optimade_to_crystal(optimade_structure) {

package/dist/structure/partial-occupancy.d.ts

@@ -0,0 +1,25 @@
+import type { Site } from './';
+export declare const PARTIAL_OCCUPANCY_SLICE_GAP_RAD = 0.001;
+export type RenderSite = {
+    site_idx: number;
+    site: Site;
+    is_image_atom: boolean;
+    source_site_indices: number[];
+};
+export type SliceGeometry = {
+    element: string;
+    occupancy: number;
+    start_phi: number;
+    end_phi: number;
+    phi_length: number;
+    render_start_cap: boolean;
+    render_end_cap: boolean;
+};
+export type CapArcConfig = {
+    start_cap_arc_start: number;
+    end_cap_arc_start: number;
+    arc_length: number;
+};
+export declare const PARTIAL_OCCUPANCY_CAP_ARC: CapArcConfig;
+export declare const merge_split_partial_sites: (sites: Site[], hidden_elements?: ReadonlySet<string>) => RenderSite[];
+export declare const compute_slice_geometry: (visible_species: Site[`species`], slice_gap_rad?: number) => SliceGeometry[];

package/dist/structure/partial-occupancy.js

@@ -0,0 +1,102 @@
+export const PARTIAL_OCCUPANCY_SLICE_GAP_RAD = 1e-3;
+const OCCUPANCY_EPS = 1e-6;
+const MIN_PHI_LENGTH = 1e-4;
+const MERGE_DISTANCE_TOLERANCE = 1e-8;
+const CAP_ARC_START = Math.PI / 2;
+const is_image_atom = (site) => typeof site.properties?.orig_site_idx === `number`;
+const make_render_site = (sites, site_idx, source_site_indices, site_override) => ({
+    site_idx,
+    site: site_override ?? sites[site_idx],
+    is_image_atom: source_site_indices.some((source_site_idx) => is_image_atom(sites[source_site_idx])),
+    source_site_indices,
+});
+const sq_dist = (xyz_1, xyz_2) => (xyz_1[0] - xyz_2[0]) ** 2 +
+    (xyz_1[1] - xyz_2[1]) ** 2 +
+    (xyz_1[2] - xyz_2[2]) ** 2;
+const is_split_partial_site = (site, hidden_elements) => {
+    const visible_species = site.species.filter(({ element }) => !hidden_elements.has(element));
+    const total_visible_occupancy = visible_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    return visible_species.length === 1 && total_visible_occupancy < 1 - OCCUPANCY_EPS;
+};
+const group_split_partial_indices = (sites, hidden_elements) => {
+    const grouped_centers = [];
+    const grouped_site_indices = [];
+    const non_grouped_site_indices = [];
+    for (const [site_idx, site] of sites.entries()) {
+        if (!is_split_partial_site(site, hidden_elements)) {
+            non_grouped_site_indices.push(site_idx);
+            continue;
+        }
+        const matched_group_idx = grouped_centers.findIndex((center_xyz) => sq_dist(center_xyz, site.xyz) <= MERGE_DISTANCE_TOLERANCE ** 2);
+        if (matched_group_idx === -1) {
+            grouped_centers.push(site.xyz);
+            grouped_site_indices.push([site_idx]);
+            continue;
+        }
+        grouped_site_indices[matched_group_idx].push(site_idx);
+    }
+    return { non_grouped_site_indices, grouped_site_indices };
+};
+const build_render_sites = (sites, non_grouped_site_indices, grouped_site_indices) => {
+    const render_sites = non_grouped_site_indices.map((site_idx) => make_render_site(sites, site_idx, [site_idx]));
+    for (const grouped_indices of grouped_site_indices) {
+        if (grouped_indices.length === 1) {
+            const site_idx = grouped_indices[0];
+            render_sites.push(make_render_site(sites, site_idx, [site_idx]));
+            continue;
+        }
+        const representative_site_idx = grouped_indices[0];
+        const representative_site = sites[representative_site_idx];
+        const merged_species = grouped_indices.flatMap((grouped_site_idx) => sites[grouped_site_idx].species);
+        render_sites.push(make_render_site(sites, representative_site_idx, [...grouped_indices], { ...representative_site, species: merged_species }));
+    }
+    return render_sites;
+};
+export const PARTIAL_OCCUPANCY_CAP_ARC = {
+    start_cap_arc_start: CAP_ARC_START,
+    end_cap_arc_start: CAP_ARC_START,
+    arc_length: Math.PI,
+};
+export const merge_split_partial_sites = (sites, hidden_elements = new Set()) => {
+    const grouped_indices = group_split_partial_indices(sites, hidden_elements);
+    return build_render_sites(sites, grouped_indices.non_grouped_site_indices, grouped_indices.grouped_site_indices);
+};
+export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_OCCUPANCY_SLICE_GAP_RAD) => {
+    if (visible_species.length === 0)
+        return [];
+    const total_visible_occupancy = visible_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    // Preserve total angular coverage at one full turn for invalid overfull inputs.
+    const occupancy_scale_factor = total_visible_occupancy > 1 + OCCUPANCY_EPS
+        ? 1 / total_visible_occupancy
+        : 1;
+    const normalized_species = visible_species.map(({ element, occu }) => ({
+        element,
+        occu: occu * occupancy_scale_factor,
+    }));
+    const normalized_total_occupancy = normalized_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    const has_vacancy_gap = normalized_total_occupancy < 1 - OCCUPANCY_EPS;
+    const last_visible_species_idx = normalized_species.length - 1;
+    let start_angle = 0;
+    return normalized_species.map(({ element, occu }, species_idx) => {
+        const start_phi_raw = 2 * Math.PI * start_angle;
+        const end_phi_raw = 2 * Math.PI * (start_angle += occu);
+        // Keep neighboring wedges from sharing the exact same plane (z-fighting).
+        const phi_span_raw = Math.max(0, end_phi_raw - start_phi_raw);
+        const max_safe_gap = Math.max(0, phi_span_raw - MIN_PHI_LENGTH);
+        const desired_gap = visible_species.length > 1
+            ? Math.min(slice_gap_rad, phi_span_raw * 0.25)
+            : 0;
+        const phi_gap = Math.min(desired_gap, max_safe_gap);
+        const start_phi = start_phi_raw + phi_gap / 2;
+        const end_phi = end_phi_raw - phi_gap / 2;
+        return {
+            element,
+            occupancy: occu,
+            start_phi,
+            end_phi,
+            phi_length: Math.max(MIN_PHI_LENGTH, end_phi - start_phi),
+            render_start_cap: has_vacancy_gap && species_idx === 0,
+            render_end_cap: has_vacancy_gap && species_idx === last_visible_species_idx,
+        };
+    });
+};

package/dist/structure/validation.js

@@ -1,8 +1,11 @@
 export function is_crystal(obj) {
     if (obj === null || typeof obj !== `object`)
         return false;
-    const input = obj;
-    const has_sites = Array.isArray(input.sites) && input.sites.length > 0;
-    const has_lattice = Boolean(input.lattice) && typeof input.lattice === `object`;
+    const structure_obj = obj;
+    const sites = structure_obj.sites;
+    const lattice = structure_obj.lattice;
+    const has_sites = Array.isArray(sites) && sites.length > 0;
+    const has_lattice = lattice !== undefined && lattice !== null &&
+        typeof lattice === `object`;
     return has_sites && has_lattice;
 }

package/dist/symmetry/SymmetryStats.svelte

@@ -4,6 +4,7 @@ import { default_sym_settings, wyckoff_positions_from_moyo } from './index';
 import * as spg from './spacegroups';
 let { sym_data, settings = $bindable(default_sym_settings), show_tooltips = true, children, label = `Symmetry`, header, ...rest } = $props();
 const wyckoff_count = $derived(sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0);
+const display_hm_symbol = $derived(sym_data?.hm_symbol?.replace(/\s+/g, ``) ?? `?`);
 const sym_ops_counts = $derived.by(() => {
     const EPS = 1e-10;
     if (!sym_data?.operations) {
@@ -36,6 +37,13 @@ const titles = {
     roto_translations: `Number of roto-translations in the crystal structure.`,
 };
 const tooltips = $derived(show_tooltips ? titles : {});
+function get_step_from_order_of_magnitude(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return 1e-5;
+    const exponent = Math.floor(Math.log10(value));
+    return Math.pow(10, exponent);
+}
+const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec));
 </script>
 
 <div {...rest} class="symmetry-stats {rest.class ?? ``}">
@@ -55,15 +63,21 @@ const tooltips = $derived(show_tooltips ? titles : {});
       <span {@attach tooltip()} title={tooltips?.symprec}>Precision</span>
       <input
         type="number"
-        step="1e-5"
+        step={symprec_step}
         value={settings.symprec}
-        onchange={(evt) => {
+        oninput={(evt) => {
           const { value } = evt.currentTarget
-          const parsed = parseFloat(value)
+          if (value === ``) return
+          const parsed = Number(value)
           if (Number.isFinite(parsed)) {
             settings = { ...settings, symprec: parsed }
           }
         }}
+        onkeydown={(evt) => {
+          if (evt.key === `Escape`) {
+            evt.currentTarget.blur()
+          }
+        }}
       />
     </label>
     <label>
@@ -91,7 +105,7 @@ const tooltips = $derived(show_tooltips ? titles : {});
         title="{tooltips?.space_group} at {settings.symprec} (using {settings.algo} algo). {tooltips?.hermann_mauguin}"
         {@attach tooltip()}
       >
-        Space Group <strong>{sym_data.number} ({sym_data.hm_symbol ?? `?`})</strong>
+        Space Group <strong>{sym_data.number} ({display_hm_symbol})</strong>
       </div>
       <div title={tooltips?.crystal_system} {@attach tooltip()}>
         Crystal System <strong>{spg.spacegroup_to_crystal_sys(sym_data.number)}</strong>

package/dist/symmetry/WyckoffTable.svelte

@@ -2,7 +2,8 @@
 import { format_fractional } from '../labels';
 import { colors } from '../state.svelte';
 let { wyckoff_positions, on_hover, on_click, active_color = `#2563eb`, ...rest } = $props();
-let selected_wyckoff = $state(null);
+let selected_key = $state(null);
+const get_row_key = (wyckoff_pos, row_idx) => `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${wyckoff_pos.site_indices?.join(`,`) ?? `none`}-${row_idx}`;
 </script>
 
 {#if wyckoff_positions && wyckoff_positions.length > 0}
@@ -22,10 +23,14 @@ let selected_wyckoff = $state(null);
       </tr>
     </thead>
     <tbody>
-      {#each wyckoff_positions as wyckoff_pos (JSON.stringify(wyckoff_pos))}
+      {#each wyckoff_positions as
+        wyckoff_pos,
+        row_idx
+        (get_row_key(wyckoff_pos, row_idx))
+      }
         {@const { wyckoff, elem, abc, site_indices } = wyckoff_pos}
-        {@const is_selected =
-        JSON.stringify(selected_wyckoff) === JSON.stringify(wyckoff_pos)}
+        {@const row_key = get_row_key(wyckoff_pos, row_idx)}
+        {@const is_selected = selected_key === row_key}
         <tr
           class="wyckoff-row"
           tabindex="0"
@@ -35,16 +40,14 @@ let selected_wyckoff = $state(null);
           onmouseenter={() => on_hover?.(site_indices ?? null)}
           onmouseleave={() => on_hover?.(null)}
           onclick={() => {
-            selected_wyckoff = is_selected ? null : wyckoff_pos
-            on_click?.(selected_wyckoff?.site_indices ?? null)
+            selected_key = is_selected ? null : row_key
+            on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
           }}
           onkeydown={(event) => {
             if ([`Enter`, ` `].includes(event.key)) {
               event.preventDefault()
-              const is_selected =
-                JSON.stringify(selected_wyckoff) === JSON.stringify(wyckoff_pos)
-              selected_wyckoff = is_selected ? null : wyckoff_pos
-              on_click?.(selected_wyckoff?.site_indices ?? null)
+              selected_key = is_selected ? null : row_key
+              on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
             }
           }}
         >
@@ -69,6 +72,11 @@ let selected_wyckoff = $state(null);
   .wyckoff-table {
     margin-top: 1em;
   }
+  .wyckoff-table :is(th, td) {
+    padding: 2px 6px;
+    text-align: center;
+    vertical-align: middle;
+  }
   .wyckoff-row {
     cursor: pointer;
     transition: background-color 0.2s ease;

package/dist/symmetry/index.d.ts

@@ -29,12 +29,15 @@ export type WyckoffPos = {
     abc: Vec3;
     site_indices?: number[];
 };
+export type SymmetryDataset = MoyoDataset & {
+    orig_indices?: number[];
+    orig_site_indices_by_std_idx?: number[][];
+};
 export declare function ensure_moyo_wasm_ready(wasm_url?: string): Promise<void>;
 export declare function to_cell_json(structure: Crystal): string;
-export declare function analyze_structure_symmetry(struct_or_mol: AnyStructure, settings: Partial<SymmetrySettings>): Promise<MoyoDataset>;
+export declare function map_std_to_orig_site_indices(std_positions: Vec3[], std_numbers: number[], input_positions: Vec3[], input_numbers: number[], orig_site_indices_by_input_idx: number[][]): number[][];
+export declare function analyze_structure_symmetry(struct_or_mol: AnyStructure, settings: Partial<SymmetrySettings>): Promise<SymmetryDataset>;
 export declare function simplicity_score(vec: number[]): number;
-export declare function wyckoff_positions_from_moyo(sym_data: (MoyoDataset & {
-    orig_indices?: number[];
-}) | null): WyckoffPos[];
+export declare function wyckoff_positions_from_moyo(sym_data: SymmetryDataset | null): WyckoffPos[];
 export declare function apply_symmetry_operations(position: Vec3, operations: MoyoDataset[`operations`], _tolerance?: number): Vec3[];
 export declare function map_wyckoff_to_all_atoms(wyckoff_positions: WyckoffPos[], displayed_structure: Crystal, orig_structure: Crystal, sym_data: MoyoDataset | null, tolerance?: number): WyckoffPos[];

package/dist/symmetry/index.js

@@ -1,5 +1,6 @@
 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';
@@ -21,6 +22,7 @@ export const default_sym_settings = {
     algo: DEFAULTS.symmetry.algo,
 };
 let initialized = false;
+const OCCUPANCY_EPS = 1e-8;
 export async function ensure_moyo_wasm_ready(wasm_url) {
     if (initialized)
         return;
@@ -29,34 +31,90 @@ export async function ensure_moyo_wasm_ready(wasm_url) {
     await init({ module_or_path: url });
     initialized = true;
 }
-export function to_cell_json(structure) {
+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}: ${String(selected_element)}`);
+    }
+    const atomic_number = SYMBOL_TO_ATOMIC_NUMBER[selected_element];
+    if (atomic_number === undefined) {
+        throw new Error(`Unknown element at site ${site_idx}: ${String(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;
-    const basis = [...v_a, ...v_b, ...v_c];
-    const positions = structure.sites.map((site) => site.abc);
-    const numbers = structure.sites.map((site, idx) => {
-        const sym = site.species?.[0]?.element;
-        const num = sym !== null ? SYMBOL_TO_ATOMIC_NUMBER[sym] : undefined;
-        if (typeof num !== `number`) {
-            throw new Error(`Unknown element at site ${idx}: ${String(sym)}`);
+    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 function map_std_to_orig_site_indices(std_positions, std_numbers, input_positions, input_numbers, orig_site_indices_by_input_idx) {
+    return 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;
+            }
         }
-        return num;
+        if (nearest_input_idx === -1)
+            return [];
+        return orig_site_indices_by_input_idx[nearest_input_idx] ?? [];
     });
-    const cell = { lattice: { basis }, positions, numbers };
-    return JSON.stringify(cell);
 }
 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 cell_json = to_cell_json(struct_or_mol);
+    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;
-    return analyze_cell(cell_json, symprec, moyo_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) {
@@ -72,7 +130,7 @@ export function wyckoff_positions_from_moyo(sym_data) {
     if (!sym_data)
         return [];
     const { positions, numbers } = sym_data.std_cell;
-    const { wyckoffs, orig_indices } = sym_data;
+    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
@@ -97,11 +155,18 @@ export function wyckoff_positions_from_moyo(sym_data) {
             return score < best.score ? { pos, score } : best;
         }, { pos: positions[0], score: simplicity_score(positions[0]) }).pos;
         // Map standardized cell indices back to original structure indices
-        const orig_site_indices = orig_indices
-            ? indices.map((i) => orig_indices[i]).filter((idx) => idx !== undefined)
-            : 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: orig_site_indices };
+        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), parseInt(w2.wyckoff)];