mdprep 0.2.0__py3-none-any.whl

mdprep/leap/ions.py

@@ -0,0 +1,112 @@
+"""Ion and salt command helpers for tleap scripts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from math import cos, radians, sqrt
+
+
+class IonPlanError(ValueError):
+    """Raised when ion placement cannot be planned safely."""
+
+
+@dataclass(frozen=True)
+class IonPlan:
+    neutralizing_ion: str | None
+    neutralizing_count: int
+    salt_pairs: int
+    commands: list[str]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "neutralizing_ion": self.neutralizing_ion,
+            "neutralizing_count": self.neutralizing_count,
+            "salt_pairs": self.salt_pairs,
+            "commands": self.commands,
+        }
+
+
+def neutralizing_ion_count(
+    total_charge: float,
+    *,
+    positive_ion: str,
+    negative_ion: str,
+    tolerance: float = 0.05,
+) -> tuple[str | None, int]:
+    rounded = round(total_charge)
+    if abs(total_charge - rounded) > tolerance:
+        raise IonPlanError(
+            f"System charge {total_charge:.6f} is not within {tolerance:.2f} e of an integer."
+        )
+    if rounded < 0:
+        return positive_ion, abs(rounded)
+    if rounded > 0:
+        return negative_ion, rounded
+    return None, 0
+
+
+def salt_pair_count(molarity: float, volume_a3: float) -> int:
+    if molarity < 0:
+        raise IonPlanError("Salt concentration cannot be negative.")
+    if volume_a3 <= 0:
+        raise IonPlanError("Periodic box volume must be positive to add salt pairs.")
+    return round(molarity * volume_a3 * 0.000602214076)
+
+
+def build_ion_plan(
+    *,
+    total_charge: float,
+    neutralize: bool,
+    positive_ion: str,
+    negative_ion: str,
+    salt_concentration_molar: float,
+    volume_a3: float | None,
+) -> IonPlan:
+    commands: list[str] = []
+    neutralizing_ion: str | None = None
+    neutralizing_count = 0
+    if neutralize:
+        neutralizing_ion, neutralizing_count = neutralizing_ion_count(
+            total_charge,
+            positive_ion=positive_ion,
+            negative_ion=negative_ion,
+        )
+        if neutralizing_ion is not None and neutralizing_count > 0:
+            commands.append(f"addionsrand system {neutralizing_ion} {neutralizing_count}")
+
+    salt_pairs = 0
+    if salt_concentration_molar > 0:
+        if volume_a3 is None:
+            raise IonPlanError("Cannot add salt pairs because solvated box volume was not determined.")
+        salt_pairs = salt_pair_count(salt_concentration_molar, volume_a3)
+        if salt_pairs > 0:
+            commands.append(f"addionsrand system {positive_ion} {salt_pairs}")
+            commands.append(f"addionsrand system {negative_ion} {salt_pairs}")
+    return IonPlan(
+        neutralizing_ion=neutralizing_ion,
+        neutralizing_count=neutralizing_count,
+        salt_pairs=salt_pairs,
+        commands=commands,
+    )
+
+
+def amber_inpcrd_box_volume(path: str) -> float | None:
+    """Return periodic box volume from an Amber restart/inpcrd file, if present."""
+
+    lines = [line.strip() for line in open(path, encoding="utf-8").read().splitlines() if line.strip()]
+    if len(lines) < 3:
+        return None
+    fields = lines[-1].split()
+    if len(fields) < 6:
+        return None
+    try:
+        a, b, c, alpha, beta, gamma = (float(value) for value in fields[:6])
+    except ValueError:
+        return None
+    cos_a = cos(radians(alpha))
+    cos_b = cos(radians(beta))
+    cos_g = cos(radians(gamma))
+    factor = 1.0 + 2.0 * cos_a * cos_b * cos_g - cos_a * cos_a - cos_b * cos_b - cos_g * cos_g
+    if factor <= 0:
+        return None
+    return a * b * c * sqrt(factor)

mdprep/leap/log_parser.py

@@ -0,0 +1,170 @@
+"""Parse tleap logs into validation-friendly summaries."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+class LeapLogError(ValueError):
+    """Raised when a tleap log indicates an unsafe build."""
+
+
+@dataclass(frozen=True)
+class LeapLogSummary:
+    returncode: int
+    warnings: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+    unknown_residues: list[str] = field(default_factory=list)
+    missing_atom_types: list[str] = field(default_factory=list)
+    missing_parameters: list[str] = field(default_factory=list)
+    atoms_created: list[str] = field(default_factory=list)
+    total_charge: float | None = None
+    check_output: list[str] = field(default_factory=list)
+    log_tail: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "returncode": self.returncode,
+            "warnings": self.warnings,
+            "errors": self.errors,
+            "unknown_residues": self.unknown_residues,
+            "missing_atom_types": self.missing_atom_types,
+            "missing_parameters": self.missing_parameters,
+            "atoms_created": self.atoms_created,
+            "total_charge": self.total_charge,
+            "check_output": self.check_output,
+            "log_tail": self.log_tail,
+        }
+
+
+_CHARGE_PATTERNS = [
+    re.compile(r"Total unperturbed charge:\s*([-+]?\d+(?:\.\d+)?)", re.IGNORECASE),
+    re.compile(r"unperturbed charge of the unit:\s*([-+]?\d+(?:\.\d+)?)", re.IGNORECASE),
+]
+
+
+def parse_tleap_log(path: str | Path, *, returncode: int = 0) -> LeapLogSummary:
+    log_path = Path(path)
+    text = log_path.read_text(encoding="utf-8", errors="replace") if log_path.exists() else ""
+    return parse_tleap_log_text(text, returncode=returncode)
+
+
+def parse_tleap_log_text(text: str, *, returncode: int = 0) -> LeapLogSummary:
+    warnings: list[str] = []
+    errors: list[str] = []
+    unknown_residues: list[str] = []
+    missing_atom_types: list[str] = []
+    missing_parameters: list[str] = []
+    atoms_created: list[str] = []
+    check_output: list[str] = []
+    total_charge: float | None = None
+
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        lower = line.lower()
+        if not line:
+            continue
+        if "warning:" in lower:
+            warnings.append(line)
+        if "fatal error" in lower or lower.startswith("error:") or " error!" in lower:
+            errors.append(line)
+        if "unknown residue" in lower:
+            unknown_residues.append(line)
+            errors.append(line)
+        if "does not have a type" in lower or "could not find type" in lower:
+            missing_atom_types.append(line)
+            errors.append(line)
+        if (
+            "could not find bond parameter" in lower
+            or "could not find angle parameter" in lower
+            or "could not find torsion parameter" in lower
+            or "missing parameters" in lower
+        ):
+            missing_parameters.append(line)
+            errors.append(line)
+        if "created a new atom named" in lower:
+            atoms_created.append(line)
+        if lower.startswith("checking") or "unit is ok" in lower:
+            check_output.append(line)
+        for pattern in _CHARGE_PATTERNS:
+            match = pattern.search(line)
+            if match:
+                total_charge = float(match.group(1))
+
+    return LeapLogSummary(
+        returncode=returncode,
+        warnings=warnings,
+        errors=_dedupe(errors),
+        unknown_residues=_dedupe(unknown_residues),
+        missing_atom_types=_dedupe(missing_atom_types),
+        missing_parameters=_dedupe(missing_parameters),
+        atoms_created=atoms_created,
+        total_charge=total_charge,
+        check_output=check_output,
+        log_tail=_tail_lines(text),
+    )
+
+
+def assert_tleap_success(
+    summary: LeapLogSummary,
+    *,
+    fail_on_warnings: bool,
+    context: str,
+) -> None:
+    if summary.returncode != 0:
+        raise LeapLogError(
+            "\n".join(
+                [
+                    f"{context} tleap exited with code {summary.returncode}.",
+                    *_summary_details(summary),
+                ]
+            )
+        )
+    if summary.unknown_residues:
+        raise LeapLogError(f"{context} tleap reported unknown residues: {summary.unknown_residues}")
+    if summary.missing_atom_types:
+        raise LeapLogError(f"{context} tleap reported missing atom types: {summary.missing_atom_types}")
+    if summary.missing_parameters:
+        raise LeapLogError(f"{context} tleap reported missing parameters: {summary.missing_parameters}")
+    if summary.errors:
+        raise LeapLogError(f"{context} tleap reported errors: {summary.errors}")
+    if fail_on_warnings and summary.warnings:
+        raise LeapLogError(f"{context} tleap warnings are fatal by validation config: {summary.warnings}")
+
+
+def _dedupe(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for value in values:
+        if value in seen:
+            continue
+        seen.add(value)
+        deduped.append(value)
+    return deduped
+
+
+def _summary_details(summary: LeapLogSummary) -> list[str]:
+    details: list[str] = []
+    if summary.errors:
+        details.append(f"errors: {summary.errors}")
+    if summary.unknown_residues:
+        details.append(f"unknown residues: {summary.unknown_residues}")
+    if summary.missing_atom_types:
+        details.append(f"missing atom types: {summary.missing_atom_types}")
+    if summary.missing_parameters:
+        details.append(f"missing parameters: {summary.missing_parameters}")
+    if summary.warnings:
+        details.append(f"warnings: {summary.warnings}")
+    if summary.log_tail:
+        details.append("tleap log tail:")
+        details.extend(summary.log_tail)
+    return details
+
+
+def _tail_lines(text: str, *, lines: int = 30) -> list[str]:
+    stripped = text.strip()
+    if not stripped:
+        return []
+    return stripped.splitlines()[-lines:]

mdprep/leap/report.py

@@ -0,0 +1,99 @@
+"""tleap report writers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from mdprep.leap.builder import TLeapStageResult
+
+
+def write_tleap_reports(
+    result: TLeapStageResult,
+    *,
+    json_path: str | Path,
+    markdown_path: str | Path,
+) -> dict[str, Any]:
+    report = result.to_report_dict()
+    json_output = Path(json_path)
+    markdown_output = Path(markdown_path)
+    json_output.parent.mkdir(parents=True, exist_ok=True)
+    json_output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    markdown_output.write_text(_render_markdown(report), encoding="utf-8")
+    return report
+
+
+def _render_markdown(report: dict[str, Any]) -> str:
+    lines = [
+        "# tleap Report",
+        "",
+        "## Force Fields",
+        "",
+    ]
+    lines.extend(f"- `{source}`" for source in report["force_fields_sourced"])
+    lines.extend(
+        [
+            "",
+            "## Ligands",
+            "",
+        ]
+    )
+    ligands = report.get("ligands", [])
+    if ligands:
+        for ligand in ligands:
+            lines.append(
+                f"- `{ligand['ligand_id']}`: mol2 `{ligand['final_mol2_path']}`, "
+                f"frcmod `{ligand['final_frcmod_path']}`"
+            )
+    else:
+        lines.append("- None")
+    lines.extend(["", "### MCPB joint-RESP ligands", ""])
+    mcpb_resp_ligands = report.get("mcpb_resp_ligands", [])
+    if mcpb_resp_ligands:
+        for ligand in mcpb_resp_ligands:
+            lines.append(
+                f"- `{ligand['ligand_id']}`: final template "
+                f"`{ligand['final_mol2_path']}` (provisional mol2 excluded from "
+                "the final tLEAP ligand list)"
+            )
+    else:
+        lines.append("- None")
+    lines.extend(["", "## Disulfide Bonds", ""])
+    bonds = report.get("disulfide_bond_commands", [])
+    if bonds:
+        lines.extend(f"- `{bond['command']}`" for bond in bonds)
+    else:
+        lines.append("- None")
+    lines.extend(["", "## 12-6-4 Post-processing", ""])
+    c4_runs = report.get("c4_postprocessing", [])
+    if c4_runs:
+        for run in c4_runs:
+            lines.append(
+                f"- `{run['output_prmtop']}`: atom types "
+                + ", ".join(f"`{atom_type}`" for atom_type in run["atom_types"])
+            )
+    else:
+        lines.append("- None")
+    lines.extend(
+        [
+            "",
+            "## Outputs",
+            "",
+            f"- Dry prmtop: `{report['dry_outputs']['prmtop']}`",
+            f"- Dry inpcrd: `{report['dry_outputs']['inpcrd']}`",
+            f"- Final prmtop: `{report['final_outputs']['prmtop']}`",
+            f"- Final inpcrd: `{report['final_outputs']['inpcrd']}`",
+            f"- Final PDB: `{report['final_outputs']['pdb']}`",
+            "",
+            "## Warnings",
+            "",
+        ]
+    )
+    warnings = report.get("warnings") or []
+    if warnings:
+        lines.extend(f"- {warning}" for warning in warnings)
+    else:
+        lines.append("- None")
+    lines.append("")
+    return "\n".join(lines)