matterviz 0.3.6 → 0.3.7

package/dist/src/lib/symmetry/SymmetryStats.svelte

@@ -1,226 +0,0 @@
-<script lang="ts">
-  import type { MoyoDataset } from '@spglib/moyo-wasm'
-  import type { Snippet } from 'svelte'
-  import { tooltip } from 'svelte-multiselect/attachments'
-  import type { HTMLAttributes } from 'svelte/elements'
-  import { SETTINGS_CONFIG } from '$lib/settings'
-  import type { SymmetrySettings } from './index'
-  import { default_sym_settings, wyckoff_positions_from_moyo } from './index'
-  import * as spg from './spacegroups'
-
-  type SymmetrySnippet = Snippet<
-    [{ sym_data?: MoyoDataset | null; settings: SymmetrySettings }]
-  >
-
-  let {
-    sym_data,
-    settings = $bindable(default_sym_settings),
-    show_tooltips = true,
-    children,
-    label = `Symmetry`,
-    header,
-    ...rest
-  }: HTMLAttributes<HTMLDivElement> & {
-    sym_data?: MoyoDataset | null
-    settings?: SymmetrySettings
-    show_tooltips?: boolean
-    children?: SymmetrySnippet
-    label?: SymmetrySnippet | string
-    header?: SymmetrySnippet
-  } = $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) {
-      return { translations: 0, rotations: 0, roto_translations: 0 }
-    }
-
-    return sym_data.operations.reduce(
-      (acc, op) => {
-        const has_translation = op.translation.some((coord) => Math.abs(coord) > EPS)
-        const is_identity = String(op.rotation) === `1,0,0,0,1,0,0,0,1`
-
-        if (is_identity && has_translation) acc.translations++
-        else if (!has_translation) acc.rotations++
-        else acc.roto_translations++
-
-        return acc
-      },
-      { translations: 0, rotations: 0, roto_translations: 0 },
-    )
-  })
-
-  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.`,
-    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.`,
-  }
-  const tooltips: Record<string, string> = $derived(show_tooltips ? titles : {})
-
-  function get_step_from_order_of_magnitude(value: number): number {
-    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 ?? ``}">
-  {#if sym_data}
-    {@render header?.({ sym_data, settings })}
-  {/if}
-
-  <!-- Always show controls so users can adjust settings even after errors -->
-  <div class="controls">
-    {#if typeof label === `string`}
-      <strong>{label}</strong>
-    {:else if label}
-      {@render label?.({ sym_data, settings })}
-    {/if}
-
-    <label>
-      <span {@attach tooltip()} title={tooltips?.symprec}>Precision</span>
-      <input
-        type="number"
-        step={symprec_step}
-        value={settings.symprec}
-        oninput={(evt) => {
-          const { value } = evt.currentTarget
-          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>
-      <span {@attach tooltip()} title={tooltips?.algo}>Algorithm</span>
-
-      <select
-        value={settings.algo}
-        onchange={(evt) =>
-        settings = {
-          ...settings,
-          algo: evt.currentTarget.value as `Moyo` | `Spglib`,
-        }}
-      >
-        {#each Object.keys(SETTINGS_CONFIG.symmetry.algo.enum ?? {}) as value (value)}
-          <option {value}>{value}</option>
-        {/each}
-      </select>
-    </label>
-  </div>
-
-  {@render children?.({ sym_data, settings })}
-  {#if sym_data}
-    <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>
-      <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)
-      </div>
-    </div>
-  {:else}
-    <div class="no-data">
-      <p>No symmetry data available</p>
-    </div>
-  {/if}
-</div>
-
-<style>
-  .controls {
-    display: flex;
-    gap: var(--sym-stats-controls-gap, 1em);
-    background: var(--sym-stats-controls-bg, var(--surface-bg));
-    padding: var(--sym-stats-controls-padding, 4pt 6pt);
-    border-radius: var(--sym-stats-controls-border-radius, 4pt);
-    margin-inline: var(--sym-stats-controls-margin-inline, -6pt);
-  }
-  .controls label {
-    display: flex;
-    gap: var(--sym-stats-label-gap, 6pt);
-    place-items: center;
-  }
-  .controls label input {
-    padding: var(--sym-stats-input-padding, 2pt 5pt);
-    width: var(--sym-stats-input-width, 5.5em);
-    box-sizing: border-box;
-  }
-  .stats-grid {
-    display: var(--sym-stats-display, grid);
-    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);
-  }
-  .stats-grid strong {
-    margin: var(--sym-stats-strong-margin, 0 0 0 3pt);
-  }
-  .no-data {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    min-height: var(--sym-stats-no-data-min-height, 100px);
-    padding: var(--sym-stats-no-data-padding, 2em);
-    background: var(--sym-stats-no-data-bg, var(--surface-bg, #f5f5f5));
-    border-radius: var(--sym-stats-no-data-border-radius, 4pt);
-    color: var(--sym-stats-no-data-color, var(--text-muted, #666));
-  }
-  .no-data p {
-    margin: 0;
-  }
-</style>

package/dist/src/lib/symmetry/WyckoffTable.svelte

@@ -1,120 +0,0 @@
-<script lang="ts">
-  import { contrast_color } from '$lib/colors'
-  import { format_fractional } from '$lib/labels'
-  import { colors } from '$lib/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}`
-  $effect(() => {
-    if (!selected_key || wyckoff_positions?.some((pos, idx) => get_row_key(pos, idx) === selected_key)) {
-      return
-    }
-    selected_key = null
-    on_click?.(null)
-  })
-</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/src/lib/symmetry/cell-transform.ts

@@ -1,118 +0,0 @@
-// Cell transformation utilities for converting between original, conventional, and primitive cells
-import type { Vec3 } from '$lib/math'
-import { ATOMIC_NUMBER_TO_SYMBOL } from '$lib/composition/parse'
-import * as math from '$lib/math'
-import type { Crystal, Site } from '$lib/structure'
-import { wrap_to_unit_cell } from '$lib/structure/pbc'
-import type { MoyoCell, MoyoDataset } from '@spglib/moyo-wasm'
-
-export type CellType = `original` | `conventional` | `primitive`
-
-const transferable_properties = (properties: Crystal[`properties`]): Crystal[`properties`] => {
-  if (properties === undefined) return undefined
-  const rest = { ...properties }
-  delete rest.bonds
-  return Object.keys(rest).length > 0 ? rest : undefined
-}
-
-// 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: MoyoCell, // The MoyoCell from symmetry analysis (std_cell or prim_std_cell)
-  original_structure: Crystal, // The original structure (used to preserve pbc and other metadata)
-): Crystal {
-  // 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: math.Matrix3x3 = [
-    [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: Site[] = 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 as Vec3)
-
-    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,
-  }
-  const properties = transferable_properties(original_structure.properties)
-  return {
-    lattice,
-    sites,
-    charge: original_structure.charge,
-    id: original_structure.id,
-    ...(properties === undefined ? {} : { properties }),
-  }
-}
-
-// 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: Crystal, // The original input structure
-  sym_data: MoyoDataset, // MoyoDataset from symmetry analysis containing std_cell
-): Crystal {
-  // 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: Crystal, // The original input structure
-  sym_data: MoyoDataset, // MoyoDataset from symmetry analysis containing prim_std_cell
-): Crystal {
-  // 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: Crystal, // The original structure
-  cell_type: CellType, // The desired cell type ('original', 'conventional', or 'primitive')
-  sym_data: MoyoDataset | null, // Optional MoyoDataset from symmetry analysis
-): Crystal {
-  //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
-}