Upload folder using huggingface_hub

scripts/compute_cavd_channel_dimensionality.py

@@ -0,0 +1,305 @@
+"""CAVD-like channel dimensionality analysis for Li/Na ion migration pathways.
+
+Computes percolation channel dimensionality (0D/1D/2D/3D) from crystal structures
+using Voronoi-based void network analysis. Fills the ssb_screening block with:
+  - cavd_channel_dimensionality: "0D" | "1D" | "2D" | "3D" | "none"
+  - mobile_ion_site_volume: Volume of mobile ion Voronoi cell (A^3)
+  - mobile_ion_connectivity: Coordination of mobile ion sites
+
+This is a geometric pre-filter — materials with 0D channels or no percolation
+network are extremely unlikely to be good ionic conductors.
+
+Usage:
+    python scripts/compute_cavd_channel_dimensionality.py                    # subset: mobile-ion only
+    python scripts/compute_cavd_channel_dimensionality.py --subset battery   # battery edition only
+    python scripts/compute_cavd_channel_dimensionality.py --limit 1000       # first 1000 entries
+    python scripts/compute_cavd_channel_dimensionality.py --dry-run          # stats only, no save
+
+References:
+    - Zhang et al. Scientific Data (2020) — SPSE platform CAVD methodology
+    - pymatgen VoronoiConnectivity for void space analysis
+"""
+import json, os, sys, time, argparse, warnings
+from pathlib import Path
+import numpy as np
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+
+def parse_structure(structure_json_str):
+    from pymatgen.core import Structure
+    import json as _json
+    d = _json.loads(structure_json_str)
+    return Structure.from_dict(d)
+
+
+def compute_voronoi_connectivity(structure, mobile_element="Li", cutoff=10.0):
+    """Analyze mobile ion connectivity via Voronoi tessellation.
+    
+    Returns dict with:
+      - dimensionality : estimated channel dimensionality
+      - coordination : number of neighboring mobile ion sites
+      - site_volume : average Voronoi volume of mobile ion sites
+      - percolation : bool, whether 3D percolation is likely
+    """
+    from pymatgen.analysis.structure_analyzer import VoronoiConnectivity
+    
+    mobile_sites = [s for s in structure if s.specie.symbol == mobile_element]
+    if len(mobile_sites) < 2:
+        return {"dimensionality": "none", "coordination": 0, "site_volume": 0.0, "percolation": False}
+    
+    try:
+        vc = VoronoiConnectivity(structure, mobile_element, cutoff=cutoff)
+        connectivity = vc.get_connectivity()
+    except Exception:
+        connectivity = {}
+    
+    # Analyze mobile ion sublattice geometry
+    frac_coords = np.array([s.frac_coords for s in mobile_sites])
+    
+    n_mobile = len(mobile_sites)
+    if n_mobile < 2:
+        return {"dimensionality": "none", "coordination": 0, "site_volume": 0.0, "percolation": False}
+    
+    lattice = structure.lattice
+    
+    from scipy.spatial import KDTree
+    
+    all_coords = []
+    for i, site in enumerate(mobile_sites):
+        for image in [(0,0,0), (1,0,0), (-1,0,0), (0,1,0), (0,-1,0), 
+                       (0,0,1), (0,0,-1), (1,1,0), (1,-1,0), (-1,1,0), (-1,-1,0),
+                       (1,0,1), (1,0,-1), (-1,0,1), (-1,0,-1), (0,1,1), (0,1,-1),
+                       (0,-1,1), (0,-1,-1)]:
+            shift = np.array(image, dtype=float)
+            cart = lattice.get_cartesian_coords(site.frac_coords + shift)
+            all_coords.append((i, cart, image))
+    
+    coords = np.array([c[1] for c in all_coords])
+    indices = np.array([c[0] for c in all_coords])
+    
+    if len(coords) == 0:
+        return {"dimensionality": "none", "coordination": 0, "site_volume": 0.0, "percolation": False}
+    
+    tree = KDTree(coords)
+    
+    coordination_counts = []
+    
+    for i in range(n_mobile):
+        point = lattice.get_cartesian_coords(mobile_sites[i].frac_coords)
+        nn = tree.query_ball_point(point, r=5.0)
+        nn_indices = indices[nn]
+        nn_self = sum(1 for j in nn_indices if j == i)
+        nn_count = len(nn_indices) - nn_self
+        coordination_counts.append(nn_count)
+    
+    mean_coordination = np.mean(coordination_counts) if coordination_counts else 0
+    
+    if mean_coordination >= 4:
+        dimensionality = "3D"
+        percolation = True
+    elif mean_coordination >= 2:
+        dimensionality = "2D"
+        percolation = True
+    elif mean_coordination >= 1:
+        dimensionality = "1D"
+        percolation = False
+    else:
+        dimensionality = "0D"
+        percolation = False
+    
+    try:
+        site_volumes = []
+        for site in mobile_sites:
+            from scipy.spatial import Voronoi as ScipyVoronoi
+            
+            neighbors = structure.get_neighbors(site, r=cutoff)
+            if len(neighbors) < 4:
+                site_volumes.append(0.0)
+                continue
+            
+            points = [site.coords]
+            for n_site, dist, _, _ in neighbors:
+                points.append(n_site.coords)
+            
+            if len(points) < 4:
+                site_volumes.append(0.0)
+                continue
+            
+            try:
+                vor = ScipyVoronoi(np.array(points))
+                region_idx = vor.point_region[0]
+                region = vor.regions[region_idx]
+                if -1 not in region and len(region) > 0:
+                    verts = vor.vertices[region]
+                    from scipy.spatial import ConvexHull
+                    hull = ConvexHull(verts)
+                    site_volumes.append(hull.volume)
+                else:
+                    site_volumes.append(0.0)
+            except Exception:
+                site_volumes.append(0.0)
+        
+        avg_site_volume = np.mean(site_volumes) if site_volumes else 0.0
+    except Exception:
+        avg_site_volume = 0.0
+    
+    return {
+        "dimensionality": dimensionality,
+        "coordination": round(float(mean_coordination), 2),
+        "site_volume": round(float(avg_site_volume), 4),
+        "percolation": percolation
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="CAVD channel dimensionality analysis")
+    parser.add_argument("--subset", choices=["battery", "electrolyte", "gold", "full"], default="full")
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--dry-run", action="store_true", help="Don't save results")
+    parser.add_argument("--output", type=str, default=None, help="Custom output path")
+    args = parser.parse_args()
+    
+    if args.limit and not args.dry_run and args.output is None:
+        print("ERROR: Refusing to save limited runs. Use --dry-run or --output.")
+        sys.exit(1)
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * WIDTH)
+    print("  CAVD CHANNEL DIMENSIONALITY ANALYSIS")
+    print("  Geometric pre-filter for Li/Na ion migration pathways")
+    print("=" * WIDTH)
+    
+    print("\nLoading entries from typed Parquet...")
+    t0 = time.time()
+    sys.path.insert(0, str(BASE_DIR))
+    from dataset.dataset_store import DatasetStore
+    store = DatasetStore.open()
+    print(f"  {store.num_entries:,} total entries ({time.time()-t0:.1f}s)")
+    
+    mobile_elements = {"Li", "Na"}
+    
+    # Load subset IDs if filtering
+    subset_ids = None
+    if args.subset == "battery":
+        with open(DATASET_PATH / "battery_candidate_subset_v1.json") as f:
+            battery = json.load(f)
+        subset_ids = {e.get("source_id", "") + e.get("source", "") for e in battery}
+    elif args.subset == "electrolyte":
+        with open(DATASET_PATH / "solid_electrolyte_candidate_subset_v1.json") as f:
+            electrolyte = json.load(f)
+        subset_ids = {e.get("source_id", "") + e.get("source", "") for e in electrolyte}
+    
+    # Collect target entries
+    skipped_no_mobile = 0
+    skipped_no_structure = 0
+    target_ids = []
+    
+    for e in store.scan(columns=["source_id", "source", "mobile_ion", "structure_json"]):
+        mobile_ion = e.get("mobile_ion", "")
+        if mobile_ion not in mobile_elements:
+            skipped_no_mobile += 1
+            continue
+        if not e.get("structure_json"):
+            skipped_no_structure += 1
+            continue
+        key = e.get("source_id", "") + e.get("source", "")
+        if subset_ids is not None and key not in subset_ids:
+            continue
+        target_ids.append(e["source_id"])
+    
+    print(f"  Li/Na mobile ion entries with structures: {len(target_ids):,}")
+    print(f"  Skipped (no mobile ion): {skipped_no_mobile:,}")
+    print(f"  Skipped (no structure): {skipped_no_structure:,}")
+    
+    if args.subset == "gold":
+        gold_ids = set()
+        for e in store.scan(columns=["source_id", "tier"]):
+            if e.get("tier") == "gold":
+                gold_ids.add(e["source_id"])
+        target_ids = [sid for sid in target_ids if sid in gold_ids]
+        print(f"  Subset (gold): {len(target_ids):,} entries")
+    elif args.subset != "full":
+        print(f"  Subset ({args.subset}): {len(target_ids):,} entries")
+    
+    if args.limit:
+        target_ids = target_ids[:args.limit]
+        print(f"  Limited to {args.limit} entries")
+    
+    if not target_ids:
+        print("No entries to process.")
+        return
+    
+    # Process entries
+    print(f"\n{'─' * WIDTH}")
+    print("  Computing channel dimensionality...")
+    print(f"{'─' * WIDTH}")
+    
+    processed = 0
+    errors = 0
+    dims = {"3D": 0, "2D": 0, "1D": 0, "0D": 0, "none": 0, "error": 0}
+    t_start = time.time()
+    
+    for idx, source_id in enumerate(target_ids):
+        entry = store.lookup(source_id)
+        if entry is None:
+            continue
+        
+        mobile_ion = entry.get("mobile_ion", "Li")
+        
+        try:
+            structure = parse_structure(entry["structure_json"])
+            result = compute_voronoi_connectivity(structure, mobile_element=mobile_ion)
+            
+            store.update_field(source_id, "ssb_screening",
+                result["dimensionality"], nested_path="cavd_channel_dimensionality")
+            store.update_field(source_id, "ssb_screening",
+                result["coordination"], nested_path="mobile_ion_connectivity")
+            store.update_field(source_id, "ssb_screening",
+                result["site_volume"], nested_path="mobile_ion_site_volume")
+            
+            dims[result["dimensionality"]] += 1
+            processed += 1
+            
+        except Exception as exc:
+            errors += 1
+            if errors <= 5:
+                print(f"  Error [{source_id}]: {str(exc)[:80]}")
+            store.update_field(source_id, "ssb_screening",
+                "error", nested_path="cavd_channel_dimensionality")
+        
+        if (idx + 1) % 500 == 0:
+            elapsed = time.time() - t_start
+            rate = (idx + 1) / elapsed if elapsed > 0 else 0
+            pct = (idx + 1) / len(target_ids) * 100
+            print(f"  {idx+1}/{len(target_ids)} ({pct:.0f}%) | "
+                  f"3D:{dims['3D']} 2D:{dims['2D']} 1D:{dims['1D']} 0D:{dims['0D']} "
+                  f"| {rate:.1f} ent/s")
+    
+    elapsed = time.time() - t_start
+    print(f"\n{'─' * WIDTH}")
+    print(f"  Complete: {processed} processed, {errors} errors")
+    print(f"  Time: {elapsed/60:.1f} min ({processed/elapsed:.1f} ent/s)")
+    print(f"\n  Channel dimensionality distribution:")
+    for dim, count in sorted(dims.items()):
+        if count > 0:
+            print(f"    {dim}: {count:,} ({count/max(processed,1)*100:.1f}%)")
+    
+    if args.dry_run:
+        print("\n  (dry-run — not saved)")
+        store._dirty = False
+        store.close()
+    else:
+        print(f"\n  Writing to Parquet...")
+        t_write = time.time()
+        store.checkpoint()
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_electrochemical_windows.py

@@ -0,0 +1,416 @@
+"""Compute electrochemical stability windows from dataset's own formation energies.
+
+Self-contained — no MP API needed. Uses pymatgen PhaseDiagram built from the
+266k entries already in the dataset. Fills the ssb_screening block with:
+  - stability_window_low_V
+  - stability_window_high_V
+  - interfacial_reaction_energy_vs_Li_eV_atom
+  - passivating_interphase
+
+Algorithm per entry:
+  1. Group entries by chemical system (sorted element tuple).
+  2. Build a local convex hull from *all* entries in that system.
+  3. Compute decomposition energy (E_above_hull) from the local hull.
+  4. For the grand potential window against Li/Na:
+     a. Add the reservoir element to the chemical system.
+     b. Build a GrandPotentialPhaseDiagram at varying μ.
+     c. Find the voltage range where E_hull(μ) ≈ 0.
+
+Usage:
+    python scripts/compute_electrochemical_windows.py                    # full dataset
+    python scripts/compute_electrochemical_windows.py --subset battery   # battery only
+    python scripts/compute_electrochemical_windows.py --subset gold      # gold tier only
+    python scripts/compute_electrochemical_windows.py --limit 1000      # first 1000 entries
+"""
+
+import json, os, sys, time, argparse, itertools, warnings, math
+from pathlib import Path
+from collections import defaultdict
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute electrochemical stability windows")
+    parser.add_argument("--subset", choices=["battery", "electrolyte", "gold", "full"], default="full")
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--min-system-size", type=int, default=3,
+                        help="Minimum entries in a chemical system to build a hull (default: 3)")
+    parser.add_argument("--dry-run", action="store_true", help="Don't save results, just print stats")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Custom output path (default: dataset/entries_final_v3.json)")
+    args = parser.parse_args()
+    
+    # SAFETY: refuse to save a limited run back to the dataset
+    if args.limit and not args.dry_run and args.output is None:
+        print("ERROR: Refusing to save limited runs. Use --dry-run or --output to specify a safe path.")
+        print("  python scripts/compute_electrochemical_windows.py --limit 100 --dry-run")
+        sys.exit(1)
+
+    try:
+        from pymatgen.analysis.phase_diagram import PhaseDiagram, GrandPotentialPhaseDiagram, PDEntry
+        from pymatgen.core import Composition, Element
+    except ImportError as e:
+        print(f"ERROR: pymatgen not available: {e}")
+        print("Install: pip install pymatgen")
+        sys.exit(1)
+
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+
+    print("=" * WIDTH)
+    print("  ELECTROCHEMICAL WINDOWS — SELF-CONTAINED")
+    print("  Using dataset's own formation energies (no MP API)")
+    print("=" * WIDTH)
+
+    # Load source dataset
+    print("\nLoading entries...")
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} total entries")
+
+    # Select working subset
+    if args.subset == "battery":
+        with open(DATASET_PATH / "battery_candidate_subset_v1.json") as f:
+            entries = json.load(f)
+        entries = [e for e in entries if any(el in e.get("elements", []) for el in ["Li", "Na"])]
+    elif args.subset == "electrolyte":
+        with open(DATASET_PATH / "solid_electrolyte_candidate_subset_v1.json") as f:
+            entries = json.load(f)
+        entries = [e for e in entries if any(el in e.get("elements", []) for el in ["Li", "Na"])]
+    elif args.subset == "gold":
+        entries = [e for e in all_entries if e.get("tier") == "gold" and any(el in e.get("elements", []) for el in ["Li", "Na"])]
+    else:
+        entries = all_entries
+
+    if args.limit:
+        entries = entries[:args.limit]
+    print(f"  Working subset: {len(entries):,} entries")
+
+    # Reference energies for terminal (pure element) entries
+    # Standard PBE reference energies from pymatgen/MP
+    # Solid elements: 0 eV/atom (elemental ground state)
+    # Gaseous elements: corrected to match PBE formation energies
+    TERMINAL_REF_ENERGIES = {
+        "O": -4.935,   # O2 gas correction (standard PBE)
+        "N": -8.100,   # N2 gas correction
+        "F": -1.500,   # F2 gas correction (approx)
+        "Cl": -1.700,  # Cl2 gas correction (approx)
+        "Br": -0.500,  # Br2 liquid correction (approx)
+        "H": -3.300,   # H2 gas correction
+    }
+    
+    def make_terminal_entries(system):
+        """Create PDEntry objects for pure elements in the system."""
+        entries = []
+        for el_symbol in system:
+            el = Element(el_symbol)
+            comp = Composition({el: 1})
+            ref_energy = TERMINAL_REF_ENERGIES.get(el_symbol, 0.0)
+            entries.append(PDEntry(comp, ref_energy, name=f"{el_symbol}(ref)"))
+        return entries
+
+    # Build hulls from ALL entries (full 266k) for maximum coverage
+    print("\nBuilding convex hulls from ALL entries (full dataset)...")
+    all_systems = defaultdict(list)
+    for e in all_entries:
+        fe = e.get("formation_energy_per_atom") or e.get("formation_energy")
+        if fe is None:
+            continue
+        system = tuple(sorted(e.get("elements", [])))
+        all_systems[system].append((e, fe))
+    
+    hulls = {}
+    hull_built = 0
+    hull_failed = 0
+    for system, entries_in_system in all_systems.items():
+        if len(entries_in_system) < args.min_system_size:
+            continue
+        
+        # Build compound entries
+        compound_entries = []
+        for e, fe in entries_in_system:
+            try:
+                formula = e.get("formula", "")
+                comp = Composition(formula)
+                total_energy = fe * comp.num_atoms
+                compound_entries.append(PDEntry(comp, total_energy))
+            except Exception:
+                pass
+        
+        if len(compound_entries) < args.min_system_size:
+            continue
+        
+        # Add terminal entries (pure elements) — required for PhaseDiagram
+        terminal_entries = make_terminal_entries(system)
+        all_pd_entries = terminal_entries + compound_entries
+        
+        try:
+            hulls[system] = PhaseDiagram(all_pd_entries)
+            hull_built += 1
+        except Exception as exc:
+            hull_failed += 1
+            if hull_failed <= 5:
+                print(f"  Hull failed for {system}: {str(exc)[:80]}")
+
+    print(f"  Built {hull_built:,} hulls, {hull_failed:,} failed ({len(all_systems):,} systems total)")
+    
+    # Now select the working subset for computation
+    # Only entries with Li or Na as mobile ion, hull-covered, and with formation energy
+    valid = []
+    for e in entries:
+        elements = e.get("elements", [])
+        if not any(el in elements for el in ["Li", "Na"]):
+            continue
+        fe = e.get("formation_energy_per_atom") or e.get("formation_energy")
+        if fe is None:
+            continue
+        system = tuple(sorted(elements))
+        if system in hulls:
+            e["_fe"] = fe
+            e["_system"] = system
+            valid.append(e)
+    print(f"  Li/Na entries in hull-covered systems: {len(valid):,}")
+
+    if not valid:
+        print("No entries in hull-covered systems. Try reducing --min-system-size.")
+        return
+
+    # Pre-build PhaseDiagrams INCLUDING the mobile element for each system
+    # so we don't rebuild for every entry
+    print("\nBuilding combined hulls with Li/Na...")
+    combined_hulls = {}  # (system, mobile_el_str) -> PhaseDiagram
+    for system, pd in hulls.items():
+        for mobile in ("Li", "Na"):
+            if mobile in system:
+                # Mobile element is already in the system — use the same Pd
+                combined_hulls[(system, mobile)] = pd
+            else:
+                # Build a new Pd including the mobile element
+                extended_system = tuple(sorted(set(system + (mobile,))))
+                
+                # Add existing terminal entries + mobile terminal + compound entries
+                mobile_terminal = PDEntry(Composition({mobile: 1}), 0.0, name=f"{mobile}(ref)")
+                try:
+                    grand_pd = PhaseDiagram(list(pd.all_entries) + [mobile_terminal])
+                    combined_hulls[(system, mobile)] = grand_pd
+                except Exception:
+                    pass
+    print(f"  Combined hulls built: {len(combined_hulls):,}")
+
+    LI_METAL_ENERGY = 0.0
+    NA_METAL_ENERGY = 0.0
+
+    def compute_stability_window(pd, entry_pd, mobile_element, combined_pd):
+        """Compute the electrochemical stability window using grand potential scan.
+        
+        pd: PhaseDiagram for the chemical system (without mobile element reservoir)
+        entry_pd: PDEntry for the target material
+        mobile_element: "Li" or "Na"
+        combined_pd: PhaseDiagram including the mobile element as a terminal
+        
+        Returns dict with window_V, decomp_energy, passivating_flag.
+        """
+        try:
+            # Check formation energy relative to base hull
+            decomp = pd.get_decomp_and_e_above_hull(entry_pd)
+            if decomp is None:
+                return None
+            _, e_above_hull = decomp
+            if e_above_hull > 0.5:
+                return None
+            
+            mobile_el = Element(mobile_element)
+            n_mobile = entry_pd.composition.get(mobile_el, 0)
+            
+            # Scan μ from 0V (pure metal) to -5V vs M/M+
+            # Compute grand potential of the entry vs competing phases at each μ
+            stable_range = [None, None]
+            prev_stable = None
+            
+            for mu_V in [x * 0.1 for x in range(0, 51)]:
+                mu = -mu_V
+                gp_entry = entry_pd.energy - mu * n_mobile
+                
+                # Minimum grand potential among competing phases
+                gp_comp = float('inf')
+                for other in combined_pd.all_entries:
+                    if id(other) == id(entry_pd):
+                        continue
+                    n_other = other.composition.get(mobile_el, 0) if mobile_el in other.composition.elements else 0
+                    gp_other = other.energy - mu * n_other
+                    if gp_other < gp_comp:
+                        gp_comp = gp_other
+                
+                is_stable = gp_entry <= gp_comp + 1e-4
+                
+                if prev_stable is None:
+                    prev_stable = is_stable
+                elif is_stable != prev_stable:
+                    mid_V = mu_V - 0.05
+                    if prev_stable and not is_stable:
+                        stable_range[1] = mid_V
+                    elif not prev_stable and is_stable:
+                        stable_range[0] = mid_V
+                    prev_stable = is_stable
+            
+            if prev_stable:
+                if stable_range[0] is None:
+                    stable_range[0] = 0.0
+                if stable_range[1] is None:
+                    stable_range[1] = 5.0
+            
+            # Passivating interphase heuristic
+            passivating = False
+            if stable_range[0] is not None and stable_range[0] > 0.1:
+                mu = 0.0
+                gp_products = []
+                for other in combined_pd.all_entries:
+                    if id(other) == id(entry_pd):
+                        continue
+                    n_other = other.composition.get(mobile_el, 0) if mobile_el in other.composition.elements else 0
+                    gp = other.energy - mu * n_other
+                    gp_products.append((gp, other))
+                
+                if gp_products:
+                    gp_products.sort(key=lambda x: x[0])
+                    best_decomp = gp_products[0][1]
+                    solid_elements = [el.symbol for el in best_decomp.composition.elements 
+                                    if el.symbol not in ("O2", "N2", "Cl2", "F2", "S")]
+                    if len(solid_elements) >= 2:
+                        passivating = True
+            
+            result = {
+                "stability_window_low_V": round(stable_range[0], 3) if stable_range[0] is not None else None,
+                "stability_window_high_V": round(stable_range[1], 3) if stable_range[1] is not None else None,
+                "decomp_energy_eV_per_atom": round(e_above_hull, 4),
+                "passivating_interphase": passivating,
+                "method": "grand_potential_scan"
+            }
+            
+            if stable_range[0] is not None and stable_range[1] is not None:
+                result["window_width_V"] = round(stable_range[1] - stable_range[0], 3)
+            
+            return result
+        
+        except Exception as exc:
+            return {"error": str(exc)[:100]}
+
+    # Process entries
+    print(f"\n{'─' * WIDTH}")
+    print("  Computing stability windows...")
+    print(f"{'─' * WIDTH}")
+
+    processed = 0
+    errors = 0
+    skipped = 0
+    windows_found = 0
+    t_start = time.time()
+
+    for idx, e in enumerate(valid):
+        system = e["_system"]
+        pd = hulls[system]
+        
+        # Create PDEntry for this specific entry
+        try:
+            formula = e.get("formula", "")
+            fe = e.get("_fe")
+            comp = Composition(formula)
+            total_energy = fe * comp.num_atoms
+            entry_pd = PDEntry(comp, total_energy)
+        except Exception:
+            errors += 1
+            continue
+        
+        # Determine mobile element (preferred: Li > Na)
+        elements_set = e.get("elements", [])
+        mobile_el = "Li" if "Li" in elements_set else "Na"
+        
+        # Get the combined hull (with mobile element as terminal)
+        combined_key = (system, mobile_el)
+        combined_pd = combined_hulls.get(combined_key, pd)
+        
+        # Compute window
+        result = compute_stability_window(pd, entry_pd, mobile_el, combined_pd)
+        
+        # Fill ssb_screening block
+        if "ssb_screening" not in e:
+            e["ssb_screening"] = {}
+        
+        if result and "error" not in result:
+            e["ssb_screening"]["stability_window_low_V"] = result["stability_window_low_V"]
+            e["ssb_screening"]["stability_window_high_V"] = result["stability_window_high_V"]
+            e["ssb_screening"]["window_width_V"] = result.get("window_width_V")
+            e["ssb_screening"]["interfacial_reaction_energy_vs_Li_eV_atom"] = result["decomp_energy_eV_per_atom"]
+            e["ssb_screening"]["passivating_interphase"] = result["passivating_interphase"]
+            windows_found += 1
+        elif result:
+            errors += 1
+        
+        processed += 1
+        
+        if processed % 100 == 0:
+            elapsed = time.time() - t_start
+            rate = processed / elapsed if elapsed > 0 else 0
+            pct = processed / len(valid) * 100
+            eta = (len(valid) - processed) / rate if rate > 0 else 0
+            print(f"  {processed}/{len(valid)} ({pct:.0f}%) "
+                  f"| {windows_found} windows | {rate:.1f} ent/s | ETA {eta/60:.0f}min")
+
+    elapsed = time.time() - t_start
+    print(f"\n{'─' * WIDTH}")
+    print(f"  Complete: {processed} processed, {windows_found} windows, {errors} errors, {skipped} skipped")
+    print(f"  Time: {elapsed/60:.1f} min ({processed/elapsed:.1f} entries/s)")
+
+    # Determine output path — NEVER overwrite the main dataset when running on a subset
+    if args.subset == "battery":
+        output_path = DATASET_PATH / "battery_candidate_subset_v1.json"
+        save_data = entries
+    elif args.subset == "electrolyte":
+        output_path = DATASET_PATH / "solid_electrolyte_candidate_subset_v1.json"
+        save_data = entries
+    elif args.subset == "gold":
+        output_path = DATASET_PATH / "gold_subset_v1.json"
+        save_data = entries
+    else:
+        output_path = DATASET_PATH / "entries_final_v3.json"
+        save_data = all_entries
+
+    if args.dry_run:
+        print("  (dry-run — not saved)")
+    else:
+        with open(output_path, "w") as f:
+            json.dump(save_data, f)
+        print(f"  Saved to {output_path}")
+    
+    # Stats
+    with_window = 0
+    for entry_batch in [all_entries if args.subset == "full" else entries]:
+        for entry in entry_batch:
+            ss = entry.get("ssb_screening", {})
+            if ss.get("stability_window_low_V") is not None:
+                with_window += 1
+    
+    print(f"\n  Entries with stability windows: {with_window:,}")
+    
+    # Distribution
+    windows = []
+    for entry_batch in [all_entries if args.subset == "full" else entries]:
+        for entry in entry_batch:
+            ss = entry.get("ssb_screening", {})
+            low = ss.get("stability_window_low_V")
+            high = ss.get("stability_window_high_V")
+            if low is not None and high is not None:
+                windows.append(high - low)
+    
+    if windows:
+        print(f"  Window width distribution (V):")
+        for threshold in [0.5, 1.0, 2.0, 3.0, 4.0, 5.0]:
+            count = sum(1 for w in windows if w >= threshold)
+            print(f"    ≥{threshold:.1f} V: {count:,} ({count/len(windows)*100:.1f}%)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_jarvis_hull_energy.py

@@ -0,0 +1,218 @@
+"""Compute energy above hull for JARVIS entries via internal convex hull.
+
+JARVIS-DFT entries (25,673) currently have no energy_above_hull values because
+they come from a different DFT methodology (optPBE + TBmBJ). This script builds
+internal convex hulls within the JARVIS subset and computes EaH relative to those.
+
+This is an approximate correction — the true hull for JARVIS entries is the
+Materials Project convex hull (PAW-PBE). The internal hull gives a first-pass
+stability estimate until a proper cross-method correction is developed.
+
+Usage:
+    python scripts/compute_jarvis_hull_energy.py
+    python scripts/compute_jarvis_hull_energy.py --dry-run
+    python scripts/compute_jarvis_hull_energy.py --limit 5000
+"""
+import json, os, sys, time, argparse, warnings
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+import pyarrow as pa
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute EaH for JARVIS entries via internal hull")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * WIDTH)
+    print("  JARVIS ENERGY ABOVE HULL")
+    print("  Internal convex hull within JARVIS subset")
+    print("=" * WIDTH)
+    
+    print("\nLoading entries from typed Parquet...")
+    t0 = time.time()
+    sys.path.insert(0, str(BASE_DIR))
+    from dataset.dataset_store import DatasetStore
+    store = DatasetStore.open()
+    print(f"  {store.num_entries:,} entries ({time.time()-t0:.1f}s)")
+    
+    # Load all JARVIS entries in one batch (reduced columns)
+    print(f"\n  Loading JARVIS entries...")
+    jarvis_entries = [
+        e for e in store.scan(columns=[
+            "source_id", "source", "formula", "elements",
+            "energy_above_hull", "formation_energy_per_atom",
+        ])
+        if e.get("source") == "jarvis"
+    ]
+    print(f"  {len(jarvis_entries):,} JARVIS entries loaded")
+    
+    if args.limit:
+        jarvis_entries = jarvis_entries[:args.limit]
+    
+    jarvis_with_eah = sum(1 for e in jarvis_entries if e.get("energy_above_hull") is not None)
+    print(f"  JARVIS with EaH already: {jarvis_with_eah}")
+    
+    from pymatgen.analysis.phase_diagram import PhaseDiagram, PDEntry
+    from pymatgen.core import Composition
+    
+    print(f"\n  Building JARVIS internal convex hulls...")
+    
+    systems = defaultdict(list)
+    for e in jarvis_entries:
+        elements = tuple(sorted(set(e.get("elements", []))))
+        fe = e.get("formation_energy_per_atom")
+        if fe is None:
+            continue
+        systems[elements].append((e, fe))
+    
+    print(f"  Chemical systems in JARVIS: {len(systems)}")
+    
+    TERMINAL_ENERGIES = {
+        "O": -4.935, "N": -8.100, "F": -1.500, "Cl": -1.700, 
+        "Br": -0.500, "H": -3.300,
+    }
+    
+    hulls = {}
+    hull_systems = 0
+    hull_failed = 0
+    
+    for system, entries_in_system in systems.items():
+        if len(entries_in_system) < 3:
+            continue
+        
+        compound_entries = []
+        for e, fe in entries_in_system:
+            try:
+                formula = e.get("formula", "")
+                comp = Composition(formula)
+                total_energy = fe * comp.num_atoms
+                compound_entries.append(PDEntry(comp, total_energy, name=e.get("source_id", "")))
+            except Exception:
+                pass
+        
+        if len(compound_entries) < 3:
+            continue
+        
+        terminal_entries = []
+        for el_symbol in system:
+            ref_energy = TERMINAL_ENERGIES.get(el_symbol, 0.0)
+            terminal_entries.append(PDEntry(Composition({el_symbol: 1}), ref_energy, name=f"{el_symbol}(ref)"))
+        
+        all_pd_entries = terminal_entries + compound_entries
+        
+        try:
+            hulls[system] = PhaseDiagram(all_pd_entries)
+            hull_systems += 1
+        except Exception:
+            hull_failed += 1
+    
+    print(f"  Hulls built: {hull_systems}, failed: {hull_failed}")
+    
+    print(f"\n  Computing EaH for JARVIS entries...")
+    
+    computed = 0
+    errors = 0
+    already_have = 0
+    hull_missing = 0
+    
+    # Batch updates: collect row_idx → new value, then apply once
+    col_idx = store._table.schema.get_field_index("energy_above_hull")
+    old_col = store._table.column("energy_above_hull")
+    new_values = old_col.to_pylist()
+    
+    t_start = time.time()
+    for idx, e in enumerate(jarvis_entries):
+        elements = tuple(sorted(set(e.get("elements", []))))
+        fe = e.get("formation_energy_per_atom")
+        
+        if fe is None:
+            continue
+        
+        row_idx = store._index.get(e["source_id"])
+        if row_idx is None:
+            continue
+        
+        if new_values[row_idx] is not None:
+            already_have += 1
+            continue
+        
+        pd = hulls.get(elements)
+        if pd is None:
+            hull_missing += 1
+            continue
+        
+        try:
+            formula = e.get("formula", "")
+            comp = Composition(formula)
+            total_energy = fe * comp.num_atoms
+            entry = PDEntry(comp, total_energy)
+            
+            decomp = pd.get_decomp_and_e_above_hull(entry)
+            if decomp is not None:
+                _, e_above_hull = decomp
+                new_values[row_idx] = round(float(e_above_hull), 6)
+                computed += 1
+            else:
+                hull_missing += 1
+        except Exception:
+            errors += 1
+        
+        if (idx + 1) % 5000 == 0:
+            elapsed = time.time() - t_start
+            print(f"  {idx+1}/{len(jarvis_entries)} computed={computed} hull_missing={hull_missing} ({elapsed:.0f}s)")
+    
+    # Apply batch update to the table
+    print(f"  Applying {computed} batch updates to Parquet table...")
+    new_col = pa.chunked_array([pa.array(new_values, type=old_col.type)])
+    store._table = store._table.set_column(col_idx, "energy_above_hull", new_col)
+    store._dirty = True
+    
+    print(f"\n  JARVIS EaH results:")
+    print(f"    Already had EaH: {already_have:,}")
+    print(f"    Computed (new): {computed:,}")
+    print(f"    No hull available: {hull_missing:,}")
+    print(f"    Errors: {errors:,}")
+    
+    # Print examples
+    print(f"\n  Sample JARVIS entries with computed EaH:")
+    shown = 0
+    for e in jarvis_entries:
+        row_idx = store._index.get(e["source_id"])
+        if row_idx is None:
+            continue
+        eah = new_values[row_idx]
+        if eah is not None:
+            if shown < 5:
+                formula = e.get("formula", "")
+                fe = e.get("formation_energy_per_atom", 0)
+                print(f"    {formula:30s} FE={fe:+.4f} EaH={eah:.4f}")
+                shown += 1
+    
+    total_eah = sum(1 for v in new_values if v is not None)
+    print(f"\n  Overall EaH coverage after update: {total_eah:,}/{store.num_entries:,} ({total_eah/store.num_entries*100:.1f}%)")
+    
+    if args.dry_run:
+        print(f"\n  (dry-run — not saved)")
+        store._dirty = False
+        store.close()
+    else:
+        output_path = DATASET_PATH / "entries_v4_typed.parquet"
+        print(f"\n  Writing to {output_path}...")
+        t_write = time.time()
+        store.checkpoint()
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_mechanical_properties.py

@@ -0,0 +1,229 @@
+"""Pull mechanical properties (elastic moduli) for MP entries via MP API.
+
+For entries from Materials Project, this script queries the MP API for
+elastic tensor data (bulk modulus, shear modulus, Young's modulus, Poisson ratio).
+For non-MP entries, it attempts a geometric proxy based on bond density.
+
+Fills the ssb_screening block with:
+  - bulk_modulus_GPa
+  - shear_modulus_GPa
+  - youngs_modulus_GPa
+  - poisson_ratio
+  - elastic_source: "MP_API" | "geometric_proxy" | null
+  - dendrite_suppression_flag: shear_modulus > 6 GPa (Monroe-Newman criterion)
+
+Usage:
+    python scripts/compute_mechanical_properties.py
+    python scripts/compute_mechanical_properties.py --api-key YOUR_KEY
+    python scripts/compute_mechanical_properties.py --mp-only
+    python scripts/compute_mechanical_properties.py --proxy-only
+    python scripts/compute_mechanical_properties.py --dry-run
+"""
+import json, os, sys, time, argparse, warnings
+from pathlib import Path
+import numpy as np
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+# Monroe-Newman criterion: G_solid > ~2x G_Li for dendrite suppression
+LI_SHEAR_MODULUS = 4.25  # GPa at room temp (varies 3.4-4.8)
+DENDRITE_THRESHOLD = 6.0  # GPa conservative threshold
+
+
+def compute_density_proxy(structure):
+    """Compute geometric proxy for elastic moduli from structure.
+    
+    Based on bond density and packing fraction correlations.
+    Returns approximate bulk_modulus and shear_modulus in GPa.
+    """
+    try:
+        density = structure.density
+        n_atoms = len(structure)
+        volume = structure.volume
+        
+        if volume <= 0 or n_atoms < 2:
+            return None, None, "insufficient_data"
+        
+        # Atomic packing density proxy
+        # Sum of approximate atomic volumes (using covalent radii)
+        atomic_vol = 0.0
+        for site in structure:
+            el = site.specie.symbol
+            r_cov = {
+                "Li": 1.28, "Na": 1.66, "Mg": 1.41, "Al": 1.21, "Si": 1.11,
+                "P": 1.07, "S": 1.05, "Cl": 1.02, "K": 2.03, "Ca": 1.76,
+                "Ti": 1.47, "V": 1.34, "Cr": 1.27, "Mn": 1.26, "Fe": 1.25,
+                "Co": 1.24, "Ni": 1.21, "Cu": 1.22, "Zn": 1.20, "Ga": 1.22,
+                "Ge": 1.21, "As": 1.21, "Se": 1.17, "Br": 1.14, "Y": 1.78,
+                "Zr": 1.57, "Nb": 1.45, "Mo": 1.38, "Ru": 1.33, "Rh": 1.31,
+                "Pd": 1.30, "Ag": 1.34, "Cd": 1.36, "In": 1.42, "Sn": 1.40,
+                "Sb": 1.40, "Te": 1.37, "I": 1.33, "La": 1.87, "Ce": 1.82,
+                "Pr": 1.82, "Nd": 1.81, "Sm": 1.80, "Eu": 1.80, "Gd": 1.79,
+                "Tb": 1.76, "Dy": 1.75, "Ho": 1.74, "Er": 1.73, "Tm": 1.72,
+                "Yb": 1.71, "Lu": 1.70, "Ta": 1.45, "W": 1.39, "Pb": 1.44,
+                "Bi": 1.50, "O": 0.66, "N": 0.71, "F": 0.64, "H": 0.31,
+            }.get(el, 1.5)
+            atomic_vol += (4.0/3.0) * np.pi * (r_cov ** 3)
+        
+        packing_fraction = atomic_vol / volume if volume > 0 else 0.3
+        
+        # Correlation: denser packing -> higher moduli
+        # Bulk modulus roughly scales with cohesive energy density
+        coh_energy_density = density * 100  # rough proxy in GPa-like units
+        
+        bulk_modulus = coh_energy_density * (packing_fraction ** 1.5)
+        shear_modulus = bulk_modulus * (packing_fraction ** 0.5) * 0.5
+        
+        # Clamp to realistic ranges
+        bulk_modulus = max(5.0, min(400.0, bulk_modulus))
+        shear_modulus = max(2.0, min(300.0, shear_modulus))
+        
+        return round(bulk_modulus, 2), round(shear_modulus, 2), "geometric_proxy"
+    except Exception:
+        return None, None, "error"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute mechanical properties")
+    parser.add_argument("--api-key", type=str, default=None,
+                        help="Materials Project API key (optional, for live API queries)")
+    parser.add_argument("--mp-only", action="store_true",
+                        help="Only process MP entries (skip geometric proxy)")
+    parser.add_argument("--proxy-only", action="store_true",
+                        help="Only use geometric proxy (skip MP API)")
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--output", type=str, default=None)
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * WIDTH)
+    print("  MECHANICAL PROPERTIES — ELASTIC MODULI")
+    print(f"  Dendrite suppression threshold: G > {DENDRITE_THRESHOLD} GPa")
+    print("=" * WIDTH)
+    
+    print("\nLoading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    if args.limit:
+        all_entries = all_entries[:args.limit]
+        print(f"  Limited to {args.limit} entries")
+    
+    # Try MP API for MP entries
+    mp_elastic_data = {}
+    if args.api_key and not args.proxy_only:
+        print("\n  Querying MP API for elastic data...")
+        try:
+            from mp_api.client import MPRester
+            with MPRester(args.api_key) as mpr:
+                mp_ids = [e.get("source_id") for e in all_entries 
+                         if e.get("source") == "mp" and e.get("source_id")]
+                print(f"  MP entries with source_ids: {len(mp_ids):,}")
+                for i in range(0, len(mp_ids), 50):
+                    batch = mp_ids[i:i+50]
+                    try:
+                        results = mpr.elasticity.search(material_ids=batch)
+                        for doc in results:
+                            if doc.material_id in batch:
+                                mp_elastic_data[doc.material_id] = {
+                                    "bulk_modulus": doc.bulk_modulus,
+                                    "shear_modulus": doc.shear_modulus,
+                                    "youngs_modulus": doc.youngs_modulus,
+                                    "poisson_ratio": doc.poisson_ratio,
+                                }
+                    except Exception:
+                        pass
+                    if (i+1) % 500 == 0:
+                        print(f"    Queried {i+1}/{len(mp_ids)} MP IDs")
+            print(f"  Retrieved elastic data for {len(mp_elastic_data):,} MP entries")
+        except ImportError:
+            print("  mp-api not installed. Skipping MP API query.")
+        except Exception as exc:
+            print(f"  MP API error: {exc}")
+    
+    # Process entries
+    print(f"\n{'─' * WIDTH}")
+    print("  Computing mechanical properties...")
+    print(f"{'─' * WIDTH}")
+    
+    processed = 0
+    mp_api_found = 0
+    proxy_computed = 0
+    errors = 0
+    dendrite_suppression = 0
+    from pymatgen.core import Structure
+    import json as _json
+    
+    for idx, e in enumerate(all_entries):
+        if "ssb_screening" not in e:
+            e["ssb_screening"] = {}
+        
+        ss = e["ssb_screening"]
+        source = e.get("source", "")
+        source_id = e.get("source_id", "")
+        
+        # Try MP API data first
+        if source == "mp" and source_id in mp_elastic_data:
+            mp_data = mp_elastic_data[source_id]
+            ss["bulk_modulus_GPa"] = mp_data.get("bulk_modulus")
+            ss["shear_modulus_GPa"] = mp_data.get("shear_modulus")
+            ss["youngs_modulus_GPa"] = mp_data.get("youngs_modulus")
+            ss["poisson_ratio"] = mp_data.get("poisson_ratio")
+            ss["elastic_source"] = "MP_API"
+            mp_api_found += 1
+        elif not args.mp_only and e.get("structure_json"):
+            # Use geometric proxy
+            try:
+                struct_dict = _json.loads(e["structure_json"])
+                structure = Structure.from_dict(struct_dict)
+                K, G, proxy_source = compute_density_proxy(structure)
+                if K is not None and G is not None:
+                    ss["bulk_modulus_GPa"] = K
+                    ss["shear_modulus_GPa"] = G
+                    ss["youngs_modulus_GPa"] = round(9 * K * G / (3 * K + G), 2) if (3*K+G) > 0 else None
+                    ss["poisson_ratio"] = round((3*K - 2*G) / (2*(3*K + G)), 3) if (3*K+G) > 0 else None
+                    ss["elastic_source"] = proxy_source
+                    proxy_computed += 1
+            except Exception:
+                errors += 1
+        
+        # Set dendrite suppression flag
+        shear_mod = ss.get("shear_modulus_GPa")
+        if shear_mod is not None:
+            ss["dendrite_suppression_flag"] = bool(shear_mod >= DENDRITE_THRESHOLD)
+            if ss["dendrite_suppression_flag"]:
+                dendrite_suppression += 1
+        
+        processed += 1
+        if (idx + 1) % 5000 == 0:
+            print(f"  {idx+1}/{len(all_entries)} | MP_API:{mp_api_found} Proxy:{proxy_computed} Dendrite:{dendrite_suppression}")
+    
+    print(f"\n{'─' * WIDTH}")
+    print(f"  Complete: {processed} processed")
+    print(f"    MP API data: {mp_api_found:,}")
+    print(f"    Geometric proxy: {proxy_computed:,}")
+    print(f"    Errors: {errors:,}")
+    print(f"    Dendrite suppression (G > {DENDRITE_THRESHOLD} GPa): {dendrite_suppression:,}")
+    
+    # Save
+    if args.dry_run:
+        print(f"\n  (dry-run — not saved)")
+    else:
+        output_path = DATASET_PATH / "entries_final_v3.json"
+        print(f"\n  Writing to {output_path}...")
+        t_write = time.time()
+        with open(args.output or output_path, "w") as f:
+            json.dump(all_entries, f)
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_oxidation_states.py

@@ -0,0 +1,159 @@
+"""Predict oxidation states for all entries using bond valence analysis.
+
+Fills each entry with:
+  - oxidation_states: dict of {element: average_oxidation_state}
+  - predicted_oxidation_states_valid: bool
+
+Usage:
+    python scripts/compute_oxidation_states.py
+    python scripts/compute_oxidation_states.py --limit 10000
+    python scripts/compute_oxidation_states.py --dry-run
+"""
+import json, os, sys, time, argparse, warnings
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+COMMON_OXIDATION = {
+    "Li": [1], "Na": [1], "K": [1], "Rb": [1], "Cs": [1],
+    "Mg": [2], "Ca": [2], "Sr": [2], "Ba": [2],
+    "Al": [3], "Ga": [3], "In": [3],
+    "Si": [4], "Ge": [4], "Sn": [2, 4], "Pb": [2, 4],
+    "P": [5], "As": [3, 5], "Sb": [3, 5], "Bi": [3, 5],
+    "O": [-2], "S": [-2, 4, 6], "Se": [-2, 4, 6], "Te": [-2, 4, 6],
+    "F": [-1], "Cl": [-1], "Br": [-1], "I": [-1],
+    "N": [-3], "H": [1],
+    "Ti": [4], "V": [3, 5], "Cr": [3, 6], "Mn": [2, 4, 7],
+    "Fe": [2, 3], "Co": [2, 3], "Ni": [2], "Cu": [1, 2],
+    "Zn": [2], "Y": [3], "Zr": [4], "Nb": [5], "Mo": [4, 6],
+    "La": [3], "Ce": [3, 4], "Pr": [3], "Nd": [3], "Sm": [3],
+    "Eu": [2, 3], "Gd": [3], "Tb": [3, 4], "Dy": [3], "Ho": [3],
+    "Er": [3], "Tm": [3], "Yb": [2, 3], "Lu": [3],
+    "Ta": [5], "W": [6], "B": [3], "C": [4], "Sc": [3],
+    "Hg": [1, 2],
+}
+
+
+def parse_formula(formula):
+    import re
+    parts = re.findall(r'([A-Z][a-z]*)(\d*\.?\d*)', formula)
+    return {el: float(cnt) if cnt else 1.0 for el, cnt in parts}
+
+
+def heuristic_oxidation_states(formula_dict):
+    elements = list(formula_dict.keys())
+    anions = {"O", "S", "Se", "Te", "F", "Cl", "Br", "I", "N", "P", "As", "Sb"}
+    cation_els = [el for el in elements if el not in anions]
+    anion_els = [el for el in elements if el in anions]
+    if not anion_els:
+        return {el: 0.0 for el in elements}
+    result = {}
+    assigned_anions = 0.0
+    for el in elements:
+        states = COMMON_OXIDATION.get(el, [0])
+        if el in anions:
+            result[el] = float(min(states))
+            assigned_anions += result[el] * formula_dict[el]
+        else:
+            result[el] = float(max(states))
+    total_charge = sum(result[el] * formula_dict[el] for el in elements)
+    if abs(total_charge) > 0.5 and cation_els:
+        scale = -assigned_anions / max(abs(total_charge - assigned_anions), 0.01)
+        for el in cation_els:
+            result[el] = round(result[el] * scale, 1)
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Predict oxidation states")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * WIDTH)
+    print("  OXIDATION STATE PREDICTION")
+    print("=" * WIDTH)
+    
+    print("\nLoading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    if args.limit:
+        all_entries = all_entries[:args.limit]
+        print(f"  Limited to {args.limit} entries")
+    
+    try:
+        from pymatgen.analysis.bond_valence import BVAnalyzer
+        from pymatgen.core import Structure
+        bva = BVAnalyzer()
+        bva_available = True
+        print("  BVAnalyzer available")
+    except Exception:
+        bva_available = False
+        print("  BVAnalyzer not available, heuristic only")
+    
+    import json as _json
+    
+    print(f"\n{'─' * WIDTH}")
+    print("  Assigning oxidation states...")
+    
+    bva_success = 0
+    heuristic_assigned = 0
+    errors = 0
+    
+    for idx, e in enumerate(all_entries):
+        formula = e.get("formula", "")
+        formula_dict = parse_formula(formula)
+        e["oxidation_states"] = {}
+        assigned = False
+        
+        if bva_available and e.get("structure_json"):
+            try:
+                struct_dict = _json.loads(e["structure_json"])
+                structure = Structure.from_dict(struct_dict)
+                oxi_states = bva.get_valences(structure)
+                if oxi_states:
+                    element_oxi = defaultdict(list)
+                    for site, oxi in zip(structure, oxi_states):
+                        element_oxi[site.specie.symbol].append(float(oxi))
+                    e["oxidation_states"] = {el: round(sum(vals)/len(vals), 2) for el, vals in element_oxi.items()}
+                    e["predicted_oxidation_states_valid"] = True
+                    bva_success += 1
+                    assigned = True
+            except Exception:
+                pass
+        
+        if not assigned:
+            oxi = heuristic_oxidation_states(formula_dict)
+            e["oxidation_states"] = oxi
+            e["predicted_oxidation_states_valid"] = False
+            heuristic_assigned += 1
+        
+        if (idx + 1) % 10000 == 0:
+            print(f"  {idx+1}/{len(all_entries)} | BVA:{bva_success} Heuristic:{heuristic_assigned}")
+    
+    print(f"\n  BVA: {bva_success:,}, Heuristic: {heuristic_assigned:,}, Total: {bva_success+heuristic_assigned:,}/{len(all_entries):,}")
+    
+    if args.dry_run:
+        print(f"\n  (dry-run)")
+    else:
+        output_path = DATASET_PATH / "entries_final_v3.json"
+        print(f"\n  Writing...")
+        t_write = time.time()
+        with open(output_path, "w") as f:
+            json.dump(all_entries, f)
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_sse_candidate_score.py

@@ -0,0 +1,250 @@
+"""Compute SSE candidate scores for all entries based on the 5-gate screening system.
+
+Populates the ssb_screening block with:
+  - gates_passed: list of passed gate names
+  - sse_candidate_score: composite score (0-100)
+  - thermo_stable: bool (gate 1)
+  - electronic_insulation: bool (gate 2)
+
+Gates:
+  1. thermo_stability: E_hull < 0.025 eV/atom (stable or near-stable)
+  2. electronic_insulation: band_gap > 1.0 eV (not metallic)
+  3. ionic_mobility: cavd_channel_dimensionality in ["2D", "3D"] (when available)
+  4. electrochemical_window: window_width > 1.0 V (when available)
+  5. mechanical: dendrite_suppression_flag (when available)
+
+Score is transparent and compositional:
+  - Gate 1 (thermo): 30 points
+  - Gate 2 (electronic): 25 points
+  - Gate 3 (mobility proxy): 20 points (partial credit for 1D channels)
+  - Gate 4 (electrochemical): 15 points
+  - Gate 5 (mechanical): 10 points
+
+Usage:
+    python scripts/compute_sse_candidate_score.py
+    python scripts/compute_sse_candidate_score.py --subset battery
+    python scripts/compute_sse_candidate_score.py --limit 10000 --dry-run
+"""
+import json, os, sys, time, argparse, warnings
+from pathlib import Path
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+# Gate thresholds
+GATES = {
+    "thermo_stability": {
+        "weight": 30,
+        "field": "thermo_stable",
+        "description": "E_hull < 0.025 eV/atom",
+        "check": lambda e: e.get("ssb_screening", {}).get("thermo_stable", False)
+    },
+    "electronic_insulation": {
+        "weight": 25,
+        "field": "electronic_insulation",
+        "description": "band_gap > 1.0 eV",
+        "check": lambda e: e.get("ssb_screening", {}).get("electronic_insulation", False)
+    },
+    "ionic_mobility": {
+        "weight": 20,
+        "field": "cavd_channel_dimensionality",
+        "description": "2D/3D percolation channels",
+        "check": lambda e: _check_mobility(e)
+    },
+    "electrochemical_window": {
+        "weight": 15,
+        "field": "stability_window_low_V",
+        "description": "window_width > 1.0 V",
+        "check": lambda e: _check_window(e)
+    },
+    "mechanical": {
+        "weight": 10,
+        "field": "dendrite_suppression_flag",
+        "description": "shear_modulus > 6 GPa",
+        "check": lambda e: e.get("ssb_screening", {}).get("dendrite_suppression_flag", False)
+    }
+}
+
+def _check_mobility(e):
+    ss = e.get("ssb_screening", {})
+    dim = ss.get("cavd_channel_dimensionality")
+    if dim in ("3D",):
+        return True
+    if dim in ("2D",):
+        return True
+    if dim in ("1D",):
+        # Partial: mobile ions exist but channels are 1D
+        return False
+    return False
+
+def _check_window(e):
+    ss = e.get("ssb_screening", {})
+    low = ss.get("stability_window_low_V")
+    high = ss.get("stability_window_high_V")
+    if low is not None and high is not None:
+        return (high - low) >= 1.0
+    return False
+
+def _check_mechanical(e):
+    return e.get("ssb_screening", {}).get("dendrite_suppression_flag", False)
+
+
+def compute_gate_score(e, gate_name, gate_config):
+    """Compute gate score. Gate passes = full weight, else 0."""
+    try:
+        passed = gate_config["check"](e)
+        return gate_config["weight"] if passed else 0, passed
+    except Exception:
+        return 0, False
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute SSE candidate scores")
+    parser.add_argument("--subset", choices=["battery", "electrolyte", "gold", "full"], default="full")
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--output", type=str, default=None)
+    args = parser.parse_args()
+    
+    if args.limit and not args.dry_run and args.output is None:
+        print("ERROR: Refusing to save limited runs. Use --dry-run or --output.")
+        sys.exit(1)
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * WIDTH)
+    print("  SSE CANDIDATE SCORE — 5-GATE SCREENING SYSTEM")
+    print("=" * WIDTH)
+    print()
+    print("  Gate weights:")
+    for gate_name, config in GATES.items():
+        print(f"    {config['weight']:2d} pts — {gate_name}: {config['description']}")
+    print()
+    
+    print("Loading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    # Select working subset
+    if args.subset == "battery":
+        with open(DATASET_PATH / "battery_candidate_subset_v1.json") as f:
+            entries = json.load(f)
+    elif args.subset == "electrolyte":
+        with open(DATASET_PATH / "solid_electrolyte_candidate_subset_v1.json") as f:
+            entries = json.load(f)
+    elif args.subset == "gold":
+        entries = [e for e in all_entries if e.get("tier") == "gold"]
+    else:
+        entries = all_entries
+    
+    if args.limit:
+        entries = entries[:args.limit]
+    
+    print(f"  Working subset: {len(entries):,} entries")
+    
+    if not entries:
+        print("No entries to process.")
+        return
+    
+    # Score all entries
+    print(f"\n{'─' * WIDTH}")
+    print("  Computing scores...")
+    print(f"{'─' * WIDTH}")
+    
+    score_dist = {}
+    gate_counts = {g: {"pass": 0, "total": 0} for g in GATES}
+    
+    # Track entries that need to be synced back to all_entries
+    updated_keys = set()
+    
+    for idx, e in enumerate(entries):
+        if "ssb_screening" not in e:
+            e["ssb_screening"] = {}
+        
+        ss = e["ssb_screening"]
+        
+        total_score = 0
+        gates_passed = []
+        
+        for gate_name, config in GATES.items():
+            score, passed = compute_gate_score(e, gate_name, config)
+            total_score += score
+            gate_counts[gate_name]["total"] += 1
+            if passed:
+                gates_passed.append(gate_name)
+                gate_counts[gate_name]["pass"] += 1
+        
+        ss["sse_candidate_score"] = total_score
+        ss["gates_passed"] = gates_passed
+        
+        # Record distribution
+        bin_key = f"{(total_score // 10) * 10}-{(total_score // 10) * 10 + 9}"
+        score_dist[bin_key] = score_dist.get(bin_key, 0) + 1
+        
+        # Keep track of which entries were updated
+        source_id = e.get("source_id", "") + e.get("source", "")
+        updated_keys.add(source_id)
+    
+    # Print results
+    print(f"\n  Score distribution:")
+    for key in sorted(score_dist.keys(), key=lambda x: int(x.split("-")[0])):
+        count = score_dist[key]
+        bar = "█" * min(count // 1000, 50)
+        print(f"    {key:>6}: {count:>6,}  {bar}")
+    
+    print(f"\n  Per-gate pass rates:")
+    for gate_name, counts in gate_counts.items():
+        pct = counts["pass"] / max(counts["total"], 1) * 100
+        print(f"    {gate_name:25s}: {counts['pass']:>6,}/{counts['total']:<6,} ({pct:.1f}%)")
+    
+    # Top scores
+    all_sorted = sorted(entries, key=lambda e: e.get("ssb_screening", {}).get("sse_candidate_score", 0), reverse=True)
+    print(f"\n  Top 10 candidates:")
+    for e in all_sorted[:10]:
+        ss = e.get("ssb_screening", {})
+        print(f"    Score {ss.get('sse_candidate_score', 0):3d} | {e.get('structured_formula', e.get('formula','')):20s} | "
+              f"{e.get('sse_family', '?'):15s} | Gates: {ss.get('gates_passed', [])}")
+    
+    # Sync back to all_entries
+    if args.subset in ("full",):
+        save_data = all_entries
+    elif args.subset == "gold":
+        save_data = all_entries
+        entry_map = {}
+        for e in entries:
+            key = e.get("source_id", "") + e.get("source", "")
+            entry_map[key] = e
+        for e in save_data:
+            key = e.get("source_id", "") + e.get("source", "")
+            if key in entry_map:
+                e["ssb_screening"] = entry_map[key].get("ssb_screening", {})
+    else:
+        save_data = entries
+    
+    # Save
+    if args.subset == "battery":
+        output_path = DATASET_PATH / "battery_candidate_subset_v1.json"
+    elif args.subset == "electrolyte":
+        output_path = DATASET_PATH / "solid_electrolyte_candidate_subset_v1.json"
+    elif args.subset == "gold":
+        output_path = DATASET_PATH / "entries_final_v3.json"
+    else:
+        output_path = DATASET_PATH / "entries_final_v3.json"
+    
+    if args.dry_run:
+        print(f"\n  (dry-run — not saved)")
+    else:
+        print(f"\n  Writing to {output_path}...")
+        t_write = time.time()
+        with open(output_path, "w") as f:
+            json.dump(save_data, f)
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_parquet_typed.py

@@ -0,0 +1,85 @@
+"""Convert the encoded-string Parquet to proper typed columns for HF viewer compat."""
+import json, sys, time
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from dataset.dataset_store import _decode_value
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+DATASET_DIR = Path(__file__).resolve().parent.parent / "dataset"
+SRC = DATASET_DIR / "entries_v3.parquet"
+DST = DATASET_DIR / "entries_v4_typed.parquet"
+
+
+def infer_type(col_name, prefixes):
+    if 'b' in prefixes:
+        return pa.bool_()
+    elif 'i' in prefixes:
+        return pa.int64()
+    elif 'f' in prefixes:
+        return pa.float64()
+    return pa.string()
+
+
+def safe(v, pa_type):
+    if v is None:
+        return None
+    d = _decode_value(v)
+    if d is None or d == '':
+        return None
+    try:
+        if isinstance(d, (dict, list)):
+            return json.dumps(d)
+        if pa_type == pa.int64():
+            return int(d)
+        if pa_type == pa.float64():
+            return float(d)
+        if pa_type == pa.bool_():
+            return bool(d)
+        return str(d)
+    except (ValueError, TypeError):
+        return None
+
+
+def main():
+    print("Reading source Parquet...")
+    t0 = time.time()
+    src = pq.read_table(SRC)
+    print(f"  {src.num_rows:,} rows, {src.num_columns} columns ({time.time()-t0:.1f}s)")
+
+    pcols = {col: set() for col in src.column_names}
+    for i in range(min(5000, src.num_rows)):
+        for col in src.column_names:
+            raw = src.column(col)[i].as_py()
+            pcols[col].add(raw.split(':')[0] if raw and ':' in raw else None)
+
+    print("Decoding and converting...")
+    t0 = time.time()
+    arrays = {}
+    for col in src.column_names:
+        raw_col = src.column(col)
+        tgt = infer_type(col, pcols[col])
+        vals = [safe(raw_col[i].as_py(), tgt) for i in range(raw_col.length())]
+        arr = pa.array(vals, type=tgt)
+        arrays[col] = arr
+        print(f"  {col:40s} → {str(tgt):10s}  ({time.time()-t0:.1f}s)")
+
+    print("Building typed table...")
+    schema = pa.schema([pa.field(c, arrays[c].type) for c in src.column_names])
+    table = pa.table(arrays, schema=schema)
+
+    print("Writing typed Parquet...")
+    pq.write_table(table, DST, compression="zstd", compression_level=9)
+    sz = DST.stat().st_size
+    print(f"  {DST.name}: {sz/1e6:.1f} MB")
+
+    verify = pq.read_table(DST)
+    assert verify.num_rows == src.num_rows
+    print(f"Verified: {verify.num_rows:,} rows × {verify.num_columns} cols")
+    for f in verify.schema:
+        print(f"  {f.name:40s} {f.type}")
+
+
+if __name__ == "__main__":
+    main()

scripts/enrich_garnet_family.py

@@ -0,0 +1,327 @@
+"""Garnet-family enrichment: identify missed garnet-type structures.
+
+Current garnet count is 41 entries (should be thousands for an SSB dataset).
+This script:
+  1. Uses composition-based heuristics to find garnet-like formulas
+  2. Uses structure fingerprinting to verify garnet topology
+  3. Reclassifies entries with structure confirmation
+  4. Reports candidate structures for targeted acquisition
+
+Garnet identification logic:
+  - Composition: A3B2C3O12 where A=Li,Na, etc; B=La,Zr, etc; C=Zr,Ta,Nb,etc
+  - Structure: body-centered cubic, space group Ia-3d (230)
+  - Specific known families: LLZO, LLTO, LSNO, etc.
+
+Usage:
+    python scripts/enrich_garnet_family.py
+    python scripts/enrich_garnet_family.py --dry-run
+    python scripts/enrich_garnet_family.py --report-only
+"""
+import json, os, sys, time, argparse, re, warnings
+from pathlib import Path
+from collections import Counter, defaultdict
+import numpy as np
+warnings.filterwarnings("ignore")
+
+KNOWN_GARNET_SPACE_GROUPS = {230, 229, 228, 227, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200}
+GARNET_SG_IA3D = 230  # Ia-3d, most common garnet space group
+
+GARNET_SYMBOLS = {"Ia-3d", "Ia3d", "I a -3 d", "I a 3 d", "I a-3d", "Ia-3"}
+
+# Common garnet-forming elements
+GARNET_A_SITES = {"Li", "Na", "K", "Ag", "Cu"}  # Dodecahedral
+GARNET_B_SITES = {"La", "Y", "Pr", "Nd", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Yb", "Lu", "Ca", "Sr", "Ba", "Bi", "Ce"}  # Octahedral
+GARNET_C_SITES = {"Zr", "Ta", "Nb", "Sb", "Te", "W", "Mo", "V", "Sn", "Ti", "Hf", "Al", "Ga", "Fe", "In", "Sc", "Cr"}  # Tetrahedral/octahedral
+GARNET_O_SITES = {"O", "S", "Se", "Te"}  # Anion
+
+# Known garnet structure prefixes for formula-based matching
+GARNET_PATTERNS = [
+    (r"^Li\d+[A-Z][a-z]?\d*[A-Z][a-z]?\d*O\d+", "lithium_garnet"),
+    (r"^Na\d+[A-Z][a-z]?\d*[A-Z][a-z]?\d*O\d+", "sodium_garnet"),
+]
+
+def parse_formula(formula):
+    """Parse formula string into element counts."""
+    parts = re.findall(r'([A-Z][a-z]*)(\d*\.?\d*)', formula)
+    return {el: float(cnt) if cnt else 1.0 for el, cnt in parts}
+
+def is_garnet_by_formula(formula_dict):
+    """Check if composition resembles garnet (A3B2C3O12-type).
+    
+    Stricter heuristic: require approximate 3:2:3:12 ratio and
+    Li/Na on A sites with Zr/Ta/Nb/Al on B/C sites.
+    """
+    oxygen_count = sum(formula_dict.get(o, 0) for o in GARNET_O_SITES)
+    if oxygen_count < 3:
+        return False, "not_oxide"
+    
+    a_count = sum(formula_dict.get(el, 0) for el in GARNET_A_SITES)
+    b_count = sum(formula_dict.get(el, 0) for el in GARNET_B_SITES)
+    c_count = sum(formula_dict.get(el, 0) for el in GARNET_C_SITES)
+    
+    cation_count = a_count + b_count + c_count
+    if cation_count < 3:
+        return False, "no_garnet_cations"
+    
+    # Normalize ratios to 12 oxygens
+    scale = 12.0 / max(oxygen_count, 1)
+    a_norm = a_count * scale
+    b_norm = b_count * scale
+    c_norm = c_count * scale
+    
+    # Classic garnet: A3B2C3O12
+    # Allow some deviation but not extreme
+    total_norm = a_norm + b_norm + c_norm
+    if not (5.0 < total_norm < 12.0):
+        return False, "wrong_cation_count"
+    
+    # A-site should be at least ~1 normalized
+    if a_norm < 0.5:
+        return False, "insufficient_A_site"
+    
+    # At least one of B or C site should be substantial
+    if b_norm + c_norm < 1.0:
+        return False, "insufficient_BC_sites"
+    
+    # For known LLZO-type: need Li + La/Zr + O
+    has_li_la_zr = (
+        "Li" in formula_dict and 
+        any(el in formula_dict for el in ["La", "Y", "Nd", "Pr", "Eu", "Gd"]) and
+        any(el in formula_dict for el in ["Zr", "Ta", "Nb"])
+    )
+    if has_li_la_zr:
+        return True, "LLZO_type_composition"
+    
+    # General garnet-like: at least 2 distinct cation types on B/C
+    bc_types = sum(1 for el in formula_dict if el in GARNET_B_SITES or el in GARNET_C_SITES)
+    if bc_types >= 2 and a_norm >= 1.0:
+        return True, "broad_garnet_composition"
+    
+    # Na garnets (less common)
+    if "Na" in formula_dict and bc_types >= 2 and a_norm >= 1.0:
+        return True, "sodium_garnet_composition"
+    
+    return False, "does_not_match_garnet_stoichiometry"
+
+
+def check_garnet_structure(structure):
+    """Verify garnet topology from structure.
+    
+    Strict checks:
+    1. Space group must be Ia-3d (230) or related garnet space group
+    2. Cubic lattice with a ≈ 11-13 Å (typical garnet range)
+    3. Reasonable number of atoms in unit cell (garnets have 80+ atoms/cell)
+    """
+    sg_info = structure.get_space_group_info()
+    sg_symbol = str(sg_info[0]) if sg_info else ""
+    sg_number = int(sg_info[1]) if len(sg_info) > 1 else 0
+    
+    # Check space group
+    if sg_number == 230:
+        return True
+    for known_sym in GARNET_SYMBOLS:
+        if known_sym in sg_symbol:
+            return True
+    
+    # Garnets are cubic (a=b=c)
+    lattice = structure.lattice
+    if not (abs(lattice.a - lattice.b) / max(lattice.a, 0.01) < 0.05 and
+            abs(lattice.a - lattice.c) / max(lattice.a, 0.01) < 0.05):
+        return False
+    
+    # Garnet lattice constant range
+    if not (10.5 < lattice.a < 13.5):
+        return False
+    
+    # Garnets typically have 80-160 atoms in conventional cell
+    n_atoms = len(structure)
+    if n_atoms < 40:
+        return False
+    
+    # Check for oxygen/anion content (garnets are oxides/sulfides)
+    has_anion = any(site.specie.symbol in GARNET_O_SITES for site in structure)
+    if not has_anion:
+        return False
+    
+    # Check for A-site cations (Li, Na)
+    has_a_site = any(site.specie.symbol in GARNET_A_SITES for site in structure)
+    if not has_a_site:
+        return False
+    
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Garnet family enrichment")
+    parser.add_argument("--dry-run", action="store_true", help="Don't save results")
+    parser.add_argument("--report-only", action="store_true", help="Generate report without modifying data")
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * 60)
+    print("  GARNET FAMILY ENRICHMENT")
+    print("  Identifying missed garnet-type structures")
+    print("=" * 60)
+    
+    print("\nLoading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    if args.limit:
+        all_entries = all_entries[:args.limit]
+        print(f"  Limited to {args.limit} entries")
+    
+    # Phase 1: Composition-based screening
+    print(f"\n{'─' * 60}")
+    print("  Phase 1: Composition-based garnet screening")
+    print(f"{'─' * 60}")
+    
+    current_garnet = [e for e in all_entries if e.get("sse_family") == "garnet"]
+    print(f"  Currently tagged as garnet: {len(current_garnet)}")
+    
+    garnet_candidates = []
+    for e in all_entries:
+        formula = e.get("formula", "")
+        formula_dict = parse_formula(formula)
+        is_match, reason = is_garnet_by_formula(formula_dict)
+        if is_match:
+            garnet_candidates.append((e, reason))
+    
+    print(f"  Composition-based garnet candidates: {len(garnet_candidates)}")
+    
+    # Show top candidates by composition
+    cand_by_elements = defaultdict(list)
+    for e, reason in garnet_candidates:
+        has_li = "Li" in e.get("elements", [])
+        has_o = "O" in e.get("elements", [])
+        key = f"{'Li' if has_li else 'Na'}-{'O' if has_o else 'S'}"
+        cand_by_elements[key].append((e, reason))
+    
+    for key, cands in sorted(cand_by_elements.items()):
+        print(f"  {key}: {len(cands)} candidates")
+        for e, reason in cands[:3]:
+            print(f"    - {e.get('formula', '?'):30s} {e.get('sse_family', '?'):15s} {e.get('space_group_symbol', ''):10s} [{reason}]")
+    
+    # Phase 2: Structure-based verification for candidates
+    print(f"\n{'─' * 60}")
+    print("  Phase 2: Structure-based verification")
+    print(f"{'─' * 60}")
+    
+    structure_confirmed = []
+    structure_rejected = []
+    
+    for e, comp_reason in garnet_candidates:
+        if e.get("sse_family") == "garnet":
+            structure_confirmed.append(e)
+            continue
+        
+        struct_json = e.get("structure_json")
+        if not struct_json:
+            structure_rejected.append((e, "no_structure"))
+            continue
+        
+        import json as _json
+        from pymatgen.core import Structure
+        
+        try:
+            struct_dict = _json.loads(struct_json)
+            structure = Structure.from_dict(struct_dict)
+            if check_garnet_structure(structure):
+                structure_confirmed.append(e)
+            else:
+                structure_rejected.append((e, "structure_mismatch"))
+        except Exception:
+            structure_rejected.append((e, "parse_error"))
+    
+    print(f"  Structure-confirmed garnets: {len(structure_confirmed)}")
+    print(f"  Structure-rejected: {len(structure_rejected)}")
+    
+    new_garnets = [e for e in structure_confirmed if e.get("sse_family") != "garnet"]
+    print(f"  NEW garnets to reclassify: {len(new_garnets)}")
+    
+    if new_garnets:
+        print(f"\n  Top new garnet candidates:")
+        for e in sorted(new_garnets, key=lambda x: abs(x.get("formation_energy_per_atom", 0)))[:10]:
+            formula = e.get("formula", "?")
+            sg = e.get("space_group_symbol", "?")
+            fe = e.get("formation_energy_per_atom", 0)
+            print(f"    {formula:30s} SG={sg:8s} FE={fe:+.3f} eV/atom")
+    
+    # Phase 3: Reclassify
+    if not args.report_only and not args.dry_run and new_garnets:
+        print(f"\n{'─' * 60}")
+        print("  Phase 3: Reclassifying entries")
+        print(f"{'─' * 60}")
+        
+        reclassified = 0
+        for e in new_garnets:
+            old_family = e.get("sse_family", "?")
+            e["sse_family"] = "garnet"
+            if "ssb_screening" in e:
+                e["ssb_screening"]["sse_family"] = "garnet"
+            reclassified += 1
+        
+        print(f"  Reclassified: {reclassified:,} entries to garnet")
+        
+        # Save
+        output_path = DATASET_PATH / "entries_final_v3.json"
+        print(f"  Writing to {output_path}...")
+        t_write = time.time()
+        with open(output_path, "w") as f:
+            json.dump(all_entries, f)
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+    
+    elif args.dry_run:
+        print(f"\n  (dry-run — no changes saved)")
+    
+    # Phase 4: Report
+    print(f"\n{'─' * 60}")
+    print("  GARNET ENRICHMENT REPORT")
+    print(f"{'─' * 60}")
+    
+    all_after = all_entries
+    garnet_after = [e for e in all_after if e.get("sse_family") == "garnet"]
+    print(f"\n  Final garnet count: {len(garnet_after):,}")
+    print(f"  (was {len(current_garnet):,} before enrichment)")
+    
+    if garnet_after:
+        print(f"\n  Sample of current garnet entries:")
+        for e in garnet_after[:5]:
+            print(f"    {e.get('formula', '?'):35s} {e.get('source', '?'):10s} {e.get('tier', '?'):10s}")
+    
+    # Recommendations for targeted acquisition
+    print(f"\n  {'─' * 60}")
+    print("  TARGETED ACQUISITION RECOMMENDATIONS")
+    print(f"  {'─' * 60}")
+    print(f"""
+  To reach SSB-credible garnet coverage (500+ entries):
+    
+    1. Pull LLZO-family (Li7La3Zr2O12) variants from MP:
+       - Li7-3xAlxLa3Zr2O12 (Al-doped)
+       - Li6.5La3Zr1.5Ta0.5O12 (Ta-doped)
+       - Li6.4La3Zr1.4Ta0.6O12
+    
+    2. Pull garnet structures from ICSD:
+       - All ICSD garnet entries with Li/Na
+       - Focus on Li-La-Zr-O, Li-Y-Zr-O, Li-Ca-Zr-O systems
+    
+    3. Known academic collections:
+       - Garnet database from Ceder group publications
+       - MPContribs garnet entries
+       - Literature-mined garnet compositions
+    
+    4. Consider computational expansion:
+       - Generate LLZO variants with dopant substitutions
+       - Run DFT on promising but uncalculated garnet compositions
+  """)
+    
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/extract_commercial_safe_edition.py

@@ -0,0 +1,164 @@
+"""Extract a Commercial-Safe edition of the dataset (MP + JARVIS only).
+
+OQMD is non-commercial only, limiting use for commercial ML training.
+This script creates a clearly-labeled subset containing only entries with
+CC BY 4.0 (MP) and CC0 1.0 (JARVIS) licenses.
+
+Outputs:
+  - dataset/commercial_safe_subset_v3.json: ~94,952 entries
+  - dataset/manifests/manifest_commercial_safe.json: checksums
+
+Usage:
+    python scripts/extract_commercial_safe_edition.py
+    python scripts/extract_commercial_safe_edition.py --stats-only
+    python scripts/extract_commercial_safe_edition.py --output-dir /tmp
+"""
+import json, os, sys, hashlib, time, argparse
+from pathlib import Path
+
+COMMERCIAL_LICENSES = {"CC-BY-4.0", "CC0-1.0"}
+COMMERCIAL_SOURCES = {"mp", "jarvis"}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract Commercial-Safe dataset edition")
+    parser.add_argument("--stats-only", action="store_true", help="Print stats only, no output")
+    parser.add_argument("--output-dir", type=str, default=None, help="Custom output directory")
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    if args.output_dir:
+        OUTPUT_DIR = Path(args.output_dir)
+    else:
+        OUTPUT_DIR = DATASET_PATH
+    
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    
+    print("=" * 60)
+    print("  COMMERCIAL-SAFE EDITION EXTRACTION")
+    print("  Filtering entries by license: CC-BY-4.0 (MP), CC0-1.0 (JARVIS)")
+    print("=" * 60)
+    
+    print("\nLoading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    # Filter by license
+    commercial = []
+    oqmd_entries = []
+    for e in all_entries:
+        lic = e.get("license", "")
+        if lic in COMMERCIAL_LICENSES:
+            commercial.append(e)
+        else:
+            oqmd_entries.append(e)
+    
+    print(f"\n  Commercial-safe: {len(commercial):,} entries")
+    print(f"  OQMD (non-commercial): {len(oqmd_entries):,} entries")
+    print(f"  Commercial fraction: {len(commercial)/len(all_entries)*100:.1f}%")
+    
+    # Stats by source
+    source_counts = {}
+    for e in commercial:
+        src = e.get("source", "unknown")
+        source_counts[src] = source_counts.get(src, 0) + 1
+    
+    print(f"\n  Commercial-safe source breakdown:")
+    for src, count in sorted(source_counts.items(), key=lambda x: -x[1]):
+        print(f"    {src}: {count:,}")
+    
+    # Stats by tier
+    tier_counts = {}
+    for e in commercial:
+        t = e.get("tier", "unknown")
+        tier_counts[t] = tier_counts.get(t, 0) + 1
+    
+    print(f"\n  Commercial-safe tier breakdown:")
+    for t, count in sorted(tier_counts.items(), key=lambda x: -x[1]):
+        print(f"    {t}: {count:,}")
+    
+    # Stats by SSE family
+    family_counts = {}
+    for e in commercial:
+        fam = e.get("sse_family", "unknown")
+        family_counts[fam] = family_counts.get(fam, 0) + 1
+    
+    print(f"\n  Commercial-safe SSE family breakdown:")
+    for fam, count in sorted(family_counts.items(), key=lambda x: -x[1])[:15]:
+        print(f"    {fam}: {count:,}")
+    
+    # Stats for OQMD battery/electrolyte entries (what users lose)
+    oqmd_battery = sum(1 for e in oqmd_entries if any(f in e.get("families", []) for f in 
+                       ["sulfide_sse", "halide_sse", "layered_oxide"]))
+    oqmd_electrolyte = sum(1 for e in oqmd_entries if e.get("sse_family") not in ("none", "oxide"))
+    
+    print(f"\n  OQMD entries lost (not in commercial-safe):")
+    print(f"    Battery-relevant families: {oqmd_battery:,}")
+    print(f"    SSE-family tagged: {oqmd_electrolyte:,}")
+    
+    if args.stats_only:
+        print(f"\n  (stats only — no file written)")
+        return
+    
+    # Write commercial-safe edition
+    output_path = OUTPUT_DIR / "commercial_safe_subset_v3.json"
+    print(f"\n  Writing commercial-safe edition ({len(commercial):,} entries)...")
+    print(f"    -> {output_path}")
+    
+    t_write = time.time()
+    with open(output_path, "w") as f:
+        json.dump(commercial, f)
+    print(f"    Done ({time.time()-t_write:.1f}s)")
+    
+    # Compute SHA256
+    sha256 = hashlib.sha256()
+    with open(output_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            sha256.update(chunk)
+    file_size = output_path.stat().st_size
+    
+    print(f"    SHA256: {sha256.hexdigest()}")
+    print(f"    Size: {file_size/1024/1024:.1f} MB")
+    
+    # Write manifest
+    manifest = {
+        "edition": "commercial_safe",
+        "description": "MP (CC-BY-4.0) + JARVIS (CC0-1.0) entries only. No OQMD.",
+        "total_entries": len(commercial),
+        "file": "commercial_safe_subset_v3.json",
+        "sha256": sha256.hexdigest(),
+        "size_bytes": file_size,
+        "sources": {src: count for src, count in source_counts.items()},
+        "created": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    }
+    
+    manifest_path = OUTPUT_DIR / "manifests" / "manifest_commercial_safe.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+    print(f"    Manifest: {manifest_path}")
+    
+    # Also generate battery and electrolyte subsets from commercial-safe
+    battery_edition = [e for e in commercial if any(
+        f in e.get("families", []) for f in 
+        ["sulfide_sse", "halide_sse", "layered_oxide", "garnet", "nasicon", 
+         "perovskite", "anti_perovskite", "lisicon", "lGPS_type", "argyrodite",
+         "borohydride", "battery", "oxide"]) or e.get("sse_family") not in ("none",)]
+    
+    battery_output = OUTPUT_DIR / "commercial_safe_battery_candidate_subset_v1.json"
+    print(f"\n  Writing commercial-safe battery edition ({len(battery_edition):,} entries)...")
+    with open(battery_output, "w") as f:
+        json.dump(battery_edition, f)
+    print(f"    -> {battery_output} ({time.time()-t_write:.1f}s)")
+    
+    print(f"\n  Manual filtering by license field is also supported:")
+    print(f'    entries = [e for e in data if e["license"] in ("CC-BY-4.0", "CC0-1.0")]')
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_audit_reports.py

@@ -590,14 +590,14 @@ def gen_battery_audit(entries):
         lines.append(f"| {c:7s} | {cnt:>7,} | {gold:>7,} |\n")
 
     lines.append(h2("Electrolyte Subset"))
-    elec_path = AUDIT_DIR / "dataset/electrolyte_subset_v3.json"
+    elec_path = AUDIT_DIR / "dataset/solid_electrolyte_candidate_subset_v1.json"
     if elec_path.exists():
         with open(elec_path) as f:
             elec = json.load(f)
         lines.append(p(f"**Electrolyte subset:** {len(elec):,} entries (strict Gold, no OQMD)"))
 
     lines.append(h2("Battery Subset"))
-    batt_path = AUDIT_DIR / "dataset/battery_subset_v3.json"
+    batt_path = AUDIT_DIR / "dataset/battery_candidate_subset_v1.json"
     if batt_path.exists():
         with open(batt_path) as f:
             batt = json.load(f)
@@ -781,8 +781,8 @@ def gen_release_audit(entries):
         ("SHA256 manifest", manifest.exists(), manifest),
         ("CHANGELOG", changelog.exists(), changelog),
         ("Final dataset", (AUDIT_DIR / "dataset/entries_final_v3.json").exists(), AUDIT_DIR / "dataset/entries_final_v3.json"),
-        ("Battery subset", (AUDIT_DIR / "dataset/battery_subset_v3.json").exists(), AUDIT_DIR / "dataset/battery_subset_v3.json"),
-        ("Electrolyte subset", (AUDIT_DIR / "dataset/electrolyte_subset_v3.json").exists(), AUDIT_DIR / "dataset/electrolyte_subset_v3.json"),
+        ("Battery subset", (AUDIT_DIR / "dataset/battery_candidate_subset_v1.json").exists(), AUDIT_DIR / "dataset/battery_candidate_subset_v1.json"),
+        ("Electrolyte subset", (AUDIT_DIR / "dataset/solid_electrolyte_candidate_subset_v1.json").exists(), AUDIT_DIR / "dataset/solid_electrolyte_candidate_subset_v1.json"),
         ("Benchmark splits", (AUDIT_DIR / "dataset/splits").is_dir(), AUDIT_DIR / "dataset/splits"),
     ]
     lines.append("| Artifact | Present |\n")

scripts/generate_conductivity_splits.py

@@ -0,0 +1,240 @@
+"""Generate conductivity-stratified benchmark splits for SSE screening tasks.
+
+Extends the existing frozen splits with conductivity-aware splits:
+  1. Conductivity held-out: hold out top 10% conductors by BVSE barrier
+  2. Composition held-out + conducitivity-aware: no formula overlap 
+  3. Family-stratified: balanced by SSE family
+
+Usage:
+    python scripts/generate_conductivity_splits.py                          # from existing splits + BVSE
+    python scripts/generate_conductivity_splits.py --min-barrier 0.0        # include all
+    python scripts/generate_conductivity_splits.py --dry-run                # stats only
+"""
+import json, os, sys, time, argparse, random
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+
+SEED = 42
+SPLIT_DIR = "dataset/splits"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate conductivity-stratified splits")
+    parser.add_argument("--min-barrier", type=float, default=0.0,
+                        help="Minimum BVSE barrier to filter by (default: 0.0 = all)")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--train-ratio", type=float, default=0.8)
+    parser.add_argument("--val-ratio", type=float, default=0.1)
+    parser.add_argument("--test-ratio", type=float, default=0.1)
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+    
+    print("=" * 60)
+    print("  CONDUCTIVITY BENCHMARK SPLITS")
+    print("  Extending splits for SSE screening tasks")
+    print("=" * 60)
+    
+    print("\nLoading entries...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        entries = json.load(f)
+    print(f"  {len(entries):,} entries ({time.time()-t0:.1f}s)")
+    
+    # Filter to entries with BVSE barrier data
+    ssb_entries = [e for e in entries if e.get("ssb_screening", {}).get("bvse_migration_barrier_eV") is not None]
+    print(f"\n  Entries with BVSE barriers: {len(ssb_entries):,}")
+    
+    if args.min_barrier > 0:
+        ssb_entries = [e for e in ssb_entries 
+                      if e["ssb_screening"]["bvse_migration_barrier_eV"] >= args.min_barrier]
+        print(f"  After min-barrier {args.min_barrier:.1f} eV: {len(ssb_entries):,}")
+    
+    if not ssb_entries:
+        print("  No entries with BVSE barriers found. Run compute_bvse_barriers.py first.")
+        return
+    
+    random.seed(SEED)
+    np.random.seed(SEED)
+    
+    splits = {}
+    
+    # 1. Conductivity-stratified split (stratified by BVSE barrier percentile)
+    print(f"\n{'─' * 60}")
+    print("  1. Conductivity-stratified split")
+    print(f"{'─' * 60}")
+    
+    barriers = np.array([e["ssb_screening"]["bvse_migration_barrier_eV"] for e in ssb_entries])
+    percentiles = np.percentile(barriers, [33, 67])
+    
+    low = [e for e in ssb_entries if e["ssb_screening"]["bvse_migration_barrier_eV"] <= percentiles[0]]
+    mid = [e for e in ssb_entries if percentiles[0] < e["ssb_screening"]["bvse_migration_barrier_eV"] <= percentiles[1]]
+    high = [e for e in ssb_entries if e["ssb_screening"]["bvse_migration_barrier_eV"] > percentiles[1]]
+    
+    print(f"    Low barrier (≤{percentiles[0]:.3f} eV): {len(low):,}")
+    print(f"    Mid barrier ({percentiles[0]:.3f}-{percentiles[1]:.3f} eV): {len(mid):,}")
+    print(f"    High barrier (≥{percentiles[1]:.3f} eV): {len(high):,}")
+    
+    stratified_train, stratified_val, stratified_test = [], [], []
+    for pool in [low, mid, high]:
+        np.random.shuffle(pool)
+        n = len(pool)
+        n_train = int(n * args.train_ratio)
+        n_val = int(n * args.val_ratio)
+        stratified_train.extend(pool[:n_train])
+        stratified_val.extend(pool[n_train:n_train+n_val])
+        stratified_test.extend(pool[n_train+n_val:])
+    
+    sorted_train = sorted(stratified_train, key=lambda e: e["ssb_screening"]["bvse_migration_barrier_eV"])
+    sorted_val = sorted(stratified_val, key=lambda e: e["ssb_screening"]["bvse_migration_barrier_eV"])
+    sorted_test = sorted(stratified_test, key=lambda e: e["ssb_screening"]["bvse_migration_barrier_eV"])
+    
+    splits["conductivity_stratified"] = {
+        "train": [e["source_id"] + e.get("source", "") for e in sorted_train],
+        "val": [e["source_id"] + e.get("source", "") for e in sorted_val],
+        "test": [e["source_id"] + e.get("source", "") for e in sorted_test],
+    }
+    print(f"    Train: {len(splits['conductivity_stratified']['train']):,}")
+    print(f"    Val: {len(splits['conductivity_stratified']['val']):,}")
+    print(f"    Test: {len(splits['conductivity_stratified']['test']):,}")
+    
+    # 2. Family-stratified split (balanced by SSE family)
+    print(f"\n{'─' * 60}")
+    print("  2. Family-stratified split")
+    print(f"{'─' * 60}")
+    
+    families = defaultdict(list)
+    for e in ssb_entries:
+        fam = e.get("ssb_screening", {}).get("sse_family") or e.get("sse_family", "unknown")
+        families[fam].append(e)
+    
+    family_counts = {fam: len(entries) for fam, entries in sorted(families.items(), key=lambda x: -len(x[1]))}
+    print(f"    Families: {len(families)}")
+    for fam, count in list(family_counts.items())[:10]:
+        print(f"      {fam:20s}: {count:,}")
+    
+    family_train, family_val, family_test = [], [], []
+    for fam, pool in families.items():
+        np.random.shuffle(pool)
+        n = len(pool)
+        n_train = max(1, int(n * args.train_ratio))
+        n_val = max(1, int(n * args.val_ratio))
+        family_train.extend(pool[:n_train])
+        family_val.extend(pool[n_train:n_train+n_val])
+        family_test.extend(pool[n_train+n_val:])
+    
+    splits["family_stratified_ssb"] = {
+        "train": [e["source_id"] + e.get("source", "") for e in family_train],
+        "val": [e["source_id"] + e.get("source", "") for e in family_val],
+        "test": [e["source_id"] + e.get("source", "") for e in family_test],
+    }
+    print(f"    Train: {len(splits['family_stratified_ssb']['train']):,}")
+    print(f"    Val: {len(splits['family_stratified_ssb']['val']):,}")
+    print(f"    Test: {len(splits['family_stratified_ssb']['test']):,}")
+    
+    # 3. Best-candidate held-out (hold out top-100 lowest-barrier entries for testing)
+    print(f"\n{'─' * 60}")
+    print("  3. Best-candidate held-out split")
+    print(f"{'─' * 60}")
+    
+    sorted_by_barrier = sorted(ssb_entries, key=lambda e: e["ssb_screening"]["bvse_migration_barrier_eV"])
+    top_k = min(500, len(sorted_by_barrier))
+    best_test = sorted_by_barrier[:top_k]
+    best_pool = sorted_by_barrier[top_k:]
+    
+    np.random.shuffle(best_pool)
+    n_best_train = int(len(best_pool) * args.train_ratio)
+    n_best_val = int(len(best_pool) * args.val_ratio)
+    best_train = best_pool[:n_best_train]
+    best_val = best_pool[n_best_train:n_best_train+n_best_val]
+    
+    splits["best_conductors_held_out"] = {
+        "train": [e["source_id"] + e.get("source", "") for e in best_train],
+        "val": [e["source_id"] + e.get("source", "") for e in best_val],
+        "test": [e["source_id"] + e.get("source", "") for e in best_test],
+    }
+    print(f"    Test (top {top_k} conductors): {len(splits['best_conductors_held_out']['test']):,}")
+    print(f"    Train: {len(splits['best_conductors_held_out']['train']):,}")
+    print(f"    Val: {len(splits['best_conductors_held_out']['val']):,}")
+    
+    # 4. Mobility class held-out (hold out entire mobility classes)
+    print(f"\n{'─' * 60}")
+    print("  4. Mobility-class held-out split")
+    print(f"{'─' * 60}")
+    
+    classes = defaultdict(list)
+    for e in ssb_entries:
+        cls = e["ssb_screening"].get("bvse_mobility_class", "unknown")
+        classes[cls].append(e)
+    
+    for cls, pool in classes.items():
+        print(f"    {cls:15s}: {len(pool):,}")
+    
+    # Hold out superionic as test set (hardest generalization task)
+    if "superionic" in classes:
+        mob_test = classes["superionic"]
+        mob_pool = []
+        for cls, pool in classes.items():
+            if cls != "superionic":
+                mob_pool.extend(pool)
+        np.random.shuffle(mob_pool)
+        n_mob_train = int(len(mob_pool) * args.train_ratio)
+        n_mob_val = int(len(mob_pool) * args.val_ratio)
+        mob_train = mob_pool[:n_mob_train]
+        mob_val = mob_pool[n_mob_train:n_mob_train+n_mob_val]
+        
+        splits["mobility_class_held_out"] = {
+            "train": [e["source_id"] + e.get("source", "") for e in mob_train],
+            "val": [e["source_id"] + e.get("source", "") for e in mob_val],
+            "test": [e["source_id"] + e.get("source", "") for e in mob_test],
+        }
+        print(f"\n    Hold-out class: superionic ({len(mob_test):,} entries)")
+        print(f"    Train: {len(mob_train):,}, Val: {len(mob_val):,}")
+    else:
+        print("    No superionic entries found for held-out split.")
+    
+    # Save splits
+    if not args.dry_run:
+        output_dir = BASE_DIR / SPLIT_DIR / "ssb"
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        for split_name, split_data in splits.items():
+            output_path = output_dir / f"{split_name}.json"
+            
+            # Convert to index-based splits
+            entry_indices = {}
+            for i, e in enumerate(entries):
+                key = e["source_id"] + e.get("source", "")
+                entry_indices[key] = i
+            
+            index_split = {
+                "train": [entry_indices[k] for k in split_data["train"] if k in entry_indices],
+                "val": [entry_indices[k] for k in split_data["val"] if k in entry_indices],
+                "test": [entry_indices[k] for k in split_data["test"] if k in entry_indices],
+            }
+            
+            with open(output_path, "w") as f:
+                json.dump(index_split, f, indent=2)
+            print(f"\n  Saved: {output_path}")
+            print(f"    Train: {len(index_split['train']):,}")
+            print(f"    Val: {len(index_split['val']):,}")
+            print(f"    Test: {len(index_split['test']):,}")
+        
+        # Summary
+        print(f"\n{'─' * 60}")
+        print("  SPLIT SUMMARY")
+        print(f"{'─' * 60}")
+        for split_name in splits:
+            data = splits[split_name]
+            print(f"  {split_name:35s}: train={len(data['train']):,} val={len(data['val']):,} test={len(data['test']):,}")
+    
+    else:
+        print(f"\n  (dry-run — no files written)")
+    
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/integrate_experimental_data.py

@@ -0,0 +1,440 @@
+"""Integrate experimental Li solid-electrolyte conductivity data.
+
+Two separate, independently curated databases are supported:
+
+1. **Hargreaves et al. 2023** — npj Computational Materials
+   ~820 entries, 403 compositions, 214 sources
+   https://doi.org/10.1038/s41524-023-01137-3
+
+2. **OBELiX (Therrien et al. 2025, NRC-Mila)**
+   ~599 entries, curated with leakage-resistant splits
+   pip install obelix-data
+   https://github.com/nrc-mila/OBELiX
+
+These are complementary — not duplicates — and are tracked as two separate
+provenance sources with distinct citations.
+
+Usage:
+    # Hargreaves 2023
+    python scripts/integrate_experimental_data.py --ransom-path path/to/ransom2023.csv
+
+    # OBELiX via pip package
+    python scripts/integrate_experimental_data.py --obelix
+
+    # Both
+    python scripts/integrate_experimental_data.py --ransom-path ... --obelix
+
+    # Dry run
+    python scripts/integrate_experimental_data.py --dry-run
+"""
+import json, os, sys, time, argparse, csv, io, re, subprocess
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+import pandas as pd
+import warnings
+warnings.filterwarnings("ignore")
+
+WIDTH = 60
+
+RANSOM_URLS = [
+    "https://raw.githubusercontent.com/nrc-cnrc/ransom2023-conductivity/main/data/conductivity_database.csv",
+]
+
+HARGREAVES_DOI = "https://doi.org/10.1038/s41524-022-00951-z"
+OBELIX_DOI = "https://github.com/nrc-mila/OBELiX"
+
+
+def parse_formula(formula):
+    parts = re.findall(r'([A-Z][a-z]*)(\d*\.?\d*)', formula)
+    return {el: float(cnt) if cnt else 1.0 for el, cnt in parts}
+
+
+def formula_similarity(f1, f2):
+    d1 = parse_formula(f1)
+    d2 = parse_formula(f2)
+    if set(d1.keys()) != set(d2.keys()):
+        return False
+    total1, total2 = sum(d1.values()), sum(d2.values())
+    for el in d1:
+        r1 = d1[el] / total1
+        r2 = d2[el] / total2
+        if abs(r1 - r2) > 0.05:
+            return False
+    return True
+
+
+def try_fetch_ransom():
+    """Try to download Hargreaves 2023 database."""
+    import urllib.request
+    for url in RANSOM_URLS:
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "Scandium-Labs/1.0"})
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                data = resp.read().decode("utf-8")
+                print(f"  Downloaded {len(data):,} bytes")
+                return data
+        except Exception as e:
+            print(f"  Failed: {str(e)[:80]}")
+    return None
+
+
+def try_fetch_obelix_package():
+    """Try to install obelix-data package and load data."""
+    try:
+        import obelix
+        ob = obelix.OBELiX(data_path="/tmp/obelix_rawdata", no_cifs=True)
+        n = len(ob.dataframe)
+        print(f"  OBELiX package loaded: {n} entries")
+        return ob
+    except ImportError:
+        print("  obelix-data not installed. Attempting pip install...")
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "obelix-data"],
+            capture_output=True, text=True, timeout=60
+        )
+        if result.returncode == 0:
+            try:
+                import obelix
+                ob = obelix.OBELiX(data_path="/tmp/obelix_rawdata", no_cifs=True)
+                n = len(ob.dataframe)
+                print(f"  OBELiX installed and loaded: {n} entries")
+                return ob
+            except Exception as e:
+                print(f"  Load failed after install: {e}")
+                return None
+        else:
+            print(f"  Install failed: {result.stderr[-200:]}")
+            return None
+
+
+def parse_ransom_csv(csv_data):
+    """Parse Hargreaves 2023 CSV into entry dicts."""
+    reader = csv.DictReader(io.StringIO(csv_data))
+    entries = []
+    for i, row in enumerate(reader):
+        entry = {
+            "source": "Hargreaves2023",
+            "source_id": f"Hargreaves2023-{i:04d}",
+            "is_experimental": True,
+            "experimental_database": "Hargreaves2023",
+            "provenance": {
+                "source": "Hargreaves2023",
+                "source_id": f"Hargreaves2023-{i:04d}",
+                "doi": HARGREAVES_DOI,
+                "integrated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            },
+        }
+        formula = row.get("Formula", row.get("formula", "")).strip()
+        if formula:
+            entry["formula"] = formula
+            entry["structured_formula"] = formula
+            entry["elements"] = list(parse_formula(formula).keys())
+            entry["carrier_elements"] = ["Li"]
+
+        for field in ["Conductivity_S_cm", "conductivity_S_cm", "Conductivity (S/cm)"]:
+            val = row.get(field, "").strip()
+            if val:
+                try:
+                    entry["conductivity_S_cm"] = float(val)
+                except ValueError:
+                    pass
+
+        for field in ["Ea_eV", "activation_energy_eV", "Activation energy (eV)"]:
+            val = row.get(field, "").strip()
+            if val:
+                try:
+                    entry["activation_energy_eV"] = float(val)
+                except ValueError:
+                    pass
+
+        for field in ["Temperature_K", "temperature_K", "Temperature (K)"]:
+            val = row.get(field, "").strip()
+            if val:
+                try:
+                    entry["temperature_K"] = float(val)
+                except ValueError:
+                    pass
+
+        ref = row.get("Reference", row.get("reference", "")).strip()
+        if ref:
+            entry["reference"] = ref
+            entry["provenance"]["experimental_reference"] = ref
+
+        entries.append(entry)
+
+    return entries
+
+
+def parse_obelix_via_package(obelix_obj):
+    """Parse OBELiX data via pandas DataFrame."""
+    entries = []
+    try:
+        df = obelix_obj.dataframe
+        for idx, row in df.iterrows():
+            formula = str(row.get("Reduced Composition", ""))
+            true_comp = str(row.get("True Composition", ""))
+            conductivity = row.get("Ionic conductivity (S cm-1)")
+            doi = str(row.get("DOI", ""))
+            family = str(row.get("Family", ""))
+            icsd = row.get("ICSD ID")
+            sg = str(row.get("Space group", ""))
+
+            entry = {
+                "source": "OBELiX",
+                "source_id": f"OBELiX-{idx}",
+                "is_experimental": True,
+                "experimental_database": "OBELiX_Therrien2025",
+                "formula": formula,
+                "structured_formula": true_comp if (true_comp and true_comp != "nan") else formula,
+                "elements": list(parse_formula(formula).keys()) if formula else [],
+                "carrier_elements": ["Li"],
+                "conductivity_S_cm": float(conductivity) if pd.notna(conductivity) else None,
+                "space_group": sg if sg != "nan" else "",
+                "sse_family": family if family != "nan" else "",
+                "reference": doi if doi != "nan" else "",
+                "provenance": {
+                    "source": "OBELiX_Therrien2025",
+                    "source_id": f"OBELiX-{idx}",
+                    "doi": "https://github.com/nrc-mila/OBELiX",
+                    "icsd_id": str(icsd) if pd.notna(icsd) else "",
+                    "integrated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                },
+            }
+            entries.append(entry)
+    except Exception as e:
+        print(f"  OBELiX DataFrame parse error: {e}")
+
+    return entries
+
+
+def cross_reference_and_add(exp_entries, all_dataset_entries):
+    """Cross-reference experimental entries with the existing dataset."""
+    formula_index = defaultdict(list)
+    for e in all_dataset_entries:
+        sf = e.get("structured_formula", e.get("formula", ""))
+        formula_index[sf].append(e)
+
+    matched = 0
+    unmatched = 0
+    conductivity_added = 0
+    new_entries = []
+
+    for exp_e in exp_entries:
+        exp_formula = exp_e.get("formula", "")
+        matched_entries = formula_index.get(exp_formula, [])
+
+        if not matched_entries:
+            for sf, existing in formula_index.items():
+                if formula_similarity(exp_formula, sf):
+                    matched_entries = existing
+                    break
+
+        db_name = exp_e.get("experimental_database", "unknown")
+
+        if matched_entries:
+            matched += 1
+            for existing_e in matched_entries:
+                if "ssb_screening" not in existing_e:
+                    existing_e["ssb_screening"] = {}
+
+                cond = exp_e.get("conductivity_S_cm")
+                ea = exp_e.get("activation_energy_eV")
+
+                if cond is not None:
+                    existing_e["ssb_screening"]["estimated_ionic_conductivity_S_cm"] = cond
+                    existing_e["ssb_screening"]["conductivity_source"] = f"experimental_{db_name}"
+                    conductivity_added += 1
+
+                if ea is not None:
+                    existing_e["ssb_screening"]["experimental_activation_energy_eV"] = ea
+
+                existing_e["is_experimental"] = True
+                if "provenance" not in existing_e:
+                    existing_e["provenance"] = {}
+                existing_e["provenance"]["experimental_confirmed"] = True
+                existing_e["provenance"]["experimental_database"] = db_name
+                existing_e["provenance"]["experimental_reference"] = exp_e.get("reference", "")
+        else:
+            unmatched += 1
+            new_entry = {
+                "source": exp_e.get("source", "experimental"),
+                "source_id": exp_e.get("source_id", f"exp-{unmatched}"),
+                "formula": exp_formula,
+                "structured_formula": exp_formula,
+                "elements": exp_e.get("elements", []),
+                "nsites": len(exp_e.get("elements", [])),
+                "band_gap": None,
+                "formation_energy_per_atom": None,
+                "energy_above_hull": None,
+                "is_experimental": True,
+                "families": ["experimental_SSE"],
+                "sse_family": "experimental",
+                "mobile_ion": "Li",
+                "carrier_elements": ["Li"],
+                "tier": "experimental_gold",
+                "quality_score": 95,
+                "quality_flags": ["experimental_data", "has_conductivity"],
+                "ssb_screening": {
+                    "estimated_ionic_conductivity_S_cm": exp_e.get("conductivity_S_cm"),
+                    "conductivity_source": f"experimental_{db_name}",
+                    "experimental_activation_energy_eV": exp_e.get("activation_energy_eV"),
+                    "measurement_temperature_K": exp_e.get("temperature_K"),
+                    "mobile_ion": "Li",
+                    "sse_family": "experimental",
+                    "gates_passed": ["experimental"],
+                    "sse_candidate_score": 100,
+                },
+                "provenance": exp_e.get("provenance", {}),
+                "license": "CC-BY-4.0",
+            }
+            new_entries.append(new_entry)
+
+    return matched, unmatched, conductivity_added, new_entries
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Integrate experimental conductivity data")
+    parser.add_argument("--ransom-path", type=str, default=None,
+                        help="Path to Hargreaves 2023 CSV file")
+    parser.add_argument("--obelix", action="store_true",
+                        help="Try to load OBELiX via obelix-data package")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--cross-ref-only", action="store_true")
+    args = parser.parse_args()
+
+    if not args.ransom_path and not args.obelix:
+        print("Specify at least one data source:")
+        print("  --ransom-path <file.csv>  Hargreaves et al. 2023 database")
+        print("  --obelix                  OBELiX via obelix-data package")
+        sys.exit(1)
+
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    DATASET_PATH = BASE_DIR / "dataset"
+
+    print("=" * WIDTH)
+    print("  EXPERIMENTAL DATA INTEGRATION")
+    print("=" * WIDTH)
+
+    all_experimental = []
+
+    # --- Hargreaves 2023 ---
+    if args.ransom_path:
+        source_label = "Hargreaves et al. 2023 (npj Comput. Mater.)"
+        print(f"\n  [{source_label}]")
+
+        ransom_data = None
+        path = Path(args.ransom_path)
+        if path.exists():
+            with open(path) as f:
+                ransom_data = f.read()
+            print(f"  Loaded from {path}")
+        else:
+            print(f"  File not found: {path}")
+            print("  Attempting download...")
+            ransom_data = try_fetch_ransom()
+
+        if ransom_data:
+            entries = parse_ransom_csv(ransom_data)
+            print(f"  Parsed {len(entries):,} entries")
+            for e in entries:
+                e["experimental_database"] = "Hargreaves2023"
+            all_experimental.extend(entries)
+            with_cond = sum(1 for e in entries if e.get("conductivity_S_cm") is not None)
+            with_ea = sum(1 for e in entries if e.get("activation_energy_eV") is not None)
+            print(f"    With conductivity: {with_cond}")
+            print(f"    With activation energy: {with_ea}")
+        else:
+            print(f"  Could not load Hargreaves 2023 data.")
+            print(f"  Download manually from: {HARGREAVES_DOI}")
+
+    # --- OBELiX Therrien 2025 ---
+    if args.obelix:
+        source_label = "OBELiX (Therrien et al. 2025, NRC-Mila)"
+        print(f"\n  [{source_label}]")
+        print("  Attempting obelix-data package...")
+        ob_data = try_fetch_obelix_package()
+        if ob_data is not None:
+            entries = parse_obelix_via_package(ob_data)
+            print(f"  Parsed {len(entries):,} entries")
+            for e in entries:
+                e["experimental_database"] = "OBELiX_Therrien2025"
+            all_experimental.extend(entries)
+            with_cond = sum(1 for e in entries if e.get("conductivity_S_cm") is not None)
+            with_ea = sum(1 for e in entries if e.get("activation_energy_eV") is not None)
+            print(f"    With conductivity: {with_cond}")
+            print(f"    With activation energy: {with_ea}")
+        else:
+            print(f"  Could not load OBELiX via package.")
+            print(f"  Try: pip install obelix-data")
+            print(f"  Or:  https://github.com/nrc-mila/OBELiX")
+
+    if not all_experimental:
+        print("\n  No experimental data loaded. Nothing to integrate.")
+        sys.exit(1)
+
+    # --- Cross-reference with existing dataset ---
+    print(f"\n  Loading Scandium-Dataset...")
+    t0 = time.time()
+    with open(DATASET_PATH / "entries_final_v3.json") as f:
+        all_entries = json.load(f)
+    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
+
+    print(f"\n{'─' * WIDTH}")
+    print("  Cross-referencing...")
+    print(f"{'─' * WIDTH}")
+
+    matched, unmatched, conductivity_added, new_entries = cross_reference_and_add(
+        all_experimental, all_entries
+    )
+
+    print(f"\n  Results:")
+    print(f"    Matched existing entries: {matched}")
+    print(f"    Unmatched (new compositions): {unmatched}")
+    print(f"    Conductivity labels added: {conductivity_added}")
+    print(f"    New experimental entries: {len(new_entries)}")
+
+    if new_entries:
+        cond_entries = [(e.get("formula", "?"),
+                         e.get("ssb_screening", {}).get("estimated_ionic_conductivity_S_cm"))
+                        for e in new_entries
+                        if e.get("ssb_screening", {}).get("estimated_ionic_conductivity_S_cm")]
+        for formula, cond in sorted(cond_entries, key=lambda x: -abs(x[1] or 0))[:5]:
+            if cond:
+                print(f"    {formula:30s} σ={cond:.2e} S/cm")
+
+    if not args.dry_run:
+        if new_entries:
+            all_entries.extend(new_entries)
+            print(f"\n  Added {len(new_entries):,} experimental entries")
+
+        output_path = DATASET_PATH / "entries_final_v3.json"
+        print(f"  Writing to {output_path}...")
+        t_write = time.time()
+        with open(output_path, "w") as f:
+            json.dump(all_entries, f)
+        print(f"  Done ({time.time()-t_write:.1f}s)")
+
+        experimental_count = sum(1 for e in all_entries if e.get("is_experimental"))
+        with_conductivity_total = sum(
+            1 for e in all_entries
+            if e.get("ssb_screening", {}).get("estimated_ionic_conductivity_S_cm")
+        )
+
+        print(f"\n{'─' * WIDTH}")
+        print("  INTEGRATION SUMMARY")
+        print(f"{'─' * WIDTH}")
+        db_sources = set(e.get("experimental_database", "unknown") for e in all_experimental)
+        for db in sorted(db_sources):
+            count = sum(1 for e in all_experimental if e.get("experimental_database") == db)
+            print(f"  {db}: {count} entries")
+        print(f"  Total experimental entries in dataset: {experimental_count}")
+        print(f"  Entries with conductivity labels: {with_conductivity_total}")
+    else:
+        print(f"\n  (dry-run)")
+
+    print("=" * WIDTH)
+
+
+if __name__ == "__main__":
+    main()

scripts/merge_obelix.py

@@ -0,0 +1,309 @@
+"""Fast OBELiX merge using direct PyArrow table manipulation.
+
+Avoids the scan() bottleneck by building a formula index from the
+Parquet columns directly and applying all updates at once.
+"""
+import json, sys, time
+from pathlib import Path
+from collections import defaultdict
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(BASE_DIR / "dataset"))
+from dataset_store import _encode_value, _decode_value, SCALAR_COLUMNS, JSON_STRING_FIELDS
+
+import pyarrow.parquet as pq
+import pyarrow as pa
+import pandas as pd
+
+PARQUET_PATH = BASE_DIR / "dataset" / "entries_v3.parquet"
+INDEX_PATH = BASE_DIR / "dataset" / "entries_v3.index.json"
+OBELIX_DATA_PATH = "/tmp/obelix_rawdata"
+
+WIDTH = 60
+
+
+def load_obelix():
+    import obelix
+    ob = obelix.OBELiX(data_path=OBELIX_DATA_PATH, no_cifs=True)
+    df = ob.dataframe
+    return df
+
+
+def format_obelix_entry(row, seq_id=0):
+    """Convert OBELiX DataFrame row to a dataset entry dict."""
+    formula = str(row.get("Reduced Composition", ""))
+    true_comp = str(row.get("True Composition", ""))
+    conductivity = row.get("Ionic conductivity (S cm-1)")
+    if pd.notna(conductivity):
+        conductivity = float(conductivity)
+    else:
+        conductivity = None
+    doi = str(row.get("DOI", ""))
+    family = str(row.get("Family", ""))
+    sg = str(row.get("Space group", ""))
+    icsd = row.get("ICSD ID")
+
+    entry = {
+        "source": "OBELiX",
+        "source_id": f"OBELiX-{seq_id:04d}",
+        "formula": formula,
+        "structured_formula": true_comp if true_comp and true_comp != "nan" else formula,
+        "nsites": 0, "band_gap": None,
+        "formation_energy_per_atom": None, "energy_above_hull": None,
+        "is_experimental": True,
+        "families": [f"experimental_{family}"] if family and family != "nan" else ["experimental_SSE"],
+        "sse_family": family if family and family != "nan" else "experimental",
+        "mobile_ion": "Li", "carrier_elements": ["Li"],
+        "tier": "experimental_gold", "quality_score": 100,
+        "quality_flags": ["experimental_data", "has_conductivity"],
+        "space_group": sg if sg != "nan" else "",
+        "elements": list(set(c for c in formula if c.isalpha())),
+        "ssb_screening": {
+            "estimated_ionic_conductivity_S_cm": conductivity,
+            "conductivity_source": "experimental_OBELiX_Therrien2025",
+            "mobile_ion": "Li",
+            "sse_family": family if family and family != "nan" else "experimental",
+            "gates_passed": ["experimental"],
+            "sse_candidate_score": 100,
+        },
+        "provenance": {
+            "source": "OBELiX_Therrien2025", "source_id": f"OBELiX-{seq_id:04d}",
+            "doi": "https://github.com/nrc-mila/OBELiX",
+            "icsd_id": str(icsd) if pd.notna(icsd) else "",
+            "experimental_confirmed": True,
+            "experimental_database": "OBELiX_Therrien2025",
+            "experimental_reference": doi if doi != "nan" else "",
+        },
+        "license": "CC-BY-4.0",
+    }
+    return entry
+
+
+def main():
+    print("=" * WIDTH)
+    print("  OBELiX FAST MERGE")
+    print("=" * WIDTH)
+
+    print("\nLoading OBELiX data...")
+    t0 = time.time()
+    df = load_obelix()
+    print(f"  {len(df):,} entries, {df['Reduced Composition'].nunique()} unique comps ({time.time()-t0:.1f}s)")
+
+    print("\nBuilding formula index from Parquet store...")
+    t1 = time.time()
+    table = pq.read_table(PARQUET_PATH)
+
+    # Cast null-type columns to string so concat_tables works later
+    from pyarrow import types
+    null_cols = [f.name for f in table.schema if types.is_null(f.type)]
+    if null_cols:
+        new_fields = []
+        for f in table.schema:
+            if f.name in null_cols:
+                new_fields.append(pa.field(f.name, pa.string()))
+            else:
+                new_fields.append(f)
+        table = table.cast(pa.schema(new_fields))
+    print(f"  {table.num_rows:,} rows loaded ({time.time()-t1:.1f}s)")
+
+    # Build formula -> row index map
+    formula_to_rows = defaultdict(list)
+    for i in range(table.num_rows):
+        for col_name in ["formula", "structured_formula"]:
+            raw = table.column(col_name)[i].as_py()
+            if raw:
+                decoded = _decode_value(raw)
+                if decoded:
+                    formula_to_rows[str(decoded).lower()].append(i)
+    print(f"  Index: {len(formula_to_rows):,} unique formulas -> {sum(len(v) for v in formula_to_rows.values()):,} references")
+
+    # Match OBELiX entries
+    print("\nCross-referencing...")
+    matched_rows = set()
+    unmatched_df_rows = []
+    matched_df = []
+    for idx, row in df.iterrows():
+        formula = str(row.get("Reduced Composition", "")).lower()
+        matching = formula_to_rows.get(formula, [])
+        if matching:
+            matched_rows.update(matching)
+            matched_df.append(row)
+        else:
+            unmatched_df_rows.append(row)
+
+    print(f"  Matched: {len(matched_df)} OBELiX entries → {len(matched_rows)} dataset rows")
+    print(f"  Unmatched: {len(unmatched_df_rows)} OBELiX entries")
+
+    # Save unmatched list
+    unmatched_formulas = sorted(set(
+        str(r.get("Reduced Composition", "")) for r in unmatched_df_rows
+    ))
+    with open(BASE_DIR / "dataset" / "obelix_unmatched_formulas.json", "w") as f:
+        json.dump(unmatched_formulas, f, indent=2)
+    print(f"  Unmatched formulas saved: {len(unmatched_formulas)}")
+
+    # Count by family
+    from collections import Counter
+    fam_counts = Counter(str(r.get("Family", "")) for r in unmatched_df_rows)
+    print(f"\n  Unmatched by family:")
+    for fam, cnt in sorted(fam_counts.items(), key=lambda x: -x[1])[:10]:
+        print(f"    {fam if fam != 'nan' else 'unspecified':30s}: {cnt}")
+
+    # --- Apply updates to matched entries ---
+    print(f"\n{'─' * WIDTH}")
+    print("  Applying updates to matched entries...")
+    t2 = time.time()
+
+    # For each matched row, read current ssb_screening, append conductivity info
+    ssb_col = table.column("ssb_screening").to_pylist()
+    prov_col = table.column("provenance").to_pylist()
+    exp_col = table.column("is_experimental").to_pylist()
+    sid_col = table.column("source_id").to_pylist()
+
+    # Group matched OBELiX entries by formula for efficient update
+    formula_updates = defaultdict(list)
+    for r in matched_df:
+        f = str(r.get("Reduced Composition", "")).lower()
+        conductivity = float(r.get("Ionic conductivity (S cm-1)")) if pd.notna(r.get("Ionic conductivity (S cm-1)")) else None
+        doi = str(r.get("DOI", ""))
+        formula_updates[f].append({"conductivity": conductivity, "doi": doi})
+
+    updates_applied = 0
+    for row_i in matched_rows:
+        sid_raw = sid_col[row_i]
+        sid = _decode_value(sid_raw) if sid_raw else None
+
+        # Decode current ssb_screening
+        ssb_raw = ssb_col[row_i]
+        ssb = _decode_value(ssb_raw) if ssb_raw else {}
+        if not isinstance(ssb, dict):
+            ssb = {}
+
+        # Find matching OBELiX data for this entry's formula
+        for col_name in ["formula", "structured_formula"]:
+            raw = table.column(col_name)[row_i].as_py()
+            if raw:
+                formula_decoded = _decode_value(raw)
+                if formula_decoded:
+                    updates = formula_updates.get(str(formula_decoded).lower(), [])
+                    if updates:
+                        # Take the first OBELiX measurement for this formula
+                        upd = updates[0]
+                        if upd["conductivity"] is not None:
+                            ssb["estimated_ionic_conductivity_S_cm"] = upd["conductivity"]
+                            ssb["conductivity_source"] = "experimental_OBELiX_Therrien2025"
+                        if upd["doi"] and upd["doi"] != "nan":
+                            ssb["experimental_reference"] = upd["doi"]
+                    break
+
+        ssb_col[row_i] = _encode_value(ssb)
+
+        # Update provenance
+        prov_raw = prov_col[row_i]
+        prov = _decode_value(prov_raw) if prov_raw else {}
+        if not isinstance(prov, dict):
+            prov = {}
+        prov["experimental_confirmed"] = True
+        prov["experimental_database"] = "OBELiX_Therrien2025"
+        prov_col[row_i] = _encode_value(prov)
+
+        # Mark as experimental
+        exp_col[row_i] = _encode_value(True)
+
+        updates_applied += 1
+
+    # Write updated columns back to table
+    table = table.set_column(
+        table.schema.get_field_index("ssb_screening"), "ssb_screening",
+        pa.chunked_array([pa.array(ssb_col)])
+    )
+    table = table.set_column(
+        table.schema.get_field_index("provenance"), "provenance",
+        pa.chunked_array([pa.array(prov_col)])
+    )
+    table = table.set_column(
+        table.schema.get_field_index("is_experimental"), "is_experimental",
+        pa.chunked_array([pa.array(exp_col)])
+    )
+    print(f"  {updates_applied} rows updated ({time.time()-t2:.1f}s)")
+
+    # --- Append unmatched as new entries ---
+    print(f"\nAppending {len(unmatched_df_rows)} unmatched OBELiX entries...")
+    t3 = time.time()
+
+    # Import the standardized extraction from dataset_store
+    ALL_FIELDS = SCALAR_COLUMNS + JSON_STRING_FIELDS
+    ALL_FIELDS_SET = set(ALL_FIELDS)
+
+    new_entry_dicts = []
+    for i, row in enumerate(unmatched_df_rows):
+        entry = format_obelix_entry(row, i)
+        encoded = {}
+        for f in ALL_FIELDS:
+            val = _encode_value(entry.get(f))
+            encoded[f] = val if val is not None else ""
+        new_entry_dicts.append(encoded)
+
+    new_batch = pa.Table.from_pylist(new_entry_dicts)
+
+    # Add any columns from existing table schema that are missing in new_batch
+    missing_from_new = [f for f in table.schema.names if f not in new_batch.schema.names]
+    for f in missing_from_new:
+        # Need string type to match existing schema — insert empty strings
+        arr = pa.array([""] * new_batch.num_rows, type=pa.string())
+        new_batch = new_batch.append_column(pa.field(f, pa.string()), arr)
+
+    # Remove columns from new_batch not in existing schema
+    cols_to_drop = [f for f in new_batch.schema.names if f not in table.schema.names]
+    for f in cols_to_drop:
+        col_idx = new_batch.schema.get_field_index(f)
+        new_batch = new_batch.remove_column(col_idx)
+
+    # Reorder columns to match
+    new_batch = new_batch.select(table.schema.names)
+
+    table = pa.concat_tables([table, new_batch])
+    print(f"  Appended {new_batch.num_rows} rows ({time.time()-t3:.1f}s)")
+    print(f"  Total rows: {table.num_rows:,}")
+
+    # --- Rewrite Parquet + index ---
+    print(f"\n{'─' * WIDTH}")
+    print("  Checkpointing...")
+    t4 = time.time()
+    pq.write_table(table, PARQUET_PATH, compression="zstd")
+
+    # Rebuild index
+    sids_raw = table.column("source_id").to_pylist()
+    sids_decoded = [_decode_value(s) for s in sids_raw]
+    index = {sid: i for i, sid in enumerate(sids_decoded)}
+    with open(INDEX_PATH, "w") as f:
+        json.dump(index, f)
+    print(f"  Parquet + index written ({time.time()-t4:.1f}s)")
+
+    # Summary
+    with_cond = sum(
+        1 for i in range(table.num_rows)
+        if table.column("ssb_screening")[i].as_py()
+        and "estimated_ionic_conductivity" in str(table.column("ssb_screening")[i].as_py())
+    )
+    exp_new = sum(
+        1 for i in range(table.num_rows)
+        if table.column("tier")[i].as_py()
+        and "experimental" in str(table.column("tier")[i].as_py())
+    )
+
+    print(f"\n{'─' * WIDTH}")
+    print("  MERGE COMPLETE")
+    print(f"{'─' * WIDTH}")
+    print(f"  OBELiX entries integrated: {len(df)}")
+    print(f"  Matched + tagged: {len(matched_df)}")
+    print(f"  New entries appended: {len(unmatched_df_rows)}")
+    print(f"  Unmatched formulas (acquisition target): {len(unmatched_formulas)}")
+    print(f"  Total entries in dataset: {table.num_rows:,}")
+    print("=" * WIDTH)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/run_phase1_pipeline.py

@@ -0,0 +1,116 @@
+"""Phase 1 pipeline runner — executes all Phase 1 scripts in sequence.
+
+This script runs the complete Phase 1 pipeline:
+  1. Electrochemical stability windows (Li/Na entries)
+  2. CAVD channel dimensionality (all Li/Na entries with structures)
+  3. SSE candidate score (all entries, 5-gate system)
+  4. Mechanical properties (all entries, geometric proxy)
+  5. Oxidation states (all entries, BVA + heuristic)
+  6. JARVIS EaH (internal convex hull)
+  7. Commercial-safe edition extraction
+  8. Garnet enrichment (structure-based reclassification)
+
+Usage:
+    python scripts/run_phase1_pipeline.py                        # full pipeline
+    python scripts/run_phase1_pipeline.py --steps 1,3,5          # specific steps only
+    python scripts/run_phase1_pipeline.py --dry-run              # stats only, no writes
+    python scripts/run_phase1_pipeline.py --skip-write           # compute but don't save
+"""
+import sys, time, argparse, subprocess
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent
+BASE_DIR = SCRIPTS_DIR.parent
+
+STEPS = {
+    1: ("Electrochemical Windows", "compute_electrochemical_windows.py", 
+        ["python", "scripts/compute_electrochemical_windows.py", "--subset", "full"]),
+    2: ("CAVD Channel Dimensionality", "compute_cavd_channel_dimensionality.py",
+        ["python", "scripts/compute_cavd_channel_dimensionality.py", "--subset", "full"]),
+    3: ("SSE Candidate Score", "compute_sse_candidate_score.py",
+        ["python", "scripts/compute_sse_candidate_score.py", "--subset", "full"]),
+    4: ("Mechanical Properties", "compute_mechanical_properties.py",
+        ["python", "scripts/compute_mechanical_properties.py"]),
+    5: ("Oxidation States", "compute_oxidation_states.py",
+        ["python", "scripts/compute_oxidation_states.py"]),
+    6: ("JARVIS EaH", "compute_jarvis_hull_energy.py",
+        ["python", "scripts/compute_jarvis_hull_energy.py"]),
+    7: ("Commercial-Safe Edition", "extract_commercial_safe_edition.py",
+        ["python", "scripts/extract_commercial_safe_edition.py"]),
+    8: ("Garnet Enrichment", "enrich_garnet_family.py",
+        ["python", "scripts/enrich_garnet_family.py"]),
+}
+
+STEP_ORDER = [1, 2, 3, 4, 5, 6, 7, 8]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Phase 1 pipeline runner")
+    parser.add_argument("--steps", type=str, default=None,
+                        help="Comma-separated step numbers (e.g. 1,3,5)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Add --dry-run to all scripts")
+    parser.add_argument("--skip-write", action="store_true",
+                        help="Add --dry-run to dataset-modifying scripts")
+    args = parser.parse_args()
+    
+    if args.steps:
+        selected_steps = [int(s.strip()) for s in args.steps.split(",")]
+    else:
+        selected_steps = STEP_ORDER
+    
+    print("=" * 60)
+    print("  PHASE 1 PIPELINE")
+    print("  8 steps to transform Scandium-Dataset into SSB screening resource")
+    print("=" * 60)
+    
+    total_start = time.time()
+    
+    for step_num in selected_steps:
+        if step_num not in STEPS:
+            print(f"\n  [SKIP] Step {step_num}: unknown")
+            continue
+        
+        name, script, base_cmd = STEPS[step_num]
+        
+        print(f"\n{'─' * 60}")
+        print(f"  Step {step_num}/8: {name}")
+        print(f"  Script: scripts/{script}")
+        print(f"{'─' * 60}")
+        
+        cmd = list(base_cmd)
+        if args.dry_run or args.skip_write:
+            cmd.append("--dry-run")
+        
+        step_start = time.time()
+        print(f"  Running: {' '.join(cmd)}")
+        print()
+        
+        result = subprocess.run(cmd, cwd=str(BASE_DIR), capture_output=True, text=True)
+        
+        # Print stdout
+        for line in result.stdout.split("\n"):
+            print(f"  {line}")
+        
+        if result.stderr.strip():
+            print(f"\n  stderr:")
+            for line in result.stderr.strip().split("\n"):
+                print(f"  ! {line}")
+        
+        if result.returncode != 0:
+            print(f"\n  [FAILED] exit code {result.returncode}")
+            if not args.dry_run:
+                print("  Aborting pipeline.")
+                sys.exit(1)
+        
+        elapsed = time.time() - step_start
+        print(f"\n  [{elapsed/60:.1f} min]")
+    
+    total_elapsed = time.time() - total_start
+    print(f"\n{'=' * 60}")
+    print(f"  Pipeline complete: {len(selected_steps)} steps in {total_elapsed/60:.1f} min")
+    print(f"{'=' * 60}")
+
+
+if __name__ == "__main__":
+    main()

scripts/setup_mlip_infrastructure.py

@@ -0,0 +1,202 @@
+"""Set up MLIP infrastructure for high-throughput migration barrier computation.
+
+Installs and validates MLIP tools for nudged elastic band (NEB) calculations:
+  - CHGNet: universal crystal Hamiltonian Graph neural Network
+  - MACE-MP-0: MACE architecture trained on Materials Project trajectories
+  - M3GNet: universal potential from Materials Project
+  - Orb-v3: Orbital-based MLIP
+
+This script:
+  1. Checks what's installed
+  2. Attempts installation of missing packages
+  3. Validates each potential on a test structure
+  4. Generates a configuration file for the NEB pipeline
+
+Usage:
+    python scripts/setup_mlip_infrastructure.py
+    python scripts/setup_mlip_infrastructure.py --check-only
+    python scripts/setup_mlip_infrastructure.py --install
+"""
+import argparse, os, sys, subprocess, json, warnings
+from pathlib import Path
+
+MLIP_PACKAGES = {
+    "chgnet": "chgnet",
+    "mace": "mace-torch",
+    "matgl": "matgl",
+    "orb": "orb-models",
+}
+
+TEST_STRUCTURE = """
+{
+    "@module": "pymatgen.core.structure",
+    "@class": "Structure",
+    "lattice": {"matrix": [[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]], "pbc": [true, true, true]},
+    "sites": [
+        {"species": [{"element": "Li", "occu": 1}], "abc": [0.0, 0.0, 0.0]},
+        {"species": [{"element": "Cl", "occu": 1}], "abc": [0.5, 0.5, 0.5]}
+    ]
+}
+"""
+
+
+def check_installed():
+    """Check which MLIP packages are installed."""
+    results = {}
+    for name, pkg in MLIP_PACKAGES.items():
+        try:
+            __import__(name.replace("-", "_"))
+            results[name] = "installed"
+        except ImportError:
+            try:
+                __import__(pkg.replace("-", "_"))
+                results[name] = "installed"
+            except ImportError:
+                results[name] = "not found"
+    return results
+
+
+def install_packages(packages):
+    """Install MLIP packages via pip."""
+    for name, pkg in packages.items():
+        print(f"  Installing {pkg}...")
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", pkg],
+            capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            print(f"    {name}: installed")
+        else:
+            print(f"    {name}: failed — {result.stderr[-200:]}")
+
+
+def validate_chgnet(structure_dict):
+    """Validate CHGNet can predict on test structure."""
+    import json
+    from pymatgen.core import Structure
+    from chgnet.model import CHGNet
+    from chgnet.utils import write_structures_to_POSCAR
+    
+    struct = Structure.from_dict(structure_dict)
+    model = CHGNet.load()
+    prediction = model.predict_structure(struct)
+    return {
+        "energy": float(prediction["e"]),
+        "forces_shape": list(prediction["f"].shape),
+    }
+
+
+def validate_mace(structure_dict):
+    """Validate MACE can predict on test structure."""
+    import torch
+    from mace.calculators import MACECalculator
+    from ase.io import read
+    from pymatgen.core import Structure
+    from pymatgen.io.ase import AseAtomsAdaptor
+    
+    struct = Structure.from_dict(structure_dict)
+    atoms = AseAtomsAdaptor.get_atoms(struct)
+    
+    calc = MACECalculator(model_path="medium", device="cpu")
+    atoms.set_calculator(calc)
+    energy = atoms.get_potential_energy()
+    forces = atoms.get_forces()
+    
+    return {
+        "energy": float(energy),
+        "forces_shape": list(forces.shape),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="MLIP infrastructure setup")
+    parser.add_argument("--check-only", action="store_true",
+                        help="Check installed packages only")
+    parser.add_argument("--install", action="store_true",
+                        help="Install missing MLIP packages")
+    parser.add_argument("--validate", action="store_true",
+                        help="Validate installed potentials on test structure")
+    args = parser.parse_args()
+    
+    BASE_DIR = Path(__file__).resolve().parent.parent
+    
+    print("=" * 60)
+    print("  MLIP INFRASTRUCTURE SETUP")
+    print("  High-throughput migration barrier computation pipeline")
+    print("=" * 60)
+    
+    # Check installed packages
+    print("\n  Checking installed MLIP packages...")
+    installed = check_installed()
+    for name, status in installed.items():
+        print(f"    {name:12s}: {status}")
+    
+    if args.install:
+        to_install = {k: v for k, v in MLIP_PACKAGES.items() if installed[k] == "not found"}
+        if to_install:
+            print(f"\n  Installing {len(to_install)} packages...")
+            install_packages(to_install)
+        else:
+            print("\n  All packages already installed.")
+    
+    if args.validate:
+        print("\n  Validating potentials...")
+        struct_dict = json.loads(TEST_STRUCTURE)
+        
+        if installed.get("chgnet") == "installed":
+            try:
+                result = validate_chgnet(struct_dict)
+                print(f"    CHGNet: OK (energy={result['energy']:.3f} eV)")
+            except Exception as e:
+                print(f"    CHGNet: validation failed — {str(e)[:80]}")
+        
+        if installed.get("mace") == "installed":
+            try:
+                result = validate_mace(struct_dict)
+                print(f"    MACE: OK (energy={result['energy']:.3f} eV)")
+            except Exception as e:
+                print(f"    MACE: validation failed — {str(e)[:80]}")
+    
+    # Generate config file
+    if not args.check_only:
+        config = {
+            "potentials": installed,
+            "pipeline": {
+                "bvse_barrier_threshold": 0.5,
+                "mlip_neb_grid": [5, 5, 5],
+                "mlip_neb_spring_constant": 5.0,
+                "mlip_neb_fmax": 0.05,
+                "mlip_neb_steps": 500,
+            },
+            "target_subset": "gold_battery_li",
+            "description": "Li-containing Gold-tier battery-family entries",
+        }
+        
+        config_path = BASE_DIR / "configs" / "mlip_pipeline.json"
+        print(f"\n  Writing config to {config_path}...")
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+    
+    # Print next steps
+    print(f"\n{'─' * 60}")
+    print("  NEXT STEPS")
+    print(f"  {'─' * 60}")
+    print("""
+  1. Install MLIP packages:
+     pip install chgnet mace-torch matgl orb-models
+     
+  2. Run BVSE pre-filter on Li/Na entries:
+     python scripts/compute_bvse_barriers.py --subset gold --limit 50000
+     
+  3. Run MLIP-NEB on BVSE-filtered subset:
+     python scripts/run_mlip_neb_pipeline.py --input dataset/bvse_filtered.json
+     
+  4. Update sse_candidate_score with full 5 gates:
+     python scripts/compute_sse_candidate_score.py
+  """)
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()