matterviz 0.4.1 → 0.4.3

package/dist/spectral/BandsAndDos.svelte

@@ -44,10 +44,12 @@
   const bands_default_axis = (range = shared_frequency_range): AxisConfig =>
     shared_y_axis ? axis_with_range(bands_props.y_axis, range) : { ...bands_props.y_axis }
   const dos_default_axis = (range = shared_frequency_range): AxisConfig =>
-    shared_y_axis ? axis_with_range(dos_props.y_axis, range, ``) : {
-      label: ``,
-      ...dos_props.y_axis,
-    }
+    shared_y_axis
+      ? axis_with_range(dos_props.y_axis, range, ``)
+      : {
+          label: ``,
+          ...dos_props.y_axis,
+        }
 
   let synced_zoom_range = $state<Vec2 | null>(null)
   let bands_y_axis = $state<AxisConfig>(bands_default_axis())
@@ -88,14 +90,14 @@
   $effect(() =>
     propagate_synced_range(
       untrack(() => bands_y_axis.range) as Vec2 | undefined,
-      (base_range) => bands_y_axis = bands_default_axis(base_range),
-    )
+      (base_range) => (bands_y_axis = bands_default_axis(base_range)),
+    ),
   )
   $effect(() =>
     propagate_synced_range(
       untrack(() => dos_y_axis.range) as Vec2 | undefined,
-      (base_range) => dos_y_axis = dos_default_axis(base_range),
-    )
+      (base_range) => (dos_y_axis = dos_default_axis(base_range)),
+    ),
   )
 
   let hovered_frequency = $state<number | null>(null)
@@ -106,7 +108,7 @@
 
 <div
   {...rest}
-  class="bands-and-dos {rest.class ?? ``}"
+  class={[`bands-and-dos`, rest.class]}
   style={`display: grid; grid-template-columns: 1fr 200px; gap: 0;` + (rest.style ?? ``)}
 >
   {@render children?.({ hovered_frequency })}

package/dist/spectral/BrillouinBandsDos.svelte

@@ -44,24 +44,12 @@
   ) as BaseBandStructure | null
 
   // Compute shared frequency/energy range from both bands and DOS data
-  let shared_frequency_range = $derived(
-    helpers.compute_frequency_range(band_structs, doses),
-  )
+  let shared_frequency_range = $derived(helpers.compute_frequency_range(band_structs, doses))
 
   // Extract Fermi level from electronic band structure or DOS data
-  let fermi_level = $derived.by((): number | undefined => {
-    // Check band structures for efermi
-    const bs_source = `efermi` in (band_structs as object)
-      ? band_structs
-      : Object.values(band_structs)[0]
-    const bs_efermi = (bs_source as Record<string, unknown>)?.efermi
-    if (typeof bs_efermi === `number`) return bs_efermi
-
-    // Check DOS for efermi
-    const dos_source = `efermi` in (doses as object) ? doses : Object.values(doses)[0]
-    const dos_efermi = (dos_source as Record<string, unknown>)?.efermi
-    return typeof dos_efermi === `number` ? dos_efermi : undefined
-  })
+  let fermi_level = $derived(
+    helpers.extract_efermi(band_structs) ?? helpers.extract_efermi(doses),
+  )
 
   // Convert fractional k-point coordinates to Cartesian reciprocal space
   // using the structure's reciprocal lattice (consistent with BZ computation)
@@ -75,13 +63,12 @@
   let hovered_band_point = $state<InternalPoint | null>(null)
   let bands_x_positions = $state<Record<string, Vec2>>({})
   let hovered_qpoint_index = $derived(
-    hovered_band_point && first_band_struct &&
-      Object.keys(bands_x_positions).length > 0
+    hovered_band_point && first_band_struct && Object.keys(bands_x_positions).length > 0
       ? helpers.find_qpoint_at_rescaled_x(
-        first_band_struct,
-        hovered_band_point.x,
-        bands_x_positions,
-      )
+          first_band_struct,
+          hovered_band_point.x,
+          bands_x_positions,
+        )
       : null,
   )
   // Q-point hovered directly on the BZ k-path (reverse direction: BZ -> bands/DOS)
@@ -89,21 +76,13 @@
   // Unified hovered q-point: a band-point hover takes priority, else a BZ k-path hover
   let active_qpoint_index = $derived(hovered_qpoint_index ?? bz_hovered_qpoint_index)
   let hovered_k_point = $derived(
-    active_qpoint_index !== null
-      ? (k_path_points[active_qpoint_index] as Vec3)
-      : null,
+    active_qpoint_index !== null ? (k_path_points[active_qpoint_index] as Vec3) : null,
   )
   const [desktop_width, tablet_width] = [1200, 600]
   let clientWidth = $state(desktop_width)
   let is_desktop = $derived(clientWidth >= desktop_width)
   let is_mobile = $derived(clientWidth < tablet_width)
-  let screen_class = $derived(
-    clientWidth >= desktop_width
-      ? `desktop`
-      : clientWidth >= tablet_width
-      ? `tablet`
-      : `phone`,
-  )
+  let screen_class = $derived(is_desktop ? `desktop` : is_mobile ? `phone` : `tablet`)
 
   const bands_default_axis = (range = shared_frequency_range): AxisConfig =>
     helpers.axis_with_range(bands_props.y_axis, range)
@@ -169,11 +148,7 @@
   let hovered_frequency = $state<number | null>(null)
 </script>
 
-<div
-  {...rest}
-  class="bands-dos-brillouin {screen_class} {rest.class ?? ``}"
-  bind:clientWidth
->
+<div {...rest} class={[`bands-dos-brillouin`, screen_class, rest.class]} bind:clientWidth>
   {@render children?.({
     hovered_frequency,
     hovered_band_point,
@@ -201,11 +176,13 @@
     {k_path_points}
     k_path_labels={first_band_struct?.qpoints?.flatMap((qpoint, idx) =>
       k_path_points[idx]
-        ? [{
-          position: k_path_points[idx],
-          label: qpoint.label ? helpers.pretty_sym_point(qpoint.label) : null,
-        }]
-        : []
+        ? [
+            {
+              position: k_path_points[idx],
+              label: qpoint.label ? helpers.pretty_sym_point(qpoint.label) : null,
+            },
+          ]
+        : [],
     ) ?? []}
     {hovered_k_point}
     hovered_qpoint_index={active_qpoint_index}

package/dist/spectral/Dos.svelte

@@ -5,6 +5,7 @@
   import type { Vec2 } from '../math'
   import ScatterPlot from '../plot/scatter/ScatterPlot.svelte'
   import type { AxisConfig, DataSeries } from '../plot/core/types'
+  import { extent } from 'd3-array'
   import type { ComponentProps } from 'svelte'
   import { tooltip as attach_tooltip } from 'svelte-multiselect/attachments'
   import {
@@ -175,17 +176,18 @@
         }
 
         // Check for spin-down data (only for electronic DOS)
-        const has_spin_down = dos.type === `electronic` &&
-          dos.spin_down_densities?.length === dos.densities.length
+        const has_spin_down =
+          dos.type === `electronic` && dos.spin_down_densities?.length === dos.densities.length
         const should_show_spin_up = effective_spin_mode !== `down_only`
-        const should_show_spin_down = has_spin_down &&
-          effective_spin_mode !== `up_only` && effective_spin_mode !== null
+        const should_show_spin_down =
+          has_spin_down && effective_spin_mode !== `up_only` && effective_spin_mode !== null
 
         // Process spin-up (or total) densities
         if (should_show_spin_up) {
-          let densities_up = sigma > 0
-            ? apply_gaussian_smearing(x_values, dos.densities, sigma)
-            : [...dos.densities]
+          let densities_up =
+            sigma > 0
+              ? apply_gaussian_smearing(x_values, dos.densities, sigma)
+              : [...dos.densities]
 
           densities_up = normalize_densities(densities_up, x_values, normalize)
 
@@ -194,8 +196,8 @@
 
           // For stacked plots, accumulate densities (only if array lengths match)
           if (stack && cumulative_spin_up?.length === densities_up.length) {
-            densities_up = densities_up.map((density, idx) =>
-              density + (cumulative_spin_up?.[idx] ?? 0)
+            densities_up = densities_up.map(
+              (density, idx) => density + (cumulative_spin_up?.[idx] ?? 0),
             )
           } else if (stack && cumulative_spin_up) {
             console.warn(`DOS stacking: length mismatch for "${label}"`)
@@ -212,9 +214,10 @@
             cumulative_spin_up = densities_up
           }
 
-          const spin_label = has_spin_down && effective_spin_mode
-            ? `${label || `DOS ${dos_idx + 1}`} (↑)`
-            : (label || `DOS ${dos_idx + 1}`)
+          const spin_label =
+            has_spin_down && effective_spin_mode
+              ? `${label || `DOS ${dos_idx + 1}`} (↑)`
+              : label || `DOS ${dos_idx + 1}`
 
           const series_up: DataSeries = {
             x: is_horizontal ? densities_up : x_values,
@@ -228,13 +231,11 @@
         }
 
         // Process spin-down densities if available
-        if (
-          should_show_spin_down && dos.type === `electronic` &&
-          dos.spin_down_densities
-        ) {
-          let densities_down = sigma > 0
-            ? apply_gaussian_smearing(x_values, dos.spin_down_densities, sigma)
-            : [...dos.spin_down_densities]
+        if (should_show_spin_down && dos.type === `electronic` && dos.spin_down_densities) {
+          let densities_down =
+            sigma > 0
+              ? apply_gaussian_smearing(x_values, dos.spin_down_densities, sigma)
+              : [...dos.spin_down_densities]
 
           densities_down = normalize_densities(densities_down, x_values, normalize)
 
@@ -246,12 +247,10 @@
           // For stacked plots with overlay mode, use separate spin-down cumulative
           // This prevents spin-down from stacking on top of spin-up within the same DOS
           if (stack && effective_spin_mode === `overlay`) {
-            const prev_spin_down = cumulative_spin_down
-              ? [...cumulative_spin_down]
-              : null
+            const prev_spin_down = cumulative_spin_down ? [...cumulative_spin_down] : null
             if (cumulative_spin_down?.length === densities_down.length) {
-              densities_down = densities_down.map((density, idx) =>
-                density + (cumulative_spin_down?.[idx] ?? 0)
+              densities_down = densities_down.map(
+                (density, idx) => density + (cumulative_spin_down?.[idx] ?? 0),
               )
             } else if (cumulative_spin_down) {
               console.warn(`DOS stacking (spin-down): length mismatch for "${label}"`)
@@ -268,9 +267,10 @@
           }
 
           // Use a slightly different shade for spin-down in overlay mode
-          const spin_down_color = effective_spin_mode === `overlay`
-            ? PLOT_COLORS[(dos_idx * 2 + 1) % PLOT_COLORS.length]
-            : color
+          const spin_down_color =
+            effective_spin_mode === `overlay`
+              ? PLOT_COLORS[(dos_idx * 2 + 1) % PLOT_COLORS.length]
+              : color
 
           const series_down: DataSeries = {
             x: is_horizontal ? densities_down : x_values,
@@ -291,55 +291,51 @@
     },
   )
 
-  let all_freqs = $derived( // for clamping phonon noise
+  let all_freqs = $derived(
+    // for clamping phonon noise
     Object.values(doses_dict).flatMap((dos) =>
-      dos.type === `phonon` ? dos.frequencies : dos.energies
+      dos.type === `phonon` ? dos.frequencies : dos.energies,
     ),
   )
   let clamp_to_zero = $derived(
     is_phonon &&
       all_freqs.length > 0 &&
-      Math.min(...all_freqs) < 0 &&
+      (extent(all_freqs)[0] ?? 0) < 0 &&
       negative_fraction(all_freqs) < IMAGINARY_MODE_NOISE_THRESHOLD,
   )
 
   // Check if we have mirrored spin-down data (negative densities)
-  let has_mirrored_spin = $derived(
-    effective_spin_mode === `mirror` && has_spin_polarized,
+  let has_mirrored_spin = $derived(effective_spin_mode === `mirror` && has_spin_polarized)
+
+  // Density axis starts at 0 (unless mirror mode needs negative values); frequency axis
+  // clamps to 0 only when negative phonon frequencies are numerical noise.
+  // Prefer d3 extent over Math.min/max(...arr) — large DOS grids can blow the call stack.
+  const compute_range = (values: number[], is_density_axis: boolean): Vec2 | undefined => {
+    if (values.length === 0) return undefined
+    const [min_val, max_val] = extent(values) as [number, number]
+    if (is_density_axis && has_mirrored_spin) return [min_val, max_val]
+    if (is_density_axis || clamp_to_zero) return [0, max_val]
+    return [min_val, max_val]
+  }
+  let x_range = $derived(
+    compute_range(
+      series_data.flatMap((srs) => srs.x),
+      is_horizontal,
+    ),
+  )
+  let y_range = $derived(
+    compute_range(
+      series_data.flatMap((srs) => srs.y),
+      !is_horizontal,
+    ),
   )
-
-  let x_range = $derived.by((): Vec2 | undefined => {
-    if (series_data.length === 0) return undefined
-    const all_x = series_data.flatMap((srs) => srs.x)
-    const min_x = Math.min(...all_x), max_x = Math.max(...all_x)
-    // For horizontal orientation with mirror mode, allow negative values (mirrored densities)
-    if (is_horizontal && has_mirrored_spin) return [min_x, max_x]
-    if (is_horizontal || clamp_to_zero) return [0, max_x]
-    return [min_x, max_x]
-  })
-
-  let y_range = $derived.by((): Vec2 | undefined => {
-    if (series_data.length === 0) return undefined
-    const all_y = series_data.flatMap((srs) => srs.y)
-    const min_y = Math.min(...all_y), max_y = Math.max(...all_y)
-    // For vertical orientation with mirror mode, allow negative values (mirrored densities)
-    if (!is_horizontal && has_mirrored_spin) return [min_y, max_y]
-    if (!is_horizontal || clamp_to_zero) return [0, max_y]
-    return [min_y, max_y]
-  })
 
   // Get axis labels based on orientation
   let x_label = $derived(
-    is_horizontal
-      ? `Density of States`
-      : is_phonon
-      ? `Frequency (${units})`
-      : `Energy (eV)`,
+    is_horizontal ? `Density of States` : is_phonon ? `Frequency (${units})` : `Energy (eV)`,
   )
   let y_label = $derived(
-    is_horizontal
-      ? (is_phonon ? `Frequency (${units})` : `Energy (eV)`)
-      : `Density of States`,
+    is_horizontal ? (is_phonon ? `Frequency (${units})` : `Energy (eV)`) : `Density of States`,
   )
 
   // Compute final axis configurations with default labels
@@ -359,7 +355,6 @@
     range: y_range,
     ...y_axis,
   })
-
   // Sync zoom changes from ScatterPlot back to parent via bindable y_axis
   // Also clears parent range when internal range becomes invalid (auto-range reset)
   $effect(() => {
@@ -381,9 +376,9 @@
   let effective_sigma_range = $derived.by((): Vec2 => {
     if (sigma_range) return sigma_range
     if (all_freqs.length === 0) return [0, 1]
-    const freq_range = Math.max(...all_freqs) - Math.min(...all_freqs)
+    const [min_freq, max_freq] = extent(all_freqs) as [number, number]
     // Reasonable sigma range: 0 to ~5% of total range
-    const max_sigma = Math.max(0.1, freq_range * 0.05)
+    const max_sigma = Math.max(0.1, (max_freq - min_freq) * 0.05)
     return [0, max_sigma]
   })
 
@@ -420,9 +415,13 @@
       lower_coords.push(`${lower_x.toFixed(2)},${lower_y.toFixed(2)}`)
     }
     // Trace upper edge forward, lower edge backward, close path
-    return `M${upper_coords[0]} ${
-      upper_coords.slice(1).map((coord) => `L${coord}`).join(` `)
-    } ${lower_coords.toReversed().map((coord) => `L${coord}`).join(` `)} Z`
+    return `M${upper_coords[0]} ${upper_coords
+      .slice(1)
+      .map((coord) => `L${coord}`)
+      .join(` `)} ${lower_coords
+      .toReversed()
+      .map((coord) => `L${coord}`)
+      .join(` `)} Z`
   }
 </script>
 
@@ -436,24 +435,22 @@
     hover_config={{ threshold_px: 50 }}
     controls={{ show: show_controls }}
     on_point_hover={(event) => {
-      hovered_frequency = is_horizontal
-        ? (event?.point?.y ?? null)
-        : (event?.point?.x ?? null)
+      hovered_frequency = is_horizontal ? (event?.point?.y ?? null) : (event?.point?.x ?? null)
     }}
     {...{ range_padding: 0, ...rest }}
   >
     {#snippet tooltip({ x_formatted, y_formatted, label })}
       {@const tooltip_data = format_dos_tooltip(
-      x_formatted,
-      y_formatted,
-      label ?? null,
-      is_horizontal,
-      is_phonon,
-      units,
-      final_x_axis.label ?? ``,
-      internal_y_axis.label ?? ``,
-      Object.keys(doses_dict).length,
-    )}
+        x_formatted,
+        y_formatted,
+        label ?? null,
+        is_horizontal,
+        is_phonon,
+        units,
+        final_x_axis.label ?? ``,
+        internal_y_axis.label ?? ``,
+        Object.keys(doses_dict).length,
+      )}
       {#if tooltip_data.title}<strong>{tooltip_data.title}</strong><br />{/if}
       {#each tooltip_data.lines as line, line_idx (line_idx)}
         {line}{#if line_idx < tooltip_data.lines.length - 1}<br />{/if}
@@ -559,15 +556,16 @@
       {/if}
 
       <!-- Fermi level line for electronic DOS -->
-      {@const fermi_pos = effective_fermi_level !== undefined
-      ? (is_horizontal
-        ? y_scale_fn(effective_fermi_level)
-        : x_scale_fn(effective_fermi_level))
-      : NaN}
+      {@const fermi_pos =
+        effective_fermi_level !== undefined
+          ? is_horizontal
+            ? y_scale_fn(effective_fermi_level)
+            : x_scale_fn(effective_fermi_level)
+          : NaN}
       {#if Number.isFinite(fermi_pos)}
         {@const [x1, x2, y1, y2] = is_horizontal
-      ? [pad.l, width - pad.r, fermi_pos, fermi_pos]
-      : [fermi_pos, fermi_pos, pad.t, height - pad.b]}
+          ? [pad.l, width - pad.r, fermi_pos, fermi_pos]
+          : [fermi_pos, fermi_pos, pad.t, height - pad.b]}
         <line
           class="fermi-level-line"
           {x1}
@@ -608,15 +606,16 @@
       {/if}
 
       <!-- Reference frequency line -->
-      {@const ref_pos = reference_frequency !== null
-      ? (is_horizontal
-        ? y_scale_fn(reference_frequency)
-        : x_scale_fn(reference_frequency))
-      : NaN}
+      {@const ref_pos =
+        reference_frequency !== null
+          ? is_horizontal
+            ? y_scale_fn(reference_frequency)
+            : x_scale_fn(reference_frequency)
+          : NaN}
       {#if Number.isFinite(ref_pos)}
         {@const [x1, x2, y1, y2] = is_horizontal
-      ? [pad.l, width - pad.r, ref_pos, ref_pos]
-      : [ref_pos, ref_pos, pad.t, height - pad.b]}
+          ? [pad.l, width - pad.r, ref_pos, ref_pos]
+          : [ref_pos, ref_pos, pad.t, height - pad.b]}
         <line
           {x1}
           {x2}

package/dist/spectral/helpers.d.ts

@@ -34,14 +34,14 @@ export declare function qpoint_x_position(band_struct: types.BaseBandStructure,
 export declare function find_qpoint_at_rescaled_x(band_struct: types.BaseBandStructure, rescaled_x: number, x_positions: Record<string, Vec2>): number | null;
 type SpinDensities = Record<string, number[]>;
 export interface PymatgenDos {
-    '@class': string;
-    '@module': string;
+    '@class'?: string;
+    '@module'?: string;
     energies: number[];
     densities: SpinDensities | number[];
     efermi: number;
 }
 export interface PymatgenCompleteDos extends PymatgenDos {
-    '@class': `CompleteDos` | `LobsterCompleteDos`;
+    '@class'?: `CompleteDos` | `LobsterCompleteDos`;
     structure?: Record<string, unknown>;
     pdos?: Record<string, SpinDensities>[];
     atom_dos?: Record<string, PymatgenDos>;