File size: 6,050 Bytes
31d1d63
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import numpy as np

from scoobdoob import _conditioning
from scoobdoob.validation import tpt

STRIDE, SEED_RELAX = 10, 50
ALPHA_V, TAU = 3.0, 0.12
TIME_SIGMA, COMM_L, COMM_S, W_FLOOR = 0.30, 3.0, 0.35, 1e-12


def fk_weights(
    C, q, horizon, comm_l=COMM_L, comm_s=COMM_S, variant="rho", alpha_rho=None
):
    """(untilted, committor-tilted) FK weight lists, one entry per horizon step."""
    row = np.asarray(C, dtype=np.float64).sum(axis=1)
    a_eff = (TAU * ALPHA_V) if alpha_rho is None else float(alpha_rho)
    if variant == "rho":
        rho = np.clip(row, 1.0, None) / row.mean()
        w_base = np.exp(-a_eff * rho)
    else:
        w_base = np.exp(-a_eff * (1.0 / (row + 1.0)))
    q_pen = np.exp(comm_l * (-((q - 0.5) ** 2)) / comm_s**2)
    t = np.arange(horizon)
    time_win = np.exp(-0.5 * ((t - (horizon - 1) / 2) / (TIME_SIGMA * horizon)) ** 2)
    wA = [np.maximum(w_base, W_FLOOR) for _ in range(horizon)]
    wB = [np.maximum(w_base * (q_pen ** time_win[i]), W_FLOOR) for i in range(horizon)]
    return wA, wB


def crossing_horizon(m, a0, B, cap=20000):
    """Return the bounded horizon and reference MFPT in lag steps."""
    P = np.asarray(m.P, dtype=np.float64)
    n = P.shape[0]
    Bs = set(int(b) for b in B)
    T = np.array([i for i in range(n) if i not in Bs])
    if not len(T):
        return cap
    try:
        mfpt = np.zeros(n)
        mfpt[T] = np.linalg.solve(np.eye(len(T)) - P[np.ix_(T, T)], np.ones(len(T)))
        h = int(np.clip(round(mfpt[a0]), 5, cap))
        return h, float(mfpt[a0])
    except Exception:
        return cap, float("nan")


def state_means(st, dg, n_states):
    """E[drug | state] and per-state counts, on whatever frame subset is passed in."""
    mu = np.full(n_states, np.nan)
    cnt = np.zeros(n_states, dtype=int)
    for s in range(n_states):
        m = st == s
        cnt[s] = m.sum()
        if cnt[s]:
            mu[s] = dg[m].mean()
    return mu, cnt


def target_set(cvm, dil, a0, n, a, dil_override=None):
    """The B set the tilt aims at."""
    if a.target == "cleft":
        B = np.array([b for b in np.where(cvm[:, 1] > a.cleft_thr)[0] if b != a0])
        if not len(B):
            raise SystemExit(
                f"empty target set B at cleft_thr={a.cleft_thr}. Under a pocket-feature MSM the "
                f"per-state mean cleft CV never reaches this threshold because pocket states mix "
                f"open and closed frames of the GLOBAL coordinate. Use --target dilation."
            )
        return B
    d = dil if dil_override is None else dil_override
    ok = np.isfinite(d)
    thr = np.quantile(d[ok], 1.0 - a.target_q)
    B = np.array([b for b in np.where(ok & (d >= thr))[0] if b != a0])
    if not len(B):
        raise SystemExit("empty dilation target set")
    return B


def build_selectors(m, cvm, C, a0, a, dil=None, B=None):
    """Weight vectors over ACTIVE states for every selector, each summing to 1."""
    P = np.asarray(m.P, dtype=np.float64)
    pi = np.asarray(m.stationary, dtype=np.float64)
    n = len(pi)

    if B is None:
        B = target_set(cvm, dil, a0, n, a)
    q = np.asarray(tpt.forward_committor(m, [a0], list(B)))

    sel = {}
    sel["equilibrium"] = pi / pi.sum()
    sel["uniform_states"] = np.full(n, 1.0 / n)

    half = np.abs(q - 0.5) <= 0.1
    if half.sum():
        w = pi * half
        sel["committor_half"] = w / w.sum()

    try:
        rf = tpt.reactive_flux(m, [a0], list(B))
        gross = np.asarray(rf.gross_flux)
        carried = gross.sum(axis=1) + gross.sum(axis=0)
        if carried.sum() > 0:
            sel["tpt_flux"] = carried / carried.sum()
    except Exception as e:
        print(f"  [warn] TPT flux unavailable: {e}")

    horizon = a.horizon
    mfpt = float("nan")
    if horizon is None:
        horizon, mfpt = crossing_horizon(m, a0, B)
    print(f"  [fk] horizon = {horizon} lag steps (MFPT a0->B = {mfpt:.1f})")

    def occupancy(wl, H):
        Ph, _ = _conditioning.build(P, wl, list(B), H, starts=[a0])
        mu = np.zeros(n)
        mu[a0] = 1.0
        acc = np.zeros(n)
        for Pn in Ph:
            mu = mu @ np.asarray(Pn)
            s = mu.sum()
            if not np.isfinite(s) or s <= 0:
                raise FloatingPointError(
                    "Conditioned occupancy lost all probability mass"
                )
            mu = mu / s
            acc += mu
        return acc / acc.sum()

    wA, wB = fk_weights(C, q, horizon, variant=a.fk_variant)
    for name, wl in (("doob_untilted", wA), ("fk_doob", wB)):
        try:
            sel[name] = occupancy(wl, horizon)
        except Exception as e:
            print(f"  [warn] {name} failed: {e}")

    for a_rho in getattr(a, "alpha_rho_sweep", []) or []:
        try:
            wa, _ = fk_weights(C, q, horizon, variant=a.fk_variant, alpha_rho=a_rho)
            sel[f"alg1[a={a_rho:g}]"] = occupancy(wa, horizon)
        except Exception as e:
            print(f"  [warn] alg1[a={a_rho:g}] failed: {e}")

    for cl in a.comm_l_sweep:
        for hf in a.horizon_sweep:
            H = max(5, int(round(horizon * hf)))
            try:
                _, wb = fk_weights(C, q, H, comm_l=cl, variant=a.fk_variant)
                sel[f"fk_doob[L={cl},H={H}]"] = occupancy(wb, H)
            except Exception:
                pass

    return sel, q, B, a0, horizon


def enrich(weights, mu_state, cnt, p_open_state, base_mean, base_open):
    """Expected druggability and open-probability under a state-weight vector."""
    ok = np.isfinite(mu_state) & (cnt > 0)
    w = np.where(ok, weights, 0.0)
    if w.sum() <= 0:
        return None
    w = w / w.sum()
    em = float((w * np.nan_to_num(mu_state)).sum())
    eo = float((w * np.nan_to_num(p_open_state)).sum())
    return {
        "E_drug": em,
        "P_open": eo,
        "enrich_mean": em / base_mean if base_mean > 0 else float("nan"),
        "enrich_open": eo / base_open if base_open > 0 else float("nan"),
        "coverage": float(weights[ok].sum() / max(weights.sum(), 1e-300)),
    }