matterviz 0.3.4 → 0.3.6

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

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

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