matterviz 0.3.6 → 0.4.0

package/dist/src/lib/phase-diagram/parse.ts

@@ -1,348 +0,0 @@
-// TDB (Thermodynamic Database) file parser
-// Parses CALPHAD TDB files to extract metadata about elements, phases, and parameters
-
-import { ELEM_SYMBOLS } from '$lib/labels'
-
-// Default temperature bounds for TDB parsing (in Kelvin)
-export const TDB_TEMP_DEFAULTS = {
-  min: 298.15, // Room temperature
-  max_fallback: 3000, // Fallback when no functions define ranges
-  max_range: 5000, // Default max for temperature ranges in FUNCTION bodies
-} as const
-
-export interface TdbElement {
-  symbol: string
-  reference_phase: string
-  mass: number
-  enthalpy: number
-  entropy: number
-}
-
-export interface TdbPhase {
-  name: string
-  model_hints: string
-  sublattice_count: number
-  sublattice_sites: number[]
-  constituents?: string[][]
-}
-
-export interface TdbFunction {
-  name: string
-  expression: string
-  temperature_ranges: { min: number; max: number; expr: string }[]
-}
-
-export interface TdbParameter {
-  type: string
-  phase: string
-  constituents: string[]
-  order: number
-  expression: string
-}
-
-export interface TdbData {
-  elements: TdbElement[]
-  phases: TdbPhase[]
-  functions: TdbFunction[]
-  parameters: TdbParameter[]
-  comments: string[]
-  raw_content: string
-}
-
-export interface TdbParseResult {
-  success: boolean
-  data: TdbData | null
-  error?: string
-  // Derived properties for convenience
-  binary_system?: [string, string]
-  available_phases?: string[]
-  temperature_range?: [number, number]
-}
-
-// Parse a TDB file content string
-export function parse_tdb(content: string): TdbParseResult {
-  try {
-    const data: TdbData = {
-      elements: [],
-      phases: [],
-      functions: [],
-      parameters: [],
-      comments: [],
-      raw_content: content,
-    }
-
-    // Normalize line endings and join continuation lines
-    const normalized = content
-      .replace(/\r\n/g, `\n`)
-      .replace(/\r/g, `\n`)
-      // Join lines that don't end with ! (continuation)
-      .split(`\n`)
-      .reduce((acc: string[], line) => {
-        const trimmed = line.trim()
-        if (trimmed.startsWith(`$`)) {
-          data.comments.push(trimmed.substring(1).trim())
-          return acc
-        }
-        if (acc.length === 0 || acc[acc.length - 1].endsWith(`!`)) {
-          acc.push(trimmed)
-        } else {
-          acc[acc.length - 1] += ` ` + trimmed
-        }
-        return acc
-      }, [])
-      .filter((line) => line.length > 0)
-
-    for (const line of normalized) {
-      parse_tdb_line(line, data)
-    }
-
-    // Derive binary system from elements (excluding VA)
-    const real_elements = data.elements.map((el) => el.symbol).filter(is_real_element)
-
-    const binary_system: [string, string] | undefined =
-      real_elements.length === 2 ? [real_elements[0], real_elements[1]] : undefined
-
-    // Extract temperature range from functions/parameters
-    // Find the actual min and max temperatures across all ranges
-    let [min_temp, max_temp] = [Infinity, -Infinity]
-    for (const func of data.functions) {
-      for (const range of func.temperature_ranges) {
-        if (range.min < min_temp) min_temp = range.min
-        if (range.max > max_temp) max_temp = range.max
-      }
-    }
-
-    // Use sensible defaults if no ranges found or if extracted range is invalid
-    if (min_temp === Infinity) min_temp = TDB_TEMP_DEFAULTS.min
-    if (max_temp === -Infinity) max_temp = TDB_TEMP_DEFAULTS.max_fallback
-    // Ensure min < max (swap if malformed data caused inversion)
-    if (min_temp > max_temp) [min_temp, max_temp] = [max_temp, min_temp]
-
-    return {
-      success: true,
-      data,
-      binary_system,
-      available_phases: data.phases.map((phase) => phase.name),
-      temperature_range: [min_temp, max_temp],
-    }
-  } catch (exc) {
-    return {
-      success: false,
-      data: null,
-      error: exc instanceof Error ? exc.message : String(exc),
-    }
-  }
-}
-
-// Parser configuration for TDB line handlers
-// Each parser has a keyword prefix, regex pattern, and transform function
-interface LineParser {
-  prefix: string
-  pattern: RegExp
-  handler: (match: RegExpMatchArray, data: TdbData) => void
-}
-
-// Line parsers for TDB format - uses a data-driven approach to reduce repetition
-const LINE_PARSERS: LineParser[] = [
-  {
-    // ELEMENT AL FCC_A1 2.698154E-02 4.5773304E+03 2.871870E+01!
-    prefix: `ELEMENT `,
-    pattern: /ELEMENT\s+(\S+)\s+(\S+)\s+([\d.E+-]+)\s+([\d.E+-]+)\s+([\d.E+-]+)/i,
-    handler: (match, data) => {
-      data.elements.push({
-        symbol: match[1].toUpperCase(),
-        reference_phase: match[2],
-        mass: parseFloat(match[3]),
-        enthalpy: parseFloat(match[4]),
-        entropy: parseFloat(match[5]),
-      })
-    },
-  },
-  {
-    // PHASE LIQUID % 1 1.0 !
-    prefix: `PHASE `,
-    pattern: /PHASE\s+(\S+)\s+(%\S*)\s+(\d+)\s+(.+?)!/i,
-    handler: (match, data) => {
-      const sublattice_sites = match[4]
-        .trim()
-        .split(/\s+/)
-        .map((val) => parseFloat(val))
-        .filter((val) => !isNaN(val))
-      data.phases.push({
-        name: match[1],
-        model_hints: match[2],
-        sublattice_count: parseInt(match[3], 10),
-        sublattice_sites,
-      })
-    },
-  },
-  {
-    // CONSTITUENT FCC_A1 :AL,ZN : VA : !
-    prefix: `CONSTITUENT `,
-    pattern: /CONSTITUENT\s+(\S+)\s*:\s*(.+?)!/i,
-    handler: (match, data) => {
-      const phase_name = match[1]
-      const constituents = match[2].split(`:`).map((sub) =>
-        sub
-          .split(`,`)
-          .map((name) => name.trim())
-          .filter((name) => name.length > 0),
-      )
-      const matched_phase = data.phases.find(
-        (candidate_phase) => candidate_phase.name.toUpperCase() === phase_name.toUpperCase(),
-      )
-      if (matched_phase) matched_phase.constituents = constituents
-    },
-  },
-  {
-    // FUNCTION GHSERAL 298.15 expr1; 700 Y expr2; 933.47 Y expr3; 2900 N !
-    prefix: `FUNCTION `,
-    pattern: /FUNCTION\s+(\S+)\s+(.+?)!/i,
-    handler: (match, data) => {
-      const ranges = parse_temperature_ranges(match[2])
-      if (ranges.length > 0) {
-        data.functions.push({
-          name: match[1],
-          expression: match[2],
-          temperature_ranges: ranges,
-        })
-      }
-    },
-  },
-  {
-    // PARAMETER G(LIQUID,AL;0) 298.15 +GHSERAL+11005.029-11.841867*T; 6000 N !
-    prefix: `PARAMETER `,
-    pattern: /PARAMETER\s+(\w+)\(([^)]+)\)\s+(.+?)!/i,
-    handler: (match, data) => {
-      const spec_match = /([^,]+),([^;]+);(\d+)/.exec(match[2])
-      if (spec_match) {
-        data.parameters.push({
-          type: match[1],
-          phase: spec_match[1],
-          constituents: spec_match[2].split(`,`).map((name) => name.trim()),
-          order: parseInt(spec_match[3], 10),
-          expression: match[3],
-        })
-      }
-    },
-  },
-]
-
-// Parse temperature ranges from FUNCTION body string
-function parse_temperature_ranges(body: string): { min: number; max: number; expr: string }[] {
-  const ranges: { min: number; max: number; expr: string }[] = []
-  for (const segment of body.split(/;\s*/)) {
-    const trimmed = segment.trim()
-    if (!trimmed) continue
-    const temp_match = /^([\d.E+-]+)\s+(.+)/i.exec(trimmed)
-    if (temp_match) {
-      const next_temp = parseFloat(temp_match[1])
-      const expr = temp_match[2].replace(/\s+[YN]\s*$/, ``).trim()
-      if (ranges.length > 0) ranges[ranges.length - 1].max = next_temp
-      ranges.push({ min: next_temp, max: TDB_TEMP_DEFAULTS.max_range, expr })
-    }
-  }
-  // Filter out invalid ranges where max <= min (malformed data)
-  return ranges.filter((range) => range.max > range.min)
-}
-
-function parse_tdb_line(line: string, data: TdbData): void {
-  const upper_line = line.toUpperCase()
-
-  for (const parser of LINE_PARSERS) {
-    if (upper_line.startsWith(parser.prefix)) {
-      const match = line.match(parser.pattern)
-      if (match) parser.handler(match, data)
-      else if (parser.prefix === `ELEMENT `) {
-        // Fallback for simpler ELEMENT format: ELEMENT AL FCC_A1!
-        const simple_match = /ELEMENT\s+(\S+)\s+(\S+)/i.exec(line)
-        if (simple_match) {
-          data.elements.push({
-            symbol: simple_match[1].toUpperCase(),
-            reference_phase: simple_match[2].replace(/!$/, ``),
-            mass: 0,
-            enthalpy: 0,
-            entropy: 0,
-          })
-        }
-      }
-      return
-    }
-  }
-  // TYPE_DEFINITION, DEFINE_SYSTEM_DEFAULT, etc. are ignored
-}
-
-// Get a normalized system name from elements (e.g., "AL-ZN" always alphabetically sorted)
-export const get_system_name = (elements: string[]): string =>
-  elements
-    .filter(is_real_element)
-    .map((el) => el.toUpperCase())
-    .sort()
-    .join(`-`)
-
-// Check if a TDB file represents a binary system
-export const is_binary_system = (tdb_data: TdbData): boolean =>
-  tdb_data.elements.map((el) => el.symbol).filter(is_real_element).length === 2
-
-// Predicate to filter out non-real elements (VA = vacancy, /- = electron)
-const is_real_element = (sym: string) => sym !== `VA` && sym !== `/-`
-
-// Known element symbols for parsing concatenated system names (e.g., "CuMg" -> ["CU", "MG"])
-const KNOWN_ELEMENTS = new Set(ELEM_SYMBOLS.map((sym) => sym.toUpperCase()))
-
-// Extract element symbols from a concatenated string (e.g., "CuMg" -> ["CU", "MG"])
-// Returns null if the string doesn't fully match as element symbols
-// Uses backtracking to handle ambiguous cases (e.g., "NBR" -> ["N", "BR"] not ["NB", ?])
-function extract_elements_from_string(input: string): string[] | null {
-  const upper = input.toUpperCase()
-
-  function parse(idx: number): string[] | null {
-    if (idx >= upper.length) return []
-
-    // Try two-letter symbol first (prefer longer match)
-    if (idx + 1 < upper.length) {
-      const two_letter = upper.slice(idx, idx + 2)
-      if (KNOWN_ELEMENTS.has(two_letter)) {
-        const rest = parse(idx + 2)
-        if (rest !== null) return [two_letter, ...rest]
-      }
-    }
-
-    // Try single-letter symbol (backtrack if two-letter path failed)
-    const one_letter = upper[idx]
-    if (KNOWN_ELEMENTS.has(one_letter)) {
-      const rest = parse(idx + 1)
-      if (rest !== null) return [one_letter, ...rest]
-    }
-
-    return null
-  }
-
-  const elements = parse(0)
-  return elements && elements.length >= 2 ? elements : null
-}
-
-// Normalize a system name string to canonical form (e.g., "cumg", "Cu-Mg", "CU_MG" -> "CU-MG")
-export function normalize_system_name(input: string): string {
-  if (!input) return ``
-
-  // First try splitting on common delimiters
-  const delimiter_parts = input.split(/[-_]/).filter(Boolean)
-
-  let elements: string[]
-  if (delimiter_parts.length >= 2) {
-    // Has delimiter, normalize each part
-    elements = delimiter_parts.map((part) => part.toUpperCase())
-  } else {
-    // No delimiter, try to parse concatenated symbols
-    const parsed = extract_elements_from_string(input)
-    if (!parsed) {
-      // Couldn't parse as elements, return uppercased input as-is
-      return input.toUpperCase()
-    }
-    elements = parsed
-  }
-
-  // Sort alphabetically and join with hyphen
-  return elements.sort().join(`-`)
-}