matterviz 0.4.0 → 0.4.2

package/dist/symmetry/SymmetryStats.svelte

@@ -5,7 +5,15 @@
   import type { HTMLAttributes } from 'svelte/elements'
   import { SETTINGS_CONFIG } from '../settings'
   import type { SymmetrySettings } from './index'
-  import { default_sym_settings, wyckoff_positions_from_moyo } from './index'
+  import {
+    count_structure_free_params,
+    default_sym_settings,
+    enrich_wyckoff_rows,
+    spacegroup_settings,
+    spacegroup_wyckoff_positions,
+    wyckoff_positions_from_moyo,
+    wyckoff_sequence,
+  } from './index'
   import * as spg from './spacegroups'
 
   type SymmetrySnippet = Snippet<
@@ -29,10 +37,34 @@
     header?: SymmetrySnippet
   } = $props()
 
-  const wyckoff_count = $derived(
-    sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0,
+  // Space-group Wyckoff database + all settings (empty when WASM is not initialized,
+  // e.g. SSR or unit tests — the stats below degrade gracefully)
+  const wyckoff_db = $derived(
+    sym_data ? spacegroup_wyckoff_positions(sym_data.hall_number) : [],
   )
+  const settings_entries = $derived(sym_data ? spacegroup_settings(sym_data.number) : [])
+  const current_setting = $derived(
+    settings_entries.find((entry) => entry.hall_number === sym_data?.hall_number),
+  )
+  const occupied_rows = $derived(
+    sym_data ? enrich_wyckoff_rows(wyckoff_positions_from_moyo(sym_data), wyckoff_db) : [],
+  )
+  const wyckoff_count = $derived(occupied_rows.length)
+  const wyckoff_seq = $derived(wyckoff_sequence(occupied_rows))
+  // Internal degrees of freedom (null when ITA coordinates are unavailable)
+  const free_params = $derived(count_structure_free_params(occupied_rows))
   const display_hm_symbol = $derived(sym_data?.hm_symbol?.replaceAll(/\s+/g, ``) ?? `?`)
+  // Crystal system, plus the lattice system in parens when it differs (e.g. trigonal
+  // space groups split into rhombohedral R-centered and hexagonal P lattices)
+  const crystal_system_label = $derived.by(() => {
+    if (!sym_data) return `?`
+    const crystal_sys = spg.spacegroup_to_crystal_sys(sym_data.number)
+    const lattice_sys = spg.spacegroup_num_to_lattice_system(sym_data.number)
+    if (!crystal_sys) return `?`
+    const suffix =
+      lattice_sys && lattice_sys !== crystal_sys ? ` (${lattice_sys} lattice)` : ``
+    return `${crystal_sys}${suffix}`
+  })
 
   const sym_ops_counts = $derived.by(() => {
     const EPS = 1e-10
@@ -56,24 +88,18 @@
   })
 
   const titles = {
-    symprec:
-      `Symmetry precision control in spglib/moyo. Lower values (e.g. 1e-4, the default) are more strict, higher values (e.g. 1e-1) are more tolerant of numerical errors in atomic positions.`,
-    algo:
-      `Symmetry detection algorithm: Moyo uses moyo's newer recommended settings, Spglib is useful if you need compatible results to an existing set of spglib-detected symmetries.`,
-    space_group:
-      `International Tables Space group number (1-230) - unique identifier for each space group. Higher numbers indicate more symmetries in the crystal.`,
-    crystal_system:
-      `Crystal system classification based on the unit cell symmetry. Seven systems: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, and cubic.`,
-    hermann_mauguin:
-      `Hermann-Mauguin symbol describes symmetry operations. Format: Lattice type + Point group symmetry. Example: P4/mmm = Primitive + 4-fold rotation + mirror planes`,
-    hall_number:
-      `Hall number: alternative numbering system for space groups. Useful for crystallographic software compatibility.`,
-    pearson_symbol:
-      `Pearson symbol. Format: Crystal system + Number of atoms per unit cell. Example: tP2 = tetragonal primitive with 2 atoms`,
-    symmetry_operations:
-      `Total symmetry operations that map the crystal structure onto itself. Includes rotations, translations, and combinations.`,
-    distinct_orbits:
-      `Number of unique Wyckoff positions (symmetry-equivalent atomic sites) in the crystal structure.`,
+    symprec: `Symmetry precision control in spglib/moyo. Lower values (e.g. 1e-4, the default) are more strict, higher values (e.g. 1e-1) are more tolerant of numerical errors in atomic positions.`,
+    algo: `Symmetry detection algorithm: Moyo uses moyo's newer recommended settings, Spglib is useful if you need compatible results to an existing set of spglib-detected symmetries.`,
+    space_group: `International Tables Space group number (1-230) - unique identifier for each space group. Higher numbers indicate more symmetries in the crystal.`,
+    crystal_system: `Crystal system classification based on the unit cell symmetry. Seven systems: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, and cubic. For trigonal space groups, the lattice system (rhombohedral for R-centered groups, hexagonal otherwise) is shown in parentheses when it differs from the crystal system.`,
+    hermann_mauguin: `Hermann-Mauguin symbol describes symmetry operations. Format: Lattice type + Point group symmetry. Example: P4/mmm = Primitive + 4-fold rotation + mirror planes`,
+    hall_number: `Hall number: alternative numbering system for space groups. Useful for crystallographic software compatibility.`,
+    pearson_symbol: `Pearson symbol. Format: Crystal system + Number of atoms per unit cell. Example: tP2 = tetragonal primitive with 2 atoms`,
+    symmetry_operations: `Total symmetry operations that map the crystal structure onto itself. Includes rotations, translations, and combinations.`,
+    distinct_orbits: `Number of unique Wyckoff positions (symmetry-equivalent atomic sites) in the crystal structure.`,
+    wyckoff_sequence: `Wyckoff sequence: letters of all occupied Wyckoff positions in descending alphabetical order, with superscript counts for letters occupied by multiple orbits. A standard structure-type fingerprint (complements the Pearson symbol).`,
+    free_params: `Internal degrees of freedom: number of free fractional-coordinate parameters (x, y, z in the ITA representative coordinates) summed over occupied Wyckoff orbits. 0 means all atomic positions are fully fixed by symmetry.`,
+    settings: `All settings of this space group in the International Tables (origin choices, unique axes, cell choices, hexagonal vs rhombohedral axes). The setting detected for this structure is highlighted.`,
     translations: `Number of translations in the crystal structure.`,
     rotations: `Number of rotations in the crystal structure.`,
     roto_translations: `Number of roto-translations in the crystal structure.`,
@@ -89,7 +115,7 @@
   const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec))
 </script>
 
-<div {...rest} class="symmetry-stats {rest.class ?? ``}">
+<div {...rest} class={[`symmetry-stats`, rest.class]}>
   {#if sym_data}
     {@render header?.({ sym_data, settings })}
   {/if}
@@ -129,10 +155,10 @@
       <select
         value={settings.algo}
         onchange={(evt) =>
-        settings = {
-          ...settings,
-          algo: evt.currentTarget.value as `Moyo` | `Spglib`,
-        }}
+          (settings = {
+            ...settings,
+            algo: evt.currentTarget.value as `Moyo` | `Spglib`,
+          })}
       >
         {#each Object.keys(SETTINGS_CONFIG.symmetry.algo.enum ?? {}) as value (value)}
           <option {value}>{value}</option>
@@ -143,36 +169,85 @@
 
   {@render children?.({ sym_data, settings })}
   {#if sym_data}
+    {@const stat_tiles = [
+      {
+        label: `Space Group`,
+        title: `${tooltips?.space_group} at ${settings.symprec} (using ${settings.algo} algo). ${tooltips?.hermann_mauguin}`,
+        value: `${sym_data.number} (${display_hm_symbol})`,
+      },
+      {
+        label: `Crystal System`,
+        title: tooltips?.crystal_system,
+        value: crystal_system_label,
+      },
+      {
+        label: `Hall Number`,
+        title: tooltips?.hall_number,
+        value: `${sym_data.hall_number}${
+          current_setting ? ` (${current_setting.hall_symbol})` : ``
+        }`,
+      },
+      { label: `Pearson`, title: tooltips?.pearson_symbol, value: sym_data.pearson_symbol },
+      { label: `Wyckoff Positions`, title: tooltips?.distinct_orbits, value: wyckoff_count },
+      wyckoff_seq && {
+        label: `Wyckoff Sequence`,
+        title: tooltips?.wyckoff_sequence,
+        value: wyckoff_seq,
+      },
+      free_params !== null && {
+        label: `Free Parameters`,
+        title: tooltips?.free_params,
+        value: free_params,
+      },
+    ].filter((tile) => typeof tile === `object`)}
     <div class="stats-grid">
-      <div
-        title="{tooltips?.space_group} at {settings.symprec} (using {settings.algo} algo). {tooltips?.hermann_mauguin}"
-        {@attach tooltip()}
-      >
-        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>
-      </div>
-      <div title={tooltips?.hall_number} {@attach tooltip()}>
-        Hall Number <strong>{sym_data.hall_number}</strong>
-      </div>
-      <div title={tooltips?.pearson_symbol} {@attach tooltip()}>
-        Pearson <strong>{sym_data.pearson_symbol}</strong>
-      </div>
-      <div title={tooltips?.distinct_orbits} {@attach tooltip()}>
-        Wyckoff Positions <strong>{wyckoff_count}</strong>
-      </div>
+      {#each stat_tiles as tile (tile.label)}
+        <div title={tile.title} {@attach tooltip()}>
+          {tile.label} <strong>{tile.value}</strong>
+        </div>
+      {/each}
       <div
         class="sym-ops-summary"
         title="{sym_ops_counts.translations} translations + {sym_ops_counts.rotations} rotations + {sym_ops_counts.roto_translations} roto-translations"
         {@attach tooltip()}
       >
         Total sym ops: <strong>{sym_data.operations.length}</strong>
-        ({sym_ops_counts.translations}T + {sym_ops_counts.rotations}R + {
-          sym_ops_counts.roto_translations
-        }RT)
+        ({sym_ops_counts.translations}T + {sym_ops_counts.rotations}R + {sym_ops_counts.roto_translations}RT)
       </div>
     </div>
+    {#if settings_entries.length > 1}
+      <details class="settings-explorer">
+        <summary title={tooltips?.settings} {@attach tooltip()}>
+          {settings_entries.length} settings of space group {sym_data.number}
+        </summary>
+        <table>
+          <thead>
+            <tr>
+              <th>Hall #</th>
+              <th>H-M full</th>
+              <th>Hall symbol</th>
+              <th>Setting</th>
+              <th>Centering</th>
+            </tr>
+          </thead>
+          <tbody>
+            {#each settings_entries as entry (entry.hall_number)}
+              {@const is_current = entry.hall_number === sym_data.hall_number}
+              <tr
+                class:current={is_current}
+                title={is_current ? `Setting detected for this structure` : null}
+              >
+                <td>{entry.hall_number}</td>
+                <td>{entry.hm_full}</td>
+                <td>{entry.hall_symbol}</td>
+                <td>{entry.setting || `—`}</td>
+                <td>{entry.centering}</td>
+              </tr>
+            {/each}
+          </tbody>
+        </table>
+      </details>
+    {/if}
   {:else}
     <div class="no-data">
       <p>No symmetry data available</p>
@@ -201,8 +276,7 @@
   }
   .stats-grid {
     display: var(--sym-stats-display, grid);
-    grid-template-columns:
-      var(--sym-stats-grid-columns, repeat(auto-fit, minmax(275px, 1fr)));
+    grid-template-columns: var(--sym-stats-grid-columns, repeat(auto-fit, minmax(275px, 1fr)));
     gap: var(--sym-stats-grid-gap, 1ex 1em);
     margin-block: var(--sym-stats-grid-margin-block, 1ex);
     align-items: var(--sym-stats-grid-align, start);
@@ -210,6 +284,25 @@
   .stats-grid strong {
     margin: var(--sym-stats-strong-margin, 0 0 0 3pt);
   }
+  .settings-explorer {
+    margin-block: var(--sym-stats-grid-margin-block, 1ex);
+  }
+  .settings-explorer summary {
+    cursor: pointer;
+    color: var(--text-muted, #666);
+  }
+  .settings-explorer table {
+    margin-top: 1ex;
+    border-collapse: collapse;
+  }
+  .settings-explorer :is(th, td) {
+    padding: 1px 8px;
+    text-align: left;
+  }
+  .settings-explorer tr.current {
+    background: color-mix(in srgb, var(--accent-color, #0066cc) 18%, transparent);
+    font-weight: bold;
+  }
   .no-data {
     display: flex;
     align-items: center;

package/dist/symmetry/WyckoffTable.svelte

@@ -2,17 +2,27 @@
   import { contrast_color } from '../colors'
   import { format_fractional } from '../labels'
   import { colors } from '../state.svelte'
+  import type { MoyoWyckoffPosition } from '@spglib/moyo-wasm'
+  import { SvelteSet } from 'svelte/reactivity'
   import type { HTMLAttributes } from 'svelte/elements'
   import type { WyckoffPos } from '.'
+  import { enrich_wyckoff_rows, wyckoff_letter } from '.'
 
   let {
     wyckoff_positions,
+    // Full Wyckoff-position database of the space group (from
+    // spacegroup_wyckoff_positions). When given, occupied rows gain an ITA coordinates
+    // column and unoccupied positions can be listed via show_unoccupied.
+    db_positions = [],
+    show_unoccupied = false,
     on_hover,
     on_click,
     active_color = `#2563eb`,
     ...rest
   }: HTMLAttributes<HTMLTableElement> & {
     wyckoff_positions: WyckoffPos[]
+    db_positions?: MoyoWyckoffPosition[]
+    show_unoccupied?: boolean
     on_hover?: (site_indices: number[] | null) => void
     on_click?: (site_indices: number[] | null) => void
     active_color?: string
@@ -20,12 +30,33 @@
 
   let selected_key = $state<string | null>(null)
 
+  // Occupied orbits enriched with ITA representative coordinates + site symmetry
+  const rows = $derived(enrich_wyckoff_rows(wyckoff_positions ?? [], db_positions))
+  // Wyckoff positions of the space group not occupied by any atom, smallest
+  // multiplicity first (matches the ascending sort of occupied rows)
+  const unoccupied_rows = $derived.by(() => {
+    if (!show_unoccupied) return []
+    const occupied_letters = new SvelteSet(rows.map((row) => wyckoff_letter(row.wyckoff)))
+    return db_positions
+      .filter((pos) => !occupied_letters.has(pos.letter))
+      .toSorted(
+        (pos_1, pos_2) =>
+          pos_1.multiplicity - pos_2.multiplicity || pos_1.letter.localeCompare(pos_2.letter),
+      )
+  })
+  const has_ita_coords = $derived(
+    rows.some((pos) => pos.coordinates) || unoccupied_rows.length > 0,
+  )
+  const has_site_symmetry = $derived(
+    rows.some((pos) => pos.site_symmetry) || unoccupied_rows.length > 0,
+  )
+
   const get_row_key = (wyckoff_pos: WyckoffPos, row_idx: number) =>
     `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${
       wyckoff_pos.site_indices?.join(`,`) ?? `none`
     }-${row_idx}`
   $effect(() => {
-    if (!selected_key || wyckoff_positions?.some((pos, idx) => get_row_key(pos, idx) === selected_key)) {
+    if (!selected_key || rows.some((pos, idx) => get_row_key(pos, idx) === selected_key)) {
       return
     }
     selected_key = null
@@ -33,28 +64,17 @@
   })
 </script>
 
-{#if wyckoff_positions && wyckoff_positions.length > 0}
-  <table {...rest} class="wyckoff-table {rest.class ?? ``}">
+{#if rows.length > 0 || unoccupied_rows.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)
-        }
+        {#each [[`Wyckoff`, `Wyckoff position: Multiplicity + Letter`], [`Element`, `Chemical element symbol`], [`Fractional Coords`, `Fractional coordinates within the unit cell`], ...(has_ita_coords ? [[`ITA Coords`, `Representative coordinates from the International Tables: x/y/z mark free parameters, fractions mark symmetry-fixed coordinates`]] : []), ...(has_site_symmetry ? [[`Site Symm.`, `Site symmetry: point group of operations leaving the site invariant`]] : [])] 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))
-      }
+      {#each rows 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}
@@ -89,6 +109,25 @@
             </span>
           </td>
           <td>({abc?.map(format_fractional).join(` , `) ?? `N/A`})</td>
+          {#if has_ita_coords}
+            <td>{wyckoff_pos.coordinates ? `(${wyckoff_pos.coordinates})` : ``}</td>
+          {/if}
+          {#if has_site_symmetry}
+            <td>{wyckoff_pos.site_symmetry ?? ``}</td>
+          {/if}
+        </tr>
+      {/each}
+      {#each unoccupied_rows as db_pos (db_pos.letter)}
+        <tr class="unoccupied" title="Wyckoff position not occupied in this structure">
+          <td>{db_pos.multiplicity}{db_pos.letter}</td>
+          <td>&mdash;</td>
+          <td>&mdash;</td>
+          {#if has_ita_coords}
+            <td>({db_pos.coordinates})</td>
+          {/if}
+          {#if has_site_symmetry}
+            <td>{db_pos.site_symmetry}</td>
+          {/if}
         </tr>
       {/each}
     </tbody>
@@ -117,4 +156,7 @@
   .wyckoff-row.selected:hover {
     background-color: color-mix(in srgb, var(--active-color) 35%, transparent);
   }
+  .unoccupied {
+    opacity: 0.5;
+  }
 </style>

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

@@ -1,7 +1,10 @@
+import type { MoyoWyckoffPosition } from '@spglib/moyo-wasm';
 import type { HTMLAttributes } from 'svelte/elements';
 import type { WyckoffPos } from '.';
 type $$ComponentProps = HTMLAttributes<HTMLTableElement> & {
     wyckoff_positions: WyckoffPos[];
+    db_positions?: MoyoWyckoffPosition[];
+    show_unoccupied?: boolean;
     on_hover?: (site_indices: number[] | null) => void;
     on_click?: (site_indices: number[] | null) => void;
     active_color?: string;

package/dist/symmetry/cell-transform.js

@@ -1,6 +1,8 @@
+// Cell transformation utilities for converting between original, conventional, and primitive cells
 import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
 import * as math from '../math';
 import { wrap_to_unit_cell } from '../structure/pbc';
+import { make_site } from '../structure/site';
 const transferable_properties = (properties) => {
     if (properties === undefined)
         return undefined;
@@ -13,17 +15,10 @@ const transferable_properties = (properties) => {
 // 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)
-    ];
+    // 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: column-major(B) ==
+    // row-major(RB)), so the flat array is row-major with each row a lattice vector.
+    const lattice_matrix = math.vec9_to_mat3x3([...cell.lattice.basis]);
     // 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);
@@ -40,8 +35,7 @@ original_structure) {
         // 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: {} };
+        return make_site(element, wrapped_abc, xyz, element);
     });
     const lattice = {
         matrix: lattice_matrix,
@@ -86,6 +80,6 @@ sym_data) {
     if (cell_type === `primitive`) {
         return get_primitive_cell(structure, sym_data);
     }
-    // Fallback to original (should never reach here with proper typing)
+    // Unknown cell_type at runtime (e.g. from stale persisted settings): leave unchanged
     return structure;
 }

package/dist/symmetry/index.d.ts

@@ -1,8 +1,12 @@
 import type { Vec3 } from '../math';
 import type { AnyStructure, Crystal } from '../structure';
-import type { MoyoDataset } from '@spglib/moyo-wasm';
+import type { MoyoCell, MoyoDataset } from '@spglib/moyo-wasm';
 export * from './cell-transform';
 export * from './spacegroups';
+export * from './symmetry-elements';
+export * from './wyckoff-db';
+export { default as SymmetryElementControls } from './SymmetryElementControls.svelte';
+export { default as SymmetryElements } from './SymmetryElements.svelte';
 export { default as SymmetryStats } from './SymmetryStats.svelte';
 export { default as WyckoffTable } from './WyckoffTable.svelte';
 export declare const BRAVAIS_LATTICES: {
@@ -28,16 +32,23 @@ export type WyckoffPos = {
     elem: string;
     abc: Vec3;
     site_indices?: number[];
+    site_symmetry?: string;
+    coordinates?: string;
 };
 export type SymmetryDataset = MoyoDataset & {
-    orig_indices?: number[];
     orig_site_indices_by_std_idx?: number[][];
+    input_cell?: Pick<MoyoCell, `positions` | `numbers`>;
+    orig_site_indices_by_input_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 const 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 const 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[][], transform?: {
+    std_linear: readonly number[];
+    std_origin_shift: readonly number[];
+}, tol?: 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 const wyckoff_multiplicity: (label: string) => 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 apply_symmetry_operations(position: Vec3, operations: MoyoDataset[`operations`]): 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[];