from __future__ import annotations import json import math from dataclasses import dataclass from pathlib import Path from typing import Any, Iterable import numpy as np import pandas as pd from rdkit import Chem from rdkit.Chem import AllChem, Descriptors, rdMolAlign, rdMolDescriptors from rdkit.Chem.MolStandardize import rdMolStandardize from scipy.optimize import linear_sum_assignment from scipy.spatial.distance import cdist from libs.docking.backend_rdock import RDockBackend, RDockConfig from libs.docking.backend_smina import SminaBackend, SminaConfig, parse_smina_score from libs.docking.base import DockingError from libs.docking.pocket import PocketSpec, resolve_pocket_spec, write_pocket_spec from libs.docking.prep import prepare_ligand_sdf from libs.utils.logging_utils import get_logger from libs.utils.subprocess_utils import run_command LOGGER = get_logger("redocking_validation") ROOT_DIR = Path(__file__).resolve().parents[2] @dataclass(frozen=True) class RedockingTarget: dataset: str target_name: str target_path: Path reference_csv: Path @dataclass(frozen=True) class RedockingValidationConfig: attempts: int = 60 base_seed: int = 20260422 backend: str = "rdock" positive_score_threshold: float = 2.0 rmsd_fail_threshold: float = 2.0 near_top_rank_percentile_threshold: float = 20.0 @dataclass(frozen=True) class CrystalLigandExtraction: pdb_block: str residue_name: str chain: str resseq: str atom_count: int def strict_targets_catalog() -> list[RedockingTarget]: return [ RedockingTarget( dataset="strict_dataset_1", target_name="EGFR", target_path=ROOT_DIR / "data/targets/prelim_set_egfr_4wkq/egfr_4wkq.pdb", reference_csv=ROOT_DIR / "data/ligands/prelim_set_egfr_4wkq/reference_ligands.csv", ), RedockingTarget( dataset="strict_dataset_2", target_name="ABL1", target_path=ROOT_DIR / "data/targets/prelim_set_abl1_1iep/abl1_1iep.pdb", reference_csv=ROOT_DIR / "data/ligands/prelim_set_abl1_1iep/reference_ligands.csv", ), RedockingTarget( dataset="strict_dataset_3", target_name="MDM2", target_path=ROOT_DIR / "data/targets/prelim_set_mdm2_4hg7/mdm2_4hg7.pdb", reference_csv=ROOT_DIR / "data/ligands/prelim_set_mdm2_4hg7/reference_ligands.csv", ), ] def _read_reference(reference_csv: Path) -> dict[str, str]: df = pd.read_csv(reference_csv) if df.empty: raise DockingError(f"Reference CSV is empty: {reference_csv}") row = df.iloc[0] return { "reference_id": str(row.get("reference_id", "")).strip(), "ligand_comp_id": str(row.get("ligand_comp_id", "")).strip(), "reference_smiles": str(row.get("reference_smiles", "")).strip(), "pdb_id": str(row.get("pdb_id", "")).strip(), } def _extract_reference_ligand_block(target_path: Path, ligand_comp_id: str) -> CrystalLigandExtraction: lines = target_path.read_text(encoding="utf-8", errors="ignore").splitlines() grouped: dict[tuple[str, str, str, str], list[str]] = {} serials_by_group: dict[tuple[str, str, str, str], set[int]] = {} ligand_filter = ligand_comp_id.strip().upper() for ln in lines: if not ln.startswith("HETATM"): continue resn = ln[17:20].strip().upper() if not resn or resn in {"HOH", "WAT", "DOD", "SO4"}: continue if ligand_filter and resn != ligand_filter: continue chain = ln[21:22].strip() resseq = ln[22:26].strip() ins = ln[26:27].strip() key = (resn, chain, resseq, ins) grouped.setdefault(key, []).append(ln) try: serial = int(ln[6:11].strip()) except Exception: continue serials_by_group.setdefault(key, set()).add(serial) if not grouped: raise DockingError( f"Cannot extract crystallographic ligand `{ligand_comp_id}` from target `{target_path}`" ) selected = max(grouped.keys(), key=lambda k: len(grouped[k])) selected_serials = serials_by_group.get(selected, set()) out_lines: list[str] = list(grouped[selected]) for ln in lines: if not ln.startswith("CONECT"): continue cols = ln.split() if len(cols) < 3: continue try: src = int(cols[1]) dst = [int(x) for x in cols[2:] if x.isdigit()] except Exception: continue if src in selected_serials and any(x in selected_serials for x in dst): out_lines.append(ln) out_lines.append("END") pdb_block = "\n".join(out_lines) + "\n" return CrystalLigandExtraction( pdb_block=pdb_block, residue_name=selected[0], chain=selected[1], resseq=selected[2], atom_count=len(grouped[selected]), ) def _safe_mol_from_pdb_block(block: str) -> Chem.Mol: mol = Chem.MolFromPDBBlock(block, removeHs=False, sanitize=False, proximityBonding=True) if mol is None: raise DockingError("Failed to parse crystal ligand PDB block with RDKit") try: Chem.SanitizeMol(mol) except Exception: pass return mol def _assign_template_bond_orders(crystal_mol: Chem.Mol, reference_smiles: str) -> Chem.Mol: template = Chem.MolFromSmiles(reference_smiles) if template is None: return crystal_mol try: assigned = AllChem.AssignBondOrdersFromTemplate(Chem.RemoveHs(template), Chem.RemoveHs(crystal_mol)) return assigned except Exception: return crystal_mol def _convert_with_obabel(src: Path, dst: Path, extra_args: list[str] | None = None, timeout: int = 120) -> None: extra = extra_args or [] cmd = ["obabel", str(src), "-O", str(dst), *extra] result = run_command(cmd, cwd=dst.parent, timeout=timeout) if result.returncode != 0 or (not dst.exists()) or dst.stat().st_size == 0: raise DockingError(f"obabel conversion failed: {' '.join(cmd)} | rc={result.returncode} | stderr={result.stderr.strip()}") def _tripos_atom_types_summary(mol2_path: Path) -> dict[str, int]: text = mol2_path.read_text(encoding="utf-8", errors="ignore").splitlines() in_atoms = False counts: dict[str, int] = {} for ln in text: if ln.startswith("@ATOM"): in_atoms = True continue if ln.startswith("@") and in_atoms: break if not in_atoms: continue cols = ln.split() if len(cols) < 6: continue atom_type = str(cols[5]).strip() counts[atom_type] = counts.get(atom_type, 0) + 1 return dict(sorted(counts.items(), key=lambda kv: kv[0])) def _tautomer_identifier(mol: Chem.Mol) -> str: try: te = rdMolStandardize.TautomerEnumerator() t = te.Canonicalize(Chem.Mol(mol)) return Chem.MolToSmiles(t, canonical=True) except Exception: return "" def _ligand_prep_audit(mol: Chem.Mol, mol2_path: Path) -> dict[str, Any]: atom_count = int(mol.GetNumAtoms()) h_count = int(sum(1 for a in mol.GetAtoms() if a.GetAtomicNum() == 1)) aromatic_count = int(sum(1 for a in mol.GetAtoms() if a.GetIsAromatic())) formal_charge = int(sum(a.GetFormalCharge() for a in mol.GetAtoms())) rot_bonds = np.nan canonical = "" tautomer_id = "" try: no_h = Chem.RemoveHs(Chem.Mol(mol)) rot_bonds = int(rdMolDescriptors.CalcNumRotatableBonds(no_h)) canonical = Chem.MolToSmiles(no_h, canonical=True) tautomer_id = _tautomer_identifier(no_h) except Exception: pass protonation_id = f"q={formal_charge}|smiles={canonical}" return { "atom_count": atom_count, "hydrogen_count": h_count, "formal_charge": formal_charge, "aromatic_atom_count": aromatic_count, "rotatable_bond_count": rot_bonds, "tautomer_identifier": tautomer_id, "protonation_identifier": protonation_id, "tripos_atom_types": _tripos_atom_types_summary(mol2_path), } def _kabsch(P: np.ndarray, Q: np.ndarray) -> tuple[np.ndarray, np.ndarray]: cp = P.mean(axis=0) cq = Q.mean(axis=0) P0 = P - cp Q0 = Q - cq C = P0.T @ Q0 V, _S, Wt = np.linalg.svd(C) d = np.linalg.det(V @ Wt) D = np.eye(3) D[2, 2] = np.sign(d) if d != 0 else 1.0 R = V @ D @ Wt t = cq - (cp @ R) return R, t def _coords_by_element(mol: Chem.Mol) -> dict[int, np.ndarray]: if mol.GetNumConformers() == 0: return {} conf = mol.GetConformer() groups: dict[int, list[list[float]]] = {} for i, atom in enumerate(mol.GetAtoms()): z = int(atom.GetAtomicNum()) if z == 1: continue p = conf.GetAtomPosition(i) groups.setdefault(z, []).append([p.x, p.y, p.z]) return {z: np.asarray(v, dtype=float) for z, v in groups.items() if v} def _rmsd_assignment_fallback(probe: Chem.Mol, ref: Chem.Mol, max_iter: int = 8) -> float: p_groups = _coords_by_element(probe) r_groups = _coords_by_element(ref) if not p_groups or not r_groups: return float("nan") if set(p_groups.keys()) != set(r_groups.keys()): return float("nan") for z in p_groups: if p_groups[z].shape[0] != r_groups[z].shape[0]: return float("nan") z_order = sorted(p_groups.keys()) R = np.eye(3) t = np.zeros(3, dtype=float) P_match = None Q_match = None for _ in range(max_iter): P_parts: list[np.ndarray] = [] Q_parts: list[np.ndarray] = [] for z in z_order: Pz = p_groups[z] Qz = r_groups[z] Pzt = (Pz @ R) + t D = cdist(Pzt, Qz) ridx, cidx = linear_sum_assignment(D) P_parts.append(Pz[ridx]) Q_parts.append(Qz[cidx]) P_match = np.vstack(P_parts) Q_match = np.vstack(Q_parts) R, t = _kabsch(P_match, Q_match) if P_match is None or Q_match is None: return float("nan") P_final = (P_match @ R) + t diff = P_final - Q_match return float(np.sqrt(np.mean(np.sum(diff * diff, axis=1)))) def heavy_atom_rmsd(probe: Chem.Mol, ref: Chem.Mol) -> float: try: probe_h = Chem.RemoveHs(Chem.Mol(probe)) ref_h = Chem.RemoveHs(Chem.Mol(ref)) except Exception: return float("nan") try: if probe_h.GetNumAtoms() == ref_h.GetNumAtoms() and probe_h.GetNumConformers() > 0 and ref_h.GetNumConformers() > 0: val = float(rdMolAlign.GetBestRMS(probe_h, ref_h)) if np.isfinite(val): return val except Exception: pass return _rmsd_assignment_fallback(probe_h, ref_h) def _safe_remove_hs(mol: Chem.Mol) -> Chem.Mol | None: try: return Chem.RemoveHs(Chem.Mol(mol)) except Exception: return None def _safe_smiles(mol: Chem.Mol | None) -> str: if mol is None: return "" try: return Chem.MolToSmiles(mol, canonical=True) except Exception: return "" def _pose_entries_from_rdock_sdf(sd_path: Path) -> list[dict[str, Any]]: entries: list[dict[str, Any]] = [] suppl = Chem.SDMolSupplier(str(sd_path), removeHs=False, sanitize=False) for idx, mol in enumerate(suppl): if mol is None: continue score = float("nan") for key in ["SCORE", "score", "SCORE.INTER"]: if mol.HasProp(key): try: score = float(mol.GetProp(key)) break except Exception: continue if not np.isfinite(score): continue entries.append({"pose_idx": idx, "score": float(score), "mol": mol}) entries.sort(key=lambda x: x["score"]) return entries def _score_only_smina( smina_executable: str, receptor_pdbqt: Path, ligand_pdbqt: Path, pocket: PocketSpec, out_dir: Path, seed: int, ) -> float: out_dir.mkdir(parents=True, exist_ok=True) cmd = [ str(smina_executable), "--receptor", str(receptor_pdbqt), "--ligand", str(ligand_pdbqt), "--center_x", f"{pocket.center[0]:.4f}", "--center_y", f"{pocket.center[1]:.4f}", "--center_z", f"{pocket.center[2]:.4f}", "--size_x", f"{pocket.box_size[0]:.4f}", "--size_y", f"{pocket.box_size[1]:.4f}", "--size_z", f"{pocket.box_size[2]:.4f}", "--score_only", "--seed", str(seed), ] result = run_command(cmd, cwd=out_dir, timeout=120) (out_dir / "score_only.stdout.log").write_text(result.stdout, encoding="utf-8") (out_dir / "score_only.stderr.log").write_text(result.stderr, encoding="utf-8") score = parse_smina_score("\n".join([result.stdout or "", result.stderr or ""])) if result.returncode != 0 or not np.isfinite(score): raise DockingError( f"smina --score_only failed: rc={result.returncode} score={score} stderr={result.stderr.strip()}" ) return float(score) def _format_target_report(target_row: dict[str, Any], fail_reasons: list[str]) -> str: verdict = "GO" if not fail_reasons else "NO-GO" lines = [ f"# Redocking Validation: {target_row['dataset']} ({target_row['target_name']})", "", f"- backend: `{target_row['backend']}`", f"- attempts: `{target_row['attempts']}`", f"- reference ligand: `{target_row['reference_ligand_id']}`", f"- crystal ligand component: `{target_row['ligand_comp_id']}`", f"- top-pose heavy-atom RMSD [A]: `{target_row['top_pose_rmsd_A']:.4f}`", f"- best-of-run heavy-atom RMSD [A]: `{target_row['best_of_run_rmsd_A']:.4f}`", f"- crystallographic in-place score: `{target_row['crystal_inplace_score']:.4f}`", f"- in-place score source: `{target_row.get('crystal_inplace_score_source', '')}`", f"- best docked score: `{target_row['best_docked_score']:.4f}`", f"- reference rank (in-place score among attempts): `{target_row['reference_rank']}` / `{target_row['attempts'] + 1}`", f"- reference rank percentile: `{target_row['reference_rank_percentile']:.3f}`", "", f"## Verdict: **{verdict}**", "", "## Fail Criteria", "- top-pose RMSD > 2.0 A and best-of-run RMSD > 2.0 A", "- crystallographic pose score strongly positive", "- reference ligand not near top in own redocking test", "", "## Triggered Fail Reasons", ] if fail_reasons: lines.extend([f"- {r}" for r in fail_reasons]) else: lines.append("- none") lines.append("") return "\n".join(lines) def run_redocking_validation( output_dir: str | Path = "results/redocking_validation", *, config: RedockingValidationConfig | None = None, datasets: Iterable[RedockingTarget] | None = None, ) -> dict[str, Any]: cfg = config or RedockingValidationConfig() if int(cfg.attempts) < 50 or int(cfg.attempts) > 100: raise DockingError(f"Redocking attempts must be in [50,100], got {cfg.attempts}") out_dir = Path(output_dir) out_dir.mkdir(parents=True, exist_ok=True) target_reports_dir = out_dir / "target_reports" target_reports_dir.mkdir(parents=True, exist_ok=True) targets = list(datasets or strict_targets_catalog()) if not targets: raise DockingError("No targets defined for redocking validation") if cfg.backend != "rdock": raise DockingError("Current strict redocking validation supports backend='rdock' only") per_attempt_rows: list[dict[str, Any]] = [] per_target_rows: list[dict[str, Any]] = [] prep_rows: list[dict[str, Any]] = [] compare_rows: list[dict[str, Any]] = [] for t in targets: target_root = out_dir / t.dataset target_root.mkdir(parents=True, exist_ok=True) ref = _read_reference(t.reference_csv) reference_id = str(ref["reference_id"]) ligand_comp_id = str(ref["ligand_comp_id"]) reference_smiles = str(ref["reference_smiles"]) extraction = _extract_reference_ligand_block(t.target_path, ligand_comp_id) crystal_pdb = target_root / "crystal_ligand.pdb" crystal_pdb.write_text(extraction.pdb_block, encoding="utf-8") crystal_sdf = target_root / "crystal_ligand.sdf" crystal_mol2 = target_root / "crystal_ligand.mol2" crystal_pdbqt = target_root / "crystal_ligand.pdbqt" _convert_with_obabel(crystal_pdb, crystal_sdf) _convert_with_obabel(crystal_pdb, crystal_mol2) _convert_with_obabel(crystal_pdb, crystal_pdbqt) crystal_raw = Chem.SDMolSupplier(str(crystal_sdf), removeHs=False, sanitize=False) crystal_mol = crystal_raw[0] if crystal_raw and len(crystal_raw) > 0 else None if crystal_mol is None: crystal_mol = _safe_mol_from_pdb_block(extraction.pdb_block) crystal_mol = _assign_template_bond_orders(crystal_mol, reference_smiles) prepared_sdf = prepare_ligand_sdf(reference_id, reference_smiles, target_root / "prepared_reference.sdf") prepared_mol2 = target_root / "prepared_reference.mol2" prepared_pdbqt = target_root / "prepared_reference.pdbqt" _convert_with_obabel(prepared_sdf, prepared_mol2) _convert_with_obabel(prepared_sdf, prepared_pdbqt) prepared_suppl = Chem.SDMolSupplier(str(prepared_sdf), removeHs=False, sanitize=False) prepared_mol = prepared_suppl[0] if prepared_suppl and len(prepared_suppl) > 0 else None if prepared_mol is None: raise DockingError(f"Cannot parse prepared reference SDF for {t.dataset}") crystal_audit = _ligand_prep_audit(Chem.Mol(crystal_mol), crystal_mol2) prepared_audit = _ligand_prep_audit(Chem.Mol(prepared_mol), prepared_mol2) prep_rows.append( { "dataset": t.dataset, "target_name": t.target_name, "reference_ligand_id": reference_id, "variant": "crystal", **{k: (json.dumps(v) if isinstance(v, dict) else v) for k, v in crystal_audit.items()}, } ) prep_rows.append( { "dataset": t.dataset, "target_name": t.target_name, "reference_ligand_id": reference_id, "variant": "prepared", **{k: (json.dumps(v) if isinstance(v, dict) else v) for k, v in prepared_audit.items()}, } ) crystal_heavy = _safe_remove_hs(crystal_mol) prepared_heavy = _safe_remove_hs(prepared_mol) compare_rows.append( { "dataset": t.dataset, "target_name": t.target_name, "reference_ligand_id": reference_id, "crystal_atom_count": int(crystal_mol.GetNumAtoms()), "prepared_atom_count": int(prepared_mol.GetNumAtoms()), "crystal_heavy_atom_count": int(crystal_heavy.GetNumAtoms()) if crystal_heavy is not None else np.nan, "prepared_heavy_atom_count": int(prepared_heavy.GetNumAtoms()) if prepared_heavy is not None else np.nan, "crystal_formal_charge": int(sum(a.GetFormalCharge() for a in crystal_mol.GetAtoms())), "prepared_formal_charge": int(sum(a.GetFormalCharge() for a in prepared_mol.GetAtoms())), "crystal_canonical_smiles": _safe_smiles(crystal_heavy), "prepared_canonical_smiles": _safe_smiles(prepared_heavy), "heavy_atom_rmsd_crystal_vs_prepared_A": ( heavy_atom_rmsd(prepared_heavy, crystal_heavy) if (prepared_heavy is not None and crystal_heavy is not None) else np.nan ), } ) rdock_backend = RDockBackend( RDockConfig( n_runs=1, command_timeout_seconds=240, parallel_jobs=1, command_log_path=str(target_root / "rdock_commands.log"), pocket_mode="reference_complex_pocket", pocket_reference_ligand_id=ligand_comp_id, pocket_relaxation_margin=0.0, ) ) cap = rdock_backend.check_capability() if not cap.available: raise DockingError(f"rDock not available for redocking validation: {cap.details}") rdock_target_ctx = rdock_backend.prepare_target(t.target_path, target_root / "rdock_target") rdock_ligand = rdock_backend.prepare_ligand(reference_id, reference_smiles, target_root / "rdock_ligand") smina_backend = SminaBackend( SminaConfig( command_timeout_seconds=120, exhaustiveness=8, num_modes=1, cpu=1, parallel_jobs=1, seed=cfg.base_seed, pocket_mode="reference_complex_pocket", pocket_reference_ligand_id=ligand_comp_id, pocket_relaxation_margin=0.0, ) ) smina_cap = smina_backend.check_capability() if not smina_cap.available: raise DockingError( f"smina is required for crystallographic in-place score in redocking validation: {smina_cap.details}" ) smina_exe = str(smina_cap.details.get("smina", "") or "") if not smina_exe: raise DockingError("smina executable path missing in capability details") smina_target_ctx = smina_backend.prepare_target(t.target_path, target_root / "smina_score_only_target") pocket = PocketSpec.from_dict(json.loads(Path(smina_target_ctx["pocket_json"]).read_text(encoding="utf-8"))) crystal_inplace_score = _score_only_smina( smina_executable=smina_exe, receptor_pdbqt=Path(smina_target_ctx["receptor_pdbqt"]), ligand_pdbqt=crystal_pdbqt, pocket=pocket, out_dir=target_root / "score_only", seed=cfg.base_seed, ) all_pose_rmsd: list[float] = [] all_pose_scores: list[float] = [] top_pose_scores: list[float] = [] top_pose_rmsd_list: list[float] = [] for attempt_idx in range(int(cfg.attempts)): rdock_backend.config.n_runs = 1 rdock_backend.config.allow_partial_failures = False rdock_backend.config.seed = int(cfg.base_seed + attempt_idx) attempt_dir = target_root / "attempts" / f"attempt_{attempt_idx:04d}" attempt_dir.mkdir(parents=True, exist_ok=True) results = rdock_backend.dock( target_context=rdock_target_ctx, ligand_files=[rdock_ligand], work_dir=attempt_dir, allow_mock=False, require_real_backend=True, ) parsed = rdock_backend.parse_results(results) if not parsed: per_attempt_rows.append( { "dataset": t.dataset, "target_name": t.target_name, "backend": cfg.backend, "attempt_idx": attempt_idx, "reference_ligand_id": reference_id, "success": False, "best_docked_score": np.nan, "top_pose_score": np.nan, "top_pose_rmsd_A": np.nan, "best_rmsd_in_attempt_A": np.nan, "n_poses": 0, "raw_output_file": "", } ) continue row = parsed[0] raw = Path(str(row.get("raw_output_file", ""))) success = bool(row.get("success", False)) and raw.exists() top_pose_score = float(row.get("docking_score", np.nan)) best_docked_score = float(top_pose_score) top_pose_rmsd = float("nan") best_rmsd_attempt = float("nan") n_poses = 0 if success and raw.exists(): poses = _pose_entries_from_rdock_sdf(raw) n_poses = int(len(poses)) if poses: top = poses[0] top_pose_score = float(top["score"]) top_pose_rmsd = heavy_atom_rmsd(top["mol"], crystal_mol) best_docked_score = float(min(float(p["score"]) for p in poses)) rmsd_values = [ heavy_atom_rmsd(p["mol"], crystal_mol) for p in poses ] rmsd_values = [float(x) for x in rmsd_values if np.isfinite(x)] if rmsd_values: best_rmsd_attempt = float(np.min(np.asarray(rmsd_values, dtype=float))) all_pose_rmsd.extend(rmsd_values) all_pose_scores.extend([float(p["score"]) for p in poses if np.isfinite(float(p["score"]))]) if np.isfinite(top_pose_score): top_pose_scores.append(float(top_pose_score)) if np.isfinite(top_pose_rmsd): top_pose_rmsd_list.append(float(top_pose_rmsd)) per_attempt_rows.append( { "dataset": t.dataset, "target_name": t.target_name, "backend": cfg.backend, "attempt_idx": attempt_idx, "reference_ligand_id": reference_id, "success": bool(success), "best_docked_score": float(best_docked_score) if np.isfinite(best_docked_score) else np.nan, "top_pose_score": float(top_pose_score) if np.isfinite(top_pose_score) else np.nan, "top_pose_rmsd_A": float(top_pose_rmsd) if np.isfinite(top_pose_rmsd) else np.nan, "best_rmsd_in_attempt_A": float(best_rmsd_attempt) if np.isfinite(best_rmsd_attempt) else np.nan, "n_poses": int(n_poses), "raw_output_file": str(raw), } ) attempts_df = pd.DataFrame([r for r in per_attempt_rows if r["dataset"] == t.dataset]) valid_attempts = attempts_df.dropna(subset=["top_pose_score"]).copy() if valid_attempts.empty: raise DockingError(f"No successful redocking attempts for {t.dataset}") valid_attempts = valid_attempts.sort_values("top_pose_score", ascending=True).reset_index(drop=True) top_pose_rmsd_global = float(valid_attempts["top_pose_rmsd_A"].iloc[0]) if not valid_attempts.empty else float("nan") best_of_run_rmsd = float(pd.to_numeric(valid_attempts["best_rmsd_in_attempt_A"], errors="coerce").min()) best_docked_score = float(pd.to_numeric(valid_attempts["best_docked_score"], errors="coerce").min()) attempt_scores = pd.to_numeric(valid_attempts["top_pose_score"], errors="coerce").dropna().to_numpy(dtype=float) ref_rank = int(1 + int(np.sum(attempt_scores < float(crystal_inplace_score)))) ref_rank_pct = float(100.0 * ref_rank / max(1, attempt_scores.shape[0] + 1)) fail_reasons: list[str] = [] if np.isfinite(top_pose_rmsd_global) and np.isfinite(best_of_run_rmsd): if top_pose_rmsd_global > cfg.rmsd_fail_threshold and best_of_run_rmsd > cfg.rmsd_fail_threshold: fail_reasons.append( f"RMSD failure: top_pose_rmsd={top_pose_rmsd_global:.3f}A and best_of_run_rmsd={best_of_run_rmsd:.3f}A exceed {cfg.rmsd_fail_threshold:.3f}A" ) else: fail_reasons.append("RMSD failure: non-finite RMSD value") if not np.isfinite(crystal_inplace_score) or crystal_inplace_score > cfg.positive_score_threshold: fail_reasons.append( f"Crystallographic in-place score is strongly positive or invalid: {crystal_inplace_score}" ) if (not np.isfinite(ref_rank_pct)) or ref_rank_pct > cfg.near_top_rank_percentile_threshold: fail_reasons.append( f"Reference ligand not near top: rank_percentile={ref_rank_pct:.3f} > {cfg.near_top_rank_percentile_threshold:.3f}" ) target_row = { "dataset": t.dataset, "target_name": t.target_name, "backend": cfg.backend, "attempts": int(cfg.attempts), "reference_ligand_id": reference_id, "ligand_comp_id": ligand_comp_id, "top_pose_rmsd_A": float(top_pose_rmsd_global), "best_of_run_rmsd_A": float(best_of_run_rmsd), "crystal_inplace_score": float(crystal_inplace_score), "crystal_inplace_score_source": "smina_score_only", "best_docked_score": float(best_docked_score), "reference_rank": int(ref_rank), "reference_rank_percentile": float(ref_rank_pct), "success_attempt_count": int(valid_attempts.shape[0]), "go": bool(len(fail_reasons) == 0), "fail_reasons": " | ".join(fail_reasons), } per_target_rows.append(target_row) report_md = _format_target_report(target_row, fail_reasons) (target_reports_dir / f"{t.dataset}.md").write_text(report_md, encoding="utf-8") per_attempt_df = pd.DataFrame(per_attempt_rows) per_target_df = pd.DataFrame(per_target_rows) prep_df = pd.DataFrame(prep_rows) compare_df = pd.DataFrame(compare_rows) per_attempt_df.to_csv(out_dir / "per_attempt_poses.csv", index=False) per_target_df.to_csv(out_dir / "per_target_metrics.csv", index=False) prep_df.to_csv(out_dir / "preparation_audit.csv", index=False) compare_df.to_csv(out_dir / "crystal_vs_prepared_comparison.csv", index=False) compare_md = [ "# Crystal vs Prepared Ligand Comparison", "", "This report captures changes introduced by conversion/preparation.", "", ] if compare_df.empty: compare_md.append("- no rows") else: for r in compare_df.itertuples(index=False): compare_md.extend( [ f"## {r.dataset} ({r.target_name})", f"- reference_ligand_id: `{r.reference_ligand_id}`", f"- crystal_atoms / prepared_atoms: `{r.crystal_atom_count}` / `{r.prepared_atom_count}`", f"- crystal_heavy / prepared_heavy: `{r.crystal_heavy_atom_count}` / `{r.prepared_heavy_atom_count}`", f"- crystal_charge / prepared_charge: `{r.crystal_formal_charge}` / `{r.prepared_formal_charge}`", f"- heavy_atom_rmsd_crystal_vs_prepared_A: `{float(r.heavy_atom_rmsd_crystal_vs_prepared_A):.4f}`", f"- crystal_canonical_smiles: `{r.crystal_canonical_smiles}`", f"- prepared_canonical_smiles: `{r.prepared_canonical_smiles}`", "", ] ) (out_dir / "crystal_vs_prepared_report.md").write_text("\n".join(compare_md) + "\n", encoding="utf-8") all_go = bool((per_target_df["go"].astype(bool)).all()) if not per_target_df.empty else False summary = { "run_name": "redocking_validation", "backend": cfg.backend, "attempts": int(cfg.attempts), "datasets": per_target_df["dataset"].astype(str).tolist(), "all_targets_go": all_go, "n_targets": int(per_target_df.shape[0]), "outputs": { "per_attempt_poses_csv": str(out_dir / "per_attempt_poses.csv"), "per_target_metrics_csv": str(out_dir / "per_target_metrics.csv"), "preparation_audit_csv": str(out_dir / "preparation_audit.csv"), "crystal_vs_prepared_comparison_csv": str(out_dir / "crystal_vs_prepared_comparison.csv"), "crystal_vs_prepared_report_md": str(out_dir / "crystal_vs_prepared_report.md"), "target_reports_dir": str(target_reports_dir), }, } (out_dir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8") gate_lines = [ "# Redocking Validation Gate", "", f"- all_targets_go: `{all_go}`", f"- backend: `{cfg.backend}`", f"- attempts: `{cfg.attempts}`", "", "## Per-target verdict", ] for r in per_target_rows: gate_lines.append(f"- {r['dataset']}: {'GO' if r['go'] else 'NO-GO'}") (out_dir / "self_audit_report.md").write_text("\n".join(gate_lines) + "\n", encoding="utf-8") return summary