matterviz 0.4.2 → 0.4.3

package/dist/spectral/Bands.svelte

@@ -250,7 +250,7 @@
 
   let num_structures = $derived(Object.keys(band_structs_dict).length)
   let all_segment_keys = $derived(Object.keys(all_segments))
-  let common_segment_keys = $derived.by(() =>
+  let common_segment_keys = $derived(
     all_segment_keys.filter(
       (segment_key) => all_segments[segment_key].length === num_structures,
     ),
@@ -337,124 +337,145 @@
     x_positions = positions
   })
 
+  // Plottable branch segments with rescaled x coordinates, shared by the band-line
+  // series and fat-band ribbon computations below
+  interface PlotSegment {
+    bs_idx: number
+    label: string
+    bs: BaseBandStructure
+    start_idx: number
+    end_idx: number // exclusive
+    segment_key: string
+    scaled_distances: number[]
+  }
+  let plot_segments = $derived.by((): PlotSegment[] => {
+    const segments: PlotSegment[] = []
+    for (const [bs_idx, [label, bs]] of Object.entries(band_structs_dict).entries()) {
+      for (const branch of bs.branches) {
+        // Skip discontinuous segments (consecutive labeled points)
+        if (branch.end_index - branch.start_index === 1) continue
+
+        const start_idx = branch.start_index
+        const end_idx = branch.end_index + 1
+        const segment_key = helpers.get_segment_key(
+          bs.qpoints[start_idx]?.label ?? undefined,
+          bs.qpoints[end_idx - 1]?.label ?? undefined,
+        )
+        if (!segments_to_plot.has(segment_key)) continue
+
+        const [x_start, x_end] = x_positions?.[segment_key] || [0, 1]
+        const scaled_distances = helpers.scale_segment_distances(
+          bs.distance.slice(start_idx, end_idx),
+          x_start,
+          x_end,
+        )
+        segments.push({ bs_idx, label, bs, start_idx, end_idx, segment_key, scaled_distances })
+      }
+    }
+    return segments
+  })
+
   // Convert band structures to scatter plot series + track max slope in one pass
   let { series_data, max_abs_slope } = $derived.by(
     (): {
       series_data: DataSeries[]
       max_abs_slope: number
     } => {
-      if (Object.keys(band_structs_dict).length === 0 || segments_to_plot.size === 0) {
-        return { series_data: [], max_abs_slope: 1 }
-      }
-
       const all_series: DataSeries[] = []
       let max_slope = 0
-
-      for (const [bs_idx, [label, bs]] of Object.entries(band_structs_dict).entries()) {
+      // Cache per band structure: segments share their bs, so avoid re-scanning
+      // all q-points once per plotted segment
+      const gamma_cache = new Map<BaseBandStructure, number[]>()
+
+      for (const {
+        bs_idx,
+        label,
+        bs,
+        start_idx,
+        end_idx,
+        scaled_distances,
+      } of plot_segments) {
         const color = PLOT_COLORS[bs_idx % PLOT_COLORS.length]
         const structure_label = label || `Structure ${bs_idx + 1}`
-        const gamma_indices =
-          detected_band_type === `phonon` ? helpers.find_gamma_indices(bs) : []
-
-        for (const branch of bs.branches) {
-          const start_idx = branch.start_index
-          const end_idx = branch.end_index + 1
-          const start_label = bs.qpoints[start_idx]?.label ?? undefined
-          const end_label = bs.qpoints[end_idx - 1]?.label ?? undefined
-          const segment_key = helpers.get_segment_key(start_label, end_label)
-
-          if (!segments_to_plot.has(segment_key)) continue
-
-          // Skip discontinuous segments (consecutive labeled points)
-          const is_discontinuity = branch.end_index - branch.start_index === 1
-          if (is_discontinuity) continue
-
-          const [x_start, x_end] = x_positions?.[segment_key] || [0, 1]
-
-          // Scale distances for this segment
-          const segment_distances = bs.distance.slice(start_idx, end_idx)
-          const scaled_distances = helpers.scale_segment_distances(
-            segment_distances,
-            x_start,
-            x_end,
-          )
+        let gamma_indices = gamma_cache.get(bs)
+        if (!gamma_indices) {
+          gamma_indices = detected_band_type === `phonon` ? helpers.find_gamma_indices(bs) : []
+          gamma_cache.set(bs, gamma_indices)
+        }
 
-          // Create series for each band (and spin channel for electronic structures)
-          for (let band_idx = 0; band_idx < bs.nb_bands; band_idx++) {
-            const frequencies = convert_band_values(
-              bs.bands[band_idx].slice(start_idx, end_idx),
-            )
-            const is_acoustic = helpers.classify_acoustic(bs, band_idx, gamma_indices)
+        // Create series for each band (and spin channel for electronic structures)
+        for (let band_idx = 0; band_idx < bs.nb_bands; band_idx++) {
+          const frequencies = convert_band_values(bs.bands[band_idx].slice(start_idx, end_idx))
+          const is_acoustic = helpers.classify_acoustic(bs, band_idx, gamma_indices)
 
-            const line_style_up = get_line_style(
-              color,
-              is_acoustic === true,
-              frequencies,
-              band_idx,
-            )
+          const line_style_up = get_line_style(
+            color,
+            is_acoustic === true,
+            frequencies,
+            band_idx,
+          )
 
-            const spin_down_band = bs.spin_down_bands?.[band_idx]
-            const has_spin_down_channel =
-              detected_band_type === `electronic` &&
-              Array.isArray(spin_down_band) &&
-              spin_down_band.length >= end_idx
-
-            const track_max_slope = (meta: helpers.BandPointMeta[]) => {
-              for (const pt of meta) {
-                if (typeof pt.slope === `number` && Number.isFinite(pt.slope)) {
-                  max_slope = Math.max(max_slope, Math.abs(pt.slope))
-                }
+          const spin_down_band = bs.spin_down_bands?.[band_idx]
+          const has_spin_down_channel =
+            detected_band_type === `electronic` &&
+            Array.isArray(spin_down_band) &&
+            spin_down_band.length >= end_idx
+
+          const track_max_slope = (meta: helpers.BandPointMeta[]) => {
+            for (const pt of meta) {
+              if (typeof pt.slope === `number` && Number.isFinite(pt.slope)) {
+                max_slope = Math.max(max_slope, Math.abs(pt.slope))
               }
             }
+          }
 
-            if (effective_spin_mode !== `down_only`) {
-              const meta = helpers.build_point_metadata({
-                x_vals: scaled_distances,
-                y_vals: frequencies,
-                band_idx,
-                spin: `up`,
-                is_acoustic,
-                bs,
-                start_idx,
-              })
-              track_max_slope(meta)
-              all_series.push({
-                x: scaled_distances,
-                y: frequencies,
-                markers: `line`,
-                label: has_spin_down_channel ? `${structure_label} (↑)` : structure_label,
-                line_style: line_style_up,
-                metadata: meta,
-              })
-            }
+          if (effective_spin_mode !== `down_only`) {
+            const meta = helpers.build_point_metadata({
+              x_vals: scaled_distances,
+              y_vals: frequencies,
+              band_idx,
+              spin: `up`,
+              is_acoustic,
+              bs,
+              start_idx,
+            })
+            track_max_slope(meta)
+            all_series.push({
+              x: scaled_distances,
+              y: frequencies,
+              markers: `line`,
+              label: has_spin_down_channel ? `${structure_label} (↑)` : structure_label,
+              line_style: line_style_up,
+              metadata: meta,
+            })
+          }
 
-            if (has_spin_down_channel && effective_spin_mode !== `up_only`) {
-              const spin_down_frequencies = convert_band_values(
-                spin_down_band.slice(start_idx, end_idx),
-              )
-              const meta = helpers.build_point_metadata({
-                x_vals: scaled_distances,
-                y_vals: spin_down_frequencies,
-                band_idx,
-                spin: `down`,
-                is_acoustic,
-                bs,
-                start_idx,
-              })
-              track_max_slope(meta)
-              all_series.push({
-                x: scaled_distances,
-                y: spin_down_frequencies,
-                markers: `line`,
-                label: `${structure_label} (↓)`,
-                line_style: {
-                  ...line_style_up,
-                  line_dash: `4,2`,
-                  stroke_width: Math.max(1, line_style_up.stroke_width - 0.1),
-                },
-                metadata: meta,
-              })
-            }
+          if (has_spin_down_channel && effective_spin_mode !== `up_only`) {
+            const spin_down_frequencies = convert_band_values(
+              spin_down_band.slice(start_idx, end_idx),
+            )
+            const meta = helpers.build_point_metadata({
+              x_vals: scaled_distances,
+              y_vals: spin_down_frequencies,
+              band_idx,
+              spin: `down`,
+              is_acoustic,
+              bs,
+              start_idx,
+            })
+            track_max_slope(meta)
+            all_series.push({
+              x: scaled_distances,
+              y: spin_down_frequencies,
+              markers: `line`,
+              label: `${structure_label} (↓)`,
+              line_style: {
+                ...line_style_up,
+                line_dash: `4,2`,
+                stroke_width: Math.max(1, line_style_up.stroke_width - 0.1),
+              },
+              metadata: meta,
+            })
           }
         }
       }
@@ -465,67 +486,39 @@
 
   // Compute ribbon data for bands with width information
   let ribbon_data = $derived.by((): RibbonData[] => {
-    if (Object.keys(band_structs_dict).length === 0 || segments_to_plot.size === 0) {
-      return []
-    }
-
     const all_ribbons: RibbonData[] = []
 
-    for (const [bs_idx, [label, bs]] of Object.entries(band_structs_dict).entries()) {
+    for (const segment of plot_segments) {
+      const { bs_idx, label, bs, start_idx, end_idx, segment_key, scaled_distances } = segment
       // Skip if this band structure has no width data
-      if (!bs.band_widths || bs.band_widths.length === 0) continue
+      if (!bs.band_widths?.length) continue
 
-      const color = PLOT_COLORS[bs_idx % PLOT_COLORS.length]
-      const structure_label = label || `Structure ${bs_idx + 1}`
       const config = helpers.get_ribbon_config(ribbon_config, label)
+      const structure_label = label || `Structure ${bs_idx + 1}`
 
-      for (const branch of bs.branches) {
-        const start_idx = branch.start_index
-        const end_idx = branch.end_index + 1
-        const start_label = bs.qpoints[start_idx]?.label ?? undefined
-        const end_label = bs.qpoints[end_idx - 1]?.label ?? undefined
-        const segment_key = helpers.get_segment_key(start_label, end_label)
-
-        if (!segments_to_plot.has(segment_key)) continue
-
-        // Skip discontinuous segments
-        const is_discontinuity = branch.end_index - branch.start_index === 1
-        if (is_discontinuity) continue
-
-        const [x_start, x_end] = x_positions?.[segment_key] || [0, 1]
-
-        // Scale distances for this segment
-        const segment_distances = bs.distance.slice(start_idx, end_idx)
-        const scaled_distances = helpers.scale_segment_distances(
-          segment_distances,
-          x_start,
-          x_end,
-        )
-
-        // Create ribbon data for each band that has width data
-        for (let band_idx = 0; band_idx < bs.nb_bands; band_idx++) {
-          const band_widths = bs.band_widths[band_idx]
-          if (!band_widths) continue
-
-          const width_values = band_widths.slice(start_idx, end_idx)
-          // Skip if all widths are zero or missing
-          if (width_values.every((wv) => !wv || wv <= 0)) continue
-
-          const y_values = convert_band_values(bs.bands[band_idx].slice(start_idx, end_idx))
-
-          all_ribbons.push({
-            x_values: scaled_distances,
-            y_values,
-            width_values,
-            color: config.color ?? color,
-            opacity: config.opacity ?? 0.3,
-            max_width: config.max_width ?? 6,
-            scale: config.scale ?? 1,
-            band_idx,
-            structure_label,
-            segment_key,
-          })
-        }
+      // Create ribbon data for each band that has width data
+      for (let band_idx = 0; band_idx < bs.nb_bands; band_idx++) {
+        const band_widths = bs.band_widths[band_idx]
+        if (!band_widths) continue
+
+        const width_values = band_widths.slice(start_idx, end_idx)
+        // Skip if all widths are zero or missing
+        if (width_values.every((wv) => !wv || wv <= 0)) continue
+
+        const y_values = convert_band_values(bs.bands[band_idx].slice(start_idx, end_idx))
+
+        all_ribbons.push({
+          x_values: scaled_distances,
+          y_values,
+          width_values,
+          color: config.color ?? PLOT_COLORS[bs_idx % PLOT_COLORS.length],
+          opacity: config.opacity ?? 0.3,
+          max_width: config.max_width ?? 6,
+          scale: config.scale ?? 1,
+          band_idx,
+          structure_label,
+          segment_key,
+        })
       }
     }
 
@@ -642,7 +635,7 @@
     ]
   })
 
-  let custom_highlight_regions = $derived.by((): FillRegion[] =>
+  let custom_highlight_regions = $derived(
     (highlight_regions ?? [])
       .filter((region) => Number.isFinite(region.y_min) && Number.isFinite(region.y_max))
       .map((region) => ({

package/dist/spectral/BrillouinBandsDos.svelte

@@ -47,18 +47,9 @@
   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)
@@ -91,13 +82,7 @@
   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)

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 {
@@ -299,34 +300,35 @@
   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 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]
-  })
+  // 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,
+    ),
+  )
 
   // Get axis labels based on orientation
   let x_label = $derived(
@@ -374,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]
   })