matterviz 0.3.4 → 0.3.6

package/dist/symmetry/WyckoffTable.svelte

@@ -1,113 +0,0 @@
-<script lang="ts">
-  import { contrast_color } from '../colors'
-  import { format_fractional } from '../labels'
-  import { colors } from '../state.svelte'
-  import type { HTMLAttributes } from 'svelte/elements'
-  import type { WyckoffPos } from '.'
-
-  let {
-    wyckoff_positions,
-    on_hover,
-    on_click,
-    active_color = `#2563eb`,
-    ...rest
-  }: HTMLAttributes<HTMLTableElement> & {
-    wyckoff_positions: WyckoffPos[]
-    on_hover?: (site_indices: number[] | null) => void
-    on_click?: (site_indices: number[] | null) => void
-    active_color?: string
-  } = $props()
-
-  let selected_key = $state<string | null>(null)
-
-  const get_row_key = (wyckoff_pos: WyckoffPos, row_idx: number) =>
-    `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${
-      wyckoff_pos.site_indices?.join(`,`) ?? `none`
-    }-${row_idx}`
-</script>
-
-{#if wyckoff_positions && wyckoff_positions.length > 0}
-  <table {...rest} class="wyckoff-table {rest.class ?? ``}">
-    <thead>
-      <tr>
-        {#each [
-          [`Wyckoff`, `Wyckoff position: Multiplicity + Letter`],
-          [`Element`, `Chemical element symbol`],
-          [`Fractional Coords`, `Fractional coordinates within the unit cell`],
-        ] as
-          [col, title]
-          (col)
-        }
-          <th {title}>{col}</th>
-        {/each}
-      </tr>
-    </thead>
-    <tbody>
-      {#each wyckoff_positions as
-        wyckoff_pos,
-        row_idx
-        (get_row_key(wyckoff_pos, row_idx))
-      }
-        {@const { wyckoff, elem, abc, site_indices } = 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"
-          class:selected={is_selected}
-          style:--active-color={active_color}
-          style:--hover-color="#6cf0ff"
-          onmouseenter={() => on_hover?.(site_indices ?? null)}
-          onmouseleave={() => on_hover?.(null)}
-          onclick={() => {
-            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()
-              selected_key = is_selected ? null : row_key
-              on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
-            }
-          }}
-        >
-          <td>{wyckoff}</td>
-          <td>
-            <span
-              style:background-color={colors.element[elem]}
-              style="display: inline-block; padding: 0 6pt; border-radius: 3pt; line-height: 1.4"
-              {@attach contrast_color()}
-            >
-              {elem}
-            </span>
-          </td>
-          <td>({abc?.map(format_fractional).join(` , `) ?? `N/A`})</td>
-        </tr>
-      {/each}
-    </tbody>
-  </table>
-{/if}
-
-<style>
-  .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;
-  }
-  .wyckoff-row:hover {
-    background-color: color-mix(in srgb, var(--hover-color) 25%, transparent);
-  }
-  .wyckoff-row.selected {
-    background-color: color-mix(in srgb, var(--active-color) 30%, transparent);
-  }
-  .wyckoff-row.selected:hover {
-    background-color: color-mix(in srgb, var(--active-color) 35%, transparent);
-  }
-</style>

package/dist/symmetry/WyckoffTable.svelte.d.ts

@@ -1,11 +0,0 @@
-import type { HTMLAttributes } from 'svelte/elements';
-import type { WyckoffPos } from '.';
-type $$ComponentProps = HTMLAttributes<HTMLTableElement> & {
-    wyckoff_positions: WyckoffPos[];
-    on_hover?: (site_indices: number[] | null) => void;
-    on_click?: (site_indices: number[] | null) => void;
-    active_color?: string;
-};
-declare const WyckoffTable: import("svelte").Component<$$ComponentProps, {}, "">;
-type WyckoffTable = ReturnType<typeof WyckoffTable>;
-export default WyckoffTable;

package/dist/symmetry/cell-transform.d.ts

@@ -1,12 +0,0 @@
-import type { Crystal } from '../structure';
-import type { MoyoCell, MoyoDataset } from '@spglib/moyo-wasm';
-export type CellType = `original` | `conventional` | `primitive`;
-export declare function moyo_cell_to_structure(cell: MoyoCell, // The MoyoCell from symmetry analysis (std_cell or prim_std_cell)
-original_structure: Crystal): Crystal;
-export declare function get_conventional_cell(original_structure: Crystal, // The original input structure
-sym_data: MoyoDataset): Crystal;
-export declare function get_primitive_cell(original_structure: Crystal, // The original input structure
-sym_data: MoyoDataset): Crystal;
-export declare function transform_cell(structure: Crystal, // The original structure
-cell_type: CellType, // The desired cell type ('original', 'conventional', or 'primitive')
-sym_data: MoyoDataset | null): Crystal;

package/dist/symmetry/cell-transform.js

@@ -1,77 +0,0 @@
-import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
-import * as math from '../math';
-import { wrap_to_unit_cell } from '../structure/pbc';
-// Convert a MoyoCell (from moyo-wasm symmetry analysis) to Crystal format.
-// MoyoCell has a flat 9-element basis array and atomic numbers; this converts to
-// the full Crystal with lattice parameters and element symbols.
-export function moyo_cell_to_structure(cell, // The MoyoCell from symmetry analysis (std_cell or prim_std_cell)
-original_structure) {
-    // Convert flat 9-element basis to 3x3 matrix
-    // moyo-wasm uses the same row-major serialization for both input and output
-    // (see to_cell_json comment: column-major(B) == row-major(RB))
-    // So the flat array is row-major: [a1, a2, a3, b1, b2, b3, c1, c2, c3]
-    // where each row is a lattice vector in the pymatgen convention
-    const basis = cell.lattice.basis;
-    const lattice_matrix = [
-        [basis[0], basis[1], basis[2]], // First lattice vector (a)
-        [basis[3], basis[4], basis[5]], // Second lattice vector (b)
-        [basis[6], basis[7], basis[8]], // Third lattice vector (c)
-    ];
-    // Calculate lattice parameters from matrix
-    const lattice_params = math.calc_lattice_params(lattice_matrix);
-    const frac_to_cart = math.create_frac_to_cart(lattice_matrix);
-    // Build sites from positions and atomic numbers
-    const sites = cell.positions.map((abc, idx) => {
-        const atomic_number = cell.numbers[idx];
-        const element = ATOMIC_NUMBER_TO_SYMBOL[atomic_number];
-        if (!element) {
-            throw new Error(`Unknown atomic number: ${atomic_number}`);
-        }
-        // Wrap fractional coordinates to [0, 1) range (moyo-wasm may return outside)
-        const wrapped_abc = wrap_to_unit_cell(abc);
-        const xyz = frac_to_cart(wrapped_abc);
-        // Oxidation state is set to 0 (unknown) because moyo-wasm only provides atomic numbers.
-        // transformed cell may have different/reordered sites, making it non-trivial to
-        // map oxidation states from original structure.
-        const species = [{ element, occu: 1, oxidation_state: 0 }];
-        return { species, abc: wrapped_abc, xyz, label: element, properties: {} };
-    });
-    const lattice = {
-        matrix: lattice_matrix,
-        pbc: original_structure.lattice.pbc,
-        ...lattice_params,
-    };
-    return { lattice, sites, charge: original_structure.charge, id: original_structure.id };
-}
-// Get the conventional (standardized) cell from symmetry analysis data.
-// The conventional cell is the standard crystallographic setting for the space group.
-export function get_conventional_cell(original_structure, // The original input structure
-sym_data) {
-    // The conventional cell as a Crystal
-    return moyo_cell_to_structure(sym_data.std_cell, original_structure);
-}
-// Get the primitive cell from symmetry analysis data.
-// The primitive cell is the smallest unit cell with one lattice point.
-export function get_primitive_cell(original_structure, // The original input structure
-sym_data) {
-    // The primitive cell as a Crystal
-    return moyo_cell_to_structure(sym_data.prim_std_cell, original_structure);
-}
-// Transform a structure based on the selected cell type.
-// Returns the original structure if cell_type is 'original' or if sym_data is not available.
-export function transform_cell(structure, // The original structure
-cell_type, // The desired cell type ('original', 'conventional', or 'primitive')
-sym_data) {
-    //transformed structure (or original if no transformation needed)
-    if (cell_type === `original` || !sym_data) {
-        return structure;
-    }
-    if (cell_type === `conventional`) {
-        return get_conventional_cell(structure, sym_data);
-    }
-    if (cell_type === `primitive`) {
-        return get_primitive_cell(structure, sym_data);
-    }
-    // Fallback to original (should never reach here with proper typing)
-    return structure;
-}

package/dist/symmetry/index.d.ts

@@ -1,43 +0,0 @@
-import type { Vec3 } from '../math';
-import type { AnyStructure, Crystal } from '../structure';
-import type { MoyoDataset } from '@spglib/moyo-wasm';
-export * from './cell-transform';
-export * from './spacegroups';
-export { default as SymmetryStats } from './SymmetryStats.svelte';
-export { default as WyckoffTable } from './WyckoffTable.svelte';
-export declare const BRAVAIS_LATTICES: {
-    readonly P: "Primitive";
-    readonly I: "Body-centered";
-    readonly F: "Face-centered";
-    readonly A: "A-face centered";
-    readonly B: "B-face centered";
-    readonly C: "C-face centered";
-    readonly R: "Rhombohedral";
-};
-export type BravaisLattice = (typeof BRAVAIS_LATTICES)[keyof typeof BRAVAIS_LATTICES];
-export type SymmetrySettings = {
-    symprec: number;
-    algo: `Moyo` | `Spglib`;
-};
-export declare const default_sym_settings: {
-    readonly symprec: number;
-    readonly algo: "Moyo" | "Spglib";
-};
-export type WyckoffPos = {
-    wyckoff: string;
-    elem: string;
-    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 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: 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,229 +0,0 @@
-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;
-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 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;
-            }
-        }
-        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 to_unit = (v) => v - Math.floor(v);
-    const near_zero = (v) => Math.min(v, 1 - v);
-    const near_half = (v) => Math.abs(v - 0.5);
-    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 }) => {
-        // Find the position with the best simplicity score to display
-        const best_pos = positions.reduce((best, pos) => {
-            const score = simplicity_score(pos);
-            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_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), parseInt(w2.wyckoff)];
-        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();
-    const wrap = (coord) => coord - Math.floor(coord);
-    const key = (pos) => pos.map((coord) => wrap(coord).toFixed(8)).join(`,`);
-    return operations
-        .map(({ rotation, translation }) => {
-        // Apply 3x3 rotation matrix and translation: new_pos = R * position + t
-        const new_pos = [0, 1, 2].map((dim) => rotation[dim * 3] * position[0] +
-            rotation[dim * 3 + 1] * position[1] +
-            rotation[dim * 3 + 2] * position[2] +
-            translation[dim]);
-        return new_pos.map(wrap);
-    })
-        .filter((pos) => {
-        const pos_key = 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;
-    }
-    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 d = Math.abs(wrapped);
-        return sum + d * d;
-    }, 0));
-    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

@@ -1,9 +0,0 @@
-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>;