matterviz 0.3.6 → 0.4.0

package/dist/src/lib/xrd/broadening.ts

@@ -1,130 +0,0 @@
-import type { XrdPattern } from './index'
-
-const LOG_2 = Math.log(2)
-
-// Broadening parameters for simulated XRD pattern.
-// U, V, W are Caglioti parameters.
-// shape_factor (eta) is the Pseudo-Voigt mixing parameter (0 = Gaussian, 1 = Lorentzian).
-export type BroadeningParams = {
-  U: number
-  V: number
-  W: number
-  shape_factor: number
-}
-
-export const DEFAULT_BROADENING: BroadeningParams = {
-  U: 0.04,
-  V: -0.02,
-  W: 0.02,
-  shape_factor: 0.5, // Mixed Gaussian/Lorentzian
-}
-
-// Calculates the Full Width at Half Maximum (FWHM) at a given theta angle
-// using the Caglioti formula: FWHM^2 = U * tan^2(theta) + V * tan(theta) + W
-export function caglioti_fwhm(
-  two_theta: number, // Angle in degrees (2θ)
-  U: number, // Caglioti parameter U
-  V: number, // Caglioti parameter V
-  W: number, // Caglioti parameter W
-): number {
-  // FWHM in degrees (2θ)
-  const theta_rad = (two_theta / 2) * (Math.PI / 180)
-  const tan_theta = Math.tan(theta_rad)
-  const fwhm_sq = U * tan_theta ** 2 + V * tan_theta + W
-  // Ensure non-negative squared width
-  return Math.sqrt(Math.max(1e-9, fwhm_sq))
-}
-
-// Normalized Gaussian profile. x: position, x0: peak center, fwhm: Full Width at Half Maximum
-function gaussian(x: number, x0: number, fwhm: number): number {
-  // Intensity at x
-  const safe_fwhm = Math.max(fwhm, 1e-9)
-  const sigma = safe_fwhm / (2 * Math.sqrt(2 * LOG_2))
-  const prefactor = 1 / (sigma * Math.sqrt(2 * Math.PI))
-  const exponent = -((x - x0) ** 2) / (2 * sigma ** 2)
-  return prefactor * Math.exp(exponent)
-}
-
-// Normalized Lorentzian profile. x: position, x0: peak center, fwhm: Full Width at Half Maximum
-function lorentzian(x: number, x0: number, fwhm: number): number {
-  // Intensity at x
-  const safe_fwhm = Math.max(fwhm, 1e-9)
-  const gamma = safe_fwhm / 2
-  const prefactor = 1 / (Math.PI * gamma)
-  const denominator = 1 + ((x - x0) / gamma) ** 2
-  return prefactor / denominator
-}
-
-// Pseudo-Voigt profile (linear combination of Gaussian and Lorentzian).
-export function pseudo_voigt(
-  x: number, // Position
-  x0: number, // Peak center
-  fwhm: number, // Full Width at Half Maximum
-  eta: number, // Mixing parameter (0 = Gaussian, 1 = Lorentzian)
-): number {
-  // Intensity at x
-  // Clamp eta to [0, 1]
-  const safe_eta = Math.max(0, Math.min(1, eta))
-  return safe_eta * lorentzian(x, x0, fwhm) + (1 - safe_eta) * gaussian(x, x0, fwhm)
-}
-
-// Computes a broadened XRD pattern from discrete peaks.
-export function compute_broadened_pattern(
-  pattern: XrdPattern, // Discrete XRD pattern (peaks)
-  params: BroadeningParams, // Broadening parameters (U, V, W, shape_factor)
-  range: [number, number], // Angular range [min, max] in degrees
-  step_size: number = 0.02, // Step size in degrees (default 0.02)
-): XrdPattern {
-  // Continuous broadened pattern
-  if (!Number.isFinite(step_size) || step_size <= 0) {
-    throw new Error(`step_size must be > 0 and finite`)
-  }
-
-  const [min_angle, max_angle] = range
-  if (!Number.isFinite(min_angle) || !Number.isFinite(max_angle) || max_angle <= min_angle) {
-    throw new Error(`range must be finite and max > min`)
-  }
-
-  const { U, V, W, shape_factor } = params
-
-  // Create x grid
-  const n_steps = Math.ceil((max_angle - min_angle) / step_size)
-  const xs = new Float32Array(n_steps)
-  const ys = new Float32Array(n_steps)
-
-  for (let idx = 0; idx < n_steps; idx++) {
-    xs[idx] = min_angle + idx * step_size
-  }
-
-  const { x: peak_pos, y: peak_int } = pattern
-
-  // Optimization: Process each peak and add to grid
-  for (let peak_idx = 0; peak_idx < peak_pos.length; peak_idx++) {
-    const x0 = peak_pos[peak_idx]
-    const intensity = peak_int[peak_idx]
-
-    // Skip negligible peaks
-    if (intensity < 1e-5) continue
-    // Skip peaks outside range (with some buffer)
-    if (x0 < min_angle - 5 || x0 > max_angle + 5) continue
-
-    const fwhm = caglioti_fwhm(x0, U, V, W)
-
-    // Define window for calculation (e.g. +/- 10 * FWHM or fixed reasonable range)
-    // Lorentzian tails are long, so we need a decent window.
-    // 20 * FWHM is usually sufficient for visual purposes.
-    const window = 20 * fwhm
-    const start_idx = Math.max(0, Math.floor((x0 - window - min_angle) / step_size))
-    const end_idx = Math.min(n_steps - 1, Math.ceil((x0 + window - min_angle) / step_size))
-
-    for (let idx = start_idx; idx <= end_idx; idx++) {
-      const x = xs[idx]
-      ys[idx] += intensity * pseudo_voigt(x, x0, fwhm, shape_factor)
-    }
-  }
-
-  // Convert back to number[]
-  // We don't map hkls to continuous profile points usually,
-  // or we could try to map them to the nearest peak, but for now leave undefined.
-  return { x: Array.from(xs), y: Array.from(ys) }
-}

package/dist/src/lib/xrd/calc-xrd.ts

@@ -1,397 +0,0 @@
-import type { CompositionType } from '$lib/composition'
-import type { ElementSymbol } from '$lib/element'
-import { element_data } from '$lib/element'
-import * as math from '$lib/math'
-import type { Crystal } from '$lib/structure/index'
-import { parse_any_structure } from '$lib/structure/parse'
-import { is_crystal } from '$lib/structure/validation'
-// Single source of truth for atomic scattering params
-import ATOMIC_SCATTERING_PARAMS from './atomic_scattering_params.json' with { type: 'json' }
-import type { Hkl, HklObj, PatternEntry, RecipPoint, XrdOptions, XrdPattern } from './index'
-import { is_xrd_data_file, parse_xrd_file } from './parse'
-
-// JSON import yields Record<string, number[][]>; type for element-keyed scattering params
-type ScatteringParamsRecord = Partial<
-  Record<ElementSymbol, number[][] | { a: number[]; b: number[]; c?: number }>
->
-
-// XRD wavelengths in Angstrom (Å)
-export const WAVELENGTHS = {
-  CuKa: 1.54184,
-  CuKa2: 1.54439,
-  CuKa1: 1.54056,
-  CuKb1: 1.39222,
-  MoKa: 0.71073,
-  MoKa2: 0.71359,
-  MoKa1: 0.7093,
-  MoKb1: 0.63229,
-  CrKa: 2.291,
-  CrKa2: 2.29361,
-  CrKa1: 2.2897,
-  CrKb1: 2.08487,
-  FeKa: 1.93735,
-  FeKa2: 1.93998,
-  FeKa1: 1.93604,
-  FeKb1: 1.75661,
-  CoKa: 1.79026,
-  CoKa2: 1.79285,
-  CoKa1: 1.78896,
-  CoKb1: 1.63079,
-  AgKa: 0.560885,
-  AgKa2: 0.563813,
-  AgKa1: 0.559421,
-  AgKb1: 0.497082,
-} as const
-
-export type RadiationKey = keyof typeof WAVELENGTHS
-
-// Type guard to safely check if a string is a valid RadiationKey
-const is_radiation_key = (key: string): key is RadiationKey => key in WAVELENGTHS
-
-// Tolerances from pymatgen.analysis.diffraction.core
-const TWO_THETA_TOL = 1e-5
-const SCALED_INTENSITY_TOL = 1e-3
-
-const ELEMENT_Z = Object.fromEntries(
-  element_data.map((entry) => [entry.symbol, entry.number]),
-) as CompositionType
-
-function get_unique_families(hkls: Hkl[]): Map<string, number> {
-  // Port of pymatgen's get_unique_families: group Miller indices by absolute-value permutations
-  const key_map = new Map<string, Hkl[]>()
-  for (const hkl of hkls) {
-    const abs_sorted = hkl.map((val) => Math.abs(val)).sort((x, y) => x - y)
-    const key = abs_sorted.join(`,`)
-    const list = key_map.get(key)
-    if (list) list.push(hkl)
-    else key_map.set(key, [hkl])
-  }
-  // Choose representative with max tuple (lexicographic) like numpy max(val)
-  const family_map = new Map<string, number>()
-  for (const group of key_map.values()) {
-    let representative: Hkl = group[0]
-    for (const candidate of group) {
-      const better =
-        candidate[0] > representative[0] ||
-        (candidate[0] === representative[0] &&
-          (candidate[1] > representative[1] ||
-            (candidate[1] === representative[1] && candidate[2] > representative[2])))
-      if (better) representative = candidate
-    }
-    family_map.set(representative.join(`,`), group.length)
-  }
-  return family_map
-}
-
-function compute_reciprocal_lattice_rows(structure: Crystal): number[][] {
-  // For row-wise lattice matrix A (rows are a, b, c), reciprocal rows are inv(A)^T
-  const direct = structure.lattice.matrix
-  const inv = math.matrix_inverse_3x3(direct)
-  const recip = math.transpose_3x3_matrix(inv)
-  return recip
-}
-
-function enumerate_reciprocal_points(
-  recip_rows: number[][],
-  max_radius: number,
-  min_radius: number,
-): RecipPoint[] {
-  const recip_b1 = recip_rows[0]
-  const recip_b2 = recip_rows[1]
-  const recip_b3 = recip_rows[2]
-  const n1 = Math.max(Math.hypot(...recip_b1), 1e-12)
-  const n2 = Math.max(Math.hypot(...recip_b2), 1e-12)
-  const n3 = Math.max(Math.hypot(...recip_b3), 1e-12)
-  const h_max = Math.ceil(max_radius / n1 + 2)
-  const k_max = Math.ceil(max_radius / n2 + 2)
-  const l_max = Math.ceil(max_radius / n3 + 2)
-  // Safety cap to avoid pathological enumeration volume
-  const CAP = 512
-  if (Math.max(h_max, k_max, l_max) > CAP) {
-    throw new Error(`enumerate_reciprocal_points: max(h,k,l) exceeds cap ${CAP}`)
-  }
-
-  const points: RecipPoint[] = []
-  for (let h_idx = -h_max; h_idx <= h_max; h_idx++) {
-    for (let k_idx = -k_max; k_idx <= k_max; k_idx++) {
-      for (let l_idx = -l_max; l_idx <= l_max; l_idx++) {
-        if (h_idx === 0 && k_idx === 0 && l_idx === 0) continue
-        const h_mul_b1 = math.scale(recip_b1, h_idx)
-        const k_mul_b2 = math.scale(recip_b2, k_idx)
-        const l_mul_b3 = math.scale(recip_b3, l_idx)
-        const g_vec = math.add(h_mul_b1, k_mul_b2, l_mul_b3)
-        const g_norm = Math.hypot(...g_vec)
-        if (g_norm < min_radius || g_norm > max_radius) continue
-        points.push({ hkl: [h_idx, k_idx, l_idx], g_norm })
-      }
-    }
-  }
-  // Sort by (g_norm asc, -h, -k, -l) to mimic pymatgen ordering
-  points.sort((p1, p2) =>
-    p1.g_norm !== p2.g_norm
-      ? p1.g_norm - p2.g_norm
-      : p2.hkl[0] !== p1.hkl[0]
-        ? p2.hkl[0] - p1.hkl[0]
-        : p2.hkl[1] !== p1.hkl[1]
-          ? p2.hkl[1] - p1.hkl[1]
-          : p2.hkl[2] - p1.hkl[2],
-  )
-  return points
-}
-
-export function compute_xrd_pattern(structure: Crystal, options: XrdOptions = {}): XrdPattern {
-  const wl_input = options.wavelength ?? `CuKa`
-  let wavelength: number
-  if (typeof wl_input === `number`) {
-    if (!Number.isFinite(wl_input) || wl_input <= 0) {
-      throw new Error(`Invalid wavelength: ${wl_input}. Must be a finite positive number.`)
-    }
-    wavelength = wl_input
-  } else {
-    if (!is_radiation_key(wl_input)) {
-      throw new Error(`Unknown radiation key: ${wl_input}`)
-    }
-    wavelength = WAVELENGTHS[wl_input]
-  }
-
-  // Symmetry refinement (symprec > 0) is not implemented in TS version.
-  // Option retained for API parity.
-  // const symprec = options.symprec ?? 0
-
-  const recip_rows = compute_reciprocal_lattice_rows(structure)
-
-  // Bragg condition bounds: reciprocal vector length r = 2 sin(theta) / lambda
-  const two_theta_range =
-    options.two_theta_range === null ? null : (options.two_theta_range ?? [0, 180])
-  const [min_radius, max_radius] =
-    two_theta_range === null
-      ? [0, 2 / wavelength]
-      : (([t_min, t_max]: [number, number]) => {
-          const r_min = (2 * Math.sin((t_min / 2) * (Math.PI / 180))) / wavelength
-          const r_max = (2 * Math.sin((t_max / 2) * (Math.PI / 180))) / wavelength
-          return [r_min, r_max]
-        })(two_theta_range)
-
-  const recip_points = enumerate_reciprocal_points(recip_rows, max_radius, min_radius)
-
-  // Flatten species with occupancies; gather coeffs, frac coords, occu, DW factors.
-  type ScatteringCoeffs = { a: number[]; b: number[]; c?: number }
-  const coeffs: ScatteringCoeffs[] = []
-  const frac_coords: math.Vec3[] = []
-  const occus: number[] = []
-  const dw_factors: number[] = []
-
-  const debye_waller_factors = options.debye_waller_factors ?? {}
-
-  for (const site of structure.sites) {
-    for (const species of site.species) {
-      const element_symbol = species.element
-      if (ELEMENT_Z[element_symbol] === undefined) {
-        throw new Error(`Unknown atomic number for element ${element_symbol}`)
-      }
-      const raw_coeff = (ATOMIC_SCATTERING_PARAMS as ScatteringParamsRecord)[element_symbol]
-      if (!raw_coeff) {
-        throw new Error(
-          `No atomic scattering coefficients for ${element_symbol}. Extend ATOMIC_SCATTERING_PARAMS.`,
-        )
-      }
-      let coeff_entry: ScatteringCoeffs
-      if (Array.isArray(raw_coeff)) {
-        const a_arr = raw_coeff.map(([a]) => a)
-        const b_arr = raw_coeff.map(([_, b]) => b)
-        coeff_entry = { a: a_arr, b: b_arr }
-      } else {
-        coeff_entry = { a: raw_coeff.a.slice(), b: raw_coeff.b.slice(), c: raw_coeff.c }
-      }
-      coeffs.push(coeff_entry)
-      frac_coords.push(site.abc)
-      occus.push(species.occu)
-      dw_factors.push(debye_waller_factors[element_symbol] ?? 0)
-    }
-  }
-
-  // Accumulate peaks by merging two_thetas within tolerance
-  const peaks = new Map<number, { intensity: number; hkls: Hkl[]; d_hkl: number }>()
-  const two_thetas: number[] = []
-  const merge_tol = options.peak_merge_tol ?? TWO_THETA_TOL
-  const scaled_tol = options.scaled_intensity_tol ?? SCALED_INTENSITY_TOL
-
-  for (const entry of recip_points) {
-    const hkl = entry.hkl
-    const g_norm = entry.g_norm
-    if (g_norm === 0) continue
-
-    const asin_arg = (wavelength * g_norm) / 2
-    // asin domain can exceed 1 by FP error — clamp to avoid NaN
-    const clamped_asin_arg = Math.min(1, Math.max(-1, asin_arg))
-    const theta = Math.asin(clamped_asin_arg)
-    const sin_theta_over_lambda = g_norm / 2
-    const sin_theta_over_lambda_sq = sin_theta_over_lambda * sin_theta_over_lambda
-
-    // g.r for all fractional coords
-    const g_dot_r_all = frac_coords.map((frac_coord) => math.dot(frac_coord, hkl))
-
-    // Atomic scattering factors (vectorized style)
-    const f_scattering: number[] = coeffs.map((coeff_entry) => {
-      const { a: a_arr, b: b_arr } = coeff_entry
-      const num_terms = Math.min(a_arr.length, b_arr.length)
-      const sum_terms = a_arr
-        .slice(0, num_terms)
-        .reduce(
-          (sum, a_i, term_idx) =>
-            sum + a_i * Math.exp(-b_arr[term_idx] * sin_theta_over_lambda_sq),
-          0,
-        )
-      return sum_terms + (coeff_entry.c ?? 0)
-    })
-
-    const dw_corr: number[] = dw_factors.map((dw_b) =>
-      Math.exp(-dw_b * sin_theta_over_lambda_sq),
-    )
-
-    // Structure factor sum: sum(fs * occu * exp(2πi g·r) * DW)
-    const { real: f_real, imag: f_imag } = f_scattering.reduce(
-      (acc, fs, idx) => {
-        const phase = 2 * Math.PI * g_dot_r_all[idx]
-        const weight = fs * occus[idx] * dw_corr[idx]
-        const real = acc.real + weight * Math.cos(phase)
-        const imag = acc.imag + weight * Math.sin(phase)
-        return { real, imag }
-      },
-      { real: 0, imag: 0 },
-    )
-
-    const sin_theta = Math.sin(theta)
-    const cos_theta = Math.cos(theta)
-    const denom_raw = sin_theta * sin_theta * Math.abs(cos_theta)
-    // Clamp denominator away from zero to avoid Inf/NaN when 2θ → 180° (cosθ → 0)
-    const denom = Math.max(denom_raw, 1e-12)
-    const lorentz = (1 + Math.cos(2 * theta) ** 2) / denom
-    const intensity_hkl = (f_real * f_real + f_imag * f_imag) * lorentz
-    const two_theta = math.to_degrees(2 * theta)
-
-    // Use (h, k, l) always. For hexagonal systems, pymatgen presents Miller–Bravais (h, k, i, l),
-    // but downstream components expect 3-index HKL. Keep 3-index form to match types/consumers.
-    const hkl_to_store: Hkl = [hkl[0], hkl[1], hkl[2]]
-
-    // Merge peaks within tolerance
-    let found_index: number | null = null
-    for (let idx = 0; idx < two_thetas.length; idx++) {
-      if (Math.abs(two_thetas[idx] - two_theta) < merge_tol) {
-        found_index = idx
-        break
-      }
-    }
-
-    if (found_index !== null) {
-      const key = two_thetas[found_index]
-      const item = peaks.get(key)
-      if (item) {
-        item.intensity += intensity_hkl
-        item.hkls.push(hkl_to_store)
-      }
-    } else {
-      const d_hkl = 1 / g_norm
-      peaks.set(two_theta, { intensity: intensity_hkl, hkls: [hkl_to_store], d_hkl })
-      two_thetas.push(two_theta)
-    }
-  }
-
-  if (peaks.size === 0) return { x: [], y: [] }
-
-  // Scale intensities so that the max intensity is 100, and filter by scaled tol
-  const max_intensity = Math.max(...Array.from(peaks.values()).map((peak) => peak.intensity))
-
-  const xs: number[] = []
-  const ys: number[] = []
-  const hkls_out: HklObj[][] = []
-  const d_out: number[] = []
-
-  const sorted_two_thetas = Array.from(peaks.keys()).sort((a, b) => a - b)
-  for (const angle of sorted_two_thetas) {
-    const item = peaks.get(angle)
-    if (!item) continue
-    const scaled_val = (item.intensity / max_intensity) * 100
-    if (scaled_val > scaled_tol) {
-      xs.push(angle)
-      ys.push(item.intensity)
-      const fam = get_unique_families(item.hkls)
-      const fam_array: HklObj[] = []
-      for (const [repr_key, multiplicity] of fam.entries()) {
-        const repr = repr_key.split(`,`).map((num_str) => parseInt(num_str, 10)) as Hkl
-        fam_array.push({ hkl: repr, multiplicity })
-      }
-      hkls_out.push(fam_array)
-      d_out.push(item.d_hkl)
-    }
-  }
-
-  // Final scaling if requested
-  if (options.scaled ?? true) {
-    const max_y = Math.max(1, ...ys)
-    for (let idx = 0; idx < ys.length; idx++) ys[idx] = (ys[idx] / max_y) * 100
-  }
-
-  return { x: xs, y: ys, hkls: hkls_out, d_hkls: d_out }
-}
-
-// Process dropped file content and return an XRD pattern.
-// Supports both direct XRD data files (.xy, .brml) and structure files
-// (which are used to compute theoretical XRD patterns).
-export async function add_xrd_pattern(
-  content: string | ArrayBufferLike, // File content as string or ArrayBuffer
-  filename: string, // Name of the file (used to detect format)
-  wavelength: number | null, // X-ray wavelength for structure-based XRD calculation
-): Promise<{ pattern?: PatternEntry; error?: string }> {
-  // Object with pattern entry or error message
-  try {
-    // Check if file is a direct XRD data file (.xy, .brml)
-    if (is_xrd_data_file(filename)) {
-      // Convert ArrayBufferLike to ArrayBuffer if needed (handles SharedArrayBuffer)
-      let buffer_content: string | ArrayBuffer
-      if (typeof content === `string`) {
-        buffer_content = content
-      } else {
-        buffer_content =
-          content instanceof ArrayBuffer ? content : new Uint8Array(content).slice().buffer
-      }
-      const pattern = await parse_xrd_file(buffer_content, filename)
-      if (pattern && pattern.x.length > 0) {
-        return { pattern: { label: filename || `XRD data`, pattern } }
-      }
-      // Get base extension (strip .gz if present) for error message
-      const base_name = filename.toLowerCase().replace(/\.gz$/, ``)
-      const ext = base_name.split(`.`).pop()?.toUpperCase() || `XRD`
-      const format_hints: Record<string, string> = {
-        XY: `Expected 2-column format: "2theta intensity" (space/tab/comma separated)`,
-        XYE: `Expected 3-column format: "2theta intensity error" (space/tab/comma separated)`,
-        BRML: `Expected Bruker RAW/BRML ZIP archive with RawData XML`,
-        XRDML: `Expected PANalytical XRDML format with dataPoints section`,
-      }
-      const hint = format_hints[ext] || `Check file format and encoding`
-      return { error: `Failed to parse ${ext} file: no valid data found. ${hint}` }
-    }
-
-    // Otherwise, try to parse as a structure file and compute XRD pattern
-    const text_content =
-      typeof content === `string` ? content : new TextDecoder().decode(content as BufferSource)
-    const parsed_structure = parse_any_structure(text_content, filename)
-    if (is_crystal(parsed_structure)) {
-      const pattern = compute_xrd_pattern(parsed_structure, {
-        wavelength: typeof wavelength === `number` ? wavelength : undefined,
-      })
-      return { pattern: { label: filename || `Dropped structure`, pattern } }
-    }
-    return {
-      error:
-        `Cannot compute XRD: structure must have a lattice and atomic sites. ` +
-        `Supported formats: CIF, POSCAR, JSON, XYZ`,
-    }
-  } catch (exc) {
-    return {
-      error: `Failed to compute XRD pattern: ${exc instanceof Error ? exc.message : String(exc)}`,
-    }
-  }
-}
-
-export const AVAILABLE_RADIATION = Object.keys(WAVELENGTHS) as RadiationKey[]

package/dist/src/lib/xrd/index.ts

@@ -1,38 +0,0 @@
-import type { CompositionType } from '$lib/composition'
-import type { Vec3 } from '$lib/math'
-import type { RadiationKey } from './calc-xrd'
-export * from './broadening'
-export * from './calc-xrd'
-export * from './parse'
-export { default as XrdPlot } from './XrdPlot.svelte'
-
-export type Hkl = Vec3
-export type HklObj = { hkl: Hkl; multiplicity?: number }
-export type RecipPoint = { hkl: Hkl; g_norm: number }
-export type HklFormat = `compact` | `full` | null
-
-export type XrdPattern = {
-  x: number[]
-  y: number[]
-  hkls?: HklObj[][]
-  d_hkls?: number[]
-}
-
-export type XrdOptions = {
-  wavelength?: number | RadiationKey
-  symprec?: number
-  debye_waller_factors?: CompositionType
-  scaled?: boolean
-  // When null, treat as unbounded up to 2/λ (Bragg maximum); when omitted, default [0, 180]
-  two_theta_range?: [number, number] | null
-  // Merge tolerance for peaks in degrees (default = TWO_THETA_TOL)
-  peak_merge_tol?: number
-  // Scaled intensity threshold (% of max) to include a peak (default = SCALED_INTENSITY_TOL)
-  scaled_intensity_tol?: number
-}
-
-export interface PatternEntry {
-  label: string
-  pattern: XrdPattern
-  color?: string
-}