matterviz 0.4.1 → 0.4.2

package/dist/structure/partial-occupancy.js

@@ -60,7 +60,8 @@ export const PARTIAL_OCCUPANCY_CAP_ARC = {
 };
 export const merge_split_partial_sites = (sites, hidden_elements = new Set()) => {
     const grouped_indices = group_split_partial_indices(sites, hidden_elements);
-    return build_render_sites(sites, grouped_indices.non_grouped_site_indices, grouped_indices.grouped_site_indices);
+    const { non_grouped_site_indices, grouped_site_indices } = grouped_indices;
+    return build_render_sites(sites, non_grouped_site_indices, grouped_site_indices);
 };
 export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_OCCUPANCY_SLICE_GAP_RAD) => {
     if (visible_species.length === 0)
@@ -72,7 +73,8 @@ export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_
         element,
         occu: occu * occupancy_scale_factor,
     }));
-    const normalized_total_occupancy = normalized_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    // Sum of scaled occupancies equals total * scale (avoids a second O(n) pass)
+    const normalized_total_occupancy = total_visible_occupancy * occupancy_scale_factor;
     const has_vacancy_gap = normalized_total_occupancy < 1 - OCCUPANCY_EPS;
     const last_visible_species_idx = normalized_species.length - 1;
     let start_angle = 0;

package/dist/structure/pbc.js

@@ -1,5 +1,5 @@
 import * as math from '../math';
-import { element_lookup, get_majority_element } from './bonding';
+import { element_lookup, get_majority_element, has_framework_potential, is_spectator_center, pack_cell_key, } from './bonding';
 // Distance slack added to the covalent-radii sum when deciding whether a
 // candidate image atom bonds to a base atom (VESTA-like bond search criterion)
 const BOND_SLACK = 0.4; // Å
@@ -34,42 +34,30 @@ const is_scattered_trajectory = (sites) => {
     const atoms_outside_cell = sites.filter(({ abc }) => abc.some((coord) => coord < -0.1 || coord > 1.1));
     return atoms_outside_cell.length > sites.length * 0.1;
 };
-// Cartesian position of fractional coords abc in the given lattice (rows = lattice vectors)
-const frac_to_cart_pos = (abc, lattice_vecs) => math.add(math.scale(lattice_vecs[0], abc[0]), math.scale(lattice_vecs[1], abc[1]), math.scale(lattice_vecs[2], abc[2]));
 export function find_image_atoms(structure, { tolerance } = {}) {
     // Find image atoms for PBC. Returns [atom_idx, image_xyz, image_abc, is_completion?]
-    // tuples; is_completion marks phase-2 images that exist only to complete bonds /
-    // coordination polyhedra at cell faces (renderers may hide them when neither shows).
-    // Skips image generation for trajectory data with scattered atoms.
+    // tuples; is_completion marks phase-2 images that only complete bonds / coordination
+    // polyhedra at cell faces (renderers may hide them). Skips scattered trajectories.
     if (!structure.lattice || !structure.sites || structure.sites.length === 0)
         return [];
     if (is_scattered_trajectory(structure.sites))
         return [];
-    // Check if this is a supercell to correctly identify external boundaries correctly
     const image_sites = [];
     const lattice_vecs = structure.lattice.matrix;
-    // Scale zero-displacement threshold by lattice length scale to avoid hard-coded magic numbers
-    const lattice_norm = Math.max(Math.hypot(...lattice_vecs[0]), Math.hypot(...lattice_vecs[1]), Math.hypot(...lattice_vecs[2]));
-    // Threshold to filter out floating-point-identical (zero-displacement) images; rarely triggers but guards against edge cases
+    const frac_to_cart = math.create_frac_to_cart(lattice_vecs);
+    const vec_lens = lattice_vecs.map((vec) => Math.hypot(...vec));
+    // Scale zero-displacement threshold by lattice length scale to avoid magic numbers
+    const lattice_norm = Math.max(...vec_lens);
     const displacement_eps_sq = (1e-10 * lattice_norm) ** 2;
-    // Tolerances determine which atoms are near cell boundaries and need image generation
-    // Use provided tolerance or default to physical tolerance of 0.5 Angstroms converted to fractional
-    // This prevents excessive image generation for large unit cells (e.g. MOFs) where 0.05 fractional is huge
-    const PHYSICAL_TOLERANCE = 0.5; // Angstroms
-    const tolerances = [0, 1, 2].map((dim) => {
-        if (tolerance !== undefined)
-            return tolerance;
-        const vec_len = Math.hypot(...lattice_vecs[dim]);
-        // zero-length lattice vector should not occur in valid structures,
-        // but fall back to 0.05 fractional tolerance if it does
-        return vec_len > 0 ? PHYSICAL_TOLERANCE / vec_len : 0.05;
-    });
-    // Respect per-axis periodicity: no images across non-periodic (vacuum) directions
-    const pbc = structure.lattice.pbc ?? [true, true, true];
+    // Boundary tolerance: physical 0.5 Å as fractional per-axis, so large cells (MOFs)
+    // don't over-generate (a flat 0.05 fractional would be huge there)
+    const PHYSICAL_TOLERANCE = 0.5; // Å
+    const tolerances = vec_lens.map((vec_len) => tolerance ?? (vec_len > 0 ? PHYSICAL_TOLERANCE / vec_len : 0.05));
+    const pbc = structure.lattice.pbc ?? [true, true, true]; // no images across vacuum
+    // Phase 1: true periodic copies of atoms within `tolerance` of a cell face (bond
+    // lengths preserved, rather than clamping the copy to the cell face)
     for (const [idx, site] of structure.sites.entries()) {
-        // Find edge dimensions and translation directions
         const edge_dims = [];
-        // Find boundary dimensions
         for (let dim = 0; dim < 3; dim++) {
             if (!pbc[dim])
                 continue;
@@ -80,10 +68,9 @@ export function find_image_atoms(structure, { tolerance } = {}) {
             if (Math.abs(coord - 1) < dim_tolerance)
                 edge_dims.push({ dim, direction: -1 });
         }
-        // Generate all translation combinations
+        // Generate all translation combinations; if both +1 and -1 are selected for a dim the
+        // net shift is zero and we skip (yields no image).
         for (let mask = 1; mask < 1 << edge_dims.length; mask++) {
-            // Track selected translation per dimension. If both +1 and -1 are selected for a dim,
-            // the net shift is zero and we skip because it yields no image.
             const selected_shift = [0, 0, 0];
             for (let bit = 0; bit < edge_dims.length; bit++) {
                 if (mask & (1 << bit)) {
@@ -91,25 +78,18 @@ export function find_image_atoms(structure, { tolerance } = {}) {
                     selected_shift[dim] += direction;
                 }
             }
-            // Early skip if no net shift across any dimension
             if (selected_shift.every((val) => val === 0))
                 continue;
-            // Build fractional coordinates by applying the integer translation
-            // This ensures the image is a true periodic copy (preserving bond lengths)
-            // rather than clamping it to the cell face.
+            const [s_a, s_b, s_c] = site.abc;
             const img_abc = [
-                site.abc[0] + selected_shift[0],
-                site.abc[1] + selected_shift[1],
-                site.abc[2] + selected_shift[2],
+                s_a + selected_shift[0],
+                s_b + selected_shift[1],
+                s_c + selected_shift[2],
             ];
-            // If no dimension actually shifted, continue
-            if (img_abc[0] === site.abc[0] &&
-                img_abc[1] === site.abc[1] &&
-                img_abc[2] === site.abc[2])
+            if (img_abc[0] === s_a && img_abc[1] === s_b && img_abc[2] === s_c)
                 continue;
-            // Compute xyz from img_abc to ensure consistency
-            const img_xyz = frac_to_cart_pos(img_abc, lattice_vecs);
-            // Skip zero-displacement images (should not happen, guards against FP edge cases)
+            const img_xyz = frac_to_cart(img_abc);
+            // Skip zero-displacement images (guards against FP edge cases)
             const displacement = math.subtract(img_xyz, site.xyz);
             const displacement_len_sq = displacement.reduce((sum, val) => sum + val * val, 0);
             if (displacement_len_sq < displacement_eps_sq)
@@ -117,87 +97,91 @@ export function find_image_atoms(structure, { tolerance } = {}) {
             image_sites.push([idx, img_xyz, img_abc]);
         }
     }
-    // Phase 2: polyhedra-completing images (VESTA boundary-mode-like). The face
-    // tolerance above only catches atoms within ~0.5 Å of a boundary, but bonds
-    // reach a covalent-radii sum further: an anion just beyond a cell face may be
-    // needed to complete the coordination shell of a cation near that face, so
-    // bonds and coordination polyhedra at cell edges come out truncated without it.
-    // Phase 2 adds ONLY such anion images: a candidate must qualify as a polyhedron
-    // vertex (a non-metal/metalloid - same condition as is_anion_vertex in
-    // polyhedra.ts) and be strictly more electronegative than the anchor atom it
-    // bonds to. Everything else - elemental metals, intermetallics (incl. multi
-    // metal ones like Al-Fe-Ni where EN differs but no polyhedra exist), equal-EN
-    // covalent networks, cation copies - gets no phase-2 images, so the default
-    // render stays minimal and grows uniformly from all cell surfaces (the phase-1
-    // boundary copies above are the only non-anion atoms outside the cell).
+    // Per-site element data for the phase-2 completion pass. present_elements is the tiny
+    // composition (so has_framework_potential doesn't re-scan every site in big supercells).
+    const site_elements = [];
     const site_radii = [];
     const site_en = [];
     const site_is_metal = [];
+    const present_elements = new Set();
     let max_radius = 0;
-    // Minimum electronegativity among potential anchors: a candidate can only ever
-    // complete some cation's shell if it's strictly more electronegative than this
-    let min_anchor_en = Infinity;
     for (const site of structure.sites) {
         const elem = get_majority_element(site);
         const data = elem === null ? undefined : element_lookup.get(elem);
         const radius = data?.covalent_radius ?? null;
-        const en = data?.electronegativity ?? null;
+        site_elements.push(elem);
+        if (elem !== null)
+            present_elements.add(elem);
         site_radii.push(radius);
-        site_en.push(en);
+        site_en.push(data?.electronegativity ?? null);
         site_is_metal.push(data?.metal === true);
         if (radius !== null && radius > max_radius)
             max_radius = radius;
-        if (radius !== null && en !== null && en < min_anchor_en)
+    }
+    // Skip spectator A-site cations (Li/Na, heavy alkaline earths) when a framework cation
+    // is present: they render no polyhedron, so completing their shells floats coordination
+    // groups (e.g. a PO4 around a corner Li) beyond the cell. Purely ionic binaries (NaCl)
+    // keep theirs. Note: a spectator force-included as a polyhedra center (compute_polyhedra's
+    // included_center_elements) is still skipped here, so its boundary polyhedra truncate at
+    // cell faces - accepted to keep image generation independent of render-only settings.
+    const skip_spectators = has_framework_potential(present_elements);
+    const site_skipped = site_elements.map((elem) => skip_spectators && elem !== null && is_spectator_center(elem));
+    // Phase 2: anion images that complete coordination polyhedra / bonds at cell faces.
+    // Phase 1's ~0.5 Å face tolerance misses anions just beyond a face that still bond a
+    // cation near it, truncating boundary polyhedra. We add ONLY such images: a candidate
+    // must be a polyhedron vertex (non-metal/metalloid, like is_anion_vertex in polyhedra.ts)
+    // AND strictly more electronegative than the anchor it bonds. Metals, intermetallics,
+    // equal-EN networks and cation copies get none, keeping renders minimal.
+    // Min anchor EN: a candidate only completes a cation's shell if more electronegative
+    // than it. Over non-skipped anchors only, so skipped spectators can't loosen the filter.
+    let min_anchor_en = Infinity;
+    for (let idx = 0; idx < structure.sites.length; idx++) {
+        if (site_skipped[idx])
+            continue;
+        const en = site_en[idx];
+        if (site_radii[idx] !== null && en !== null && en < min_anchor_en)
             min_anchor_en = en;
     }
     const max_bond_dist = 2 * max_radius + BOND_SLACK;
     if (max_bond_dist > BOND_SLACK && min_anchor_en < Infinity) {
-        // Perpendicular cell heights: |frac| * height lower-bounds the Cartesian
-        // distance along each axis (valid for oblique cells)
-        const volume = Math.abs(math.dot(lattice_vecs[0], math.cross_3d(lattice_vecs[1], lattice_vecs[2])));
-        // height = volume / opposite-face area. A zero-volume (degenerate) cell has two
-        // parallel lattice vectors and ill-defined heights; treat every axis as
-        // infinitely tall so the pad logic below adds no images (pad -> 0) instead of
-        // dividing by zero. When volume > 0 the vectors are linearly independent, so no
-        // pairwise cross product can be zero.
-        const heights = volume === 0
-            ? [Infinity, Infinity, Infinity]
-            : [
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[1], lattice_vecs[2])),
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[0], lattice_vecs[2])),
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[0], lattice_vecs[1])),
-            ];
-        // Anchor set for the bond test: base atoms plus the phase-1 boundary images
-        // (corner/edge/face copies). Anchoring on those too matches VESTA - every
-        // displayed boundary cation gets its shell completed (e.g. all 8 corner
-        // octahedra in rutile, not just the one at the origin).
+        // Per-axis fractional bond reach via perpendicular cell heights (correct for oblique
+        // cells; 0 for degenerate cells → no images). The + face tolerance covers phase-1
+        // anchors sitting slightly outside the cell.
+        const pad_per_axis = math.frac_cutoff_per_axis(lattice_vecs, max_bond_dist + PHYSICAL_TOLERANCE);
+        // Bond-test anchors = base atoms + phase-1 boundary images, so every displayed
+        // boundary cation gets its shell completed (VESTA-like; e.g. all 8 rutile corners).
         const anchor_positions = structure.sites.map((site) => site.xyz);
         const anchor_radii = [...site_radii];
         const anchor_en = [...site_en];
+        const anchor_skipped = [...site_skipped];
         for (const [src_idx, img_xyz] of image_sites) {
             anchor_positions.push(img_xyz);
             anchor_radii.push(site_radii[src_idx]);
             anchor_en.push(site_en[src_idx]);
+            anchor_skipped.push(site_skipped[src_idx]);
         }
-        // Spatial grid over anchors for the bond check
+        // Spatial grid over anchors for the bond check (integer-packed keys: this
+        // grid is probed 27x per candidate image in the loop below)
         const grid = new Map();
-        const grid_key = (pos) => pos.map((coord) => Math.floor(coord / max_bond_dist)).join(`,`);
         for (const [idx, pos] of anchor_positions.entries()) {
-            const key = grid_key(pos);
+            const key = pack_cell_key(Math.floor(pos[0] / max_bond_dist), Math.floor(pos[1] / max_bond_dist), Math.floor(pos[2] / max_bond_dist));
             const cell = grid.get(key);
             if (cell)
                 cell.push(idx);
             else
                 grid.set(key, [idx]);
         }
-        // True when the candidate (an anion image) bonds a strictly less
-        // electronegative anchor, i.e. completes some cation's coordination shell
+        // True when the candidate (an anion image) bonds a strictly less electronegative
+        // anchor, i.e. completes some cation's coordination shell
         const completes_cation_shell = (pos, radius, en) => {
             const [cx, cy, cz] = pos.map((coord) => Math.floor(coord / max_bond_dist));
             for (let dx = -1; dx <= 1; dx++) {
                 for (let dy = -1; dy <= 1; dy++) {
                     for (let dz = -1; dz <= 1; dz++) {
-                        for (const anchor_idx of grid.get(`${cx + dx},${cy + dy},${cz + dz}`) ?? []) {
+                        for (const anchor_idx of grid.get(pack_cell_key(cx + dx, cy + dy, cz + dz)) ??
+                            []) {
+                            if (anchor_skipped[anchor_idx])
+                                continue;
                             const anchor_radius = anchor_radii[anchor_idx];
                             const anchor_electroneg = anchor_en[anchor_idx];
                             if (anchor_radius === null)
@@ -221,22 +205,19 @@ export function find_image_atoms(structure, { tolerance } = {}) {
         for (const [idx, site] of structure.sites.entries()) {
             const radius = site_radii[idx];
             const en = site_en[idx];
-            // Skip candidates that could never be a polyhedron vertex: metals (e.g.
-            // Fe/Ni in Al-Fe-Ni intermetallics, despite their higher EN) and anything
-            // not strictly more electronegative than at least one anchor (covers all
-            // sites of elemental/equal-EN structures and all cations)
+            // Skip candidates that could never be a polyhedron vertex: metals (e.g. Fe/Ni in
+            // Al-Fe-Ni intermetallics) and anything not strictly more electronegative than at
+            // least one anchor (covers elemental/equal-EN structures and all cations)
             if (radius === null || en === null || en <= min_anchor_en)
                 continue;
             if (site_is_metal[idx])
                 continue;
-            // Per-axis shifts that could land a copy of this atom within bonding reach
-            // of the cell: {0} plus +1/-1 when the atom is within max_bond_dist of the
-            // respective boundary
+            // Per-axis shifts that could land a copy of this atom within bonding reach of the
+            // cell: {0} plus +1/-1 when the atom is within max_bond_dist of the boundary
             const axis_shifts = [0, 1, 2].map((axis) => {
                 if (!pbc[axis])
                     return [0];
-                // + face tolerance: anchors (phase-1 images) can sit slightly outside the cell
-                const pad = (max_bond_dist + PHYSICAL_TOLERANCE) / heights[axis];
+                const pad = pad_per_axis[axis];
                 const shifts = [0];
                 if (site.abc[axis] < pad)
                     shifts.push(1);
@@ -257,7 +238,7 @@ export function find_image_atoms(structure, { tolerance } = {}) {
                             site.abc[1] + shift_b,
                             site.abc[2] + shift_c,
                         ];
-                        const img_xyz = frac_to_cart_pos(img_abc, lattice_vecs);
+                        const img_xyz = frac_to_cart(img_abc);
                         if (!completes_cation_shell(img_xyz, radius, en))
                             continue;
                         seen_images.add(key);
@@ -281,7 +262,6 @@ export function get_pbc_image_sites(...args) {
     // Add image atoms to regular crystal structures
     const image_sites = find_image_atoms(...args);
     const imaged_struct = { ...structure, sites: [...structure.sites] };
-    // Add image atoms as new sites using provided (xyz, abc) from find_image_atoms
     for (const [site_idx, img_xyz, img_abc, is_completion] of image_sites) {
         const orig_site = structure.sites[site_idx];
         imaged_struct.sites.push({

package/dist/structure/polyhedra.d.ts

@@ -36,6 +36,5 @@ export interface MergedPolyhedraBuffers {
 }
 export declare function convex_hull_3d(points: readonly Vec3[], eps_scale?: number): ConvexHullResult;
 export declare function build_adjacency(bonds: readonly BondPair[]): Map<number, Set<number>>;
-export declare const is_spectator_center: (element: string) => boolean;
 export declare function compute_polyhedra(structure: AnyStructure, bonds: readonly BondPair[], options?: PolyhedraOptions): Polyhedron[];
 export declare function merge_polyhedra_buffers(polyhedra: readonly Polyhedron[], get_vertex_color: (poly: Polyhedron, vertex_idx: number) => string, coplanar_tol?: number): MergedPolyhedraBuffers;

package/dist/structure/polyhedra.js

@@ -6,7 +6,7 @@
 import { rgb as parse_rgb } from 'd3-color';
 import { DEFAULTS } from '../settings';
 import { get_orig_site_idx } from './atom-properties';
-import { element_lookup, get_majority_element } from './bonding';
+import { element_lookup, get_majority_element, has_framework_potential, is_spectator_center, } from './bonding';
 const face_of = (points, vert_a, vert_b, vert_c) => {
     const [ax, ay, az] = points[vert_a];
     const abx = points[vert_b][0] - ax;
@@ -294,15 +294,6 @@ export function build_adjacency(bonds) {
     return adjacency;
 }
 // --- Center selection ---
-// Large low-valent A-site cations whose coordination polyhedra (CN 8-12) tend to
-// obscure the structural framework. VESTA-style figures draw the framework
-// (e.g. TiO6 in BaTiO3, FeO6/PO4 in LiFePO4) and leave these as plain spheres.
-// They still get polyhedra when they are the only qualifying cations (e.g. NaCl)
-// or when force-included via `included_center_elements`.
-const SPECTATOR_CATEGORIES = new Set([`alkali metal`]);
-const HEAVY_ALKALINE_EARTHS = new Set([`Ca`, `Sr`, `Ba`, `Ra`]);
-export const is_spectator_center = (element) => SPECTATOR_CATEGORIES.has(element_lookup.get(element)?.category ?? ``) ||
-    HEAVY_ALKALINE_EARTHS.has(element);
 // A bonded neighbor counts as a polyhedron vertex only if it's an anion-former:
 // a nonmetal or metalloid that is more electronegative than the center. This keeps
 // spurious cation-cation bonds (e.g. Ti-Ba in perovskites, Li-P in thiophosphates)
@@ -426,13 +417,7 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     // the anions). Composition-based rather than candidate-based so boundary
     // truncation of framework polyhedra doesn't promote Li/Na/Ba clutter; purely
     // ionic binaries like NaCl or CaF2 still draw their spectator polyhedra.
-    const max_en = Math.max(...unique_elements.map((el) => element_lookup.get(el)?.electronegativity ?? -Infinity));
-    const has_framework_potential = unique_elements.some((el) => {
-        if (is_spectator_center(el))
-            return false;
-        const en = element_lookup.get(el)?.electronegativity;
-        return en !== null && en !== undefined && en < max_en;
-    });
+    const has_framework = has_framework_potential(unique_elements);
     // Weakly-bound center species (mean bond length well beyond the covalent-radii
     // sum, e.g. lone-pair Bi3+ with 8 long Bi-O bonds) are hidden when a
     // strongly-bound framework species exists - mirrors how pyrochlore-type figures
@@ -455,7 +440,7 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     const visible = candidates.filter(({ element }) => {
         if (included.has(element))
             return true;
-        if (is_spectator_center(element) && has_framework_potential)
+        if (is_spectator_center(element) && has_framework)
             return false;
         return !is_weak_species(element);
     });

package/dist/structure/supercell.d.ts

@@ -1,8 +1,7 @@
 import type { Vec3 } from '../math';
-import { scale_lattice_matrix } from '../math';
 import type { Crystal } from './index';
 export declare function parse_supercell_scaling(scaling: string | number | Vec3): Vec3;
 export declare function generate_lattice_points(scaling_factors: Vec3): Vec3[];
-export { scale_lattice_matrix };
+export { scale_lattice_matrix } from '../math';
 export declare function make_supercell(structure: Crystal, scaling: string | number | Vec3, to_unit_cell?: boolean): Crystal;
 export declare function is_valid_supercell_input(input: string): boolean;

package/dist/structure/supercell.js

@@ -1,5 +1,4 @@
 import * as math from '../math';
-import { scale_lattice_matrix } from '../math';
 import { wrap_frac_coord } from './pbc';
 import { normalize_structure_bond } from './bonding';
 const mod = (value, divisor) => ((value % divisor) + divisor) % divisor;
@@ -79,7 +78,7 @@ export function generate_lattice_points(scaling_factors) {
     return points;
 }
 // Re-export from $lib/math for backward compatibility
-export { scale_lattice_matrix };
+export { scale_lattice_matrix } from '../math';
 // Create a supercell from a Crystal
 // Takes original structure, scaling factors, and whether to fold coordinates back to unit cell (default: true)
 // Returns new supercell structure
@@ -96,19 +95,14 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
     }
     const orig_matrix = structure.lattice.matrix;
     // Create new scaled lattice
-    const new_lattice_matrix = scale_lattice_matrix(orig_matrix, supercell_scaling);
-    const lattice_params = math.calc_lattice_params(new_lattice_matrix);
-    const new_lattice = {
-        ...structure.lattice,
-        matrix: new_lattice_matrix,
-        ...lattice_params,
-    };
+    const new_matrix = math.scale_lattice_matrix(orig_matrix, supercell_scaling);
+    const lattice_params = math.calc_lattice_params(new_matrix);
+    const new_lattice = { ...structure.lattice, matrix: new_matrix, ...lattice_params };
     // Pre-allocate sites array
     const n_sites = structure.sites.length;
     const new_sites = Array(n_sites * total_cells);
     // Destructure lattice vectors for fast inline arithmetic (avoid function calls in hot loop)
     const [[ax, ay, az], [bx, by, bz], [cx, cy, cz]] = orig_matrix;
-    const [sx, sy, sz] = supercell_scaling;
     let write_idx = 0;
     const sites = structure.sites;
     // Loop order: k, j, i to match typical pymatgen/standard ordering
@@ -124,9 +118,9 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
                 for (let site_idx = 0; site_idx < n_sites; site_idx++) {
                     const site = sites[site_idx];
                     // new_abc = (old_abc + [ii, jj, kk]) / supercell_scaling
-                    let new_a = (site.abc[0] + ii) / sx;
-                    let new_b = (site.abc[1] + jj) / sy;
-                    let new_c = (site.abc[2] + kk) / sz;
+                    let new_a = (site.abc[0] + ii) / scale_x;
+                    let new_b = (site.abc[1] + jj) / scale_y;
+                    let new_c = (site.abc[2] + kk) / scale_z;
                     if (to_unit_cell) {
                         new_a = wrap_frac_coord(new_a);
                         new_b = wrap_frac_coord(new_b);

package/dist/symmetry/SymmetryElements.svelte

@@ -20,6 +20,7 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
 <script lang="ts">
   import type { Matrix3x3, Vec2, Vec3 } from '../math'
   import * as math from '../math'
+  import { quaternion_from_direction } from '../structure/geometry'
   import type { ShowSymmetryKinds, SymmetryElement } from './symmetry-elements'
   import {
     clip_line_to_cell,
@@ -39,7 +40,6 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
     LinearFilter,
     Matrix4,
     OctahedronGeometry,
-    Quaternion,
     RepeatWrapping,
     RGBAFormat,
     Vector3,
@@ -92,7 +92,6 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
     inversion_color?: string
   } = $props()
 
-  const UP = new Vector3(0, 1, 0)
   const UNIT_SCALE = new Vector3(1, 1, 1)
 
   // 1D stripe alpha texture for glide fills (three.js alphaMap samples the GREEN
@@ -136,14 +135,12 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
     dir_unit: Vector3,
     radius: number,
     length: number,
-  ): CylinderGeometry =>
-    new CylinderGeometry(radius, radius, length, 12).applyMatrix4(
-      new Matrix4().compose(
-        center,
-        new Quaternion().setFromUnitVectors(UP, dir_unit),
-        UNIT_SCALE,
-      ),
+  ): CylinderGeometry => {
+    const orientation = quaternion_from_direction(dir_unit.toArray() as Vec3)
+    return new CylinderGeometry(radius, radius, length, 12).applyMatrix4(
+      new Matrix4().compose(center, orientation, UNIT_SCALE),
     )
+  }
 
   // Axes (cylinders) + rotoinversion center markers (spheres), merged per color/radius.
   // Pure rotations render solid; screw axes render DASHED so the two are
@@ -152,9 +149,9 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
   const axis_groups: MaterialGroup[] = $derived.by(() => {
     const axis_elements = elements.filter(
       (elem) =>
-        (elem.kind === `rotation` || elem.kind === `screw` ||
-          elem.kind === `rotoinversion`) &&
-        show_kinds[elem.kind] && elem.axis,
+        (elem.kind === `rotation` || elem.kind === `screw` || elem.kind === `rotoinversion`) &&
+        show_kinds[elem.kind] &&
+        elem.axis,
     )
     // Drop 2-fold axes coincident with a higher-order axis (4 contains 2, 6 contains
     // 2 and 3, -4 contains 2, …) to reduce visual clutter. Computed over the VISIBLE
@@ -168,9 +165,8 @@ color/opacity instead of one mesh per element) and disposed on change/unmount. -
 
     const parts_by_group = new Map<string, BufferGeometry[]>()
     for (const elem of axis_elements) {
-      if (
-        hide_redundant_axes && elem.order < (max_order_by_line.get(line_key(elem)) ?? 0)
-      ) continue
+      if (hide_redundant_axes && elem.order < (max_order_by_line.get(line_key(elem)) ?? 0))
+        continue
       const clipped = clip_line_to_cell(elem.point, elem.axis as Vec3, lattice)
       if (!clipped) continue
       const [start, end] = clipped