matterviz 0.3.6 → 0.4.0

package/dist/src/lib/trajectory/parse/index.ts

@@ -1,411 +0,0 @@
-// Parsing functions for trajectory data from various formats
-import type { ElementSymbol } from '$lib/element/types'
-import { is_binary } from '$lib/io/is-binary'
-import type { Vec3 } from '$lib/math'
-import * as math from '$lib/math'
-import type { AnyStructure } from '$lib/structure/index'
-import { parse_xyz } from '$lib/structure/parse'
-import { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD } from '$lib/trajectory/constants'
-import {
-  FORMAT_PATTERNS,
-  is_trajectory_file,
-  strip_compression_extensions,
-} from '$lib/trajectory/format-detect'
-import { TrajFrameReader } from '$lib/trajectory/frame-reader'
-import { create_trajectory_frame, validate_3x3_matrix } from '$lib/trajectory/helpers'
-import type {
-  FrameLoader,
-  ParseProgress,
-  TrajectoryFrame,
-  TrajectoryMetadata,
-  TrajectoryType,
-} from '$lib/trajectory/index'
-import type { AtomTypeMapping, LoadingOptions } from '$lib/trajectory/types'
-import { parse_ase_trajectory } from './ase'
-import { parse_torch_sim_hdf5 } from './hdf5'
-import { parse_lammps_trajectory } from './lammps'
-import { parse_vasp_xdatcar } from './vasp'
-import { parse_xyz_trajectory } from './xyz'
-
-// Silently swallow expected parse fallbacks — the caller throws if ALL formats fail
-const log_parse_debug = (_message: string, _error: unknown): void => {}
-
-// Re-export constants and types for consumers
-export {
-  INDEX_SAMPLE_RATE,
-  LARGE_FILE_THRESHOLD,
-  MAX_BIN_FILE_SIZE,
-  MAX_METADATA_SIZE,
-  MAX_SAFE_STRING_LENGTH,
-  MAX_TEXT_FILE_SIZE,
-} from '$lib/trajectory/constants'
-export type { AtomTypeMapping, LoadingOptions } from '$lib/trajectory/types'
-export { is_trajectory_file, TrajFrameReader }
-
-export async function parse_trajectory_data(
-  data: unknown,
-  filename?: string,
-  atom_type_mapping?: AtomTypeMapping,
-): Promise<TrajectoryType> {
-  if (data instanceof ArrayBuffer) {
-    if (FORMAT_PATTERNS.ase(data, filename)) return parse_ase_trajectory(data, filename)
-    if (FORMAT_PATTERNS.hdf5(data, filename)) return parse_torch_sim_hdf5(data, filename)
-    throw new Error(`Unsupported binary format${filename ? `: ${filename}` : ``}`)
-  }
-
-  if (typeof data === `string`) {
-    const content = data.trim()
-    if (FORMAT_PATTERNS.xyz_multi(content, filename)) return parse_xyz_trajectory(content)
-    if (FORMAT_PATTERNS.vasp(content, filename)) {
-      return parse_vasp_xdatcar(content, filename)
-    }
-    if (FORMAT_PATTERNS.lammpstrj(content, filename)) {
-      return parse_lammps_trajectory(content, filename, atom_type_mapping)
-    }
-
-    // Single XYZ fallback
-    if (filename?.toLowerCase().match(/\.(?:xyz|extxyz)$/)) {
-      try {
-        const structure = parse_xyz(content)
-        if (structure) {
-          return {
-            frames: [{ structure, step: 0, metadata: {} }],
-            metadata: { source_format: `single_xyz`, frame_count: 1 },
-          }
-        }
-      } catch (error) {
-        // Single-frame XYZ parsing failed, continue to JSON parsing.
-        log_parse_debug(
-          `Single XYZ parse fallback failed for ${filename ?? `unknown file`}:`,
-          error,
-        )
-      }
-    }
-
-    try {
-      data = JSON.parse(content)
-    } catch (error) {
-      log_parse_debug(`JSON parse failed for ${filename ?? `unknown file`}:`, error)
-      throw new Error(`Unsupported text format`, { cause: error })
-    }
-  }
-
-  if (!data || typeof data !== `object`) throw new Error(`Invalid data format`)
-
-  // Handle JSON formats
-  if (Array.isArray(data)) {
-    const frames = data.map((frame_data, idx) => {
-      const frame_obj = frame_data as Record<string, unknown>
-      const frame_step = frame_obj.step
-      return {
-        structure: (frame_obj.structure || frame_obj) as AnyStructure,
-        step: typeof frame_step === `number` ? frame_step : idx,
-        metadata: (frame_obj.metadata as Record<string, unknown>) || {},
-      }
-    })
-    return { frames, metadata: { source_format: `array`, frame_count: frames.length } }
-  }
-
-  const obj = data as Record<string, unknown>
-
-  // Pymatgen format
-  if (obj[`@class`] === `Trajectory` && obj.species && obj.coords && obj.lattice) {
-    const species = obj.species as { element: ElementSymbol }[]
-    const frame_elements = species.map((specie) => specie.element)
-    const coords = obj.coords as number[][][]
-    const matrix = validate_3x3_matrix(obj.lattice)
-    const frame_properties = (obj.frame_properties as Record<string, unknown>[]) || []
-    const frac_to_cart = math.create_frac_to_cart(matrix)
-
-    const frames = coords.map((frame_coords, idx) => {
-      const positions = frame_coords.map((abc) => frac_to_cart(abc as Vec3))
-
-      // Process frame properties to extract numpy arrays
-      const raw_properties = frame_properties[idx] || {}
-      const processed_properties: Record<string, unknown> = {}
-
-      Object.entries(raw_properties).forEach(([key, value]) => {
-        if (
-          value &&
-          typeof value === `object` &&
-          (value as Record<string, unknown>)[`@class`] === `array`
-        ) {
-          // Extract numpy array data
-          const array_obj = value as Record<string, unknown>
-          processed_properties[key] = array_obj.data
-
-          // Calculate force statistics for forces
-          if (key === `forces` && Array.isArray(array_obj.data)) {
-            const forces = array_obj.data as number[][]
-            const force_magnitudes = forces.map((force) => Math.hypot(...force))
-            if (force_magnitudes.length > 0) {
-              processed_properties.force_max = force_magnitudes.reduce(
-                (max_val, magnitude) => (magnitude > max_val ? magnitude : max_val),
-                force_magnitudes[0],
-              )
-              processed_properties.force_norm = Math.sqrt(
-                force_magnitudes.reduce((sum, f) => sum + f ** 2, 0) / force_magnitudes.length,
-              )
-            }
-          }
-
-          // Calculate stress statistics for stress tensor
-          if (key === `stress` && Array.isArray(array_obj.data)) {
-            const stress_tensor = array_obj.data
-            if (!math.is_square_matrix(stress_tensor, 3)) {
-              console.warn(`Invalid stress tensor structure in frame ${idx}`)
-            } else {
-              // Calculate stress components (diagonal elements represent normal stresses)
-              const normal_stresses = [
-                stress_tensor[0][0],
-                stress_tensor[1][1],
-                stress_tensor[2][2],
-              ]
-              processed_properties.stress_max = Math.max(...normal_stresses.map(Math.abs))
-              // Calculate hydrostatic pressure (negative of mean normal stress)
-              processed_properties.pressure =
-                -(normal_stresses[0] + normal_stresses[1] + normal_stresses[2]) / 3
-            }
-          }
-        } else {
-          processed_properties[key] = value
-        }
-      })
-
-      return create_trajectory_frame(
-        positions,
-        frame_elements,
-        matrix,
-        [true, true, true],
-        idx,
-        processed_properties,
-      )
-    })
-
-    return {
-      frames,
-      metadata: {
-        filename,
-        source_format: `pymatgen_trajectory`,
-        frame_count: frames.length,
-        species_list: [...new Set(species.map((specie) => specie.element))],
-        periodic_boundary_conditions: [true, true, true],
-      },
-    }
-  }
-
-  // Object with frames
-  if (Array.isArray(obj.frames)) {
-    const metadata = (obj.metadata ?? {}) as Record<string, unknown>
-    return {
-      frames: obj.frames as TrajectoryFrame[],
-      metadata: { ...metadata, source_format: `object_with_frames` },
-    }
-  }
-
-  // Single structure
-  if (obj.sites) {
-    return {
-      frames: [{ structure: obj as AnyStructure, step: 0, metadata: {} }],
-      metadata: { source_format: `single_structure`, frame_count: 1 },
-    }
-  }
-
-  throw new Error(`Unrecognized trajectory format`)
-}
-
-export function get_unsupported_format_message(
-  filename: string,
-  content: string,
-): string | null {
-  const lower = filename.toLowerCase()
-
-  // Check for unsupported compression formats first
-  const unsupported_compression = [
-    { ext: `.bz2`, name: `BZ2` },
-    { ext: `.xz`, name: `XZ` },
-    { ext: `.zip`, name: `ZIP` },
-  ]
-  for (const { ext, name } of unsupported_compression) {
-    if (lower.endsWith(ext)) {
-      return `🚫 ${name} compression not supported in browser\nPlease decompress the file first`
-    }
-  }
-
-  // .dump files are LAMMPS binary dumps which require external tools to parse.
-  // .lammpstrj files are LAMMPS text-based trajectory files supported by parse_lammps_trajectory().
-  const formats = [
-    { extensions: [`.dump`], name: `LAMMPS binary dump`, tool: `pymatgen` },
-    { extensions: [`.nc`, `.netcdf`], name: `NetCDF`, tool: `MDAnalysis` },
-    { extensions: [`.dcd`], name: `DCD`, tool: `MDAnalysis` },
-  ]
-
-  for (const { extensions, name, tool } of formats) {
-    if (extensions.some((ext) => lower.endsWith(ext))) {
-      return `🚫 ${name} format not supported\nConvert with ${tool} first`
-    }
-  }
-
-  return is_binary(content)
-    ? `🚫 Binary format not supported${filename ? `: ${filename}` : ``}`
-    : null
-}
-
-// Unified async parser with streaming support
-export async function parse_trajectory_async(
-  data: ArrayBuffer | string,
-  filename: string,
-  on_progress?: (progress: ParseProgress) => void,
-  options: LoadingOptions = {},
-): Promise<TrajectoryType> {
-  const {
-    use_indexing,
-    index_sample_rate = INDEX_SAMPLE_RATE,
-    extract_plot_metadata = true,
-    atom_type_mapping,
-  } = options
-
-  const update_progress = (current: number, stage: string) =>
-    on_progress?.({ current, total: 100, stage })
-
-  try {
-    update_progress(0, `Detecting format...`)
-
-    const data_size =
-      data instanceof ArrayBuffer ? data.byteLength : new TextEncoder().encode(data).byteLength
-    const is_large_file = data_size > LARGE_FILE_THRESHOLD
-    const should_use_indexing = use_indexing ?? is_large_file
-
-    if (is_large_file) {
-      update_progress(5, `Large file detected (${Math.round(data_size / 1024 / 1024)}MB)`)
-    }
-
-    // Use indexed loading for supported large files (including compressed names).
-    const base_filename = strip_compression_extensions(filename)
-    if (should_use_indexing && /\.(xyz|extxyz|traj)$/.test(base_filename)) {
-      return await parse_with_unified_loader(
-        data,
-        filename,
-        {
-          index_sample_rate,
-          extract_plot_metadata,
-        },
-        on_progress,
-      )
-    }
-
-    // Fallback to direct parsing
-    update_progress(10, `Parsing trajectory...`)
-    const result = await parse_trajectory_data(data, filename, atom_type_mapping)
-
-    update_progress(100, `Complete`)
-    return result
-  } catch (error) {
-    const error_message = error instanceof Error ? error.message : `Unknown error`
-    update_progress(100, `Error: ${error_message}`)
-    throw error
-  }
-}
-
-// Unified frame loading using new TrajFrameReader
-async function parse_with_unified_loader(
-  data: string | ArrayBuffer,
-  filename: string,
-  options: { index_sample_rate: number; extract_plot_metadata: boolean },
-  on_progress?: (progress: ParseProgress) => void,
-): Promise<TrajectoryType> {
-  const { index_sample_rate, extract_plot_metadata } = options
-  const loader = new TrajFrameReader(filename)
-
-  on_progress?.({ current: 10, total: 100, stage: `Counting frames...` })
-  const total_frames = await loader.get_total_frames(data)
-
-  on_progress?.({ current: 20, total: 100, stage: `Building frame index...` })
-  const frame_index = await loader.build_frame_index(data, index_sample_rate, (progress) => {
-    const adjusted = 20 + (progress.current / 100) * 30
-    on_progress?.({
-      current: adjusted,
-      total: 100,
-      stage: `Building index: ${progress.stage}`,
-    })
-  })
-
-  on_progress?.({ current: 50, total: 100, stage: `Loading initial frames...` })
-  const initial_frame_count = Math.min(10, total_frames)
-  const frame_promises = Array.from({ length: initial_frame_count }, (_, idx) =>
-    loader.load_frame(data, idx),
-  )
-  const loaded_frames = await Promise.all(frame_promises)
-  const frames = loaded_frames.filter((frame): frame is TrajectoryFrame => frame !== null)
-
-  let plot_metadata: TrajectoryMetadata[] | undefined
-  if (extract_plot_metadata) {
-    on_progress?.({ current: 70, total: 100, stage: `Extracting plot metadata...` })
-    try {
-      plot_metadata = await loader.extract_plot_metadata(
-        data,
-        { sample_rate: 1 },
-        (progress) => {
-          const adjusted = 70 + (progress.current / 100) * 20
-          on_progress?.({
-            current: adjusted,
-            total: 100,
-            stage: `Extracting: ${progress.stage}`,
-          })
-        },
-      )
-    } catch (error) {
-      console.warn(`Failed to extract plot metadata:`, error)
-    }
-  }
-
-  const stage = `Ready: ${total_frames} frames indexed`
-  on_progress?.({ current: 100, total: 100, stage })
-  const source_format = filename.toLowerCase().endsWith(`.traj`)
-    ? `ase_trajectory`
-    : `xyz_trajectory`
-
-  return {
-    frames,
-    metadata: { source_format, frame_count: total_frames },
-    total_frames,
-    indexed_frames: frame_index,
-    plot_metadata,
-    is_indexed: true,
-    frame_loader: loader,
-  }
-}
-
-// Factory function for frame loader (simplified)
-export function create_frame_loader(filename: string): FrameLoader {
-  if (!/\.(xyz|extxyz|traj)$/.exec(filename.toLowerCase())) {
-    throw new Error(`Unsupported format for frame loading: ${filename}`)
-  }
-  return new TrajFrameReader(filename)
-}
-
-export async function load_binary_traj(
-  resp: Response,
-  type: string,
-  fallback = false,
-): Promise<ArrayBuffer | string> {
-  try {
-    // Read binary from a clone so the original can be used for text fallback
-    return await resp.clone().arrayBuffer()
-  } catch (binary_error) {
-    if (fallback) {
-      console.warn(`Binary load failed for ${type}, using text fallback:`, binary_error)
-      try {
-        return await resp.text()
-      } catch (text_error) {
-        const combined_error = new AggregateError(
-          [binary_error, text_error],
-          `Failed to load ${type} as binary or text`,
-        )
-        console.error(`Binary and text fallback both failed for ${type}:`, combined_error)
-        throw combined_error
-      }
-    }
-    throw new Error(`Failed to load ${type} as binary`, { cause: binary_error })
-  }
-}

package/dist/src/lib/trajectory/parse/lammps.ts

@@ -1,215 +0,0 @@
-// LAMMPS trajectory (.lammpstrj) parsing
-import type { ElementSymbol } from '$lib/element/types'
-import { ELEM_SYMBOLS } from '$lib/labels'
-import type { Vec3 } from '$lib/math'
-import * as math from '$lib/math'
-import type { Pbc } from '$lib/structure/pbc'
-import type { TrajectoryFrame, TrajectoryType } from '$lib/trajectory/index'
-import { coerce_element_symbol, create_trajectory_frame } from '$lib/trajectory/helpers'
-import type { AtomTypeMapping } from '$lib/trajectory/types'
-
-const is_periodic = (token: string): boolean => token.toLowerCase().startsWith(`p`)
-
-// Parse LAMMPS box bounds → lattice matrix. Handles orthogonal and triclinic boxes.
-// Triclinic: converts bounding box to actual dims per https://docs.lammps.org/Howto_triclinic.html
-// Lattice vectors: a=(lx,0,0), b=(xy,ly,0), c=(xz,yz,lz)
-export function parse_lammps_box(
-  box_lines: string[],
-  is_triclinic: boolean,
-): math.Matrix3x3 | null {
-  if (box_lines.length !== 3) return null
-  const bounds = box_lines.map((line) => line.split(/\s+/).map(Number))
-  const min_cols = is_triclinic ? 3 : 2
-  if (bounds.some((row) => row.length < min_cols || row.slice(0, min_cols).some(isNaN))) {
-    return null
-  }
-
-  if (!is_triclinic) {
-    // Orthogonal: bounds = [lo, hi] per dimension
-    const [[lo_x, hi_x], [lo_y, hi_y], [lo_z, hi_z]] = bounds
-    return [
-      [hi_x - lo_x, 0, 0],
-      [0, hi_y - lo_y, 0],
-      [0, 0, hi_z - lo_z],
-    ]
-  }
-  // Triclinic: bounds = [lo_bound, hi_bound, tilt] with tilts xy, xz, yz
-  const [[xlo_b, xhi_b, xy], [ylo_b, yhi_b, xz], [zlo_b, zhi_b, yz]] = bounds
-  const lx = xhi_b - Math.max(0, xy, xz, xy + xz) - (xlo_b - Math.min(0, xy, xz, xy + xz))
-  const ly = yhi_b - Math.max(0, yz) - (ylo_b - Math.min(0, yz))
-  const lz = zhi_b - zlo_b
-  return [
-    [lx, 0, 0],
-    [xy, ly, 0],
-    [xz, yz, lz],
-  ]
-}
-
-// Parse LAMMPS trajectory (.lammpstrj). Atom types mapped to elements via atom_type_mapping
-// or by default: 1→H, 2→He, etc. Supports orthogonal and triclinic simulation boxes.
-export function parse_lammps_trajectory(
-  content: string,
-  filename?: string,
-  atom_type_mapping?: AtomTypeMapping,
-): TrajectoryType {
-  const lines = content.trim().split(/\r?\n/)
-  const frames: TrajectoryFrame[] = []
-  const atom_types_found = new Set<number>()
-  let id_fallback_warning_emitted = false
-  let idx = 0
-
-  const read_line = (): string => lines[idx++]?.trim() ?? ``
-  const peek_line = (): string => lines[idx]?.trim() ?? ``
-  const skip_to = (prefix: string): boolean => {
-    while (idx < lines.length && !peek_line().startsWith(prefix)) idx++
-    return idx < lines.length
-  }
-
-  // Helper to map atom type to element symbol
-  const get_element = (atom_type: number): ElementSymbol => {
-    if (atom_type_mapping?.[atom_type]) return atom_type_mapping[atom_type]
-    return ELEM_SYMBOLS[Math.max(0, atom_type - 1) % ELEM_SYMBOLS.length]
-  }
-
-  while (idx < lines.length) {
-    if (!skip_to(`ITEM: TIMESTEP`)) break
-    idx++
-    const timestep = parseInt(read_line(), 10) || 0
-
-    if (!skip_to(`ITEM: NUMBER OF ATOMS`)) break
-    idx++
-    const num_atoms = parseInt(read_line(), 10)
-    if (!num_atoms || num_atoms <= 0) continue
-
-    // BOX BOUNDS: orthogonal="pp pp pp", triclinic="xy xz yz pp pp pp"
-    if (!skip_to(`ITEM: BOX BOUNDS`)) break
-    const box_header = read_line()
-    const is_triclinic = /BOX BOUNDS\s+xy\s+xz\s+yz/i.test(box_header)
-    const tokens = box_header.replace(`ITEM: BOX BOUNDS`, ``).trim().split(/\s+/).slice(-3)
-    const pbc: Pbc =
-      tokens.length === 3
-        ? [is_periodic(tokens[0]), is_periodic(tokens[1]), is_periodic(tokens[2])]
-        : [true, true, true]
-
-    const lattice_matrix = parse_lammps_box(
-      [read_line(), read_line(), read_line()],
-      is_triclinic,
-    )
-    if (!lattice_matrix) continue
-
-    // Find ITEM: ATOMS and parse column headers
-    if (!skip_to(`ITEM: ATOMS`)) break
-    const cols = read_line().replace(`ITEM: ATOMS`, ``).trim().toLowerCase().split(/\s+/)
-    const col = Object.fromEntries(cols.map((name, col_idx) => [name, col_idx]))
-
-    // Determine position columns: prefer unwrapped (xu/yu/zu) > scaled (xs/ys/zs) > regular (x/y/z)
-    const pos_keys = [`xu`, `yu`, `zu`].every((key) => key in col)
-      ? [`xu`, `yu`, `zu`]
-      : [`xs`, `ys`, `zs`].every((key) => key in col)
-        ? [`xs`, `ys`, `zs`]
-        : [`x`, `y`, `z`]
-    const pos_cols = pos_keys.map((key) => col[key])
-    // Atom identity: prefer numeric type, else explicit element symbol.
-    // Fallback to ID-based mapping only for legacy dumps; this can be inaccurate
-    // for large or non-element-like IDs, so prefer TYPE column when available.
-    const type_col = col.type
-    const element_col = col.element
-    const id_col = col.id
-    const use_scaled = pos_keys[0] === `xs`
-    const max_col_idx = Math.max(...pos_cols, type_col ?? -1, element_col ?? -1, id_col ?? -1)
-
-    if (pos_cols.some((col_idx) => col_idx === undefined)) continue
-    if (type_col === undefined && element_col === undefined && id_col === undefined) {
-      console.warn(
-        `Skipping LAMMPS frame at timestep ${timestep}: missing type/element/id column`,
-      )
-      continue
-    }
-
-    // Parse atom data
-    const positions: number[][] = []
-    const elements: ElementSymbol[] = []
-    const frac_to_cart = use_scaled ? math.create_frac_to_cart(lattice_matrix) : null
-
-    for (let atom = 0; atom < num_atoms && idx < lines.length; atom++) {
-      const parts = read_line().split(/\s+/)
-      const coords = pos_cols.map((col_idx) => parseFloat(parts[col_idx]))
-      if (coords.some(isNaN) || parts.length <= max_col_idx) continue
-
-      // Convert scaled coordinates to Cartesian if needed
-      const xyz = frac_to_cart ? frac_to_cart(coords as Vec3) : coords
-      let element_symbol: ElementSymbol | undefined
-
-      if (type_col !== undefined) {
-        // Map atom type to element using custom mapping or default (type 1 -> H, etc.)
-        const atom_type = parseInt(parts[type_col], 10) || 1
-        atom_types_found.add(atom_type)
-        element_symbol = get_element(atom_type)
-      } else if (element_col !== undefined) {
-        const raw_symbol = parts[element_col]
-        if (!raw_symbol) continue
-        element_symbol = coerce_element_symbol(raw_symbol)
-        if (!element_symbol) {
-          console.warn(
-            `Skipping LAMMPS atom with unknown element symbol "${raw_symbol}" at timestep ${timestep}`,
-          )
-          continue
-        }
-      } else if (id_col !== undefined) {
-        const atom_id = parseInt(parts[id_col], 10) || 1
-        atom_types_found.add(atom_id)
-        if (!id_fallback_warning_emitted) {
-          console.warn(
-            `LAMMPS parser fallback: mapping atom IDs to elements from ID column; this may be incorrect for large or sequential IDs. Prefer a TYPE column when available.`,
-          )
-          id_fallback_warning_emitted = true
-        }
-        element_symbol = get_element(atom_id)
-      }
-
-      if (!element_symbol) continue
-      positions.push(xyz)
-      elements.push(element_symbol)
-    }
-
-    if (positions.length === elements.length && positions.length === num_atoms) {
-      const { volume } = math.calc_lattice_params(lattice_matrix)
-      frames.push(
-        create_trajectory_frame(positions, elements, lattice_matrix, pbc, timestep, {
-          volume,
-          timestep,
-        }),
-      )
-    }
-  }
-
-  if (frames.length === 0) {
-    throw new Error(`No valid frames found in LAMMPS trajectory`)
-  }
-
-  const first_frame = frames[0]
-  const element_counts = first_frame.structure.sites.reduce<Record<string, number>>(
-    (counts, site) => {
-      const elem = site.species[0].element
-      counts[elem] = (counts[elem] || 0) + 1
-      return counts
-    },
-    {},
-  )
-
-  return {
-    frames,
-    metadata: {
-      filename,
-      source_format: `lammps_trajectory`,
-      frame_count: frames.length,
-      total_atoms: first_frame.structure.sites.length,
-      periodic_boundary_conditions:
-        `lattice` in first_frame.structure
-          ? first_frame.structure.lattice.pbc
-          : [true, true, true],
-      atom_types: Array.from(atom_types_found).sort((a, b) => a - b),
-      element_counts,
-    },
-  }
-}