matterviz 0.3.5 → 0.3.6

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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,397 @@
+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

@@ -0,0 +1,38 @@
+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
+}