matterviz 0.3.5 → 0.3.6

package/dist/src/lib/convex-hull/helpers.ts

@@ -0,0 +1,932 @@
+import { type D3InterpolateName, get_d3_interpolator } from '$lib/colors'
+import { ELEM_SYMBOL_TO_NAME } from '$lib/composition'
+import type { EnergyModeInfo } from '$lib/convex-hull'
+import type { ElementSymbol } from '$lib/element'
+import { format_fractional, format_num, symbol_map } from '$lib/labels'
+import { scaleSequential } from 'd3-scale'
+import { symbol } from 'd3-shape'
+import {
+  analyze_gas_data as _analyze_gas_data,
+  apply_gas_corrections as _apply_gas_corrections,
+} from './gas-thermodynamics'
+import type {
+  ConvexHullConfig,
+  GasAnalysis,
+  GasThermodynamicsConfig,
+  HighlightStyle,
+  MarkerSymbol,
+  PhaseData,
+} from './types'
+import { DEFAULT_GAS_TEMP } from './types'
+export { DEFAULT_GAS_TEMP }
+
+// Tolerance for classifying a phase as on the convex hull (eV/atom)
+export const HULL_STABILITY_TOL = 1e-6
+
+// Clamp raw hull distance and compute stability for a single entry.
+// Excluded entries keep their raw (possibly negative) distance and are never stable.
+export function compute_hull_stability(
+  raw_distance: number,
+  exclude_from_hull?: boolean,
+  tol: number = HULL_STABILITY_TOL,
+): { e_above_hull: number; is_stable: boolean } {
+  if (exclude_from_hull) return { e_above_hull: raw_distance, is_stable: false }
+  const e_above_hull = Math.abs(raw_distance) < tol ? 0 : Math.max(0, raw_distance)
+  return { e_above_hull, is_stable: e_above_hull <= tol }
+}
+
+type StabilityEntry = { is_stable?: boolean; e_above_hull?: number }
+
+export const entry_is_stable = (
+  entry: StabilityEntry,
+  tol: number = HULL_STABILITY_TOL,
+): boolean =>
+  entry.is_stable === true ||
+  (entry.is_stable !== false && Math.abs(entry.e_above_hull ?? Infinity) <= tol)
+
+// Check if entry is on the convex hull (stable or e_above_hull ≈ 0)
+export const is_on_hull = (entry: PhaseData, tol: number = HULL_STABILITY_TOL): boolean =>
+  !entry.exclude_from_hull && entry_is_stable(entry, tol)
+
+export const get_arity = (entry: PhaseData): number =>
+  Object.values(entry.composition).filter((count) => count > 0).length
+
+export const is_unary_entry = (entry: PhaseData) => get_arity(entry) === 1
+
+export const entry_is_unstable = (entry: StabilityEntry): boolean => !entry_is_stable(entry)
+
+export const entry_is_visible = (
+  entry: StabilityEntry,
+  show_stable: boolean,
+  show_unstable: boolean,
+): boolean => (entry_is_stable(entry) ? show_stable : show_unstable)
+
+export const visible_entries = <Entry extends StabilityEntry>(
+  entries: readonly Entry[],
+  show_stable: boolean,
+  show_unstable: boolean,
+): Entry[] => entries.filter((entry) => entry_is_visible(entry, show_stable, show_unstable))
+
+// Energy color scale factory (shared)
+export function get_energy_color_scale(
+  color_mode: `stability` | `energy`,
+  color_scale: D3InterpolateName,
+  plot_entries: { e_above_hull?: number }[],
+): ((value: number) => string) | null {
+  if (color_mode !== `energy` || plot_entries.length === 0) return null
+  let lo = Number.POSITIVE_INFINITY
+  let hi_raw = 0.1
+  for (const entry of plot_entries) {
+    const val = entry.e_above_hull
+    if (typeof val !== `number` || !Number.isFinite(val)) continue
+    lo = Math.min(lo, val)
+    hi_raw = Math.max(hi_raw, val)
+  }
+  if (!Number.isFinite(lo)) return null
+  const hi = Math.max(hi_raw, lo + 1e-6)
+  const interpolator = get_d3_interpolator(color_scale)
+  return scaleSequential(interpolator).domain([lo, hi])
+}
+
+// Point color resolver (shared)
+export function get_point_color_for_entry(
+  entry: { is_stable?: boolean; e_above_hull?: number },
+  color_mode: `stability` | `energy`,
+  colors: ConvexHullConfig[`colors`] | undefined,
+  energy_scale: ((value: number) => string) | null,
+): string {
+  const is_stable = entry_is_stable(entry)
+  if (color_mode === `stability`) {
+    return is_stable ? colors?.stable || `#0072B2` : colors?.unstable || `#E69F00`
+  }
+  return energy_scale && typeof entry.e_above_hull === `number`
+    ? energy_scale(entry.e_above_hull)
+    : `#666`
+}
+
+// Robust drag-and-drop JSON parsing for convex hull entries
+export async function parse_hull_entries_from_drop(
+  event: DragEvent,
+): Promise<PhaseData[] | null> {
+  event.preventDefault()
+  const file = event.dataTransfer?.files?.[0]
+  if (!file?.name.endsWith(`.json`)) return null
+  try {
+    const data = JSON.parse(await file.text()) as PhaseData[]
+    if (!Array.isArray(data) || data.length === 0) return null
+    if (!data[0].composition || typeof data[0].energy !== `number`) return null
+    return data
+  } catch (error) {
+    console.error(`Error parsing dropped file:`, error)
+    return null
+  }
+}
+
+// Compute a consistent max energy threshold for controls (shared)
+export function calc_max_hull_dist_in_data(processed_entries: PhaseData[]): number {
+  if (processed_entries.length === 0) return 0.5
+  let max_hull_dist = 0
+  for (const entry of processed_entries) {
+    const val = entry.e_above_hull
+    if (typeof val === `number` && Number.isFinite(val)) {
+      max_hull_dist = Math.max(max_hull_dist, val)
+    }
+  }
+  const max_val = max_hull_dist + 0.001
+  return Math.max(0.1, max_val)
+}
+
+// Smart threshold for showing unstable entries based on entry count.
+// Few entries (≤25): show all. Many entries (≥100): use static default. Between: interpolate.
+export function compute_auto_hull_dist_threshold(
+  n_entries: number,
+  max_hull_dist_in_data: number,
+  static_default: number,
+): number {
+  const [LOW, HIGH] = [25, 100]
+  if (n_entries <= LOW) return max_hull_dist_in_data
+  if (n_entries >= HIGH) return static_default
+  const t = (n_entries - LOW) / (HIGH - LOW)
+  return max_hull_dist_in_data * (1 - t) + static_default * t
+}
+
+export function auto_threshold_reset(default_threshold: number) {
+  let source: unknown
+  let auto_threshold = default_threshold
+  let initialized = false
+  return (next_source: unknown, current_threshold: number, next_auto_threshold: number) => {
+    if (initialized && next_source === source) return undefined
+    const user_changed = initialized && Math.abs(current_threshold - auto_threshold) > 0.001
+    source = next_source
+    auto_threshold = next_auto_threshold
+    initialized = true
+    return user_changed ? undefined : next_auto_threshold
+  }
+}
+
+export function current_entry<Entry extends { entry_id?: string }>(
+  entry: Entry | null | undefined,
+  entries: readonly Entry[],
+): Entry | null {
+  if (!entry) return null
+  if (entry.entry_id) {
+    return entries.find((candidate) => candidate.entry_id === entry.entry_id) ?? null
+  }
+  return entries.includes(entry) ? entry : null
+}
+
+// Build a tooltip text for any phase entry (shared)
+export function build_entry_tooltip_text(entry: PhaseData): string {
+  const is_element = is_unary_entry(entry)
+  const elem_symbol = is_element ? Object.keys(entry.composition)[0] : ``
+
+  const elem_name = is_element ? (ELEM_SYMBOL_TO_NAME[elem_symbol as ElementSymbol] ?? ``) : ``
+
+  let text = is_element
+    ? `${elem_symbol}${elem_name ? ` (${elem_name})` : ``}\n`
+    : `${entry.name || entry.reduced_formula || ``}\n`
+
+  if (!is_element) {
+    const total = Object.values(entry.composition).reduce((sum, amt) => sum + amt, 0)
+    if (total > 0) {
+      const fractions = Object.entries(entry.composition)
+        .filter(([, amt]) => amt > 0)
+        .map(([el, amt]) => `${el}: ${format_fractional(amt / total)}`)
+      if (fractions.length > 1) {
+        text += `Composition: ${fractions.join(`, `)}\n`
+      }
+    }
+  }
+
+  if (entry.e_above_hull !== undefined) {
+    const e_hull_str = format_num(entry.e_above_hull, `.3~`)
+    text += `E<sub>above hull</sub>: ${e_hull_str} eV/atom\n`
+  }
+  // Fallback to energy_per_atom if e_form_per_atom is absent
+  const e_form_display = entry.e_form_per_atom ?? entry.energy_per_atom
+  if (e_form_display !== undefined) {
+    const e_form_str = format_num(e_form_display, `.3~`)
+    text += `E<sub>form</sub>: ${e_form_str} eV/atom`
+  }
+  if (entry.entry_id) text += `\nID: ${entry.entry_id}`
+  return text
+}
+
+// Generic mouse hit-testing for projected 3D points (shared)
+export function find_hull_entry_at_mouse<
+  T extends {
+    x: number
+    y: number
+    z: number
+    size?: number
+    is_stable?: boolean
+    e_above_hull?: number
+  },
+>(
+  canvas: HTMLCanvasElement | undefined,
+  event: MouseEvent,
+  plot_entries: T[],
+  project_point: (x: number, y: number, z: number) => { x: number; y: number },
+): T | null {
+  if (!canvas) return null
+  const rect = canvas.getBoundingClientRect()
+  const mouse_x = event.clientX - rect.left
+  const mouse_y = event.clientY - rect.top
+  const container_scale = Math.min(canvas.clientWidth || 600, canvas.clientHeight || 600) / 600
+  for (const entry of plot_entries) {
+    const projected = project_point(entry.x, entry.y, entry.z)
+    const distance = Math.hypot(mouse_x - projected.x, mouse_y - projected.y)
+    const base = entry.size ?? (entry_is_stable(entry) ? 6 : 4)
+    if (distance < base * container_scale + 5) return entry
+  }
+  return null
+}
+
+// Calculate which side of the viewport has more space for modal placement
+export function calculate_modal_side(wrapper: HTMLDivElement | undefined): boolean {
+  if (!wrapper) return true
+  const rect = wrapper.getBoundingClientRect()
+  const viewport_width = globalThis.innerWidth
+  const space_on_right = viewport_width - rect.right
+  const space_on_left = rect.left
+  return space_on_right >= space_on_left
+}
+
+// Compute energy source mode information for convex hull entries. Returns energy mode information including capability flags and resolved mode.
+// This determines whether we can use precomputed energies or need to compute on-the-fly.
+export function compute_energy_mode_info(
+  entries: PhaseData[], // Array of phase entries to analyze
+  find_lowest_energy_unary_refs_fn: (entries: PhaseData[]) => Record<string, PhaseData>, // Function to find unary references
+  energy_source_mode: `precomputed` | `on-the-fly`, // User-specified energy source mode preference
+): EnergyModeInfo {
+  const has_precomputed_e_form =
+    entries.length > 0 && entries.every((entry) => typeof entry.e_form_per_atom === `number`)
+  const has_precomputed_hull =
+    entries.length > 0 && entries.every((entry) => typeof entry.e_above_hull === `number`)
+
+  const unary_refs = find_lowest_energy_unary_refs_fn(entries)
+
+  const elements_in_entries = new Set<string>()
+  for (const entry of entries) {
+    for (const el of Object.keys(entry.composition)) elements_in_entries.add(el)
+  }
+  let can_compute_e_form = true
+  for (const el of elements_in_entries) {
+    if (!unary_refs[el]) {
+      can_compute_e_form = false
+      break
+    }
+  }
+  const can_compute_hull = can_compute_e_form
+
+  // Resolve mode to avoid inconsistent states:
+  // - If full precomputed available, honor user toggle
+  // - Else if we can compute both, use on-the-fly automatically
+  // - Else fall back to precomputed (best-effort)
+  const energy_mode =
+    has_precomputed_e_form && has_precomputed_hull
+      ? energy_source_mode
+      : can_compute_e_form && can_compute_hull
+        ? `on-the-fly`
+        : `precomputed`
+
+  return {
+    has_precomputed_e_form,
+    has_precomputed_hull,
+    can_compute_e_form,
+    can_compute_hull,
+    energy_mode,
+    unary_refs,
+  }
+}
+
+// Compute effective entries with formation energies based on the energy mode.
+// Returns entries with formation energies populated (either precomputed or on-the-fly)
+export function get_effective_entries(
+  entries: PhaseData[], // Original phase entries
+  energy_mode: `precomputed` | `on-the-fly`, // Energy source mode (precomputed or on-the-fly)
+  unary_refs: Record<string, PhaseData>, // Unary reference entries for energy computation
+  compute_e_form_fn: (
+    entry: PhaseData,
+    unary_refs: Record<string, PhaseData>,
+  ) => number | null, // Function to compute formation energy per atom
+): PhaseData[] {
+  if (energy_mode === `precomputed`) return entries
+
+  return entries.map((entry) => {
+    const e_form = compute_e_form_fn(entry, unary_refs)
+    if (e_form === null) return entry
+    return { ...entry, e_form_per_atom: e_form }
+  })
+}
+
+// Copy text to clipboard with visual feedback
+export async function copy_entry_to_clipboard(
+  entry: PhaseData,
+  position: { x: number; y: number },
+  on_feedback: (visible: boolean, pos: { x: number; y: number }) => void,
+): Promise<void> {
+  const text = build_entry_tooltip_text(entry)
+  await navigator.clipboard.writeText(text)
+  on_feedback(true, position)
+  setTimeout(() => on_feedback(false, position), 1500)
+}
+
+export const DEFAULT_HIGHLIGHT_STYLE: Required<HighlightStyle> = {
+  effect: `pulse`,
+  color: `#ff4444`, // Bright red for visibility
+  size_multiplier: 1.8, // Moderate base size
+  opacity: 0.85, // High visibility
+  pulse_speed: 3, // Smooth pulsing
+}
+
+export const merge_highlight_style = (
+  custom_style: HighlightStyle | undefined,
+): Required<HighlightStyle> => ({
+  ...DEFAULT_HIGHLIGHT_STYLE,
+  ...custom_style,
+})
+
+// Check if entry matches any item in highlighted_list (by structure_id or entry_id)
+export function is_entry_highlighted<T extends { entry_id?: string; structure_id?: string }>(
+  entry: T,
+  highlighted_list: (string | T)[],
+): boolean {
+  if (!highlighted_list.length) return false
+  const { entry_id, structure_id } = entry
+  if (!entry_id && !structure_id) return false
+
+  return highlighted_list.some((item) => {
+    if (typeof item === `string`) {
+      return item === entry_id || item === structure_id
+    }
+    // Object: match by structure_id if present, else fall back to entry_id
+    return item?.structure_id
+      ? structure_id === item.structure_id
+      : item?.entry_id === entry_id
+  })
+}
+
+// Calculate fractional composition (normalized composition) for an entry
+export function get_fractional_composition(
+  composition: Record<string, number>,
+): Record<string, number> {
+  const total = Object.values(composition).reduce((sum, amt) => sum + amt, 0)
+  if (total <= 0) return {} // Return empty object if total is zero or negative (invalid composition)
+  const fractional: Record<string, number> = {}
+  for (const [elem, amt] of Object.entries(composition)) {
+    // Only include positive amounts in fractional composition
+    if (amt > 0) fractional[elem] = amt / total
+  }
+  return fractional
+}
+
+export interface PolymorphStats {
+  total: number
+  higher: number
+  lower: number
+  equal: number
+}
+
+// Energy metric types for consistent polymorph comparison
+type EnergyMetric = `e_form_per_atom` | `energy_per_atom` | `e_above_hull` | null
+
+// Check if value is a finite number
+const is_finite = (val: unknown): val is number =>
+  typeof val === `number` && Number.isFinite(val)
+
+// Compute energy_per_atom from total energy and composition
+function compute_energy_per_atom(entry: PhaseData): number | null {
+  if (!is_finite(entry.energy)) return null
+  const total_atoms = Object.values(entry.composition).reduce((sum, amt) => sum + amt, 0)
+  return total_atoms > 0 ? entry.energy / total_atoms : null
+}
+
+// Get energy value for an entry using a specific metric
+// NOTE: We prioritize absolute energies (e_form_per_atom, energy_per_atom) over e_above_hull
+// because polymorphs of the same composition on the hull all have e_above_hull=0
+function get_entry_energy_by_metric(entry: PhaseData, metric: EnergyMetric): number | null {
+  if (metric === `e_form_per_atom` && is_finite(entry.e_form_per_atom)) {
+    return entry.e_form_per_atom
+  }
+  if (metric === `energy_per_atom`) {
+    return is_finite(entry.energy_per_atom)
+      ? entry.energy_per_atom
+      : compute_energy_per_atom(entry)
+  }
+  if (metric === `e_above_hull` && is_finite(entry.e_above_hull)) {
+    return entry.e_above_hull
+  }
+  return null
+}
+
+function get_label_representative_energy(entry: PhaseData): number {
+  if (is_finite(entry.e_form_per_atom)) return entry.e_form_per_atom
+  if (is_finite(entry.energy_per_atom)) return entry.energy_per_atom
+  const energy_per_atom = compute_energy_per_atom(entry)
+  if (energy_per_atom !== null) return energy_per_atom
+  if (is_finite(entry.energy)) return entry.energy
+  if (is_finite(entry.e_above_hull)) return entry.e_above_hull
+  return Number.POSITIVE_INFINITY
+}
+
+function get_fractional_composition_key(composition: Record<string, number>): string {
+  return Object.entries(get_fractional_composition(composition))
+    .sort(([elem_a], [elem_b]) => elem_a.localeCompare(elem_b))
+    .map(([elem, frac]) => `${elem}:${frac.toFixed(6)}`)
+    .join(`|`)
+}
+
+// Pick one label target per normalized composition. Multiple polymorphs, supercell
+// formulas, or same-composition entries often project to the same screen position.
+export function get_composition_label_entries<T extends PhaseData>(entries: Iterable<T>): T[] {
+  const label_entry_by_composition = new Map<string, T>()
+
+  for (const entry of entries) {
+    const comp_key = get_fractional_composition_key(entry.composition)
+    if (!comp_key) continue
+
+    const existing = label_entry_by_composition.get(comp_key)
+    if (
+      !existing ||
+      get_label_representative_energy(entry) < get_label_representative_energy(existing)
+    ) {
+      label_entry_by_composition.set(comp_key, entry)
+    }
+  }
+
+  return Array.from(label_entry_by_composition.values())
+}
+
+// Determine which energy metric to use for a composition group
+// Returns the first metric that ALL entries in the group can provide
+function select_group_energy_metric(polymorphs: PhaseData[]): EnergyMetric {
+  // Try e_form_per_atom first (best for comparing polymorphs)
+  if (polymorphs.every((entry) => is_finite(entry.e_form_per_atom))) {
+    return `e_form_per_atom`
+  }
+  // Try energy_per_atom (either direct field or computed from total energy)
+  if (
+    polymorphs.every(
+      (entry) => is_finite(entry.energy_per_atom) || compute_energy_per_atom(entry) !== null,
+    )
+  )
+    return `energy_per_atom`
+  // Last resort: e_above_hull (will fail to differentiate stable polymorphs with e_above_hull=0)
+  if (polymorphs.every((entry) => is_finite(entry.e_above_hull))) {
+    return `e_above_hull`
+  }
+
+  return null // No valid metric available for this group
+}
+
+// Pre-compute polymorph statistics for all entries at once (O(n²) but done once)
+// Returns a Map keyed by entry_id for O(1) lookups during hover
+export function compute_all_polymorph_stats(
+  all_entries: PhaseData[],
+): Map<string, PolymorphStats> {
+  const stats_map = new Map<string, PolymorphStats>()
+  const zero_stats = { total: 0, higher: 0, lower: 0, equal: 0 }
+
+  // Group entries by fractional composition (normalized stoichiometry)
+  const composition_groups = new Map<string, PhaseData[]>()
+  for (const entry of all_entries) {
+    const comp_key = get_fractional_composition_key(entry.composition)
+    const group = composition_groups.get(comp_key) ?? []
+    if (group.length === 0) composition_groups.set(comp_key, group)
+    group.push(entry)
+  }
+
+  // Calculate stats for each polymorph group
+  for (const polymorphs of composition_groups.values()) {
+    // Select one consistent metric for the entire composition group
+    const group_metric = select_group_energy_metric(polymorphs)
+
+    // If no valid metric available, set all entries in group to zero stats
+    if (group_metric === null) {
+      for (const entry of polymorphs) {
+        if (entry.entry_id) stats_map.set(entry.entry_id, zero_stats)
+      }
+      continue
+    }
+
+    // Compare entries using the consistent group metric
+    for (const entry of polymorphs) {
+      if (!entry.entry_id) continue
+
+      const entry_energy = get_entry_energy_by_metric(entry, group_metric)
+      if (entry_energy === null) {
+        stats_map.set(entry.entry_id, zero_stats)
+        continue
+      }
+
+      let [total, higher, lower, equal] = [0, 0, 0, 0]
+      for (const other of polymorphs) {
+        if (other === entry || other.entry_id === entry.entry_id) continue
+
+        const other_energy = get_entry_energy_by_metric(other, group_metric)
+        if (other_energy === null) continue
+
+        total++
+        if (other_energy > entry_energy) higher++
+        else if (other_energy < entry_energy) lower++
+        else equal++
+      }
+
+      stats_map.set(entry.entry_id, { total, higher, lower, equal })
+    }
+  }
+
+  return stats_map
+}
+
+function apply_alpha_to_color(color: string, alpha: number): string {
+  // Handle existing rgba format
+  if (color.includes(`rgba`)) return color.replace(/[\d.]+\)$/, `${alpha})`)
+
+  if (color.includes(`rgb(`)) {
+    // Convert rgb to rgba
+    return color.replace(/rgb\(/, `rgba(`).replace(/\)$/, `, ${alpha})`)
+  }
+
+  const hex_match = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.exec(color) // Convert hex to rgba
+  if (hex_match) {
+    let hex = hex_match[1]
+    // Expand short form (e.g. "03F") to full form (e.g. "0033FF")
+    if (hex.length === 3)
+      hex = hex
+        .split(``)
+        .map((char) => char + char)
+        .join(``)
+
+    const red = parseInt(hex.slice(0, 2), 16)
+    const green = parseInt(hex.slice(2, 4), 16)
+    const blue = parseInt(hex.slice(4, 6), 16)
+    return `rgba(${red}, ${green}, ${blue}, ${alpha})`
+  }
+
+  return color // Return unchanged if format not recognized
+}
+
+export function draw_highlight_effect(
+  ctx: CanvasRenderingContext2D,
+  projected: { x: number; y: number },
+  size: number,
+  container_scale: number,
+  pulse_time: number,
+  style: Required<HighlightStyle>,
+): void {
+  const { effect, color: hl_color, size_multiplier, opacity, pulse_speed } = style
+
+  if (effect === `pulse`) {
+    // Smooth pulsating effect with moderate size and opacity changes
+    const pulse_val = 0.5 + 0.5 * Math.sin(pulse_time * pulse_speed)
+    const hl_size = size * (size_multiplier + 0.5 * pulse_val)
+    const hl_opacity = opacity * (0.5 + 0.5 * pulse_val)
+
+    // Draw pulsating ring
+    ctx.lineWidth = (1.5 + pulse_val) * container_scale
+    ctx.beginPath()
+    ctx.arc(projected.x, projected.y, hl_size, 0, 2 * Math.PI)
+    ctx.fillStyle = apply_alpha_to_color(hl_color, hl_opacity * 0.3)
+    ctx.strokeStyle = apply_alpha_to_color(hl_color, hl_opacity)
+    ctx.fill()
+    ctx.stroke()
+  } else if (effect === `glow`) {
+    // Soft glow effect with layered circles for depth
+    const hl_size = size * size_multiplier
+
+    // Outer soft glow
+    ctx.beginPath()
+    ctx.arc(projected.x, projected.y, hl_size * 1.3, 0, 2 * Math.PI)
+    ctx.fillStyle = apply_alpha_to_color(hl_color, opacity * 0.15)
+    ctx.fill()
+
+    // Inner glow with stroke
+    ctx.lineWidth = 1.5 * container_scale
+    ctx.beginPath()
+    ctx.arc(projected.x, projected.y, hl_size, 0, 2 * Math.PI)
+    ctx.fillStyle = apply_alpha_to_color(hl_color, opacity * 0.4)
+    ctx.strokeStyle = apply_alpha_to_color(hl_color, opacity * 0.8)
+    ctx.fill()
+    ctx.stroke()
+  } else if (effect === `size`) {
+    // Simple size highlight with stroke
+    const hl_size = size * size_multiplier
+    ctx.lineWidth = 2 * container_scale
+    ctx.beginPath()
+    ctx.arc(projected.x, projected.y, hl_size, 0, 2 * Math.PI)
+    ctx.strokeStyle = hl_color
+    ctx.stroke()
+  }
+  // effect === `color` is handled in the main drawing code
+}
+
+// Draw selection highlight for currently selected entry (with pulsing animation)
+export function draw_selection_highlight(
+  ctx: CanvasRenderingContext2D,
+  projected: { x: number; y: number },
+  base_size: number,
+  container_scale: number,
+  pulse_time: number,
+  pulse_opacity: number,
+): void {
+  const highlight_size = base_size * (1.8 + 0.3 * Math.sin(pulse_time * 4))
+  ctx.fillStyle = apply_alpha_to_color(`rgba(102, 240, 255, 1)`, pulse_opacity * 0.6)
+  ctx.strokeStyle = apply_alpha_to_color(`rgba(102, 240, 255, 1)`, pulse_opacity)
+  ctx.lineWidth = 2 * container_scale
+  ctx.beginPath()
+  ctx.arc(projected.x, projected.y, highlight_size, 0, 2 * Math.PI)
+  ctx.fill()
+  ctx.stroke()
+}
+
+// Get text color for canvas rendering. Canvas 2D context doesn't understand CSS functions
+// like light-dark() or var(), so we fall back to appropriate colors based on dark mode.
+export function get_canvas_text_color(
+  dark_mode: boolean,
+  element?: HTMLElement | null,
+): string {
+  const fallback = dark_mode ? `#ffffff` : `#212121`
+  if (typeof document === `undefined`) return fallback
+  const css_value = getComputedStyle(element ?? document.documentElement)
+    .getPropertyValue(`--text-color`)
+    ?.trim()
+  // Check for unsupported CSS functions that canvas can't render
+  return css_value && !/light-dark|var\(/i.test(css_value) ? css_value : fallback
+}
+
+// Create a Path2D for a marker symbol. Uses d3-shape for consistent rendering with ScatterPlot.
+export function create_marker_path(size: number, marker: MarkerSymbol = `circle`): Path2D {
+  const safe_size = Number.isFinite(size) ? size : 0
+  const rounded_size = Math.max(0, Number(safe_size.toFixed(3)))
+
+  // Capitalize first letter to get D3 symbol name (e.g. 'circle' -> 'Circle')
+  const d3_name = marker.charAt(0).toUpperCase() + marker.slice(1)
+  const symbol_type = symbol_map[d3_name as keyof typeof symbol_map]
+  const symbol_area = Math.PI * rounded_size * rounded_size
+  const path_data = symbol_type ? symbol().type(symbol_type).size(symbol_area)() : null
+  const path = new Path2D(path_data ?? undefined)
+
+  if (!path_data) {
+    path.arc(0, 0, rounded_size, 0, 2 * Math.PI)
+  }
+
+  return path
+}
+
+// Temperature-dependent free energy helpers (use integer K values for exact matching)
+
+// Result of analyzing entries for temperature-dependent data
+export interface TemperatureAnalysis {
+  has_temp_data: boolean
+  available_temperatures: number[] // sorted unique T values (union across all entries)
+}
+
+// Analyze entries for temperature-dependent free energy data.
+// Returns available temperatures (union of all T values across entries) if any entries have temp data.
+export function analyze_temperature_data(entries: PhaseData[]): TemperatureAnalysis {
+  const unique_temperatures = new Set<number>()
+  for (const entry of entries) {
+    if (!entry_has_temp_data(entry)) continue
+    for (const temperature of entry.temperatures ?? []) unique_temperatures.add(temperature)
+  }
+  const available_temperatures = [...unique_temperatures].sort((a, b) => a - b)
+  return {
+    has_temp_data: available_temperatures.length > 0,
+    available_temperatures,
+  }
+}
+
+// Check if an entry has valid temperature-dependent data (matching array lengths, non-empty)
+function entry_has_temp_data(entry: PhaseData): boolean {
+  const { temperatures, free_energies } = entry
+  return Boolean(
+    temperatures?.length &&
+    free_energies?.length &&
+    temperatures.length === free_energies.length,
+  )
+}
+
+// Check if entry has data at exact temperature T
+export const entry_has_temperature = (entry: PhaseData, T: number): boolean =>
+  entry_has_temp_data(entry) && (entry.temperatures?.includes(T) ?? false)
+
+// Get energy at temperature T (throws if T not found - validate with entry_has_temperature first)
+export function get_energy_at_temperature(entry: PhaseData, T: number): number {
+  const temps = entry.temperatures ?? []
+  const energies = entry.free_energies ?? []
+  const idx = temps.indexOf(T)
+  if (idx === -1) {
+    throw new Error(`Temperature ${T}K not found in entry temperatures`)
+  }
+  return energies[idx]
+}
+
+// Find bracketing temperatures for interpolation (T_low < T < T_high)
+// Returns null if T is outside the range or no valid bracket exists
+function find_bracket_temperatures(
+  entry: PhaseData,
+  T: number,
+): { T_low: number; T_high: number; E_low: number; E_high: number } | null {
+  const temps = entry.temperatures ?? []
+  const energies = entry.free_energies ?? []
+  if (temps.length < 2) return null
+
+  // Find the largest T_low < T and smallest T_high > T
+  let T_low = -Infinity
+  let T_high = Infinity
+  let E_low = 0
+  let E_high = 0
+
+  // Must scan all temperatures to find the tightest bracket (arrays may be unsorted)
+  for (const [idx, temp] of temps.entries()) {
+    if (temp < T && temp > T_low) {
+      T_low = temp
+      E_low = energies[idx]
+    } else if (temp > T && temp < T_high) {
+      T_high = temp
+      E_high = energies[idx]
+    }
+  }
+
+  // Must have valid brackets on both sides
+  if (!isFinite(T_low) || !isFinite(T_high)) return null
+  return { T_low, T_high, E_low, E_high }
+}
+
+// Check if we can interpolate energy at temperature T
+// Requires temperatures both above and below T within max_gap
+export function can_interpolate_at_temperature(
+  entry: PhaseData,
+  T: number,
+  max_gap: number,
+): boolean {
+  const bracket = find_bracket_temperatures(entry, T)
+  if (!bracket) return false
+  return bracket.T_high - bracket.T_low <= max_gap
+}
+
+// Linearly interpolate energy at temperature T
+// Returns null if interpolation is not possible
+export function interpolate_energy_at_temperature(
+  entry: PhaseData,
+  T: number,
+  max_gap: number,
+): number | null {
+  const bracket = find_bracket_temperatures(entry, T)
+  if (!bracket) return null
+  if (bracket.T_high - bracket.T_low > max_gap) return null
+
+  // Linear interpolation: E(T) = E_low + (E_high - E_low) * (T - T_low) / (T_high - T_low)
+  const fraction = (T - bracket.T_low) / (bracket.T_high - bracket.T_low)
+  return bracket.E_low + (bracket.E_high - bracket.E_low) * fraction
+}
+
+// Options for temperature filtering
+export interface TemperatureFilterOptions {
+  // Enable linear interpolation for missing temperatures (default: true)
+  interpolate?: boolean
+  // Maximum temperature gap (in Kelvin) allowed for interpolation (default: 500K)
+  max_interpolation_gap?: number
+}
+
+const DEFAULT_TEMP_FILTER_OPTIONS: Required<TemperatureFilterOptions> = {
+  interpolate: true,
+  max_interpolation_gap: 500,
+}
+
+// Filter entries for temperature T, replacing energy with G(T) where available.
+// - Entries WITH temp data at T: use G(T) as energy
+// - Entries WITHOUT any temp data: keep with static energy (e.g., pure element refs)
+// - Entries WITH temp data but MISSING T: interpolate if enabled and possible, else excluded
+export function filter_entries_at_temperature(
+  entries: PhaseData[],
+  T: number,
+  options: TemperatureFilterOptions = {},
+): PhaseData[] {
+  const { interpolate, max_interpolation_gap } = {
+    ...DEFAULT_TEMP_FILTER_OPTIONS,
+    ...options,
+  }
+
+  return entries.flatMap((entry) => {
+    // No temp data - keep with static energy
+    if (!entry_has_temp_data(entry)) return [entry]
+
+    // Exact temperature match - use G(T)
+    // Set both energy and energy_per_atom so downstream formation energy
+    // calculations use the temperature-dependent value (not stale 0K energy_per_atom)
+    if (entry_has_temperature(entry, T)) {
+      // free_energies stores per-atom values (E_0K/atom + F_vib/atom),
+      // so energy is already per-atom — set both fields to the same value
+      const energy = get_energy_at_temperature(entry, T)
+      return [{ ...entry, energy, energy_per_atom: energy }]
+    }
+
+    // Try interpolation if enabled
+    if (interpolate) {
+      const energy = interpolate_energy_at_temperature(entry, T, max_interpolation_gap)
+      if (energy !== null) {
+        // interpolated energy is also per-atom (interpolated from per-atom free_energies)
+        return [{ ...entry, energy, energy_per_atom: energy }]
+      }
+    }
+
+    // Exclude entry (has temp data but can't get energy at T)
+    return []
+  })
+}
+
+// Gas-dependent chemical potential helpers
+
+// Analyze entries for gas-dependent elements (safe wrapper with optional config)
+// Returns information about which gases are relevant for the chemical system.
+export function safe_analyze_gas_data(
+  entries: PhaseData[],
+  config?: GasThermodynamicsConfig,
+): GasAnalysis {
+  if (!config?.enabled_gases?.length) {
+    return {
+      has_gas_dependent_elements: false,
+      gas_elements: [],
+      relevant_gases: [],
+    }
+  }
+  return _analyze_gas_data(entries, config)
+}
+
+// Apply gas chemical potential corrections to entries (safe wrapper with optional config)
+// This adjusts formation energies based on gas atmosphere conditions (T, P).
+// Should be applied after temperature filtering.
+export function safe_apply_gas_corrections(
+  entries: PhaseData[],
+  config: GasThermodynamicsConfig | undefined,
+  T: number,
+): PhaseData[] {
+  if (!config?.enabled_gases?.length) return entries
+  return _apply_gas_corrections(entries, config, T)
+}
+
+// Get gas-corrected entries in one call (consolidates analysis + correction)
+// Merges gas_pressures with config.pressures and applies corrections if the
+// chemical system contains gas-dependent elements. Returns original entries
+// if no gas config or no relevant gases.
+export function get_gas_corrected_entries(
+  entries: PhaseData[],
+  gas_config: GasThermodynamicsConfig | undefined,
+  gas_pressures: Partial<Record<string, number>>,
+  temperature: number,
+): {
+  entries: PhaseData[]
+  analysis: GasAnalysis
+  merged_config: GasThermodynamicsConfig | undefined
+} {
+  if (!gas_config?.enabled_gases?.length) {
+    return {
+      entries,
+      analysis: {
+        has_gas_dependent_elements: false,
+        gas_elements: [],
+        relevant_gases: [],
+      },
+      merged_config: undefined,
+    }
+  }
+
+  const merged_config: GasThermodynamicsConfig = {
+    ...gas_config,
+    pressures: { ...gas_config.pressures, ...gas_pressures },
+  }
+  const analysis = _analyze_gas_data(entries, merged_config)
+
+  if (!analysis.has_gas_dependent_elements) {
+    return { entries, analysis, merged_config }
+  }
+
+  return {
+    entries: _apply_gas_corrections(entries, merged_config, temperature),
+    analysis,
+    merged_config,
+  }
+}
+
+// Derive a display label for a convex hull entry, falling back to composition
+// when reduced_formula and name are both missing.
+export function get_entry_label(
+  entry: { reduced_formula?: string; name?: string; composition: Record<string, number> },
+  elements?: ElementSymbol[],
+): string {
+  if (entry.reduced_formula) return entry.reduced_formula
+  if (entry.name) return entry.name
+  let pairs = Object.entries(entry.composition).filter(([, amt]) => amt > 0)
+  if (elements) {
+    pairs = pairs.sort(
+      ([el1], [el2]) =>
+        elements.indexOf(el1 as ElementSymbol) - elements.indexOf(el2 as ElementSymbol),
+    )
+  }
+  return pairs
+    .map(([el, amt]) => (Math.abs(amt - 1) < 1e-6 ? el : `${el}${format_num(amt, `.2~`)}`))
+    .join(``)
+}