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