matterviz 0.4.1 → 0.4.3

package/dist/fermi-surface/FermiSurfaceScene.svelte

@@ -57,7 +57,7 @@
     bz_color = `#888888`,
     bz_opacity = 0.1,
     bz_edge_color = `#333333`,
-    bz_edge_width = 0.02,
+    bz_edge_width = 0.002,
     show_vectors = true,
     tile_bz = false,
     // Clipping plane
@@ -153,8 +153,8 @@
 
   // Filter surfaces based on selected bands
   let visible_surfaces = $derived(
-    fermi_data?.isosurfaces.filter((surface) =>
-      selected_bands === undefined || selected_bands.includes(surface.band_index)
+    fermi_data?.isosurfaces.filter(
+      (surface) => selected_bands === undefined || selected_bands.includes(surface.band_index),
     ) ?? [],
   )
 
@@ -172,21 +172,11 @@
 
   // Map from surface to its render order based on size (inner surfaces first)
   let surface_render_orders = $derived.by((): Map<Isosurface, number> => {
-    const order_map = new SvelteMap<Isosurface, number>()
-    if (visible_surfaces.length === 0) return order_map
-
-    // Compute radius for each surface and sort by it
-    const surfaces_with_radius = visible_surfaces.map((surface) => ({
-      surface,
-      radius: compute_surface_radius(surface),
-    }))
-    surfaces_with_radius.sort((a, b) => a.radius - b.radius)
-
-    // Assign render order: smaller radius (inner) = lower order = rendered first
-    for (let idx = 0; idx < surfaces_with_radius.length; idx++) {
-      order_map.set(surfaces_with_radius[idx].surface, idx)
-    }
-    return order_map
+    const by_radius = visible_surfaces
+      .map((surface) => ({ surface, radius: compute_surface_radius(surface) }))
+      .toSorted((surf_a, surf_b) => surf_a.radius - surf_b.radius)
+    // Smaller radius (inner) = lower order = rendered first
+    return new SvelteMap(by_radius.map(({ surface }, idx) => [surface, idx]))
   })
 
   // Compute property range for color scaling
@@ -208,9 +198,6 @@
 
   // Get color for a surface/vertex
   function get_surface_color(surface: Isosurface, vertex_idx?: number): string {
-    if (color_property === `band`) {
-      return constants.BAND_COLORS[surface.band_index % constants.BAND_COLORS.length]
-    }
     if (
       (color_property === `velocity` || color_property === `custom`) &&
       surface.properties &&
@@ -218,9 +205,7 @@
     ) {
       const prop = surface.properties[vertex_idx]
       const [min_val, max_val] = property_range
-      const normalized = max_val > min_val
-        ? (prop - min_val) / (max_val - min_val)
-        : 0.5
+      const normalized = max_val > min_val ? (prop - min_val) / (max_val - min_val) : 0.5
       return get_d3_interpolator(color_scale as D3InterpolateName)(normalized)
     }
     // Spin coloring
@@ -240,8 +225,7 @@
     const normals: number[] = []
     const colors: number[] = []
 
-    const use_vertex_colors = color_property === `velocity` ||
-      color_property === `custom`
+    const use_vertex_colors = color_property === `velocity` || color_property === `custom`
 
     const n_vertices = surface.vertices.length
 
@@ -257,9 +241,12 @@
 
         // Validate face indices are within bounds (protects against malformed JSON files)
         if (
-          idx0 < 0 || idx0 >= n_vertices ||
-          idx1 < 0 || idx1 >= n_vertices ||
-          idx2 < 0 || idx2 >= n_vertices
+          idx0 < 0 ||
+          idx0 >= n_vertices ||
+          idx1 < 0 ||
+          idx1 >= n_vertices ||
+          idx2 < 0 ||
+          idx2 >= n_vertices
         ) {
           continue
         }
@@ -297,10 +284,7 @@
     }
 
     const geometry = new BufferGeometry()
-    geometry.setAttribute(
-      `position`,
-      new BufferAttribute(new Float32Array(positions), 3),
-    )
+    geometry.setAttribute(`position`, new BufferAttribute(new Float32Array(positions), 3))
     geometry.setAttribute(`normal`, new BufferAttribute(new Float32Array(normals), 3))
 
     if (use_vertex_colors) {
@@ -358,18 +342,20 @@
     camera_position || default_camera_position(scene_size),
   )
 
-  const orbit_controls_props = $derived(build_orbit_props({
-    camera_projection,
-    target: rotation_target,
-    rotate_speed,
-    zoom_speed,
-    zoom_to_cursor,
-    pan_speed,
-    max_zoom,
-    min_zoom,
-    auto_rotate,
-    rotation_damping,
-  }))
+  const orbit_controls_props = $derived(
+    build_orbit_props({
+      camera_projection,
+      target: rotation_target,
+      rotate_speed,
+      zoom_speed,
+      zoom_to_cursor,
+      pan_speed,
+      max_zoom,
+      min_zoom,
+      auto_rotate,
+      rotation_damping,
+    }),
+  )
 
   // Create BZ geometry
   const bz_geometry = $derived(
@@ -423,11 +409,7 @@
     let [min_dist, nearest_idx] = [Infinity, 0]
     for (let idx = 0; idx < surface.vertices.length; idx++) {
       const vertex = surface.vertices[idx]
-      const dist = Math.hypot(
-        point[0] - vertex[0],
-        point[1] - vertex[1],
-        point[2] - vertex[2],
-      )
+      const dist = Math.hypot(point[0] - vertex[0], point[1] - vertex[1], point[2] - vertex[2])
       if (dist < min_dist) {
         min_dist = dist
         nearest_idx = idx
@@ -459,9 +441,8 @@
     const nearest_idx = find_nearest_vertex(surface, local_position)
     const property_value = surface.properties?.[nearest_idx]
     const has_velocities = fermi_data?.metadata?.has_velocities
-    const property_name = property_value != null
-      ? (has_velocities ? `velocity` : `custom`)
-      : undefined
+    const property_name =
+      property_value != null ? (has_velocities ? `velocity` : `custom`) : undefined
 
     const { clientX, clientY } = event.nativeEvent
     return {
@@ -533,19 +514,11 @@
 
   <!-- Reciprocal lattice vectors -->
   {#if show_vectors && fermi_data?.k_lattice}
-    <ReciprocalVectors
-      k_lattice={fermi_data.k_lattice}
-      {vector_scale}
-      size={scene_size}
-    />
+    <ReciprocalVectors k_lattice={fermi_data.k_lattice} {vector_scale} size={scene_size} />
   {/if}
 
   <!-- Fermi surfaces (with optional symmetry tiling) -->
-  {#each visible_surfaces as
-    surface,
-    surface_idx
-    (`surface-${surface.band_index}-${surface.spin}-${surface_idx}`)
-  }
+  {#each visible_surfaces as surface, surface_idx (`surface-${surface.band_index}-${surface.spin}-${surface_idx}`)}
     {@const geo_key = `${surface.band_index}-${surface.spin}-${surface_idx}`}
     {@const geo_data = geometry_cache.get(geo_key)}
     {@const surface_color = get_surface_color(surface)}
@@ -555,89 +528,44 @@
 
     {#if geo_data}
       {#each symmetry_ops as sym_matrix, sym_idx (`sym-${sym_idx}`)}
-        {#if representation === `wireframe`}
+        {#snippet mesh_pass(order: number, pass: `wireframe` | `front` | `back`)}
           <T.Mesh
             geometry={geo_data.geometry}
             matrix={sym_matrix}
             matrixAutoUpdate={false}
-            {renderOrder}
+            renderOrder={order}
             onpointermove={(event: ThreltePointerEvent) =>
-            handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
+              handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
             onpointerleave={clear_hover}
           >
-            <T.MeshBasicMaterial
-              color={surface_color}
-              wireframe
-              transparent={surface_opacity < 1}
-              opacity={surface_opacity}
-              depthWrite={true}
-              depthTest={true}
-            />
+            {#if pass === `wireframe`}
+              <T.MeshBasicMaterial
+                color={surface_color}
+                wireframe
+                transparent={surface_opacity < 1}
+                opacity={surface_opacity}
+                depthWrite={true}
+                depthTest={true}
+              />
+            {:else}
+              <T.MeshStandardMaterial
+                {...get_material_props(surface_color, use_vertex_colors, surface_idx, pass)}
+                metalness={0.1}
+                roughness={0.6}
+                flatShading={false}
+              />
+            {/if}
           </T.Mesh>
+        {/snippet}
+
+        {#if representation === `wireframe`}
+          {@render mesh_pass(renderOrder, `wireframe`)}
         {:else if surface_opacity < 1}
-          <!-- Two-pass rendering for transparent surfaces -->
-          <!-- Pass 1: Back faces (rendered first, lower renderOrder) -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            renderOrder={renderOrder * 2}
-            onpointermove={(event: ThreltePointerEvent) =>
-            handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(surface_color, use_vertex_colors, surface_idx, `back`)}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
-          <!-- Pass 2: Front faces (rendered second, higher renderOrder) -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            renderOrder={renderOrder * 2 + 1}
-            onpointermove={(event: ThreltePointerEvent) =>
-            handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(
-                surface_color,
-                use_vertex_colors,
-                surface_idx,
-                `front`,
-              )}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
+          <!-- Two-pass transparent rendering: back faces first, front faces on top -->
+          {@render mesh_pass(renderOrder * 2, `back`)}
+          {@render mesh_pass(renderOrder * 2 + 1, `front`)}
         {:else}
-          <!-- Single pass for opaque surfaces -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            {renderOrder}
-            onpointermove={(event: ThreltePointerEvent) =>
-            handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(
-                surface_color,
-                use_vertex_colors,
-                surface_idx,
-                `front`,
-              )}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
+          {@render mesh_pass(renderOrder, `front`)}
         {/if}
       {/each}
     {/if}

package/dist/fermi-surface/FermiSurfaceScene.svelte.d.ts

@@ -25,6 +25,6 @@ type $$ComponentProps = SceneControlProps & {
     vector_scale?: number;
     hover_data?: FermiHoverData | null;
 };
-declare const FermiSurfaceScene: import("svelte").Component<$$ComponentProps, {}, "scene" | "camera" | "camera_projection" | "camera_position" | "surface_opacity" | "bz_data" | "hover_data" | "fermi_data">;
+declare const FermiSurfaceScene: import("svelte").Component<$$ComponentProps, {}, "camera" | "camera_projection" | "camera_position" | "scene" | "surface_opacity" | "bz_data" | "hover_data" | "fermi_data">;
 type FermiSurfaceScene = ReturnType<typeof FermiSurfaceScene>;
 export default FermiSurfaceScene;

package/dist/fermi-surface/FermiSurfaceTooltip.svelte

@@ -5,7 +5,10 @@
   import { KCoords, TooltipContent } from '../tooltip'
   import type { FermiHoverData, FermiTooltipProp } from './types'
 
-  let { hover_data, tooltip }: {
+  let {
+    hover_data,
+    tooltip,
+  }: {
     hover_data: FermiHoverData
     tooltip?: FermiTooltipProp
   } = $props()
@@ -27,15 +30,15 @@
 
     {#if hover_data.property_value != null}
       <div class="property-row">
-        {hover_data.property_name || `Property`}: {
-          format_num(hover_data.property_value, `.4~`)
-        }
+        {hover_data.property_name || `Property`}: {format_num(
+          hover_data.property_value,
+          `.4~`,
+        )}
         <span class="nearest-note">(nearest)</span>
       </div>
     {/if}
 
-    {#if hover_data.is_tiled && hover_data.symmetry_index != null &&
-        hover_data.symmetry_index > 0}
+    {#if hover_data.is_tiled && hover_data.symmetry_index != null && hover_data.symmetry_index > 0}
       <div class="tiling-info">
         Symmetry copy #{hover_data.symmetry_index + 1}/48
       </div>

package/dist/fermi-surface/compute.js

@@ -3,6 +3,8 @@ import * as math from '../math';
 import { EPS } from '../math';
 import { CLOSED_CONTOUR_TOLERANCE, IRREDUCIBLE_BZ_MIN_VERTICES, IRREDUCIBLE_BZ_TOLERANCE, SPANNING_THRESHOLD, } from './constants';
 import { marching_cubes } from '../marching-cubes';
+// clamp01 guards float jitter at the cell boundary
+import { clamp01 } from '../utils';
 const safe_mod = (val, dim) => ((val % dim) + dim) % dim;
 // Precompute Catmull-Rom coefficients for a given t value
 // Returns [c0, c1, c2, c3] where result = c0*p0 + c1*p1 + c2*p2 + c3*p3
@@ -24,18 +26,15 @@ function tricubic_interpolate(grid, fx, fy, fz, px, py, pz) {
     const iy = Math.floor(fy);
     const iz = Math.floor(fz);
     // Precompute Catmull-Rom coefficients
-    const [cx0, cx1, cx2, cx3] = catmull_rom_coeffs(fx - ix);
-    const [cy0, cy1, cy2, cy3] = catmull_rom_coeffs(fy - iy);
-    const [cz0, cz1, cz2, cz3] = catmull_rom_coeffs(fz - iz);
+    const cx = catmull_rom_coeffs(fx - ix);
+    const cy = catmull_rom_coeffs(fy - iy);
+    const cz = catmull_rom_coeffs(fz - iz);
     // Wrapped stencil indices (modulo hoisted out of the inner loop); a zero period
     // (single-point axis) has no neighbours, so collapse the stencil onto index 0
     const stencil = (idx, period) => [idx - 1, idx, idx + 1, idx + 2].map((stencil_idx) => period > 0 ? ((stencil_idx % period) + period) % period : 0);
     const [wx, wy, wz] = [stencil(ix, px), stencil(iy, py), stencil(iz, pz)];
     // Interpolate along z, then y, then x (fully inlined)
     let result = 0;
-    const cx = [cx0, cx1, cx2, cx3];
-    const cy = [cy0, cy1, cy2, cy3];
-    const cz = [cz0, cz1, cz2, cz3];
     for (let xi = 0; xi < 4; xi++) {
         const row = grid[wx[xi]];
         let y_sum = 0;
@@ -204,7 +203,7 @@ export function compute_surface_area(surface) {
         const cy = e1z * e2x - e1x * e2z;
         const cz = e1x * e2y - e1y * e2x;
         // Area is half the magnitude of cross product
-        total_area += Math.sqrt(cx * cx + cy * cy + cz * cz) * 0.5;
+        total_area += Math.hypot(cx, cy, cz) * 0.5;
     }
     return total_area;
 }
@@ -218,8 +217,6 @@ function compute_fermi_velocities(surface, velocity_grid, k_lattice, k_grid, per
     const k_inv = math.matrix_inverse_3x3(math.transpose_3x3_matrix(k_lattice));
     // Grid point i sits at frac i/(n−1) (endpoint-inclusive BXSF) or i/n (periodic)
     const [sx, sy, sz] = periodic ? [nx, ny, nz] : [nx - 1, ny - 1, nz - 1];
-    // Clamp guards float jitter at the cell boundary
-    const clamp01 = (val) => Math.min(Math.max(val, 0), 1);
     for (const vertex of surface.vertices) {
         const frac = math.mat3x3_vec3_multiply(k_inv, vertex); // centered, in [-0.5, 0.5]
         const gx = clamp01(frac[0] + 0.5) * sx;
@@ -286,36 +283,26 @@ function analyze_surface_topology(surface, k_lattice) {
         spans[axis_idx] = surface_size > SPANNING_THRESHOLD * bz_size;
     }
     const n_spanning = spans.filter(Boolean).length;
-    if (n_spanning === 0) {
-        // Closed surface, no spanning directions
+    // 0 spanning = closed 3D pocket; 3 spanning = complex warped network
+    if (n_spanning === 0)
         return { dimensionality: `3D`, orientation: null };
-    }
-    else if (n_spanning === 1) {
-        // 2D sheet spanning one direction
-        const axis_idx = spans.indexOf(true);
-        const orientation = [0, 0, 0];
-        orientation[axis_idx] = 1;
-        return { dimensionality: `2D`, orientation };
-    }
-    else if (n_spanning === 2) {
-        // 1D noodle-like (tube spanning 2 directions, bounded in 1)
-        const axis_idx = spans.indexOf(false);
-        const orientation = [0, 0, 0];
-        orientation[axis_idx] = 1;
-        return { dimensionality: `1D`, orientation };
-    }
-    // Spans all 3 directions - complex warped network
-    return { dimensionality: `quasi-2D`, orientation: null };
+    if (n_spanning === 3)
+        return { dimensionality: `quasi-2D`, orientation: null };
+    // 1 spanning = 2D sheet (oriented along the spanning axis);
+    // 2 spanning = 1D noodle-like tube (oriented along the bounded axis)
+    const axis_idx = n_spanning === 1 ? spans.indexOf(true) : spans.indexOf(false);
+    const orientation = [0, 0, 0];
+    orientation[axis_idx] = 1;
+    return { dimensionality: n_spanning === 1 ? `2D` : `1D`, orientation };
 }
 // Compute 2D Fermi slice along a specified plane
 export function compute_fermi_slice(fermi_data, options = {}) {
     const { miller_indices = [0, 0, 1], distance = 0 } = options;
-    // Validate miller indices are not all zero
-    if (miller_indices[0] === 0 && miller_indices[1] === 0 && miller_indices[2] === 0) {
+    if (miller_indices.every((miller_idx) => miller_idx === 0)) {
         throw new Error(`Invalid miller indices [0, 0, 0]: at least one index must be non-zero to define a plane`);
     }
     // Compute plane normal in Cartesian coordinates
-    const plane_normal = math.add(math.add(math.scale(fermi_data.k_lattice[0], miller_indices[0]), math.scale(fermi_data.k_lattice[1], miller_indices[1])), math.scale(fermi_data.k_lattice[2], miller_indices[2]));
+    const plane_normal = math.add(math.scale(fermi_data.k_lattice[0], miller_indices[0]), math.scale(fermi_data.k_lattice[1], miller_indices[1]), math.scale(fermi_data.k_lattice[2], miller_indices[2]));
     const normal_len = Math.hypot(...plane_normal);
     if (normal_len < EPS) {
         throw new Error(`Degenerate plane normal: k_lattice vectors produce a zero-length normal for miller indices [${miller_indices.join(`, `)}]`);
@@ -324,11 +311,7 @@ export function compute_fermi_slice(fermi_data, options = {}) {
     // Compute in-plane basis vectors
     const [in_plane_u, in_plane_v] = math.compute_in_plane_basis(unit_normal);
     // Slice each isosurface
-    const isolines = [];
-    for (const surface of fermi_data.isosurfaces) {
-        const lines = slice_surface_with_plane(surface, unit_normal, distance, in_plane_u, in_plane_v);
-        isolines.push(...lines);
-    }
+    const isolines = fermi_data.isosurfaces.flatMap((surface) => slice_surface_with_plane(surface, unit_normal, distance, in_plane_u, in_plane_v));
     return {
         isolines,
         plane_normal: unit_normal,
@@ -340,8 +323,6 @@ export function compute_fermi_slice(fermi_data, options = {}) {
         },
     };
 }
-// Helper to create edge key (sorted vertex indices)
-const make_edge_key = (v0_idx, v1_idx) => `${Math.min(v0_idx, v1_idx)},${Math.max(v0_idx, v1_idx)}`;
 // Compute intersection point on an edge
 function compute_edge_intersection(surface, vertex_distances, v0_idx, v1_idx) {
     const d0 = vertex_distances[v0_idx];
@@ -383,7 +364,7 @@ function slice_surface_with_plane(surface, plane_normal, plane_distance, in_plan
         for (let edge_idx = 0; edge_idx < face.length; edge_idx++) {
             const v0_idx = face[edge_idx];
             const v1_idx = face[(edge_idx + 1) % face.length];
-            const edge_key = make_edge_key(v0_idx, v1_idx);
+            const edge_key = `${Math.min(v0_idx, v1_idx)},${Math.max(v0_idx, v1_idx)}`;
             const intersection = compute_edge_intersection(surface, vertex_distances, v0_idx, v1_idx);
             if (intersection) {
                 crossing_edges.push({ edge_key, intersection });
@@ -516,24 +497,10 @@ function slice_surface_with_plane(surface, plane_normal, plane_distance, in_plan
 // For cubic Oh symmetry, this is the region where all vertices are in the first octant
 // (x >= 0, y >= 0, z >= 0) with some tolerance. Such data needs tiling to show the full BZ.
 export function detect_irreducible_bz(fermi_data) {
-    if (fermi_data.isosurfaces.length === 0)
+    const vertex_count = fermi_data.isosurfaces.reduce((sum, surface) => sum + surface.vertices.length, 0);
+    // Only consider it irreducible if we have significant data and all vertices are
+    // in the positive octant (with small tolerance for numerical error)
+    if (vertex_count <= IRREDUCIBLE_BZ_MIN_VERTICES)
         return false;
-    // Check if all vertices are in the positive octant (with small tolerance for numerical error)
-    let all_positive = true;
-    let vertex_count = 0;
-    for (const surface of fermi_data.isosurfaces) {
-        for (const vertex of surface.vertices) {
-            vertex_count++;
-            if (vertex[0] < -IRREDUCIBLE_BZ_TOLERANCE ||
-                vertex[1] < -IRREDUCIBLE_BZ_TOLERANCE ||
-                vertex[2] < -IRREDUCIBLE_BZ_TOLERANCE) {
-                all_positive = false;
-                break;
-            }
-        }
-        if (!all_positive)
-            break;
-    }
-    // Only consider it irreducible if we have significant data and all positive
-    return all_positive && vertex_count > IRREDUCIBLE_BZ_MIN_VERTICES;
+    return fermi_data.isosurfaces.every((surface) => surface.vertices.every((vertex) => vertex.every((coord) => coord >= -IRREDUCIBLE_BZ_TOLERANCE)));
 }