matterviz 0.3.0 → 0.3.2

package/dist/convex-hull/thermodynamics.d.ts

@@ -1,31 +1,18 @@
 import type { ElementSymbol } from '../element';
-import type { ConvexHullTriangle, PhaseData, Point2D, Point3D, ProcessedPhaseData } from './types';
+import type { ConvexHullEntry, ConvexHullTriangle, PhaseData, PhaseStats, Point2D, Point3D, ProcessedPhaseData } from './types';
 export declare function normalize_hull_composition_keys(composition: Record<string, number>): Partial<Record<ElementSymbol, number>>;
 export declare function process_hull_entries(entries: PhaseData[]): ProcessedPhaseData;
 export declare function compute_e_form_per_atom(entry: PhaseData, el_refs: Record<string, PhaseData>): number | null;
 export declare function find_lowest_energy_unary_refs(entries: PhaseData[]): Record<string, PhaseData>;
 export declare function calculate_e_above_hull(entry: PhaseData, reference_entries: PhaseData[]): number;
 export declare function calculate_e_above_hull(entries: PhaseData[], reference_entries: PhaseData[]): Record<string, number>;
-export declare function get_convex_hull_stats(processed_entries: PhaseData[], elements: ElementSymbol[], max_arity: 3 | 4): {
-    total: number;
-    unary: number;
-    binary: number;
-    ternary: number;
-    quaternary: number;
-    stable: number;
-    unstable: number;
-    energy_range: {
-        min: number;
-        max: number;
-        avg: number;
-    };
-    hull_distance: {
-        max: number;
-        avg: number;
-    };
-    elements: number;
-    chemical_system: string;
-} | null;
+export declare function get_convex_hull_stats(processed_entries: PhaseData[], elements: ElementSymbol[], max_arity?: number): PhaseStats | null;
+export interface HighDimHullResult {
+    stable_entries: ConvexHullEntry[];
+    unstable_entries: ConvexHullEntry[];
+    phase_stats: PhaseStats | null;
+}
+export declare function process_hull_for_stats(entries: PhaseData[], elements?: ElementSymbol[]): HighDimHullResult | null;
 export declare function compute_lower_hull_2d(points: Point2D[]): Point2D[];
 export declare function interpolate_hull_2d(hull: Point2D[], x: number): number | null;
 export declare function compute_quickhull_triangles(points: Point3D[]): ConvexHullTriangle[];

package/dist/convex-hull/thermodynamics.js

@@ -1,7 +1,7 @@
 import { count_atoms_in_composition, extract_formula_elements, sort_by_electronegativity, } from '../composition';
 import * as math from '../math';
 import { barycentric_to_ternary_xyz, barycentric_to_tetrahedral, composition_to_barycentric_3d, composition_to_barycentric_4d, composition_to_barycentric_nd, } from './barycentric-coords';
-import { is_unary_entry } from './types';
+import { get_arity, HULL_STABILITY_TOL, is_on_hull, is_unary_entry } from './types';
 // Track warned keys to avoid log spam on large datasets with repeated invalid keys
 const warned_keys = new Set();
 // Normalize convex hull composition keys by stripping oxidation states (e.g. "V4+" -> "V")
@@ -365,32 +365,57 @@ export function calculate_e_above_hull(input, reference_entries) {
     }
     return results;
 }
-export function get_convex_hull_stats(processed_entries, elements, max_arity) {
-    if (!processed_entries || processed_entries.length === 0)
+export function get_convex_hull_stats(processed_entries, elements, max_arity = 4) {
+    if (processed_entries.length === 0)
         return null;
-    const composition_counts = (max_arity === 4 ? [1, 2, 3, 4] : [1, 2, 3]).map((target) => processed_entries.filter((entry) => Object.keys(entry.composition).filter((el) => (entry.composition[el] ?? 0) > 0).length === target).length);
-    const [unary, binary, ternary, quaternaryMaybe] = composition_counts;
-    const quaternary = max_arity === 4 ? (quaternaryMaybe ?? 0) : 0;
-    const stable_count = processed_entries.filter((e) => e.is_stable === true ||
-        (typeof e.e_above_hull === `number` && e.e_above_hull < 1e-6)).length;
+    max_arity = Math.max(1, max_arity);
+    let unary = 0;
+    let binary = 0;
+    let ternary = 0;
+    let quaternary = 0;
+    let quinary_plus = 0;
+    for (const entry of processed_entries) {
+        const arity = get_arity(entry);
+        if (arity === 1)
+            unary++;
+        else if (arity === 2)
+            binary++;
+        else if (arity === 3)
+            ternary++;
+        else if (arity === 4)
+            quaternary++;
+        else if (arity >= 5)
+            quinary_plus++;
+    }
+    // Zero out counts beyond system dimensionality for cleaner display
+    // quinary_plus is intentionally not zeroed — it's a catch-all bucket that
+    // is naturally 0 for systems with fewer than 5 elements
+    if (max_arity < 4)
+        quaternary = 0;
+    if (max_arity < 3)
+        ternary = 0;
+    if (max_arity < 2)
+        binary = 0;
+    const stable_count = processed_entries.filter((entry) => is_on_hull(entry)).length;
     const unstable_count = processed_entries.length - stable_count;
     const energies = processed_entries
-        .map((e) => e.e_form_per_atom ?? e.energy_per_atom)
-        .filter((v) => typeof v === `number` && Number.isFinite(v));
+        .map((entry) => entry.e_form_per_atom ?? entry.energy_per_atom ?? get_energy_per_atom(entry))
+        .filter(Number.isFinite);
+    // Use reduce instead of Math.min/max(...arr) to avoid stack overflow on large datasets
     const energy_range = energies.length > 0
         ? {
-            min: Math.min(...energies),
-            max: Math.max(...energies),
-            avg: energies.reduce((a, b) => a + b, 0) / energies.length,
+            min: energies.reduce((min, val) => val < min ? val : min, Infinity),
+            max: energies.reduce((max, val) => val > max ? val : max, -Infinity),
+            avg: energies.reduce((sum, val) => sum + val, 0) / energies.length,
         }
         : { min: 0, max: 0, avg: 0 };
     const hull_distances = processed_entries
-        .map((e) => e.e_above_hull)
-        .filter((v) => typeof v === `number` && v >= 0);
+        .map((entry) => entry.e_above_hull)
+        .filter((val) => typeof val === `number` && val >= 0);
     const hull_distance = hull_distances.length > 0
         ? {
-            max: Math.max(...hull_distances),
-            avg: hull_distances.reduce((a, b) => a + b, 0) / hull_distances.length,
+            max: hull_distances.reduce((max, val) => val > max ? val : max, -Infinity),
+            avg: hull_distances.reduce((sum, val) => sum + val, 0) / hull_distances.length,
         }
         : { max: 0, avg: 0 };
     return {
@@ -399,12 +424,76 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity) {
         binary,
         ternary,
         quaternary,
+        quinary_plus,
         stable: stable_count,
         unstable: unstable_count,
         energy_range,
         hull_distance,
         elements: elements.length,
         chemical_system: sort_by_electronegativity([...elements]).join(`-`),
+        max_arity,
+    };
+}
+// Convert a PhaseData entry to a ConvexHullEntry with default visual fields.
+// x/y/z default to 0 since high-dim systems aren't visually plotted.
+function to_hull_entry(entry) {
+    return {
+        ...entry,
+        visible: true,
+        is_element: get_arity(entry) === 1,
+        x: 0,
+        y: 0,
+        z: 0,
+    };
+}
+// Process raw hull entries for high-dimensional systems (5+ elements) where the
+// ConvexHull visual component can't render. Computes formation energies, hull distances,
+// stable/unstable classification, and phase stats. Returns null on failure.
+// Optionally accepts `elements` to scope the chemical system; if omitted, elements
+// are derived from the entries' compositions.
+export function process_hull_for_stats(entries, elements) {
+    if (!entries.length)
+        return null;
+    const processed = process_hull_entries(entries);
+    if (!processed.entries.length)
+        return null;
+    const hull_elements = elements ?? processed.elements;
+    // Compute formation energies
+    const el_refs = find_lowest_energy_unary_refs(processed.entries);
+    for (const entry of processed.entries) {
+        if (entry.e_form_per_atom === undefined) {
+            const e_form = compute_e_form_per_atom(entry, el_refs);
+            if (e_form !== null)
+                entry.e_form_per_atom = e_form;
+        }
+    }
+    // Compute hull distances. Note: entries without entry_id are keyed by
+    // JSON.stringify(composition), so polymorphs at the same composition
+    // collide — the last-processed entry's distance wins for all of them.
+    try {
+        const hull_distances = calculate_e_above_hull(processed.entries, processed.entries);
+        for (const entry of processed.entries) {
+            const dist = hull_distances[entry.entry_id ?? JSON.stringify(entry.composition)];
+            if (typeof dist === `number` && Number.isFinite(dist)) {
+                entry.e_above_hull = dist;
+                entry.is_stable = dist < HULL_STABILITY_TOL;
+            }
+            else {
+                // Clear stale hull metadata so previous values don't persist
+                entry.e_above_hull = undefined;
+                entry.is_stable = undefined;
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`Failed to compute high-dim hull:`, err);
+        return null;
+    }
+    const hull_entries = processed.entries.map(to_hull_entry);
+    return {
+        stable_entries: hull_entries.filter((entry) => is_on_hull(entry)),
+        unstable_entries: hull_entries.filter((entry) => !is_on_hull(entry)),
+        phase_stats: get_convex_hull_stats(processed.entries, hull_elements, hull_elements.length),
     };
 }
 // --- 2D Convex Hull (Binary Phase Diagrams) ---

package/dist/convex-hull/types.d.ts

@@ -39,6 +39,8 @@ export interface Point3D extends Point2D {
     z: number;
 }
 export type MarkerSymbol = `circle` | `star` | `triangle` | `cross` | `diamond` | `square` | `wye`;
+export type HullFaceColorMode = `uniform` | `formation_energy` | `dominant_element` | `facet_index`;
+export declare const HULL_FACE_COLOR_MODES: readonly HullFaceColorMode[];
 export interface ConvexHullEntry extends PhaseData, Point3D {
     is_element: boolean;
     size?: number;
@@ -104,6 +106,7 @@ export interface PhaseStats {
     binary: number;
     ternary: number;
     quaternary: number;
+    quinary_plus: number;
     stable: number;
     unstable: number;
     energy_range: {
@@ -117,7 +120,11 @@ export interface PhaseStats {
     };
     elements: number;
     chemical_system: string;
+    max_arity: number;
 }
+export type PhaseArityField = Extract<keyof PhaseStats, `unary` | `binary` | `ternary` | `quaternary` | `quinary_plus`>;
+export declare const HULL_STABILITY_TOL = 0.000001;
+export declare const is_on_hull: (entry: PhaseData, tol?: number) => boolean;
 export declare const get_arity: (entry: PhaseData) => number;
 export declare const is_unary_entry: (entry: PhaseData) => boolean;
 export declare const is_binary_entry: (entry: PhaseData) => boolean;

package/dist/convex-hull/types.js

@@ -1,3 +1,14 @@
+export const HULL_FACE_COLOR_MODES = [
+    `uniform`,
+    `formation_energy`,
+    `dominant_element`,
+    `facet_index`,
+];
+// Tolerance for classifying a phase as on the convex hull (eV/atom)
+export const HULL_STABILITY_TOL = 1e-6;
+// Check if entry is on the convex hull (stable or e_above_hull ≈ 0)
+export const is_on_hull = (entry, tol = HULL_STABILITY_TOL) => entry.is_stable === true ||
+    (typeof entry.e_above_hull === `number` && entry.e_above_hull < tol);
 // Arity helpers (inlined from former arity.ts)
 export const get_arity = (entry) => Object.values(entry.composition).filter((count) => count > 0).length;
 export const is_unary_entry = (entry) => get_arity(entry) === 1;

package/dist/coordination/CoordinationBarPlot.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">import { PLOT_COLORS } from '../colors';
 import { StatusMessage } from '../feedback';
-import { decompress_file, handle_url_drop } from '../io';
+import { create_file_drop_handler } from '../io';
 import { format_value } from '../labels';
 import { BarPlot } from '../plot';
 import { parse_any_structure } from '../structure/parse';
@@ -135,55 +135,38 @@ const bar_series = $derived.by(() => {
         ];
     }
 });
-async function handle_file_drop(event) {
-    event.preventDefault();
-    dragover = false;
-    if (!allow_file_drop)
-        return;
-    loading = true;
-    error_msg = undefined;
-    const compute_and_add = (content, filename) => {
-        try {
-            const text_content = content instanceof ArrayBuffer
-                ? new TextDecoder().decode(content)
-                : content;
-            const parsed_structure = parse_any_structure(text_content, filename);
-            if (is_crystal(parsed_structure)) {
-                dropped_entries = [{
-                        label: filename || `Dropped structure`,
-                        structure: parsed_structure,
-                    }, ...dropped_entries];
-            }
-            else {
-                error_msg = `Structure has no lattice or sites; cannot compute coordination`;
-            }
-        }
-        catch (exc) {
-            error_msg = `Failed to process structure: ${exc instanceof Error ? exc.message : String(exc)}`;
-        }
-    };
+const compute_and_add = (content, filename) => {
     try {
-        // Handle URL-based drops
-        const handled = await handle_url_drop(event, on_file_drop || compute_and_add)
-            .catch(() => false);
-        if (handled)
-            return;
-        const file = event.dataTransfer?.files?.[0];
-        if (file) {
-            try {
-                const { content, filename } = await decompress_file(file);
-                if (content)
-                    (on_file_drop || compute_and_add)(content, filename);
-            }
-            catch (exc) {
-                error_msg = `Failed to load file ${file.name}: ${exc instanceof Error ? exc.message : String(exc)}`;
-            }
+        const text_content = content instanceof ArrayBuffer
+            ? new TextDecoder().decode(content)
+            : content;
+        const parsed_structure = parse_any_structure(text_content, filename);
+        if (is_crystal(parsed_structure)) {
+            dropped_entries = [{
+                    label: filename || `Dropped structure`,
+                    structure: parsed_structure,
+                }, ...dropped_entries];
+        }
+        else {
+            error_msg = `Structure has no lattice or sites; cannot compute coordination`;
         }
     }
-    finally {
-        loading = false;
+    catch (exc) {
+        error_msg = `Failed to process structure: ${exc instanceof Error ? exc.message : String(exc)}`;
     }
-}
+};
+const handle_file_drop = create_file_drop_handler({
+    allow: () => allow_file_drop,
+    on_drop: (content, filename) => (on_file_drop || compute_and_add)(content, filename),
+    on_error: (msg) => {
+        error_msg = msg;
+    },
+    set_loading: (val) => {
+        loading = val;
+        if (val)
+            [error_msg, dragover] = [undefined, false];
+    },
+});
 let display = $state({ x_zero_line: false, y_zero_line: false });
 // Update display when orientation changes
 $effect(() => {

package/dist/element/BohrAtom.svelte

@@ -42,7 +42,7 @@ export {};
   {/if}
 
   <!-- electron orbitals -->
-  {#each shells as electrons, shell_idx ([electrons, shell_idx])}
+  {#each shells as electrons, shell_idx (`${shell_idx}-${electrons}`)}
     {@const n = shell_idx + 1}
     {@const shell_radius = _nucleus_props.r + n * shell_width}
     {@const active = n === highlight_shell}