matterviz 0.3.6 → 0.3.7

package/dist/phase-diagram/parse.js

@@ -0,0 +1,272 @@
+// TDB (Thermodynamic Database) file parser
+// Parses CALPHAD TDB files to extract metadata about elements, phases, and parameters
+import { ELEM_SYMBOLS } from '../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
+};
+// Parse a TDB file content string
+export function parse_tdb(content) {
+    try {
+        const data = {
+            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, 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 = 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),
+        };
+    }
+}
+// Line parsers for TDB format - uses a data-driven approach to reduce repetition
+const LINE_PARSERS = [
+    {
+        // 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) {
+    const ranges = [];
+    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, data) {
+    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) => 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) => 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) => 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) {
+    const upper = input.toUpperCase();
+    function parse(idx) {
+        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) {
+    if (!input)
+        return ``;
+    // First try splitting on common delimiters
+    const delimiter_parts = input.split(/[-_]/).filter(Boolean);
+    let elements;
+    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(`-`);
+}

package/dist/phase-diagram/svg-to-diagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramInput } from './diagram-input';
+export declare function parse_phase_diagram_svg(svg_string: string): DiagramInput;