matterviz 0.1.0

package/dist/structure/StructureScene.svelte

@@ -0,0 +1,331 @@
+<script lang="ts">import { add, atomic_radii, Bond, BOND_DEFAULTS, element_data, euclidean_dist, Lattice, pbc_dist, scale, } from '..';
+import { format_num } from '../labels';
+import { colors } from '../state.svelte';
+import { T } from '@threlte/core';
+import { Gizmo, HTML, interactivity, OrbitControls } from '@threlte/extras';
+import {} from 'svelte';
+import * as bonding_strategies from './bonding';
+let { structure = undefined, atom_radius = 0.5, 
+// label_radius = 1,
+same_size_atoms = false, camera_position = [0, 0, 0], rotation_damping = 0.1, max_zoom = undefined, min_zoom = undefined, zoom_speed = 0.3, pan_speed = 1, show_atoms = true, show_bonds = true, show_site_labels = false, gizmo = true, hovered_idx = $bindable(null), active_idx = $bindable(null), hovered_site = $bindable(null), active_site = $bindable(null), precision = `.3~f`, auto_rotate = 0, bond_thickness = BOND_DEFAULTS.thickness, bond_color = `#ffffff`, bonding_strategy = `nearest_neighbor`, bonding_options = {}, active_hovered_dist = { color: `green`, width: 0.1, opacity: 0.5 }, fov = 10, ambient_light = 1.8, directional_light = 2.5, sphere_segments = 20, lattice_props = {}, atom_label, camera_is_moving = $bindable(false), } = $props();
+let bond_pairs = $state([]);
+interactivity();
+$effect.pre(() => {
+    hovered_site = structure?.sites?.[hovered_idx ?? -1] ?? null;
+});
+$effect.pre(() => {
+    active_site = structure?.sites?.[active_idx ?? -1] ?? null;
+});
+let lattice = $derived(structure && `lattice` in structure ? structure.lattice : null);
+$effect.pre(() => {
+    if (camera_position.every((val) => val === 0) && structure) {
+        // Simple approach: use sum of lattice dimensions as size estimate
+        const size = lattice ? (lattice.a + lattice.b + lattice.c) / 2 : 10;
+        const distance = size * (65 / fov);
+        camera_position[0] = distance;
+        camera_position[1] = distance * 0.3;
+        camera_position[2] = distance * 0.8;
+    }
+});
+$effect.pre(() => {
+    if (structure && show_bonds) {
+        bond_pairs = bonding_strategies[bonding_strategy](structure, bonding_options);
+    }
+});
+// Create modest gizmo options with balanced colors
+let gizmo_options = $derived.by(() => {
+    const axis_options = Object.fromEntries([
+        [`x`, `#d75555`, `#e66666`], // red
+        [`y`, `#55b855`, `#66c966`], // green
+        [`z`, `#5555d7`, `#6666e6`], // blue
+        [`nx`, `#b84444`, `#cc5555`], // darker red
+        [`ny`, `#44a044`, `#55b155`], // darker green
+        [`nz`, `#4444b8`, `#5555c9`], // darker blue
+    ].map(([axis, color, hover_color]) => [
+        axis,
+        {
+            color,
+            labelColor: `#555555`,
+            opacity: axis.startsWith(`n`) ? 0.7 : 0.85,
+            hover: {
+                color: hover_color,
+                labelColor: `#222222`,
+                opacity: axis.startsWith(`n`) ? 0.85 : 0.95,
+            },
+        },
+    ]));
+    const default_options = {
+        size: 100,
+        background: { enabled: false },
+        ...axis_options,
+    };
+    return { ...default_options, ...(typeof gizmo === `boolean` ? {} : gizmo) };
+});
+</script>
+
+<T.PerspectiveCamera makeDefault position={camera_position} {fov}>
+  <!-- fix the ugly target -->
+  <OrbitControls
+    position={[0, 0, 0]}
+    enableZoom={zoom_speed > 0}
+    zoomSpeed={zoom_speed}
+    enablePan={pan_speed > 0}
+    panSpeed={pan_speed}
+    target={lattice ? (scale(add(...lattice.matrix), 0.5) as Vector3) : [0, 0, 0]}
+    maxZoom={max_zoom}
+    minZoom={min_zoom}
+    autoRotate={Boolean(auto_rotate)}
+    autoRotateSpeed={auto_rotate}
+    enableDamping={Boolean(rotation_damping)}
+    dampingFactor={rotation_damping}
+    onstart={() => {
+      camera_is_moving = true
+      // Clear any existing hover state to immediately hide tooltips
+      hovered_idx = null
+    }}
+    onend={() => {
+      camera_is_moving = false
+    }}
+  >
+    {#if gizmo}
+      <Gizmo {...gizmo_options} />
+    {/if}
+  </OrbitControls>
+</T.PerspectiveCamera>
+
+<T.DirectionalLight position={[3, 10, 10]} intensity={directional_light} />
+<T.AmbientLight intensity={ambient_light} />
+
+{#if show_atoms && structure?.sites}
+  {#each structure.sites as site, site_idx (JSON.stringify({ site, site_idx }))}
+    {@const { species, xyz } = site}
+    {@const site_radius = same_size_atoms ? atom_radius : species.reduce(
+    (sum, spec) => sum + spec.occu * (atomic_radii[spec.element] ?? 1),
+    0,
+  ) * atom_radius}
+    {#each species as { element: elem, occu }, spec_idx ([elem, occu])}
+      {@const start_angle = species
+    .slice(0, spec_idx)
+    .reduce((total, spec) => total + spec.occu, 0)}
+      <T.Group
+        position={xyz}
+        scale={site_radius}
+        onpointerenter={(_event: PointerEvent) => {
+          hovered_idx = site_idx
+        }}
+        onpointerleave={(_event: PointerEvent) => {
+          hovered_idx = null
+        }}
+        onclick={(_event: MouseEvent) => {
+          if (active_idx == site_idx) active_idx = null
+          else active_idx = site_idx
+        }}
+      >
+        <!-- Main partial sphere -->
+        <T.Mesh>
+          <T.SphereGeometry
+            args={[
+              0.5,
+              sphere_segments,
+              sphere_segments,
+              2 * Math.PI * start_angle,
+              2 * Math.PI * occu,
+            ]}
+          />
+          <T.MeshStandardMaterial color={colors.element?.[elem]} />
+        </T.Mesh>
+
+        <!-- Cap the open surfaces with flat circles if partial occupancy -->
+        {#if occu < 1}
+          {@const start_phi = 2 * Math.PI * start_angle}
+          {@const end_phi = 2 * Math.PI * (start_angle + occu)}
+
+          <!-- Start cap - positioned at the start angle -->
+          <T.Mesh rotation={[0, start_phi, 0]}>
+            <T.CircleGeometry args={[0.5, sphere_segments]} />
+            <T.MeshStandardMaterial color={colors.element?.[elem]} side={2} />
+          </T.Mesh>
+
+          <!-- End cap - positioned at the end angle -->
+          <T.Mesh rotation={[0, end_phi, 0]}>
+            <T.CircleGeometry args={[0.5, sphere_segments]} />
+            <T.MeshStandardMaterial color={colors.element?.[elem]} side={2} />
+          </T.Mesh>
+        {/if}
+      </T.Group>
+      <!-- use polar coordinates + offset if site has partial occupancy to move the text to the side of the corresponding sphere slice -->
+      <!-- TODO fix render multiple labels for disordered sites
+        {@const phi = 2 * Math.PI * (start_angle + occu / 2)}
+      {@const pos = add(
+        xyz,
+        scale([Math.cos(phi), 0, Math.sin(phi)], label_radius * radius),
+      )} -->
+      {#if show_site_labels}
+        <HTML center position={xyz}>
+          {#if atom_label}
+            {@render atom_label(site)}
+          {:else}
+            <span class="atom-label">
+              {@html species.map((sp) => sp.element).join(`&nbsp;`)}
+            </span>
+          {/if}
+        </HTML>
+      {/if}
+    {/each}
+  {/each}
+{/if}
+
+{#if show_bonds}
+  {#each bond_pairs as [from, to, idx_a, idx_b] ([from, to, idx_a, idx_b])}
+    {@const site_a = structure?.sites[idx_a]}
+    {@const site_b = structure?.sites[idx_b]}
+    {@const get_majority_color = (site: typeof site_a) => {
+    if (!site?.species || site.species.length === 0) return bond_color
+    // Find species with highest occupancy
+    const majority_species = site.species.reduce((max, spec) =>
+      spec.occu > max.occu ? spec : max
+    )
+    return colors.element?.[majority_species.element] || bond_color
+  }}
+    {@const from_color = get_majority_color(site_a)}
+    {@const to_color = get_majority_color(site_b)}
+    <Bond
+      {from}
+      {to}
+      thickness={bond_thickness}
+      {from_color}
+      {to_color}
+      color={bond_color}
+    />
+  {/each}
+{/if}
+
+<!-- highlight active and hovered sites -->
+{#each [{ site: hovered_site, opacity: 0.2 }, { site: active_site, opacity: 0.3 }] as
+  { site, opacity }
+  (opacity)
+}
+  {#if site}
+    {@const { xyz, species } = site}
+    {@const highlight_radius = same_size_atoms ? atom_radius : species.reduce(
+    (sum, spec) => sum + spec.occu * (atomic_radii[spec.element] ?? 1),
+    0,
+  ) * atom_radius}
+    <T.Mesh position={xyz} scale={1.02 * highlight_radius}>
+      <T.SphereGeometry args={[0.5, 20, 20]} />
+      <T.MeshStandardMaterial color="white" transparent {opacity} />
+    </T.Mesh>
+  {/if}
+{/each}
+
+<!-- cylinder between active and hovered site to indicate measured distance -->
+{#if active_site && hovered_site && active_hovered_dist}
+  {@const { color, width } = active_hovered_dist}
+  <Bond from={active_site.xyz} to={hovered_site.xyz} thickness={width} {color} />
+{/if}
+
+<!-- hovered site tooltip -->
+{#if hovered_site && !camera_is_moving}
+  <HTML position={hovered_site.xyz} pointerEvents="none">
+    <div class="tooltip">
+      <!-- Element names with occupancies for disordered sites -->
+      <div class="elements">
+        {#each hovered_site.species ?? [] as
+          { element, occu, oxidation_state: oxi_state },
+          idx
+          ([element, occu, oxi_state])
+        }
+          {@const oxi_str = oxi_state != null && oxi_state !== 0
+          ? `<sup>${oxi_state}${oxi_state > 0 ? `+` : `-`}</sup>`
+          : ``}
+          {@const element_name = element_data.find((elem) =>
+          elem.symbol === element
+        )?.name ?? ``}
+          {#if idx > 0}
+            &thinsp;
+          {/if}
+          {#if occu !== 1}
+            <span class="occupancy">{format_num(occu, `.3~f`)}</span>
+          {/if}
+          <strong>{element}{@html oxi_str}</strong>
+          {#if element_name}
+            <span class="elem-name">{element_name}</span>
+          {/if}
+        {/each}
+      </div>
+
+      <!-- Fractional coordinates -->
+      <div class="coordinates">
+        abc: ({hovered_site.abc.map((num) => format_num(num, precision)).join(`, `)})
+      </div>
+
+      <!-- Cartesian coordinates -->
+      <div class="coordinates">
+        xyz: ({hovered_site.xyz.map((num) => format_num(num, precision)).join(`, `)}) Å
+      </div>
+
+      <!-- distance from hovered to active site -->
+      {#if active_site && active_site != hovered_site && active_hovered_dist}
+        {@const direct_distance = euclidean_dist(hovered_site.xyz, active_site.xyz)}
+        {@const pbc_distance = lattice
+        ? pbc_dist(hovered_site.xyz, active_site.xyz, lattice.matrix)
+        : direct_distance}
+        <div class="distance">
+          <strong>dist:</strong>
+          {format_num(pbc_distance, precision)} Å{lattice ? ` (PBC)` : ``}
+          {#if lattice && Math.abs(pbc_distance - direct_distance) > 0.1}
+            <small> | direct: {format_num(direct_distance, precision)} Å</small>
+          {/if}
+        </div>
+      {/if}
+    </div>
+  </HTML>
+{/if}
+
+{#if lattice}
+  <Lattice matrix={lattice.matrix} {...lattice_props} />
+{/if}
+
+<style>
+  div.tooltip {
+    width: max-content;
+    box-sizing: border-box;
+    border-radius: var(--struct-tooltip-border-radius, 5pt);
+    background: var(--struct-tooltip-bg, rgba(0, 0, 0, 0.5));
+    padding: var(--struct-tooltip-padding, 1pt 5pt);
+    text-align: left;
+    color: var(--struct-tooltip-text-color);
+    font-family: var(--struct-tooltip-font-family);
+    font-size: var(--struct-tooltip-font-size);
+    line-height: var(--struct-tooltip-line-height);
+  }
+
+  div.tooltip .elements {
+    margin-bottom: var(--struct-tooltip-elements-margin);
+  }
+
+  div.tooltip .occupancy {
+    font-size: var(--struct-tooltip-occu-font-size);
+    opacity: var(--struct-tooltip-occu-opacity);
+    margin-right: var(--struct-tooltip-occu-margin);
+  }
+
+  div.tooltip .elem-name {
+    font-size: var(--struct-tooltip-elem-name-font-size, 0.85em);
+    opacity: var(--struct-tooltip-elem-name-opacity, 0.7);
+    margin: var(--struct-tooltip-elem-name-margin, 0 0 0 0.3em);
+    font-weight: var(--struct-tooltip-elem-name-font-weight, normal);
+  }
+
+  div.tooltip .coordinates,
+  div.tooltip .distance {
+    font-size: var(--struct-tooltip-coords-font-size);
+    margin: var(--struct-tooltip-coords-margin);
+  }
+
+  .atom-label {
+    background: var(--struct-atom-label-bg, rgba(0, 0, 0, 0.1));
+    border-radius: var(--struct-atom-label-border-radius, 3pt);
+    padding: var(--struct-atom-label-padding, 0 3px);
+  }
+</style>

package/dist/structure/StructureScene.svelte.d.ts

@@ -0,0 +1,47 @@
+import type { AnyStructure, Site, Vector3 } from '..';
+import { Lattice } from '..';
+import { Gizmo } from '@threlte/extras';
+import type { ComponentProps } from 'svelte';
+import { type Snippet } from 'svelte';
+import * as bonding_strategies from './bonding';
+type ActiveHoveredDist = {
+    color: string;
+    width: number;
+    opacity: number;
+};
+interface Props {
+    structure?: AnyStructure | undefined;
+    atom_radius?: number;
+    same_size_atoms?: boolean;
+    camera_position?: Vector3;
+    rotation_damping?: number;
+    max_zoom?: number | undefined;
+    min_zoom?: number | undefined;
+    zoom_speed?: number;
+    pan_speed?: number;
+    show_atoms?: boolean;
+    show_bonds?: boolean;
+    show_site_labels?: boolean;
+    gizmo?: boolean | ComponentProps<typeof Gizmo>;
+    hovered_idx?: number | null;
+    active_idx?: number | null;
+    hovered_site?: Site | null;
+    active_site?: Site | null;
+    precision?: string;
+    auto_rotate?: number;
+    bond_thickness?: number;
+    bond_color?: string;
+    bonding_strategy?: keyof typeof bonding_strategies;
+    bonding_options?: Record<string, unknown>;
+    active_hovered_dist?: ActiveHoveredDist | null;
+    fov?: number;
+    ambient_light?: number;
+    directional_light?: number;
+    sphere_segments?: number;
+    lattice_props?: Omit<ComponentProps<typeof Lattice>, `matrix`>;
+    atom_label?: Snippet<[Site]>;
+    camera_is_moving?: boolean;
+}
+declare const StructureScene: import("svelte").Component<Props, {}, "hovered_idx" | "active_idx" | "hovered_site" | "active_site" | "camera_is_moving">;
+type StructureScene = ReturnType<typeof StructureScene>;
+export default StructureScene;

package/dist/structure/bonding.d.ts

@@ -0,0 +1,16 @@
+import type { AnyStructure, BondPair } from '..';
+export type BondingAlgo = typeof max_dist | typeof nearest_neighbor | typeof vdw_radius_based;
+export declare function max_dist(structure: AnyStructure, { max_bond_dist, min_bond_dist }?: {
+    max_bond_dist?: number | undefined;
+    min_bond_dist?: number | undefined;
+}): BondPair[];
+export declare function nearest_neighbor(structure: AnyStructure, { scaling_factor, min_bond_dist }?: {
+    scaling_factor?: number | undefined;
+    min_bond_dist?: number | undefined;
+}): BondPair[];
+export declare function vdw_radius_based(structure: AnyStructure, { tolerance, // Extra distance beyond sum of VdW radii
+min_bond_dist, max_bond_dist, }?: {
+    tolerance?: number | undefined;
+    min_bond_dist?: number | undefined;
+    max_bond_dist?: number | undefined;
+}): BondPair[];

package/dist/structure/bonding.js

@@ -0,0 +1,150 @@
+// Efficient distance-based bonding algorithm using squared distances and unique bond IDs.
+// Finds all bonds within the specified distance range.
+export function max_dist(structure, { max_bond_dist = 3, min_bond_dist = 0.4 } = {}) {
+    const bonds = [];
+    const max_dist_sq = max_bond_dist ** 2;
+    const min_dist_sq = min_bond_dist ** 2;
+    const sites = structure.sites;
+    if (sites.length < 2)
+        return bonds;
+    // Use nested loops with early termination optimizations
+    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+        const site_a = sites[idx_a];
+        const [x1, y1, z1] = site_a.xyz;
+        for (let idx_b = idx_a + 1; idx_b < sites.length; idx_b++) {
+            const site_b = sites[idx_b];
+            const [x2, y2, z2] = site_b.xyz;
+            // Fast squared distance calculation
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
+            const dist_sq = dx * dx + dy * dy + dz * dz;
+            if (dist_sq >= min_dist_sq && dist_sq <= max_dist_sq) {
+                const distance = Math.sqrt(dist_sq);
+                bonds.push([site_a.xyz, site_b.xyz, idx_a, idx_b, distance]);
+            }
+        }
+    }
+    return bonds;
+}
+// Optimized nearest neighbor bonding with proper duplicate prevention.
+// Uses spatial hashing for better O(n) performance on large structures.
+export function nearest_neighbor(structure, { scaling_factor = 1.8, min_bond_dist = 0.4 } = {}) {
+    const sites = structure.sites;
+    const bonds = [];
+    if (sites.length < 2)
+        return bonds;
+    const min_dist_sq = min_bond_dist ** 2;
+    const nearest_dist_sq = new Float64Array(sites.length).fill(Infinity);
+    // First pass: find nearest neighbor distances efficiently
+    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+        const [x1, y1, z1] = sites[idx_a].xyz;
+        for (let idx_b = idx_a + 1; idx_b < sites.length; idx_b++) {
+            const [x2, y2, z2] = sites[idx_b].xyz;
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
+            const dist_sq = dx * dx + dy * dy + dz * dz;
+            if (dist_sq >= min_dist_sq) {
+                if (dist_sq < nearest_dist_sq[idx_a])
+                    nearest_dist_sq[idx_a] = dist_sq;
+                if (dist_sq < nearest_dist_sq[idx_b])
+                    nearest_dist_sq[idx_b] = dist_sq;
+            }
+        }
+    }
+    // Second pass: create bonds within scaled nearest neighbor distances
+    const scaling_sq = scaling_factor ** 2;
+    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+        const site_a = sites[idx_a];
+        const [x1, y1, z1] = site_a.xyz;
+        const max_dist_sq = nearest_dist_sq[idx_a] * scaling_sq;
+        for (let idx_b = idx_a + 1; idx_b < sites.length; idx_b++) {
+            const site_b = sites[idx_b];
+            const [x2, y2, z2] = site_b.xyz;
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
+            const dist_sq = dx * dx + dy * dy + dz * dz;
+            if (dist_sq >= min_dist_sq && dist_sq <= max_dist_sq) {
+                const distance = Math.sqrt(dist_sq);
+                bonds.push([site_a.xyz, site_b.xyz, idx_a, idx_b, distance]);
+            }
+        }
+    }
+    return bonds;
+}
+// Van der Waals radius-based bonding algorithm.
+// Uses atomic radii to determine reasonable bonding distances.
+export function vdw_radius_based(structure, { tolerance = 0.3, // Extra distance beyond sum of VdW radii
+min_bond_dist = 0.4, max_bond_dist = 4.0, } = {}) {
+    // Default VdW radii in Angstroms (simplified set)
+    const vdw_radii = {
+        H: 1.2,
+        He: 1.4,
+        Li: 1.82,
+        Be: 1.53,
+        B: 1.92,
+        C: 1.7,
+        N: 1.55,
+        O: 1.52,
+        F: 1.47,
+        Ne: 1.54,
+        Na: 2.27,
+        Mg: 1.73,
+        Al: 1.84,
+        Si: 2.1,
+        P: 1.8,
+        S: 1.8,
+        Cl: 1.75,
+        Ar: 1.88,
+        K: 2.75,
+        Ca: 2.31,
+        Fe: 2.04,
+        Co: 2.0,
+        Ni: 1.97,
+        Cu: 1.96,
+        Zn: 2.01,
+        Br: 1.85,
+        Kr: 2.02,
+        Ag: 2.11,
+        I: 1.98,
+        Xe: 2.16,
+        Au: 2.14,
+        Hg: 2.23,
+        Pb: 2.02,
+    };
+    const bonds = [];
+    const sites = structure.sites;
+    if (sites.length < 2)
+        return bonds;
+    const min_dist_sq = min_bond_dist ** 2;
+    const max_dist_sq = max_bond_dist ** 2;
+    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+        const site_a = sites[idx_a];
+        const [x1, y1, z1] = site_a.xyz;
+        // Get primary element for site A
+        const elem_a = site_a.species?.[0]?.element || `C`;
+        const radius_a = vdw_radii[elem_a] || 1.7;
+        for (let idx_b = idx_a + 1; idx_b < sites.length; idx_b++) {
+            const site_b = sites[idx_b];
+            const [x2, y2, z2] = site_b.xyz;
+            // Get primary element for site B
+            const elem_b = site_b.species?.[0]?.element || `C`;
+            const radius_b = vdw_radii[elem_b] || 1.7;
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
+            const dist_sq = dx * dx + dy * dy + dz * dz;
+            const distance = Math.sqrt(dist_sq);
+            // Check if distance is reasonable for bonding
+            const expected_bond_dist = radius_a + radius_b + tolerance;
+            if (dist_sq >= min_dist_sq &&
+                dist_sq <= max_dist_sq &&
+                distance <= expected_bond_dist) {
+                bonds.push([site_a.xyz, site_b.xyz, idx_a, idx_b, distance]);
+            }
+        }
+    }
+    return bonds;
+}

package/dist/structure/index.d.ts

@@ -0,0 +1,98 @@
+import type { ElementSymbol, Vec3 } from '..';
+import type { Matrix3x3 } from '../math';
+export { default as Bond } from './Bond.svelte';
+export * as bonding_strategies from './bonding';
+export { default as Lattice } from './Lattice.svelte';
+export * from './pbc';
+export { default as Structure } from './Structure.svelte';
+export { default as StructureCard } from './StructureCard.svelte';
+export { default as StructureControls } from './StructureControls.svelte';
+export { default as StructureLegend } from './StructureLegend.svelte';
+export { default as StructureScene } from './StructureScene.svelte';
+export declare const CELL_DEFAULTS: {
+    readonly edge_opacity: 0.4;
+    readonly surface_opacity: 0.05;
+    readonly color: "#ffffff";
+    readonly line_width: 1.5;
+};
+export declare const BOND_DEFAULTS: {
+    readonly thickness: 0.25;
+    readonly offset: 0;
+    readonly color: "white";
+    readonly from_color: "white";
+    readonly to_color: "white";
+};
+export type Species = {
+    element: ElementSymbol;
+    occu: number;
+    oxidation_state: number;
+};
+export type Site = {
+    species: Species[];
+    abc: Vec3;
+    xyz: Vec3;
+    label: string;
+    properties: Record<string, unknown>;
+};
+export declare const lattice_param_keys: readonly ["a", "b", "c", "alpha", "beta", "gamma"];
+export type LatticeParams = {
+    [key in (typeof lattice_param_keys)[number]]: number;
+};
+export type PymatgenLattice = {
+    matrix: Matrix3x3;
+    pbc: [boolean, boolean, boolean];
+    volume: number;
+} & LatticeParams;
+export type PymatgenMolecule = {
+    sites: Site[];
+    charge?: number;
+    id?: string;
+};
+export type PymatgenStructure = PymatgenMolecule & {
+    lattice: PymatgenLattice;
+};
+export type Edge = {
+    to_jimage: [number, number, number];
+    id: number;
+    key: number;
+};
+export type Graph = {
+    directed: boolean;
+    multigraph: boolean;
+    graph: [
+        [
+            `edge_weight_name`,
+            null
+        ] | [`edge_weight_units`, null] | [`name`, string]
+    ];
+    nodes: {
+        id: number;
+    }[];
+    adjacency: Edge[][];
+};
+export type StructureGraph = {
+    '@module': string;
+    '@class': string;
+    structure: PymatgenStructure;
+    graphs: Graph[];
+};
+export type BondPair = [Vec3, Vec3, number, number, number];
+export type IdStructure = PymatgenStructure & {
+    id: string;
+};
+export type StructureWithGraph = IdStructure & {
+    graph: Graph;
+};
+export type AnyStructure = PymatgenStructure | PymatgenMolecule;
+export type AnyStructureGraph = AnyStructure & {
+    graph: Graph;
+};
+export declare function get_elem_amounts(structure: AnyStructure): Partial<Record<"K" | "H" | "He" | "Li" | "Be" | "B" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "S" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>>;
+export declare function format_chemical_formula(structure: AnyStructure, sort_fn: (symbols: ElementSymbol[]) => ElementSymbol[]): string;
+export declare function alphabetical_formula(structure: AnyStructure): string;
+export declare function electro_neg_formula(structure: AnyStructure): string;
+export declare const atomic_radii: Partial<Record<ElementSymbol, number>>;
+export declare const atomic_weights: Partial<Record<ElementSymbol, number>>;
+export declare function get_elements(structure: AnyStructure): ElementSymbol[];
+export declare function density(structure: PymatgenStructure, prec?: string): string;
+export declare function get_center_of_mass(struct_or_mol: AnyStructure): Vec3;