scripts/compute_cavd_channel_dimensionality.py

"""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()