| 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("@<TRIPOS>ATOM"): |
| in_atoms = True |
| continue |
| if ln.startswith("@<TRIPOS>") 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 |
|
|
