Übersicht — Computational Anwendungsplattform

mATOMIC und SBPA sind die zwei zentralen computationalen Anwendungen der Parvotec-Plattform. Sie ergänzen die biophysikalischen Methoden (SAXS, SPR, PPMS) um strukturelle Simulationen und sequenzbasierte Vorhersagen — und erweitern den Fitness Oracle um physikalisch begründete Features die rein experimentell schwer zugänglich sind.

mATOMIC — Multiscale ATOMIC Molecular Dynamics

Anwendungsziel

mATOMIC (Multiscale AT/CG Simulation Infrastructure for Capsid) simuliert die strukturellen Auswirkungen von 7-Mer Insertionen auf den AAV-Capsid. Es kombiniert All-Atom Molecular Dynamics (MD) für lokale Strukturanalysen mit Coarse-Grained (CG) Simulationen für große Systeme und längere Zeitskalen. Output ist ein mechanistisch begründeter Stabilitätsscore pro Insertion.

mATOMIC Simulationsparameter

# mATOMIC CG Prescreening Pipeline
import subprocess, pandas as pd, numpy as np
from pathlib import Path

def run_cg_screening(insert_sequences: list[str],
                      aav_base_pdb: str = "aav6_wt.pdb",
                      output_dir: str = "matomic_results") -> pd.DataFrame:
    """CG Prescreening für alle 7-Mer Insertionen via GROMACS/MARTINI."""
    results = []
    for seq in insert_sequences:
        # Insertion modellieren (PyMOL API oder Modeller)
        pdb = model_insertion(aav_base_pdb, seq, position=587)
        # GROMACS martinize2 + GROMACS run
        cg_pdb = martinize2(pdb)
        ddg = run_gromacs_cg(cg_pdb, sim_length="1us", output=output_dir)
        rmsf = extract_rmsf(ddg["traj"], residue_range=(580, 600))
        results.append({"sequence": seq, "ddg_kcal": ddg["ddg"],
                         "rmsf_insert": rmsf.mean(), "passed": ddg["ddg"] > -3.0})
    return pd.DataFrame(results)

def prescreening_filter(df: pd.DataFrame, ddg_threshold=-3.0) -> pd.DataFrame:
    """Entfernt stark destabilisierende Insertionen vor experimentellem Screen."""
    return df[df["ddg_kcal"] > ddg_threshold].copy()

SBPA — Sequence-Based Property Analysis

Anwendungsziel

SBPA (Sequence-Based Property Analysis) ist eine mehrstufige Bioinformatik-Pipeline die direkt aus der AAV-Aminosäuresequenz eine Vielzahl von Eigenschaften berechnet: evolutionäre Konservierung, Immunogenizitätsrisiko (T-Zell-Epitope), Aggregationspropensität, Hydrophobizitätsprofil und Herstellbarkeitsindex. SBPA deckt 100% der ~1M DMS-Varianten ab (keine Synchrotron- oder Instrumentenzeit nötig) und ist damit das wichtigste Vorfilterungs-Tool.

SBPA Scores — Übersicht & Schwellenwerte

# SBPA Pipeline — Massenscreening
from Bio import SeqIO
import pandas as pd

class SBPAPipeline:
    """Sequenzbasierte Property Analysis für AAV 7-Mer Insertionen."""

    def __init__(self):
        self.consurfdb   = ConSurfDatabase("aav6_msa.fasta")
        self.netmhcii    = NetMHCIIPredictor(alleles=["DRB1*04:01", "DRB1*07:01"])
        self.camsol      = CamSolIntrinsic()
        self.aggrescan   = AGGRESCAN3D(template_pdb="aav6_wt_cg.pdb")

    def analyze(self, sequence: str, position: int = 587) -> dict:
        full_seq = self._insert_into_wt(sequence, position)
        return {
            "consurv_score":  self.consurfdb.score(position, position+7),
            "mhcii_ic50_min": self.netmhcii.min_ic50(full_seq[580:600]),
            "camsol_score":   self.camsol.score(full_seq),
            "agg_propensity": self.aggrescan.score(position, position+7),
            "manuf_score":    self._codon_optimization_score(full_seq),
        }

    def batch_analyze(self, sequences: list[str]) -> pd.DataFrame:
        return pd.DataFrame([self.analyze(s) for s in sequences])

    def apply_hard_filter(self, df: pd.DataFrame) -> pd.DataFrame:
        """Entfernt Kandidaten mit starken T-Zell-Epitopen."""
        return df[df["mhcii_ic50_min"] >= 50.0].copy()

Gantt — Implementierung 12 Monate

Oracle Integration — mATOMIC & SBPA

Zusammen liefern mATOMIC und SBPA 9 zusätzliche Oracle-Features. Da SBPA alle ~1M Varianten abdeckt, sind diese Features besonders wertvoll als Vorfilter und als maskenlose Training-Labels:

API & Integrierter Workflow

Kombinierter Vorfilterungs-Workflow (Pre-Experimental Screen)

1. SBPA Massenscreening (Tag 1, automatisiert). Alle ~1M DMS-Sequenzen durch SBPA laufen lassen (batch_analyze). Hardcut: Entferne Kandidaten mit MHC-II IC50 <50 nM. Softcut: Flagge Kandidaten mit AggPropensity >0.6. Ausgabe: ~700k–800k Kandidaten nach Filter.
2. mATOMIC CG Prescreening (Tag 1–2, GPU). Alle SBPA-gefilterten Kandidaten (oder Top-10k nach Oracle-Ranking) durch CG-ΔΔG Screen. Filter: ΔΔG <-3 kcal/mol → verwerfen. Ausgabe: ~600k–700k Kandidaten nach kombiniertem Filter.
3. Oracle-Scoring (Tag 2, automatisiert). ESM-2 Embedding aller verbleibenden Kandidaten (Pre-computed). Fitness Predictor Vorhersage (VSMC, EC, Leber, SAXS-Features). Composite Score Berechnung. Ranking aller Kandidaten.
4. BO-Selektion (Tag 2, automatisiert). Multi-objective BO (EHVI) auf Top-50.000 nach Composite Score. Ausgabe: 50 Kandidaten für experimentelle Validierung. Diese 50 sind bereits durch SBPA + mATOMIC + Oracle dreifach validiert.
5. Experimentelle Validierung (Tag 3–28). Synthese und Produktion der 50 Kandidaten. PPMS-Prescreening aller 50 (Tag 3–5). SPR-Screening Top-20 (Tag 5–15). SAXS Top-10 (Synchrotron oder Labor). In vitro Transduktionsassay (FACS).

Python Integration — Unified Screening API

from parvotec.oracle import VascularOracle
from parvotec.sbpa import SBPAPipeline
from parvotec.matomic import mATOMICScreener

# Initialisierung
oracle   = VascularOracle.load("vascular_oracle_v2.0.pth")
sbpa     = SBPAPipeline()
matomic  = mATOMICScreener(gpu_device="cuda:0")

# Kombinierter Vorfilterungs-Workflow
def prescreen_candidates(sequences: list[str]) -> list[str]:
    """Dreistufige Vorfilterung vor experimenteller Validierung."""
    # Stufe 1: SBPA (100% Abdeckung, schnell)
    sbpa_df  = sbpa.batch_analyze(sequences)
    s1       = sbpa.apply_hard_filter(sbpa_df)["sequence"].tolist()
    print(f"Nach SBPA: {len(s1)}/{len(sequences)} ({100*len(s1)//len(sequences)}%)")

    # Stufe 2: mATOMIC CG Prescreening (Top-10k, GPU)
    top10k   = oracle.rank_by_embedding(s1)[:10_000]
    mat_df   = matomic.cg_prescreening(top10k)
    s2       = mat_df[mat_df["passed"]]["sequence"].tolist()
    print(f"Nach mATOMIC: {len(s2)}/{len(top10k)}")

    # Stufe 3: Oracle BO-Selektion
    candidates = oracle.generate(
        sequences=s2, targets={"vsmc":0.85, "liver":0.08}, n=50, strategy="bo"
    )
    return candidates

# Ergebnis: 50 dreifach-validierte Kandidaten für experimentellen Screen
final_50 = prescreen_candidates(all_dms_sequences)