matterviz 0.3.1 → 0.3.2

package/dist/isosurface/Isosurface.svelte

@@ -4,7 +4,7 @@
 import { marching_cubes } from '../marching-cubes';
 import { T } from '@threlte/core';
 import { BackSide, BufferAttribute, BufferGeometry, DoubleSide, FrontSide, Uint32BufferAttribute, } from 'three';
-import { DEFAULT_ISOSURFACE_SETTINGS } from './types';
+import { DEFAULT_ISOSURFACE_SETTINGS, downsample_grid, pad_periodic_grid, } from './types';
 let { volume, settings = DEFAULT_ISOSURFACE_SETTINGS, } = $props();
 // Resolve layers: use explicit layers array if provided, else build from single-isovalue settings
 let resolved_layers = $derived.by(() => {
@@ -48,22 +48,34 @@ function build_geometry(vertices, faces) {
     geometry.computeBoundingSphere();
     return geometry;
 }
-// Run marching cubes at the given isovalue.
-// Uses volume.periodic for correct coordinate scaling:
-// periodic grids (CHGCAR) use 1/N spacing, non-periodic (.cube) use 1/(N-1).
-function extract_surface(isovalue) {
-    if (!volume || isovalue === 0)
+// Downsample large grids once when volume changes to keep marching cubes interactive
+let ds_result = $derived.by(() => {
+    if (!volume)
+        return undefined;
+    return downsample_grid(volume.grid, volume.grid_dims);
+});
+// Run marching cubes at the given isovalue with pre-prepared grid/lattice/shift.
+function extract_surface(isovalue, mc_grid, mc_lattice, origin_shift) {
+    if (isovalue === 0)
         return null;
-    const result = marching_cubes(volume.grid, isovalue, volume.lattice, {
-        periodic: volume.periodic,
+    const result = marching_cubes(mc_grid, isovalue, mc_lattice, {
+        periodic: false,
         interpolate: true,
         centered: false,
         normals: false,
     });
+    if (origin_shift) {
+        for (const vert of result.vertices) {
+            vert[0] += origin_shift[0];
+            vert[1] += origin_shift[1];
+            vert[2] += origin_shift[2];
+        }
+    }
     return build_geometry(result.vertices, result.faces);
 }
 let active_geometries = $state([]);
 let raf_id = 0;
+let debounce_id = 0;
 // Dispose all current geometries
 function dispose_all() {
     for (const entry of active_geometries)
@@ -72,50 +84,94 @@ function dispose_all() {
 }
 // Dispose on unmount
 $effect(() => () => dispose_all());
-// Rebuild all layer geometries on next animation frame when layers or volume change
-$effect(() => {
-    const layers = resolved_layers;
-    const vol = volume;
-    if (!vol) {
-        dispose_all();
+function rebuild_geometries(layers) {
+    if (!volume || !ds_result)
         return;
+    const old = active_geometries;
+    const entries = [];
+    // Prepare grid/lattice/shift once for all layers.
+    // When halo > 0 for periodic volumes, the downsampled grid is padded with
+    // halo cells from the opposite face so isosurfaces extend beyond the unit
+    // cell and close into complete enclosed shapes around boundary atoms.
+    let mc_grid = ds_result.grid;
+    let mc_lattice = volume.lattice;
+    let origin_shift = null;
+    if (settings.halo > 0 && volume.periodic) {
+        const padded = pad_periodic_grid(ds_result.grid, ds_result.dims, settings.halo);
+        mc_grid = padded.grid;
+        // marching_cubes maps [0,1] fractional -> Cartesian via lattice.
+        // The padded grid covers a wider fractional range, so scale the lattice
+        // to match. Then shift all vertices by the fractional offset.
+        const [la, lb, lc] = volume.lattice;
+        const sx = padded.dims[0] / ds_result.dims[0];
+        const sy = padded.dims[1] / ds_result.dims[1];
+        const sz = padded.dims[2] / ds_result.dims[2];
+        mc_lattice = [
+            [la[0] * sx, la[1] * sx, la[2] * sx],
+            [lb[0] * sy, lb[1] * sy, lb[2] * sy],
+            [lc[0] * sz, lc[1] * sz, lc[2] * sz],
+        ];
+        const [ox, oy, oz] = padded.offset;
+        origin_shift = [
+            ox * la[0] + oy * lb[0] + oz * lc[0],
+            ox * la[1] + oy * lb[1] + oz * lc[1],
+            ox * la[2] + oy * lb[2] + oz * lc[2],
+        ];
     }
-    raf_id = requestAnimationFrame(() => {
-        const old = active_geometries;
-        const entries = [];
-        for (let layer_idx = 0; layer_idx < layers.length; layer_idx++) {
-            const layer = layers[layer_idx];
-            if (!layer.visible || layer.isovalue <= 0)
-                continue;
-            // Render order: inner shells (higher isovalue) first for correct transparency.
-            // Each layer gets 4 slots (positive back/front + negative back/front).
-            const base_order = (layers.length - 1 - layer_idx) * 4;
-            const pos_geo = extract_surface(layer.isovalue);
-            if (pos_geo) {
+    const surface_at = (isovalue) => extract_surface(isovalue, mc_grid, mc_lattice, origin_shift);
+    // Render lower-isovalue (outer) shells earlier so per-layer back/front passes
+    // interleave back-to-front across shells and reduce transparency artefacts.
+    const layer_render_rank = new Map(layers
+        .map((layer, layer_idx) => ({ layer_idx, isovalue: layer.isovalue }))
+        .sort((layer_a, layer_b) => layer_a.isovalue - layer_b.isovalue)
+        .map(({ layer_idx }, rank) => [layer_idx, rank]));
+    for (let layer_idx = 0; layer_idx < layers.length; layer_idx++) {
+        const layer = layers[layer_idx];
+        if (!layer.visible || layer.isovalue <= 0)
+            continue;
+        // Each layer gets 4 slots (positive back/front + negative back/front).
+        const base_order = (layer_render_rank.get(layer_idx) ?? layer_idx) * 4;
+        const pos_geo = surface_at(layer.isovalue);
+        if (pos_geo) {
+            entries.push({
+                geometry: pos_geo,
+                color: layer.color,
+                opacity: layer.opacity,
+                render_order: base_order,
+            });
+        }
+        if (layer.show_negative) {
+            const neg_geo = surface_at(-layer.isovalue);
+            if (neg_geo) {
                 entries.push({
-                    geometry: pos_geo,
-                    color: layer.color,
+                    geometry: neg_geo,
+                    color: layer.negative_color,
                     opacity: layer.opacity,
-                    render_order: base_order,
+                    render_order: base_order + 2,
                 });
             }
-            if (layer.show_negative) {
-                const neg_geo = extract_surface(-layer.isovalue);
-                if (neg_geo) {
-                    entries.push({
-                        geometry: neg_geo,
-                        color: layer.negative_color,
-                        opacity: layer.opacity,
-                        render_order: base_order + 2,
-                    });
-                }
-            }
         }
-        active_geometries = entries;
-        for (const entry of old)
-            entry.geometry.dispose();
-    });
-    return () => cancelAnimationFrame(raf_id);
+    }
+    active_geometries = entries;
+    for (const entry of old)
+        entry.geometry.dispose();
+}
+// Rebuild all layer geometries when layers or volume change.
+// Debounces rapid changes (e.g. slider drags) to avoid repeated expensive marching cubes.
+$effect(() => {
+    const layers = resolved_layers;
+    void settings.halo;
+    if (!ds_result) {
+        dispose_all();
+        return;
+    }
+    debounce_id = window.setTimeout(() => {
+        raf_id = requestAnimationFrame(() => rebuild_geometries(layers));
+    }, 50);
+    return () => {
+        clearTimeout(debounce_id);
+        cancelAnimationFrame(raf_id);
+    };
 });
 </script>
 

package/dist/isosurface/IsosurfaceControls.svelte

@@ -39,6 +39,7 @@ function update_layer(idx, updates) {
     opacity: settings.opacity,
     show_negative: settings.show_negative,
     wireframe: settings.wireframe,
+    halo: settings.halo,
     layers: n_layers,
   }}
   on_reset={() => {
@@ -205,6 +206,24 @@ function update_layer(idx, updates) {
     </div>
   {/if}
 
+  {#if volumes?.[active_volume_idx]?.periodic}
+    <label
+      {@attach tooltip({
+        content:
+          `Extend isosurface beyond cell boundaries to close partial spheres (fraction of cell)`,
+      })}
+    >
+      Halo: {format_num(settings.halo, `.2f`)}
+      <input
+        type="range"
+        min={0}
+        max={0.5}
+        step={0.01}
+        bind:value={settings.halo}
+      />
+    </label>
+  {/if}
+
   {#if volumes[active_volume_idx]}
     <div class="grid-info">
       {volumes[active_volume_idx].grid_dims.join(` × `)} grid &nbsp;|&nbsp; [{

package/dist/isosurface/parse.js

@@ -87,13 +87,11 @@ function read_lines(text, pos, count) {
     }
     return { lines: result, next: pos };
 }
-// Build 3D grid directly from Float64Array, computing data_range in the same pass.
-function build_grid(data, nx, ny, nz, divisor = 1) {
+function build_grid({ data, nx, ny, nz, divisor = 1, data_order = `z_fastest` }) {
     const grid = new Array(nx);
     let min_val = Infinity;
     let max_val = -Infinity;
     let sum = 0;
-    const ny_nz = ny * nz;
     const total = nx * ny * nz;
     const data_len = Math.min(data.length, total);
     if (data_len === 0) {
@@ -106,35 +104,65 @@ function build_grid(data, nx, ny, nz, divisor = 1) {
         }
         return { grid, data_range: { min: 0, max: 0, abs_max: 0, mean: 0 } };
     }
-    for (let ix = 0; ix < nx; ix++) {
-        const plane = new Array(ny);
-        for (let iy = 0; iy < ny; iy++) {
-            const row = new Array(nz).fill(0);
-            const base = ix * ny_nz + iy * nz;
-            const row_end = Math.min(base + nz, data_len);
-            for (let flat_idx = base; flat_idx < row_end; flat_idx++) {
-                const val = data[flat_idx] / divisor;
-                row[flat_idx - base] = val;
-                if (val < min_val)
-                    min_val = val;
-                if (val > max_val)
-                    max_val = val;
-                sum += val;
+    if (data_order === `z_fastest`) {
+        // .cube convention: z varies fastest, then y, then x.
+        const ny_nz = ny * nz;
+        for (let ix = 0; ix < nx; ix++) {
+            const plane = new Array(ny);
+            for (let iy = 0; iy < ny; iy++) {
+                const row = new Array(nz).fill(0);
+                const base = ix * ny_nz + iy * nz;
+                const row_end = Math.min(base + nz, data_len);
+                for (let flat_idx = base; flat_idx < row_end; flat_idx++) {
+                    const val = data[flat_idx] / divisor;
+                    row[flat_idx - base] = val;
+                    if (val < min_val)
+                        min_val = val;
+                    if (val > max_val)
+                        max_val = val;
+                    sum += val;
+                }
+                plane[iy] = row;
+            }
+            grid[ix] = plane;
+        }
+    }
+    else {
+        // VASP CHGCAR/ELFCAR/LOCPOT convention: x varies fastest, then y, then z.
+        for (let ix = 0; ix < nx; ix++) {
+            const plane = new Array(ny);
+            for (let iy = 0; iy < ny; iy++)
+                plane[iy] = new Array(nz).fill(0);
+            grid[ix] = plane;
+        }
+        let flat_idx = 0;
+        let data_exhausted = false;
+        for (let iz = 0; iz < nz; iz++) {
+            for (let iy = 0; iy < ny; iy++) {
+                for (let ix = 0; ix < nx; ix++) {
+                    if (flat_idx >= data_len) {
+                        data_exhausted = true;
+                        break;
+                    }
+                    const val = data[flat_idx] / divisor;
+                    grid[ix][iy][iz] = val;
+                    if (val < min_val)
+                        min_val = val;
+                    if (val > max_val)
+                        max_val = val;
+                    sum += val;
+                    flat_idx++;
+                }
+                if (data_exhausted)
+                    break;
             }
-            plane[iy] = row;
+            if (data_exhausted)
+                break;
         }
-        grid[ix] = plane;
     }
     const abs_max = Math.max(Math.abs(min_val), Math.abs(max_val));
-    return {
-        grid,
-        data_range: {
-            min: min_val,
-            max: max_val,
-            abs_max,
-            mean: sum / data_len,
-        },
-    };
+    const data_range = { min: min_val, max: max_val, abs_max, mean: sum / data_len };
+    return { grid, data_range };
 }
 // === CHGCAR Parser ===
 // Parse VASP CHGCAR/AECCAR/ELFCAR/LOCPOT file format.
@@ -289,13 +317,21 @@ export function parse_chgcar(content) {
         // Use Math.abs to guard against negative determinant (left-handed lattice).
         const cell_volume = Math.abs(lattice_params.volume);
         const divisor = cell_volume > 1e-30 ? cell_volume : 1;
-        const { grid, data_range } = build_grid(data.subarray(0, parsed_count), ngx, ngy, ngz, divisor);
+        const { grid, data_range } = build_grid({
+            data: data.subarray(0, parsed_count),
+            nx: ngx,
+            ny: ngy,
+            nz: ngz,
+            divisor,
+            data_order: `x_fastest`,
+        });
         volumes.push({
             grid,
             grid_dims: [ngx, ngy, ngz],
             lattice,
             origin: [0, 0, 0],
             data_range,
+            data_order: `x_fastest`,
             periodic: true, // VASP grids span [0,1) with N points, wrapping at boundaries
             label: volume_labels[vol_idx],
         });
@@ -438,13 +474,20 @@ export function parse_cube(content, options = {}) {
             return null;
         }
     }
-    const { grid, data_range } = build_grid(data.subarray(0, parsed_count), n_grid[0], n_grid[1], n_grid[2]);
+    const { grid, data_range } = build_grid({
+        data: data.subarray(0, parsed_count),
+        nx: n_grid[0],
+        ny: n_grid[1],
+        nz: n_grid[2],
+        data_order: `z_fastest`,
+    });
     const volumes = [{
             grid,
             grid_dims: n_grid,
             lattice,
             origin,
             data_range,
+            data_order: `z_fastest`,
             periodic: is_periodic, // periodic systems wrap; molecular .cube files include both endpoints
             label: `volumetric data`,
         }];

package/dist/isosurface/slice.d.ts

@@ -1,3 +1,4 @@
+import type { Vec3 } from '../math';
 import type { VolumetricData } from './types';
 export interface SliceResult {
     data: Float64Array;
@@ -7,4 +8,4 @@ export interface SliceResult {
     max: number;
 }
 export declare function trilinear_interpolate(grid: number[][][], fx: number, fy: number, fz: number, periodic: boolean): number;
-export declare function sample_hkl_slice(volume: VolumetricData, miller_indices: [number, number, number], distance: number): SliceResult | null;
+export declare function sample_hkl_slice(volume: VolumetricData, miller_indices: Vec3, distance: number, n_points?: number): SliceResult | null;

package/dist/isosurface/slice.js

@@ -56,7 +56,7 @@ export function trilinear_interpolate(grid, fx, fy, fz, periodic) {
 // `miller_indices` [h,k,l] defines the plane normal in reciprocal space.
 // `distance` is fractional [0,1] along the normal direction within the cell.
 // Returns null if indices are all zero.
-export function sample_hkl_slice(volume, miller_indices, distance) {
+export function sample_hkl_slice(volume, miller_indices, distance, n_points) {
     const [h_idx, k_idx, l_idx] = miller_indices;
     if (h_idx === 0 && k_idx === 0 && l_idx === 0)
         return null;
@@ -113,8 +113,8 @@ export function sample_hkl_slice(volume, miller_indices, distance) {
     }
     // Plane position: fractional distance [0,1] along the normal extent
     const d_cartesian = normal_min + distance * (normal_max - normal_min);
-    // Sampling resolution: square grid using max dimension
-    const width = Math.max(nx, ny, nz);
+    // Sampling resolution: caller-specified or default to max grid dimension
+    const width = n_points ?? Math.max(nx, ny, nz);
     const height = width;
     const data = new Float64Array(width * height);
     let data_min = Infinity;

package/dist/isosurface/types.d.ts

@@ -8,10 +8,11 @@ export interface DataRange {
 }
 export interface VolumetricData {
     grid: number[][][];
-    grid_dims: [number, number, number];
+    grid_dims: Vec3;
     lattice: Matrix3x3;
     origin: Vec3;
     data_range: DataRange;
+    data_order?: `x_fastest` | `z_fastest`;
     periodic: boolean;
     label?: string;
 }
@@ -34,10 +35,21 @@ export interface IsosurfaceSettings {
     negative_color: string;
     show_negative: boolean;
     wireframe: boolean;
+    halo: number;
     layers?: IsosurfaceLayer[];
 }
 export declare const LAYER_COLORS: readonly ["#3b82f6", "#ef4444", "#22c55e", "#a855f7", "#f97316", "#06b6d4", "#eab308", "#ec4899"];
 export declare function grid_data_range(grid: number[][][]): DataRange;
+export declare function pad_periodic_grid(grid: number[][][], dims: Vec3, pad_fraction: number): {
+    grid: number[][][];
+    dims: Vec3;
+    offset: Vec3;
+};
+export declare function downsample_grid(grid: number[][][], dims: Vec3): {
+    grid: number[][][];
+    dims: Vec3;
+    factor: number;
+};
 export declare const DEFAULT_ISOSURFACE_SETTINGS: IsosurfaceSettings;
 export declare function auto_isosurface_settings(data_range: DataRange): IsosurfaceSettings;
 export declare function generate_layers(data_range: DataRange, n_layers: number): IsosurfaceLayer[];

package/dist/isosurface/types.js

@@ -34,6 +34,103 @@ export function grid_data_range(grid) {
     const abs_max = Math.max(Math.abs(min_val), Math.abs(max_val));
     return { min: min_val, max: max_val, abs_max, mean: count > 0 ? sum / count : 0 };
 }
+// Pad a periodic 3D grid with halo cells from the opposite face so isosurfaces
+// extend beyond the unit cell and close into complete enclosed shapes.
+// Returns a larger grid with dims [nx+2*pad, ny+2*pad, nz+2*pad] and the
+// fractional offset that the padded grid's origin has shifted by.
+export function pad_periodic_grid(grid, dims, pad_fraction) {
+    const [nx, ny, nz] = dims;
+    const frac = Math.max(0, pad_fraction);
+    const px = Math.min(Math.ceil(nx * frac), Math.floor(nx / 2));
+    const py = Math.min(Math.ceil(ny * frac), Math.floor(ny / 2));
+    const pz = Math.min(Math.ceil(nz * frac), Math.floor(nz / 2));
+    if (px === 0 && py === 0 && pz === 0)
+        return { grid, dims, offset: [0, 0, 0] };
+    const out_nx = nx + 2 * px;
+    const out_ny = ny + 2 * py;
+    const out_nz = nz + 2 * pz;
+    const wrap = (val, size) => ((val % size) + size) % size;
+    const out = new Array(out_nx);
+    for (let ix = 0; ix < out_nx; ix++) {
+        const plane = new Array(out_ny);
+        const src_x = wrap(ix - px, nx);
+        for (let iy = 0; iy < out_ny; iy++) {
+            const row = new Array(out_nz);
+            const src_y = wrap(iy - py, ny);
+            for (let iz = 0; iz < out_nz; iz++) {
+                row[iz] = grid[src_x][src_y][wrap(iz - pz, nz)];
+            }
+            plane[iy] = row;
+        }
+        out[ix] = plane;
+    }
+    // Fractional offset: the padded grid starts at -pad/n in each axis
+    const offset = [-px / nx, -py / ny, -pz / nz];
+    return { grid: out, dims: [out_nx, out_ny, out_nz], offset };
+}
+// Max total grid points before downsampling is applied for isosurface extraction.
+// 500K balances visual quality with interactive performance (<200ms marching cubes).
+const MAX_GRID_POINTS = 500_000;
+// Downsample a 3D volumetric grid to keep total point count under MAX_GRID_POINTS.
+// Uses block averaging to preserve data fidelity while reducing grid dimensions.
+// Returns original grid/dims if already within budget.
+export function downsample_grid(grid, dims) {
+    const [nx, ny, nz] = dims;
+    const total = nx * ny * nz;
+    if (total <= MAX_GRID_POINTS)
+        return { grid, dims, factor: 1 };
+    // Increase factor until the clamped output fits within budget.
+    // A single cbrt step can overshoot for anisotropic grids where max(2,...)
+    // clamping prevents a small axis from shrinking below 2.
+    // clamp_dim: returns 1 for single-cell axes, otherwise clamps to [2, src]
+    const clamp_dim = (src, fac) => Math.min(src, Math.max(2, Math.ceil(src / fac)));
+    let factor = Math.ceil(Math.cbrt(total / MAX_GRID_POINTS));
+    let new_nx = clamp_dim(nx, factor);
+    let new_ny = clamp_dim(ny, factor);
+    let new_nz = clamp_dim(nz, factor);
+    while (new_nx * new_ny * new_nz > MAX_GRID_POINTS) {
+        factor++;
+        new_nx = clamp_dim(nx, factor);
+        new_ny = clamp_dim(ny, factor);
+        new_nz = clamp_dim(nz, factor);
+    }
+    // Proportional partitioning: evenly divides [0, n) into new_n non-empty blocks.
+    // Unlike fixed-stride (ix * factor), this is safe when max(2,...) clamping
+    // produces more output cells than ceil(n/factor) would — no empty blocks.
+    const partition = (n_out, n_src) => Array.from({ length: n_out }, (_, idx) => [
+        Math.round(idx * n_src / n_out),
+        Math.round((idx + 1) * n_src / n_out),
+    ]);
+    const x_ranges = partition(new_nx, nx);
+    const y_ranges = partition(new_ny, ny);
+    const z_ranges = partition(new_nz, nz);
+    const out = new Array(new_nx);
+    for (let ix = 0; ix < new_nx; ix++) {
+        const plane = new Array(new_ny);
+        const [sx_start, sx_end] = x_ranges[ix];
+        for (let iy = 0; iy < new_ny; iy++) {
+            const row = new Array(new_nz);
+            const [sy_start, sy_end] = y_ranges[iy];
+            for (let iz = 0; iz < new_nz; iz++) {
+                let sum = 0;
+                const [sz_start, sz_end] = z_ranges[iz];
+                for (let sx = sx_start; sx < sx_end; sx++) {
+                    const src_plane = grid[sx];
+                    for (let sy = sy_start; sy < sy_end; sy++) {
+                        const src_row = src_plane[sy];
+                        for (let sz = sz_start; sz < sz_end; sz++) {
+                            sum += src_row[sz];
+                        }
+                    }
+                }
+                row[iz] = sum / ((sx_end - sx_start) * (sy_end - sy_start) * (sz_end - sz_start));
+            }
+            plane[iy] = row;
+        }
+        out[ix] = plane;
+    }
+    return { grid: out, dims: [new_nx, new_ny, new_nz], factor };
+}
 // Default isosurface rendering settings
 export const DEFAULT_ISOSURFACE_SETTINGS = {
     isovalue: 0.05,
@@ -42,6 +139,7 @@ export const DEFAULT_ISOSURFACE_SETTINGS = {
     negative_color: `#ef4444`, // red
     show_negative: false,
     wireframe: false,
+    halo: 0,
 };
 // Compute reasonable isosurface settings from a volume's data range.
 // Sets isovalue to 20% of abs_max and enables negative lobe when data has

package/dist/labels.d.ts

@@ -1,4 +1,5 @@
 import type { ChemicalElement, ElementCategory } from './element/types';
+import type { Vec3 } from './math';
 import type { SymbolType } from 'd3-shape';
 import * as d3_symbols from 'd3-shape';
 export type D3Symbol = keyof typeof d3_symbols & `symbol${Capitalize<string>}`;
@@ -12,7 +13,7 @@ export declare const ELEM_HEATMAP_LABELS: Partial<Record<string, keyof ChemicalE
 export declare const DEFAULT_FMT: [string, string];
 export declare const FRACTION_GLYPHS: ReadonlyArray<readonly [number, string]>;
 export declare const format_num: (num: number, fmt?: string | number) => string;
-export declare const format_vec3: (vec: readonly [number, number, number], fmt_spec?: string) => string;
+export declare const format_vec3: (vec: Readonly<Vec3>, fmt_spec?: string) => string;
 export declare const format_bytes: (bytes?: number) => string;
 export declare function format_fractional(value: number): string;
 export declare function parse_si_float<T extends string | number | null | undefined>(value: T): T | number | string;

package/dist/labels.js

@@ -56,6 +56,7 @@ export const ELEM_PROPERTY_LABELS = {
     electronegativity: [`Electronegativity`, null],
     first_ionization: [`First Ionization Energy`, `eV`],
     melting_point: [`Melting Point`, `K`],
+    mendeleev_number: [`Mendeleev Number`, null],
     // molar_heat: [`Molar Heat`, `J/(mol·K)`],
     n_shells: [`Number of Shells`, null],
     n_valence: [`Electron Valency`, null],