matterviz 0.4.1 → 0.4.3

package/dist/fermi-surface/parse.js

@@ -1,12 +1,13 @@
 import * as math from '../math';
-import { is_plain_object } from '../utils';
+import { is_plain_object, normalize_scientific_notation, parse_leading_num, to_error, } from '../utils';
 import * as constants from './constants';
 import { compute_vertex_normals } from '../marching-cubes';
 const parse_number_tokens = (line) => line.split(/\s+/).filter(Boolean);
-// Parse whitespace-separated floats from a line (optimized with unary +)
-const parse_floats = (line) => parse_number_tokens(line).map(Number);
+// Parse whitespace-separated floats from a line. Normalizes Fortran D-exponents
+// (`0.1234D+01`) which Fortran codes emit in BXSF/FRMSF and Number() rejects
+const parse_floats = (line) => parse_number_tokens(normalize_scientific_notation(line)).map(Number);
 // Parse whitespace-separated integers from a line
-const parse_ints = (line) => parse_number_tokens(line).map((part) => parseInt(part, 10));
+const parse_ints = (line) => parse_number_tokens(line).map((part) => Math.trunc(Number(part)));
 // Parse BXSF (Band-XSF) format used by XCrySDen, Quantum ESPRESSO, etc.
 // Format specification: http://www.xcrysden.org/doc/XSF.html
 function parse_bxsf(content) {
@@ -40,7 +41,7 @@ function parse_bxsf(content) {
         throw new Error(`Expected BANDGRID_3D header, got: ${bandgrid_line}`);
     }
     // Parse number of bands
-    const n_bands = parseInt(next_line(), 10);
+    const n_bands = Math.trunc(Number(next_line()));
     if (isNaN(n_bands) || n_bands <= 0) {
         throw new Error(`Invalid number of bands in BXSF file`);
     }
@@ -94,18 +95,11 @@ function parse_bxsf(content) {
         if (energy_values.length < total_points) {
             throw new Error(`Band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
         }
-        // Reshape into 3D grid [kx][ky][kz] (preallocated for speed)
-        const band_grid = Array(nx);
-        let val_idx = 0;
-        for (let ix = 0; ix < nx; ix++) {
-            const iy_arr = Array(ny);
-            for (let iy = 0; iy < ny; iy++) {
-                const iz_arr = energy_values.slice(val_idx, val_idx + nz);
-                val_idx += nz;
-                iy_arr[iy] = iz_arr;
-            }
-            band_grid[ix] = iy_arr;
-        }
+        // Reshape into 3D grid [kx][ky][kz]
+        const band_grid = Array.from({ length: nx }, (_x_row, ix) => Array.from({ length: ny }, (_y_row, iy) => {
+            const offset = (ix * ny + iy) * nz;
+            return energy_values.slice(offset, offset + nz);
+        }));
         energies[0].push(band_grid);
     }
     // Try to find Fermi energy (often in a comment or as FERMI_ENERGY keyword)
@@ -114,9 +108,9 @@ function parse_bxsf(content) {
         const lower = line.toLowerCase();
         if (lower.includes(`fermi`) && lower.includes(`energy`)) {
             // Match patterns like "Fermi Energy = 5.123" or "fermi_energy: -0.5"
-            const match = /(?:=|:)\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i.exec(line);
+            const match = /(?:=|:)\s*(?<value>[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i.exec(line);
             if (match) {
-                fermi_energy = parseFloat(match[1]);
+                fermi_energy = Number(match[1]);
                 break;
             }
         }
@@ -149,70 +143,49 @@ function parse_frmsf(content) {
     // 0 = Monkhorst-Pack grid (shifted)
     // 1 = Gamma-centered grid
     // 2 = Gamma + half grid shift
-    const lshift = parseInt(lines[line_idx++], 10);
+    const lshift = Math.trunc(Number(lines[line_idx++]));
     if (isNaN(lshift) || lshift < 0 || lshift > 2) {
         throw new Error(`FRMSF: Invalid lshift value (expected 0, 1, or 2)`);
     }
     // Line 3: number of bands
-    const n_bands = parseInt(lines[line_idx++], 10);
+    const n_bands = Math.trunc(Number(lines[line_idx++]));
     if (isNaN(n_bands) || n_bands <= 0) {
         throw new Error(`FRMSF: Invalid number of bands`);
     }
-    // FRMSF format has single spin channel (no spin-polarized support in standard format)
-    const n_spins = 1;
     // Lines 4-6: reciprocal lattice vectors (in Bohr^-1, convert to Å^-1)
     const inv_bohr = 1 / constants.BOHR_TO_ANGSTROM;
-    const k_lattice = [
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-    ];
+    const parse_k_vector = () => parse_floats(lines[line_idx++])
+        .slice(0, 3)
+        .map((val) => val * inv_bohr);
+    const k_lattice = [parse_k_vector(), parse_k_vector(), parse_k_vector()];
     const [nx, ny, nz] = k_grid;
     const total_points = nx * ny * nz;
-    // Parse band energies for each spin and band
-    // FRMSF format: one energy value per line per grid point. Any additional columns
-    // (e.g. auxiliary color/velocity data) are ignored to prevent grid corruption.
-    const energies = [];
-    for (let spin_idx = 0; spin_idx < n_spins; spin_idx++) {
-        energies[spin_idx] = [];
-        for (let band_idx = 0; band_idx < n_bands; band_idx++) {
-            const energy_values = [];
-            // Read energy values (first value per line only, ignore auxiliary columns)
-            while (energy_values.length < total_points && line_idx < lines.length) {
-                const line = lines[line_idx];
-                const first_token = line?.split(/\s+/)[0];
-                if (first_token && !isNaN(parseFloat(first_token))) {
-                    energy_values.push(parseFloat(first_token));
-                    line_idx++;
-                }
-                else {
-                    break;
-                }
-            }
-            if (energy_values.length < total_points) {
-                throw new Error(`FRMSF spin ${spin_idx} band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
-            }
-            // Reshape into 3D grid [kx][ky][kz]
-            const band_grid = [];
-            let val_idx = 0;
-            for (let ix = 0; ix < nx; ix++) {
-                band_grid[ix] = [];
-                for (let iy = 0; iy < ny; iy++) {
-                    band_grid[ix][iy] = [];
-                    for (let iz = 0; iz < nz; iz++) {
-                        // FRMSF uses Hartree, convert to eV
-                        band_grid[ix][iy][iz] = energy_values[val_idx++] * constants.HARTREE_TO_EV;
-                    }
-                }
-            }
-            energies[spin_idx].push(band_grid);
+    // Parse band energies (FRMSF has a single spin channel — no spin-polarized support
+    // in the standard format). One energy value per line per grid point; any additional
+    // columns (e.g. auxiliary color/velocity data) are ignored to prevent grid corruption.
+    const energies = [[]];
+    for (let band_idx = 0; band_idx < n_bands; band_idx++) {
+        const energy_values = [];
+        // Read energy values (first value per line only, ignore auxiliary columns;
+        // normalize Fortran D-exponents like parse_floats does)
+        while (energy_values.length < total_points && line_idx < lines.length) {
+            const energy = parse_leading_num(normalize_scientific_notation(lines[line_idx] ?? ``));
+            if (isNaN(energy))
+                break;
+            energy_values.push(energy);
+            line_idx++;
+        }
+        if (energy_values.length < total_points) {
+            throw new Error(`FRMSF band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
         }
+        // Reshape into 3D grid [kx][ky][kz], converting Hartree to eV
+        const band_grid = Array.from({ length: nx }, (_x_row, ix) => Array.from({ length: ny }, (_y_row, iy) => {
+            const offset = (ix * ny + iy) * nz;
+            return energy_values
+                .slice(offset, offset + nz)
+                .map((energy) => energy * constants.HARTREE_TO_EV);
+        }));
+        energies[0].push(band_grid);
     }
     return {
         energies,
@@ -220,7 +193,7 @@ function parse_frmsf(content) {
         k_lattice,
         fermi_energy: 0, // FRMSF typically expects Fermi level at 0
         n_bands,
-        n_spins,
+        n_spins: 1,
         periodic: true, // FRMSF stores k=i/n with no duplicated endpoint (unlike BXSF)
     };
 }
@@ -347,7 +320,7 @@ function parse_ifermi_surface(data) {
     const band_indices = new Set();
     let has_spin = false;
     for (const [band_key, iso_list] of Object.entries(isosurfaces_obj)) {
-        const band_index = parseInt(band_key, 10);
+        const band_index = Math.trunc(Number(band_key));
         // spin is determined by sign: positive = up, negative = down
         const spin = band_index < 0 ? `down` : `up`;
         const abs_band_idx = Math.abs(band_index);
@@ -359,27 +332,20 @@ function parse_ifermi_surface(data) {
             const faces = ifermi_iso.faces;
             // Compute vertex normals from faces
             const normals = compute_vertex_normals(vertices, faces);
-            // Extract properties if available
-            let properties;
-            if (ifermi_iso.properties) {
-                // IFermi stores properties like fermi_velocity, spin, etc.
-                const prop_keys = Object.keys(ifermi_iso.properties);
-                if (prop_keys.length > 0) {
-                    // Use first available property as vertex colors
-                    properties = ifermi_iso.properties[prop_keys[0]];
-                }
-            }
+            // IFermi stores properties like fermi_velocity, spin, etc.
+            // Use first available property as vertex colors
+            const properties = Object.values(ifermi_iso.properties ?? {})[0];
             // Parse dimensionality
             let dimensionality;
             if (ifermi_iso.dimensionality) {
                 const dim = ifermi_iso.dimensionality.toLowerCase();
-                if (dim.includes(`1d`) || dim === `1d`)
+                if (dim.includes(`1d`))
                     dimensionality = `1D`;
-                else if (dim.includes(`quasi`) || dim === `quasi-2d`)
+                else if (dim.includes(`quasi`))
                     dimensionality = `quasi-2D`;
-                else if (dim.includes(`2d`) || dim === `2d`)
+                else if (dim.includes(`2d`))
                     dimensionality = `2D`;
-                else if (dim.includes(`3d`) || dim === `3d`)
+                else if (dim.includes(`3d`))
                     dimensionality = `3D`;
             }
             // Compute area for this isosurface using fan triangulation for N-gons
@@ -438,7 +404,7 @@ export function parse_fermi_file(content, filename) {
             return parse();
         }
         catch (error) {
-            errors.push(`${format}: ${error instanceof Error ? error.message : String(error)}`);
+            errors.push(`${format}: ${to_error(error).message}`);
             console.error(`${format} parse error:`, error);
             return null;
         }