matterviz 0.3.4 → 0.3.6

package/dist/structure/index.js

@@ -1,168 +0,0 @@
-import { ATOMIC_WEIGHTS } from '../composition/parse';
-import { element_data } from '../element';
-import * as math from '../math';
-export { default as Arrow } from './Arrow.svelte';
-export * from './atom-properties';
-export { default as AtomLegend } from './AtomLegend.svelte';
-export { default as Bond } from './Bond.svelte';
-export * as bonding_strategies from './bonding';
-export { default as CanvasTooltip } from './CanvasTooltip.svelte';
-export { default as Cylinder } from './Cylinder.svelte';
-export { default as Lattice } from './Lattice.svelte';
-export * from './pbc';
-export { default as Structure } from './Structure.svelte';
-export { default as StructureControls } from './StructureControls.svelte';
-export { default as StructureExportPane } from './StructureExportPane.svelte';
-export { default as StructureInfoPane } from './StructureInfoPane.svelte';
-export { default as StructureScene } from './StructureScene.svelte';
-export * from './supercell';
-export const LATTICE_PARAM_KEYS = [`a`, `b`, `c`, `alpha`, `beta`, `gamma`];
-export function get_element_counts(structure) {
-    const elements = {};
-    for (const site of structure.sites) {
-        for (const species of site.species) {
-            const { element: elem, occu } = species;
-            elements[elem] = (elements[elem] ?? 0) + occu;
-        }
-    }
-    return elements;
-}
-export function format_chemical_formula(structure, sort_fn) {
-    // concatenate elements in a structure followed by their amount
-    const elements = get_element_counts(structure);
-    const formula = [];
-    for (const element of sort_fn(Object.keys(elements))) {
-        const amount = elements[element] ?? 0;
-        if (amount === 1)
-            formula.push(element);
-        else
-            formula.push(`${element}<sub>${amount}</sub>`);
-    }
-    return formula.join(` `);
-}
-export function format_formula_by_electronegativity(structure) {
-    // concatenate elements in a structure followed by their amount sorted by electronegativity
-    return format_chemical_formula(structure, (symbols) => symbols.sort((el1, el2) => {
-        const elec_neg1 = element_data.find((el) => el.symbol === el1)?.electronegativity ?? 0;
-        const elec_neg2 = element_data.find((el) => el.symbol === el2)?.electronegativity ?? 0;
-        // Sort by electronegativity (ascending), then alphabetically for ties
-        if (elec_neg1 !== elec_neg2)
-            return elec_neg1 - elec_neg2;
-        return el1.localeCompare(el2);
-    }));
-}
-// Atomic radii in Angstroms (used for relative sizing, not absolute rendering scale)
-export const atomic_radii = Object.fromEntries(element_data.map((el) => [el.symbol, el.atomic_radius ?? 1]));
-// unified atomic mass units (u) per cubic angstrom (Å^3)
-// to grams per cubic centimeter (g/cm^3)
-const AMU_PER_A3_TO_G_PER_CM3 = 1.66053907;
-export function get_density(structure) {
-    // calculate the density of a Crystal in g/cm³
-    const elements = get_element_counts(structure);
-    let mass = 0;
-    for (const [element, amount] of Object.entries(elements)) {
-        const weight = ATOMIC_WEIGHTS.get(element);
-        if (weight !== undefined)
-            mass += amount * weight;
-    }
-    return (AMU_PER_A3_TO_G_PER_CM3 * mass) / structure.lattice.volume;
-}
-export function get_center_of_mass(structure) {
-    let center = [0, 0, 0];
-    let total_weight = 0;
-    for (const site of structure.sites) {
-        // Handle disordered sites by summing contributions from all species
-        for (const species of site.species) {
-            const atomic_weight = ATOMIC_WEIGHTS.get(species.element) ?? 1;
-            const weight = atomic_weight * species.occu;
-            const scaled_pos = math.scale(site.xyz, weight);
-            center = math.add(center, scaled_pos);
-            total_weight += weight;
-        }
-    }
-    return math.scale(center, 1 / total_weight);
-}
-// Recognized prefixes for per-site vector data (force, magnetic moment, spin).
-// Both singular and plural forms are accepted. Keys matching exactly or starting
-// with one of these followed by `_` (e.g. `force_DFT`) are treated as vectors.
-export const VECTOR_KEY_PREFIXES = [
-    `force`,
-    `forces`,
-    `magmom`,
-    `magmoms`,
-    `spin`,
-    `spins`,
-];
-export function is_vector_key(key) {
-    return VECTOR_KEY_PREFIXES.some((prefix) => key === prefix || key.startsWith(`${prefix}_`));
-}
-// Default color palette for distinguishing multiple vector layers
-export const VECTOR_PALETTE = [
-    `#e74c3c`,
-    `#3498db`,
-    `#2ecc71`,
-    `#f39c12`,
-    `#9b59b6`,
-    `#1abc9c`,
-];
-// Single key → null color (semantic coloring); multiple keys → palette colors.
-export const default_vector_configs = (keys) => Object.fromEntries(keys.map((key, idx) => [
-    key,
-    {
-        visible: true,
-        color: keys.length > 1 ? VECTOR_PALETTE[idx % VECTOR_PALETTE.length] : null,
-        scale: null,
-    },
-]));
-function try_parse_vec3(val) {
-    if (Array.isArray(val) &&
-        val.length === 3 &&
-        val.every((elem) => typeof elem === `number` && isFinite(elem)))
-        return val;
-    if (typeof val === `number` && isFinite(val))
-        return [0, 0, val];
-    return null;
-}
-// Priority index for ordering: bare names first in VECTOR_KEY_PREFIXES order,
-// then prefixed keys in the same prefix order, alphabetically within each prefix group.
-function vector_key_sort_order(key) {
-    for (const [prefix_idx, prefix] of VECTOR_KEY_PREFIXES.entries()) {
-        if (key === prefix)
-            return [prefix_idx, 0, ``];
-        if (key.startsWith(`${prefix}_`))
-            return [prefix_idx, 1, key];
-    }
-    return [VECTOR_KEY_PREFIXES.length, 0, key];
-}
-function compare_vector_keys(left, right) {
-    const ord_l = vector_key_sort_order(left);
-    const ord_r = vector_key_sort_order(right);
-    return ord_l[0] - ord_r[0] || ord_l[1] - ord_r[1] || ord_l[2].localeCompare(ord_r[2]);
-}
-// Extract ALL vector properties from a site (not just the first match).
-// Returns entries for every key that is_vector_key() and has a valid 3D vector value.
-// Ordered by VECTOR_KEY_PREFIXES priority, then alphabetically for prefixed keys.
-export function get_all_site_vectors(site) {
-    const props = site.properties;
-    if (!props)
-        return [];
-    const results = [];
-    for (const key of Object.keys(props)) {
-        if (!is_vector_key(key))
-            continue;
-        const vec = try_parse_vec3(props[key]);
-        if (vec)
-            results.push({ vec, key });
-    }
-    return results.sort((left, right) => compare_vector_keys(left.key, right.key));
-}
-// Collect the union of all vector property keys across all sites in a structure,
-// preserving VECTOR_KEY_PREFIXES priority order.
-export function get_structure_vector_keys(structure) {
-    const seen = new Set();
-    for (const site of structure.sites) {
-        for (const { key } of get_all_site_vectors(site))
-            seen.add(key);
-    }
-    return [...seen].sort(compare_vector_keys);
-}

package/dist/structure/measure.d.ts

@@ -1,6 +0,0 @@
-import type { LatticeConverters, Matrix3x3, Vec3 } from '../math';
-export type AngleMode = `degrees` | `radians`;
-export declare const MAX_SELECTED_SITES = 8;
-export declare function displacement_pbc(from: Vec3, to: Vec3, lattice_matrix: Matrix3x3 | null | undefined, converters?: LatticeConverters): Vec3;
-export declare function distance_pbc(a: Vec3, b: Vec3, lattice_matrix: Matrix3x3): number;
-export declare function angle_between_vectors(v1: Vec3, v2: Vec3, mode?: AngleMode): number;

package/dist/structure/measure.js

@@ -1,29 +0,0 @@
-// functions for measuring distances and angles between structure sites
-import { min_image_displacement, subtract } from '../math';
-export const MAX_SELECTED_SITES = 8;
-// Calculate minimum image displacement between two points under PBC
-// If lattice_matrix is null/undefined, returns Euclidean displacement
-export function displacement_pbc(from, to, lattice_matrix, converters) {
-    if (!lattice_matrix)
-        return subtract(to, from);
-    return min_image_displacement(from, to, lattice_matrix, converters);
-}
-export function distance_pbc(a, b, lattice_matrix) {
-    const [dx, dy, dz] = displacement_pbc(a, b, lattice_matrix);
-    return Math.hypot(dx, dy, dz);
-}
-export function angle_between_vectors(v1, v2, mode = `degrees`) {
-    const n1 = Math.hypot(v1[0], v1[1], v1[2]);
-    const n2 = Math.hypot(v2[0], v2[1], v2[2]);
-    if (n1 === 0 || n2 === 0)
-        return 0;
-    // Dot product of vectors
-    const dot = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-    // Normalize dot product to get cosine
-    const cos_angle = dot / (n1 * n2);
-    // Clamp to [-1, 1] to avoid numerical errors with acos
-    const clamped = Math.max(-1, Math.min(1, cos_angle));
-    // Compute angle using arccos
-    const ang = Math.acos(clamped);
-    return mode === `degrees` ? (ang * 180) / Math.PI : ang;
-}

package/dist/structure/parse.d.ts

@@ -1,65 +0,0 @@
-import type { OptimadeStructure } from '../api/optimade';
-import * as math from '../math';
-import type { AnyStructure, Crystal, Site } from './';
-import type { Pbc } from './pbc';
-export interface ParsedStructure {
-    sites: Site[];
-    lattice?: {
-        matrix: math.Matrix3x3;
-        a: number;
-        b: number;
-        c: number;
-        alpha: number;
-        beta: number;
-        gamma: number;
-        volume: number;
-        pbc?: Pbc;
-    };
-}
-export interface PhonopyCell {
-    lattice: number[][];
-    points: {
-        symbol: string;
-        coordinates: number[];
-        mass: number;
-        reduced_to?: number;
-    }[];
-    reciprocal_lattice?: number[][];
-}
-export interface PhonopyData {
-    phono3py?: {
-        version: string;
-        [key: string]: unknown;
-    };
-    phonopy?: {
-        version: string;
-        [key: string]: unknown;
-    };
-    space_group?: {
-        type: string;
-        number: number;
-        Hall_symbol: string;
-    };
-    primitive_cell?: PhonopyCell;
-    unit_cell?: PhonopyCell;
-    supercell?: PhonopyCell;
-    phonon_primitive_cell?: PhonopyCell;
-    phonon_supercell?: PhonopyCell;
-    phonon_displacements?: unknown[];
-    [key: string]: unknown;
-}
-export declare function parse_poscar(content: string): ParsedStructure | null;
-export declare function parse_xyz(content: string): ParsedStructure | null;
-export declare function parse_cif(content: string, wrap_fractional_coords?: boolean, strict?: boolean): ParsedStructure | null;
-export type CellType = `primitive_cell` | `unit_cell` | `supercell` | `phonon_primitive_cell` | `phonon_supercell` | `auto`;
-export declare function parse_phonopy_yaml(content: string, cell_type?: CellType): ParsedStructure | null;
-export declare function normalize_fractional_coords(structure: ParsedStructure): ParsedStructure;
-export declare function parse_structure_file(content: string, filename?: string): ParsedStructure | null;
-export declare function parse_any_structure(content: string, filename: string): AnyStructure | null;
-export declare function parse_optimade_json(content: string): ParsedStructure | null;
-export declare function parse_optimade_from_raw(raw: unknown): ParsedStructure | null;
-export declare function is_optimade_json(content: string): boolean;
-export declare const is_optimade_raw: (raw: unknown) => boolean;
-export declare function optimade_to_crystal(optimade_structure: OptimadeStructure): Crystal | null;
-export declare function is_structure_file(filename: string): boolean;
-export declare const detect_structure_type: (filename: string, content: string) => `crystal` | `molecule` | `unknown`;