diff --git a/README.md b/README.md index c30b869..116d5b8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# maxcal_poisson +# maxcal Maximum-caliber (MaxCal) correction of an underestimated folding barrier in first-passage trajectories, with the aim of recovering two-state (Poisson) kinetics @@ -137,7 +137,7 @@ Pure reweighting is therefore reliable only when the trajectories already contai many failed attempts. The script reports the Kish effective sample size [7] $$ -N_\text{eff} = \frac{\left(\sum_i w_i\right)^2}{\sum_i w_i^2} +N_\text{eff} = \frac{(\sum_i w_i)^2}{\sum_i w_i^2} $$ and flags the result when N_eff falls below a threshold (default 30). @@ -265,8 +265,11 @@ surface. With r = p′/p fixed by the attempt statistics at Q‡, the corrected is $$ -q'(x) = r q_m(x) \quad (q_m < q^*), \qquad -1 - q'(x) = r \left(1 - q_m(x)\right) \quad (q_m > q^*). +q'(x) = r q_m(x) \quad \text{for } q_m < q^* +$$ + +$$ +1 - q'(x) = r (1 - q_m(x)) \quad \text{for } q_m > q^* $$ In words: @@ -291,7 +294,8 @@ exact to about 10⁻⁴ away from the bump (`tests/test_committor.py`). "correct structures, underestimated barrier." - **Other locations.** For q* ≠ 1/2 the TS moves toward the barrier as λ grows, and reaches it once the tilt is strong enough. `ts_location.csv` and `ts_location.png` - scan q* from 0.1 to 0.9 for λ_min, λ_min+1 and λ_min+2 (or `--tse-lams`), so you + scan q* from 0.1 to 0.9 for the λ values given by `--lams` (or λ_min, λ_min+1, λ_min+2 + with `--from-stitch`), so you can see how much your TSE depends on this assumption. Values of q* before the attempt interface are flagged, because the tilt assumes the barrier lies beyond Q‡. - **Bounds.** The corrected TS always lies between Q‡ and Q_f (§2.8). `ts_location.csv` @@ -335,13 +339,25 @@ exact to about 10⁻⁴ away from the bump (`tests/test_committor.py`). ```bash git clone git@github.com:multi-ego/MaxCal.git cd MaxCal -pip install -e ".[test]" # installs the maxcal-poisson and maxcal-joint commands +pip install -e ".[test]" pytest -q # fast tests; add --runslow for the validation tests ``` -The scripts can also be run directly with `python maxcal_poisson.py ...`. +The code is the package `maxcal`; one executable per step, all sharing `maxcal/core.py` +(trajectory parsing, attempt counting, the tilt, survival/KS statistics, status codes): + +| command | module | what it does | +|---|---|---| +| `maxcal-stitch` | `maxcal/stitching.py` | thinning barrier crossings: λ_min, attempt statistics, the (Q‡, λ) decision map (§2.5–2.8) | +| `maxcal-reweight` | `maxcal/reweight.py` | MaxCal weights on whole trajectories: λ*, N_eff, per-trajectory weights (§2.3–2.4) | +| `maxcal-committor` | `maxcal/committor.py` | model and corrected committor, TS location, committor-based TSE frames (§2.10) | +| `maxcal-joint` | `maxcal/joint.py` | forward + backward runs: kinetic ΔG, transition-path symmetry, coupled tilt (§6) | +| `maxcal-target` | `maxcal/target.py` | reweighting onto experimental rates with a Poisson target (§7) | + +Each is also runnable as `python -m maxcal.stitching ...`, and `import maxcal as m` +re-exports the shared functions (`m.attempts`, `m.stitch`, `m.cv_curve`, `m.ts_location`). -**Demo notebook.** `notebooks/demo.ipynb` walks through the method interactively, +**Demo notebooks.** `notebooks/demo.ipynb` walks through the method interactively, using the test datasets: - attempt counting as Q‡ moves; - the reweighting weights, their saturation, and the resulting CV and N_eff; @@ -355,6 +371,11 @@ pip install -e ".[demo]" jupyter lab notebooks/demo.ipynb ``` +`notebooks/target_demo.ipynb` does the same for `maxcal-target` (§7) on the twelve-system +PDZ2-like dataset of its regression test: the clock calibration and what is left per +system, the weights and their CDFs, the N_eff cost of the correction, how weights change a +structural observable, and the affinity scatter before and after. + `examples/walkthrough_ks_lambda.py` is a short script version of the key steps: raw folding times fail the KS test, reweighting and stitching are compared as λ grows, and λ_min is compared with the true λ of a simulated higher barrier. @@ -365,8 +386,10 @@ committed outputs: `MAXCAL_DEMO_STATIC=1 jupyter nbconvert --to notebook --execute --inplace notebooks/demo.ipynb`. ```bash -python maxcal_poisson.py "runs/q_*.xvg" --qu 0.3 --qf 0.8 \ - --qts 0.40 --qtse 0.55 --out results +maxcal-stitch "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.40 --out stitch_out +maxcal-reweight "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.40 --qtse 0.55 --out reweight_out +maxcal-committor "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.40 \ + --from-stitch stitch_out/summary.csv --out committor_out ``` Input files contain either one column (Q; give `--dt`) or two columns (time, Q). @@ -376,26 +399,28 @@ Lines starting with `#` or `@` are ignored, so GROMACS `.xvg` files work directl |---|---| | `--qu`, `--qf` | U basin (Q < Qu); folded state (Q ≥ Qf), where trajectories stop | | `--qts` | reference attempt interface, at the barrier foot (default: middle of the scan grid) | -| `--qtse` | surface for TSE frames (default: same as each Q‡) | -| `--barrier-q` | assumed location of the missing barrier, as a model committor value q* (default 0.5, the model TS; §2.10) | -| `--tse-lams` | λ values for the committor-based TSE (default λ_min, λ_min+1, λ_min+2) | -| `--committor-bins`, `--tse-window` | committor binning along Q; half-width of the TSE window | -| `--heatmap-nlam`, `--heatmap-lam-max` | λ grid of the (Q‡, λ) KS heatmap (default 21 values in [0, 5] kT; 0 disables) | +| `--qtse` | *(reweight)* surface for TSE frames (default: same as each Q‡) | +| `--barrier-q` | *(committor, stitch)* assumed location of the missing barrier, as a model committor value q* (default 0.5, the model TS; §2.10) | +| `--lams`, `--from-stitch` | *(committor)* λ values for the TSE, or λ_min (+1, +2) taken from a `maxcal-stitch` summary | +| `--committor-bins`, `--tse-window` | *(committor)* binning along Q; half-width of the TSE window | +| `--nstitch`, `--nsub`, `--lam-max`, `--nlam` | *(stitch)* synthetic times per λ, KS subsamples, λ grid | +| `--boot`, `--neff-min` | *(reweight)* bootstrap resamples for λ*, N_eff threshold | +| `--heatmap-nlam`, `--heatmap-lam-max` | *(stitch)* λ grid of the decision map (default 21 values in [0, 5] kT; 0 disables) | | `--nqts` | number of Q‡ values scanned for robustness | | `--t0` | discard an initial relaxation window | | `--include-initial` | keep the first segment of each trajectory in the stitching pools | | `--alpha`, `--cv-tol` | Poisson criterion for stitching: median KS p ≥ α and \|CV − 1\| ≤ tol | | `--neff-min` | N_eff threshold below which reweighting is flagged | -**Outputs** +**Outputs** (each tool writes into its own `--out` directory) -- `summary.csv`: one row per Q‡, with p̂, geometric-test p, lag-1 correlation, CV, - KS p-values, λ* with bootstrap CI, N_eff, stitching threshold, and - `cv_stitch0`/`ksp_stitch0` (stitching at λ = 0). -- `tse_frames_*.csv`: TSE frame per completed trajectory, with its weight. -- `heatmap.csv`, `heatmap.png`: the (Q‡, λ) Poisson decision map (§2.8). -- `committor.csv`, `ts_location.csv`, `ts_location.png`, `tse_committor_*.csv`: model - committor, corrected TS location, and committor-based TSE frames (§2.10). +- **stitch**: `summary.csv` (one row per Q‡: attempt statistics, independence tests, CV + and KS at λ = 0, `cv_stitch0`/`ksp_stitch0`, λ_min, status codes), `heatmap.csv`/`.png` + (the decision map, §2.8), `survival.png`, `robustness_qts.png`. +- **reweight**: `summary.csv` (λ* with bootstrap interval, N_eff, KS at λ*, `cv_lammax`, + status codes), `weights_qts*.csv` (one weight per trajectory), `tse_frames_qts*.csv`, + `survival.png`, `lambda_scan.png`. +- **committor**: `committor.csv`, `ts_location.csv`/`.png`, `tse_committor_*.csv` (§2.10). **Status columns.** Every NaN in `summary.csv` comes with a reason code, so it can be told apart from a failure of the code. @@ -406,7 +431,6 @@ told apart from a failure of the code. | `lag1_status` | `ok`; `too_few_pairs` (fewer than 10 consecutive failure cycles); `constant_cycles` (correlation undefined) | | `reweight_status` | `ok`; `no_root` (weighted CV never reaches 1, §2.4); `low_neff` (N_eff below `--neff-min`); `cv_ge_1_at_lambda0` (already over-dispersed: a missing barrier does not explain the deviation) | | `stitch_status` | `ok`; `ok_pool_fallback` (initial segments had to be used); `no_pass` (Poisson criterion never met in the scan); `empty_pool` (no failed attempts past this Q‡, typically at or beyond the barrier) | -- `survival.png`, `lambda_scan.png`, `robustness_qts.png`. **Reading the results** @@ -423,18 +447,18 @@ told apart from a failure of the code. ## 5. Tests ```bash -pytest -q tests/ # 63 fast tests (~15 s) -pytest -q tests/ --runslow # + 15 validation tests and the demo notebook (~35 s) +pytest -q tests/ # 67 fast tests (~15 s) +pytest -q tests/ --runslow # + 15 validation tests and the demo notebook (~32 s) MAXCAL_UPDATE_REF=1 pytest tests/test_regtest.py # regenerate the reference ``` - **`test_unit.py`**: parsing, attempt counting, tilt identities (§2.2–2.4), Kaplan–Meier, KS/Lilliefors size and power, geometric test, stitching moments (§2.5), and I/O. -- **`test_regtest.py`**: full command-line run on 100 seeded overdamped Langevin - trajectories, compared with `tests/regtest/reference_summary.csv`. Deterministic - columns use rtol 1e-5; RNG-dependent stitching columns use loose absolute - tolerances. +- **`test_regtest.py`**: runs `maxcal-stitch`, `maxcal-reweight` and `maxcal-committor` + on 100 seeded overdamped Langevin trajectories and compares the two summaries with + `tests/regtest/reference_stitching.csv` and `reference_reweight.csv`. Deterministic + columns use rtol 1e-5; RNG-dependent stitching columns use loose absolute tolerances. - **`test_reweight_path.py`**: end-to-end test of the path where reweighting succeeds, which the Langevin data never reach. It uses hand-built trajectories (`tests/synthetic.py`) in which the weighted CV crosses 1 at λ* ≈ 1.1 with @@ -463,7 +487,7 @@ MAXCAL_UPDATE_REF=1 pytest tests/test_regtest.py # regenerate the reference --- -## 6. Joint mode: forward and backward trajectories (`maxcal_joint.py`) +## 6. Joint mode: forward and backward trajectories (`maxcal-joint`) This mode analyses first-passage runs in both directions together: A→B (folding or binding) and B→A (unfolding or unbinding). You must state explicitly whether the @@ -505,7 +529,7 @@ scaled time of the model cancels. **Kinetic ΔG.** The quantity $$ -\Delta G_\text{kin} = -kT\ln\left(\frac{M_{BA}}{M_{AB}}\right) +\Delta G_\text{kin} = -kT\ln(\frac{M_{BA}}{M_{AB}}) $$ must equal the equilibrium ΔG for two-state behaviour [25]. It is reported @@ -579,7 +603,7 @@ box equilibrium constant is K_box = P_bound/P_unbound = k′_on/k_off, where k the pseudo-first-order rate at [L] = 1/V. The standard binding free energy is [30] $$ -\Delta G^\circ = \Delta G_\text{box} - kT\ln\left(V C^\circ\right), +\Delta G^\circ = \Delta G_\text{box} - kT\ln(V C^\circ), \qquad C^\circ = 1\ \text{M} = 0.6022\ \text{nm}^{-3}. $$ @@ -593,17 +617,17 @@ missing barrier may be desolvation or induced fit. ```bash # folding / unfolding at the same temperature, experimental DeltaG imposed -python maxcal_joint.py --fwd "fold/*.xvg" --bwd "unfold/*.xvg" \ +maxcal-joint --fwd "fold/*.xvg" --bwd "unfold/*.xvg" \ --qa 0.3 --qb 0.8 --qts-fwd 0.4 --qts-bwd 0.7 --qtse 0.55 \ --temperature-relation same --dG -2.5 --out joint # unfolding simulated at a higher temperature -python maxcal_joint.py --fwd "fold/*.xvg" --bwd "unfold_hot/*.xvg" \ +maxcal-joint --fwd "fold/*.xvg" --bwd "unfold_hot/*.xvg" \ --qa 0.3 --qb 0.8 --qts-fwd 0.4 --qts-bwd 0.7 --qtse 0.55 \ --temperature-relation different --out joint_hot # binding / unbinding on a distance CV (A = unbound at d > 2.0 nm) -python maxcal_joint.py --fwd "on/*.xvg" --bwd "off/*.xvg" --system binding \ +maxcal-joint --fwd "on/*.xvg" --bwd "off/*.xvg" --system binding \ --qa 2.0 --qb 0.6 --qts-fwd 1.4 --qts-bwd 0.8 --qtse 1.0 \ --temperature-relation same --dG -8.0 --box-volume 343 --out joint_bind ``` @@ -644,7 +668,10 @@ python maxcal_joint.py --fwd "on/*.xvg" --bwd "off/*.xvg" --system binding \ --- -## 7. Matching experimental rates with a Poisson target (`maxcal_target.py`) +## 7. Matching experimental rates with a Poisson target (`maxcal-target`) + +*A focused guide with the full derivation, the cost analysis, a worked example and +references is in [`docs/TARGET.md`](docs/TARGET.md); this section is the summary.* A complementary tool for the case where **experimental rate constants are available for several systems** (e.g. mutant series) and the model is systematically fast. Instead of @@ -688,7 +715,7 @@ KS check is satisfied by construction and is only reported for completeness. ### 7.3 Usage ```bash -python maxcal_target.py systems.csv --conc 0.017 --clock balanced --out target_out +maxcal-target systems.csv --conc 0.017 --clock balanced --out target_out ``` with `systems.csv`: @@ -715,12 +742,18 @@ mechanisms. ### 7.4 Tests -`test_target.py`: the weights reproduce the target mean and CDF; they are flat when the +`test_target.py` (unit): the weights reproduce the target mean and CDF; they are flat when the target equals the model; the `mean` mode is an exact exponential tilt; clock modes; the N_eff formula; an observable test in which reweighting a mis-shaped model sample recovers the target's average of a descriptor correlated with the first-passage time; and an end-to-end run whose needed factors scale with 1/c. +`test_target_regtest.py` (regression): a seeded 12-system PDZ2-like dataset built from +the experimental table and the model rates (`tests/synthetic.py: write_rate_dataset`) is +run through `maxcal-target` and compared with `tests/regtest/reference_target.csv`, with +sanity checks that every weighted mean equals its target, the needed factors stay in a +reachable range, and N_eff stays above 20 of 50. + --- ## References diff --git a/docs/TARGET.md b/docs/TARGET.md new file mode 100644 index 0000000..557c9f0 --- /dev/null +++ b/docs/TARGET.md @@ -0,0 +1,321 @@ +# maxcal-target: matching experimental rates with a Poisson target + +Reweighting first-passage trajectories so that they reproduce **measured rate constants** +and a **single-exponential (Poisson) shape**, with minimum perturbation. The weights are +the result: applied to structural observables, they show which trajectories — and which +mechanisms — the experimental kinetics favour. + +This is the companion of the barrier correction in the main [README](../README.md): there +the missing barrier is unknown and inferred from the shape of the folding-time +distribution; here the rates are known from experiment and the question is what the model +must look like to reproduce them. + +--- + +## 1. When to use it + +Suitable when all three hold: + +- **Experimental rate constants** are available, ideally for several related systems + (a mutant series), so the model's systematic time-scale error can be separated from its + per-system error. +- **The model is trustworthy structurally** but quantitatively off in kinetics, e.g. a + coarse-grained or structure-based model with a smoothed landscape. +- **The needed correction is mild**, within a factor of ~2 per system after the global + time-scale factor. Larger corrections are not reachable by reweighting, which is itself + informative (§6). + +Not suitable for absolute-rate prediction: the time-scale factor is fitted, not derived. + +--- + +## 2. Setup and notation + +For each system and direction (binding/unbinding, or folding/unfolding) the model provides +N independent first-passage times t₁ … t_N, drawn from its own density f_model. Experiment +provides a rate constant k_exp. The corresponding target is a Poisson process: + +$$ +f_\text{target}(t) = \frac{1}{\tau_\text{target}} e^{-t/\tau_\text{target}} +$$ + +with τ_target the experimental mean first-passage time expressed in model time units (§3). +For binding at simulation concentration [C] (one ligand in the box, pseudo-first-order), +k_on = 1/(τ_bind·[C]); for unbinding, k_off = 1/τ_unbind. + +--- + +## 3. Time-scale calibration + +Model and experimental times are not directly comparable: a simplified model with a +smoother landscape crosses barriers faster, often by orders of magnitude. Define, per +system s and direction d, + +$$ +A_{s,d} = k^\text{model}_{s,d} / k^\text{exp}_{s,d} +$$ + +If the model's acceleration were a pure clock rescaling, all A would be equal. They are +not, and the deviations are the model's per-system error. Fit one global factor c and keep +the residuals: + +$$ +f_{s,d} = A_{s,d} / c +$$ + +f is the factor by which the mean first-passage time must change. Only the f are physical: +c cancels in every ratio, so relative rates, Φ-values and affinities do not depend on it. + +**Choosing c matters** because of the asymmetric cost in §5: slowing a sample down is +cheap, speeding it up is expensive and impossible beyond a factor of 2. + +| `--clock` | c | effect | +|---|---|---| +| `geometric` | geometric mean of A | the natural estimate; some systems may need lengthening | +| `decrease-only` | max A | every system needs a slowdown (f ≤ 1) | +| `balanced` (default) | maximises min(2f − f²) | best worst-case effective sample size | +| a number | as given | e.g. a clock calibrated independently | + +The spread of ln f is a useful summary: it is the model's own per-system kinetic error, +free of the clock. + +--- + +## 4. The weights + +### 4.1 Minimum-perturbation reweighting onto a specified target + +The target is fully specified, so this is a maximum-entropy (minimum relative entropy) +problem with the whole marginal distribution of t constrained. Minimising the +Kullback–Leibler divergence D(P′‖P_model) over path measures P′ whose marginal in t is +f_target gives + +$$ +P'(\omega) = P_\text{model}(\omega) \frac{f_\text{target}(t(\omega))}{f_\text{model}(t(\omega))} +$$ + +so the weights are the importance ratio, + +$$ +w_i \propto f_\text{target}(t_i) / f_\text{model}(t_i) +$$ + +Two consequences: + +- **Conditional structure is preserved.** P′(ω | t) = P_model(ω | t): given the + first-passage time, everything the trajectory does is the model's. The correction acts + only on how much each trajectory counts, never on what it contains. +- **Any observable can be reweighted.** For a per-trajectory observable O, + ⟨O⟩_target ≈ Σ wᵢOᵢ. Note the correction only reaches the part of the model's error that + is correlated with the first-passage time (§6). + +### 4.2 Estimating f_model + +f_model is estimated by a gamma fitted to the times by maximum likelihood: a smooth, +two-parameter stand-in flexible enough for first-passage densities (exponential and +lag-shifted shapes alike). Smoothness matters: a nearest-neighbour (spacing) estimate makes +the weights fluctuate with the random gaps between sorted times, wasting N_eff even when +the model already matches the target. With the gamma fit, the weights are flat when nothing +needs changing, and N_eff ≈ N. + +A final exponential tilt matches the target mean exactly, since the experimental rate is +the primary constraint and the sample cannot represent target mass beyond its longest +observed time (§5, `tail_gap`). + +### 4.3 Mean-only alternative (`--mode mean`) + +Constraining only the mean, ⟨t⟩ = τ_target, gives the classic one-parameter maximum-entropy +solution + +$$ +w_i \propto e^{-\theta t_i} +$$ + +with θ from the constraint. This leaves the shape to the model instead of imposing a +Poisson one; comparing the two modes shows how much of the correction is rate and how much +is shape. + +--- + +## 5. What the correction costs + +With Kish's effective sample size, N_eff = (Σw)²/Σw², the cost of an exponential tilt on an +exponential sample can be computed in closed form. Writing the achieved mean as a factor f +of the original, θτ = 1/f − 1, and + +$$ +N_\text{eff}/N = \frac{(E[w])^2}{E[w^2]} = 2f - f^2 +$$ + +independent of N. Hence: + +- **f = 1:** no cost. +- **f = 0.5** (twice as fast): 75% retained. +- **f = 0.2:** 36% retained. +- **f → 2⁻:** N_eff → 0. **Lengthening beyond a factor of 2 is impossible**, because the + second moment of the tilted exponential diverges. + +Three diagnostics accompany every system and direction: + +| diagnostic | meaning | +|---|---| +| `N_eff`, `N_eff_expected` | achieved vs the analytic 2f − f² prediction | +| `max_weight` | largest single weight; a value near 1 means one trajectory dominates | +| `tail_gap` = exp(−t_max/τ_target) | target probability beyond the longest observed time: what the sample cannot represent | + +In `target` mode the KS statistic against the target is satisfied by construction and is +reported only for completeness; read N_eff, `max_weight` and `tail_gap` instead. + +--- + +## 6. What it can and cannot do + +- **It cannot invent mechanisms.** Weights redistribute probability over trajectories the + model produced. If the experimental kinetics require behaviour the model never samples, + N_eff collapses — a result about the model, not a failure of the analysis. +- **It corrects only the t-correlated part of the error.** An observable independent of the + first-passage time is unchanged by reweighting. That is the correct minimal-assumption + behaviour, not a limitation to hide: the kinetics constrain what they constrain. +- **The clock is assumed shared** across systems. Check the spread of ln f; a mutation that + changes the model's effective friction would break this. +- **Affinities follow automatically.** Matching both directions fixes + K_D = k_off/k_on per system, so an affinity comparison after reweighting is a + consistency check, not an independent test. +- **Reweighting is per system.** Cross-system statements come from comparing separately + reweighted ensembles, not from reweighting one system onto another's data. + +--- + +## 7. Usage + +```bash +maxcal-target systems.csv --conc 0.017 --clock balanced --out target_out +``` + +`systems.csv`: + +``` +system,kon_exp,koff_exp,bind_times,unbind_times +EQVTAV_WT,2.6,22,times/EQVTAV_WT_bind.dat,times/EQVTAV_WT_unbind.dat +EQVTAV_L18A,2.4,10.4,times/EQVTAV_L18A_bind.dat,times/EQVTAV_L18A_unbind.dat +``` + +- `kon_exp` in µM⁻¹s⁻¹, `koff_exp` in s⁻¹; `--conc` is the ligand concentration in the + simulation box, in M. For a first-order process (folding/unfolding) use + `--system-kind first-order` and give both rates in s⁻¹. +- Each times file holds one first-passage time per line, in the model's own time units, in + trajectory order. + +| option | meaning | +|---|---| +| `--clock` | `geometric`, `decrease-only`, `balanced` (default) or a number (§3) | +| `--mode` | `target` (rate + Poisson shape, default) or `mean` (rate only) | +| `--conc`, `--system-kind` | concentration and whether binding is pseudo-first-order | + +**Outputs** + +| file | content | +|---|---| +| `summary.csv` | per system and direction: τ_model, τ_target, needed factor, N_eff and its expectation, weighted mean, KS, max weight, tail gap | +| `weights__.csv` | trajectory index, time, weight — join this to your structural analysis | +| `calibration.png` | needed factors and N_eff per system | +| `cdf_bind.png`, `cdf_unbind.png` | model, reweighted and target CDFs | + +--- + +## 8. Worked example + +`tests/synthetic.py: write_rate_dataset` builds twelve PDZ2-like systems (two peptides × +WT plus five mutants) from published experimental k_on/k_off and model rates, with seeded +exponential times in place of the real per-trajectory data: + +```bash +python -c "import sys; sys.path.insert(0,'tests'); import synthetic as S; print(S.write_rate_dataset('example_data'))" +maxcal-target example_data/systems.csv --conc 0.017 --clock balanced --out example_out +``` + +Fitted clock: **c ≈ 6 × 10⁻⁸** (model time × c = experimental time), i.e. the model is about +10⁷–10⁸ times faster in these units. What remains per system: + +| system | f (binding) | N_eff | f (unbinding) | N_eff | +|---|---|---|---|---| +| EQVTAV WT | 0.97 | 50 | 0.84 | 48 | +| EQVTAV L18A | 0.79 | 47 | 1.13 | 48 | +| EQVTAV L25A | 1.66 | 38 | 0.59 | 43 | +| EQVTAV T35G | 0.62 | 43 | 0.34 | 32 | +| EQVTAV V44A | 0.69 | 45 | 0.66 | 43 | +| EQVTAV A53G | 0.84 | 49 | 0.64 | 45 | +| EQVSAV WT | 0.65 | 44 | 1.49 | 43 | +| EQVSAV L18A | 0.80 | 46 | 1.34 | 45 | +| EQVSAV L25A | 0.95 | 47 | 1.43 | 38 | +| EQVSAV T35G | 0.71 | 47 | 0.48 | 38 | +| EQVSAV V44A | 0.50 | 38 | 0.78 | 47 | +| EQVSAV A53G | 0.56 | 40 | 0.51 | 39 | + +Every system is within a factor of ~1.7 of experiment once the clock is removed, and the +worst effective sample size is 32 of 50. The experimental kinetics are therefore reachable +*within* the mechanisms the model already samples. The affinity errors, mean |log₁₀ K_D| +0.19 for the model, go to 0 by construction after matching both directions. + +**Using the weights.** For a per-trajectory descriptor O (encounter-complex lifetime, which +contacts form first, how much of a mutated side-chain contact is present at the +transition): + +```python +import csv, numpy as np +rows = list(csv.DictReader(open("example_out/weights_EQVTAV_L25A_bind.csv"))) +w = np.array([float(r["weight"]) for r in rows]) # trajectory order = input order +O = my_descriptor_per_trajectory # your own analysis +print("model:", O.mean(), " reweighted:", np.sum(w * O)) +``` + +Bootstrap over trajectories for error bars, and report N_eff alongside: a large shift with +N_eff ≈ 40 of 50 is meaningful, the same shift with N_eff = 5 is one trajectory talking. + +`notebooks/target_demo.ipynb` runs this example interactively: clock calibration, the +weights per system, the N_eff cost curve, a descriptor example and the affinity scatter. + +--- + +## 9. Tests + +- `tests/test_target.py` — the weights reproduce the target mean and CDF; they are flat + when the target equals the model; `--mode mean` is an exact exponential tilt; the clock + modes; the N_eff formula; recovery of a descriptor's target average from a mis-shaped + model sample; and an end-to-end run whose needed factors scale with 1/c. +- `tests/test_target_regtest.py` — the twelve-system example above against + `tests/regtest/reference_target.csv`, with sanity checks on the weighted means, the + reachability of the factors and N_eff. + +--- + +## References + +1. Jaynes E. T. "Information theory and statistical mechanics." *Phys. Rev.* **106**, + 620–630 (1957). (Maximum entropy.) +2. Pressé S., Ghosh K., Lee J., Dill K. A. "Principles of maximum entropy and maximum + caliber in statistical physics." *Rev. Mod. Phys.* **85**, 1115–1141 (2013). +3. Cover T. M., Thomas J. A. *Elements of Information Theory*, 2nd ed. Wiley (2006). + (Minimum relative entropy and exponential tilting.) +4. Torrie G. M., Valleau J. P. "Nonphysical sampling distributions in Monte Carlo + free-energy estimation: umbrella sampling." *J. Comput. Phys.* **23**, 187–199 (1977). + (Importance reweighting of simulation ensembles.) +5. Ferrenberg A. M., Swendsen R. H. "New Monte Carlo technique for studying phase + transitions." *Phys. Rev. Lett.* **61**, 2635–2638 (1988). +6. Kish L. *Survey Sampling*. Wiley (1965). (Effective sample size.) +7. Martino L., Elvira V., Louzada F. "Effective sample size for importance sampling based + on discrepancy measures." *Signal Processing* **131**, 386–401 (2017). +8. Efron B. "Bootstrap methods: another look at the jackknife." *Ann. Stat.* **7**, 1–26 + (1979). +9. Lilliefors H. W. "On the Kolmogorov–Smirnov test for the exponential distribution with + mean unknown." *J. Am. Stat. Assoc.* **64**, 387–389 (1969). +10. Gianni S., Haq S. R., Montemiglio L. C., Jürgens M. C., Engström Å., Chi C. N., + Brunori M., Jemth P. "Sequence-specific long range networks in PSD-95/Discs + Large/ZO-1 (PDZ) domains tune their binding selectivity." *J. Biol. Chem.* **286**, + 27167–27175 (2011). (Source of the experimental rates used in the example.) +11. Scalone E. *et al.* "Multi-eGO: an in silico lens to look into protein aggregation + kinetics at atomic resolution." *PNAS* **119**, e2203181119 (2022). +12. Fersht A. R., Matouschek A., Serrano L. "The folding of an enzyme. I. Theory of protein + engineering analysis of stability and pathway of protein folding." *J. Mol. Biol.* + **224**, 771–782 (1992). (Φ-value analysis, for interpreting reweighted ensembles + across a mutant series.) diff --git a/examples/walkthrough_ks_lambda.py b/examples/walkthrough_ks_lambda.py index 59820b0..47b61cd 100644 --- a/examples/walkthrough_ks_lambda.py +++ b/examples/walkthrough_ks_lambda.py @@ -5,7 +5,7 @@ import sys; import os ROOT=os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path[:0]=[ROOT, os.path.join(ROOT,'tests')] -import numpy as np, maxcal_poisson as mp, langevin as L +import numpy as np, maxcal as mp, langevin as L import matplotlib; matplotlib.use('Agg'); import matplotlib.pyplot as plt OUT='walkthrough_ks_lambda.png' QU,QF,QTS=0.3,0.8,0.40 diff --git a/maxcal/__init__.py b/maxcal/__init__.py new file mode 100644 index 0000000..f4ff0ea --- /dev/null +++ b/maxcal/__init__.py @@ -0,0 +1,21 @@ +"""maxcal - MaxCal correction of an underestimated barrier in first-passage trajectories. + +Executables (each a module with a main()): + maxcal-stitch (maxcal.stitching) thinning barrier crossings -> Poisson kinetics, lambda_min, decision map + maxcal-reweight MaxCal weights on whole trajectories (memory-safe, no stitching) + maxcal-committor model/corrected committor, TS location, committor-based TSE frames + maxcal-joint forward + backward runs: kinetic DeltaG, TP symmetry, coupled tilt + maxcal-target reweighting onto experimental rates with a Poisson target + +Importing the package re-exports the shared functions, so `import maxcal as m` gives +m.attempts, m.stitch, m.cv_curve, m.ts_location, ... as in the original single module. +""" +from .core import (load_traj, parse_traj, attempts, success_prob, log_weights, tilted_p, + cv_curve, first_crossing, weighted_km, ks_exp_weighted, null_D, D_rows, + lilliefors_p, geometric_test, geom_status, lag1_status, reweight_status, + stitch_status, add_common_args, load_trajectories, qts_grid, write_csv) +from .stitching import stitch, stitch_scan, ks_heatmap +from .committor import (committor_frames, isotonic, committor_profile, corrected_committor, + q_at, ts_location) + +__version__ = "0.2.0" diff --git a/maxcal/committor.py b/maxcal/committor.py new file mode 100644 index 0000000..4ffe0bb --- /dev/null +++ b/maxcal/committor.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python3 +"""maxcal-committor - model committor along Q, corrected committor for a located missing +barrier, transition-state location, and TSE frames (README 2.10). + +The tilt fixes how much barrier is missing (r = p'/p from lambda) but not where it sits. +The location is an input, --barrier-q, given as a value q* of the MODEL committor; the +default 0.5 puts the missing barrier on the model's own transition state, where the TS does +not move with lambda. + +Example: + maxcal-committor "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.4 --lams 0.3 1.3 2.3 --out com_out +""" +import argparse +import csv +import os + +import numpy as np + +import matplotlib.pyplot as plt # backend set in main() + +from .core import (attempts, success_prob, tilted_p, add_common_args, load_trajectories, + qts_grid) + + +def committor_frames(trajs, qu, qf): + """Frames inside excursions out of U, labelled by the outcome of their excursion + (1 = reaches Qf before returning below Qu). For a frame x this outcome is a + sample of the committor q(x). Returns arrays (traj index, frame, Q, outcome).""" + ti, fr, qq, oo = [], [], [], [] + for i, tr in enumerate(trajs): + q, F = tr["q"], tr["fails"] + for s, e, _ in F: + s, e = int(s), int(e) + idx = np.arange(s, e) + ti.append(np.full(idx.size, i)); fr.append(idx); qq.append(q[idx]); oo.append(np.zeros(idx.size)) + f = tr["fold"] + if f is not None: + inU = np.flatnonzero(q[:f] < qu) + s = inU[-1] + 1 if inU.size else 0 + idx = np.arange(s, f) + ti.append(np.full(idx.size, i)); fr.append(idx); qq.append(q[idx]); oo.append(np.ones(idx.size)) + cat = lambda a, dt: np.concatenate(a).astype(dt) if a else np.zeros(0, dt) + return cat(ti, int), cat(fr, int), cat(qq, float), cat(oo, float) + + +def isotonic(y, w): + """Weighted non-decreasing fit (pool-adjacent-violators).""" + blocks = [] # [value, weight, length] + for yi, wi in zip(y, w): + blocks.append([yi, wi, 1]) + while len(blocks) > 1 and blocks[-2][0] > blocks[-1][0]: + v2, w2, n2 = blocks.pop(); v1, w1, n1 = blocks.pop() + wt = w1 + w2 + blocks.append([(v1 * w1 + v2 * w2) / wt if wt > 0 else 0.5 * (v1 + v2), wt, n1 + n2]) + return np.concatenate([np.full(n, v) for v, _, n in blocks]) + + +def committor_profile(qvals, outcome, qu, qf, nbins): + edges = np.linspace(qu, qf, nbins + 1) + b = np.clip(np.digitize(qvals, edges) - 1, 0, nbins - 1) + n = np.bincount(b, minlength=nbins).astype(float) + s = np.bincount(b, weights=outcome, minlength=nbins) + raw = np.where(n > 0, s / np.maximum(n, 1), np.nan) + ok = n > 0 + iso = np.full(nbins, np.nan) + iso[ok] = isotonic(raw[ok], n[ok]) + return 0.5 * (edges[1:] + edges[:-1]), n, raw, iso + + +def corrected_committor(qm, r, qstar): + qm = np.asarray(qm, float) + return np.where(qm < qstar, r * qm, 1.0 - r * (1.0 - qm)) + + +def q_at(centers, q_iso, level): + """Q where the (monotone) model committor reaches `level` (linear interpolation).""" + ok = np.isfinite(q_iso) + c, q = centers[ok], q_iso[ok] + if q.size == 0 or level < q[0] or level > q[-1]: + return np.nan + j = np.flatnonzero(q >= level)[0] + if j == 0 or q[j] == q[j - 1]: + return c[j] + return c[j - 1] + (level - q[j - 1]) * (c[j] - c[j - 1]) / (q[j] - q[j - 1]) + + +def ts_location(centers, q_iso, r, qstar): + """Location of the corrected transition state q' = 1/2, and which part of the + corrected committor puts it there ('barrier', 'U_side', 'F_side').""" + if r * qstar <= 0.5 <= 1.0 - r * (1.0 - qstar): + return q_at(centers, q_iso, qstar), "barrier" # the jump straddles 1/2 + if r * qstar > 0.5: # reached 1/2 before the barrier + return q_at(centers, q_iso, 0.5 / r), "U_side" + return q_at(centers, q_iso, 1.0 - 0.5 / r), "F_side" + + + +def profile(trajs, args): + """Model committor along Q from excursion outcomes, plus the frame table.""" + ti, fr, qv, oc = committor_frames(trajs, args.qu, args.qf) + centers, n, raw, iso = committor_profile(qv, oc, args.qu, args.qf, args.committor_bins) + return dict(ti=ti, fr=fr, qv=qv, oc=oc, centers=centers, n=n, raw=raw, iso=iso) + + +def lambdas_from(args): + if args.from_stitch: + with open(args.from_stitch) as fh: + rows = list(csv.DictReader(fh)) + qts = args.qts if args.qts is not None else None + pick = min(rows, key=lambda r: abs(float(r["qts"]) - qts)) if qts else rows[0] + base = float(pick["lam_stitch"]) if pick["lam_stitch"] not in ("", "nan") else 0.0 + return [base, base + 1.0, base + 2.0] + return list(args.lams) if args.lams else [0.0, 1.0, 2.0] + + +def main(argv=None): + plt.switch_backend("Agg") + ap = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + add_common_args(ap, qts_help="attempt interface used for p and for the validity check") + ap.add_argument("--barrier-q", type=float, default=0.5, + help="assumed barrier location as a MODEL committor value q* (default 0.5)") + ap.add_argument("--lams", type=float, nargs="*", default=None, + help="lambda values (default 0 1 2, or lambda_min + 0/1/2 with --from-stitch)") + ap.add_argument("--from-stitch", default=None, + help="summary.csv from maxcal-stitch: take lambda_min at the reference Q‡") + ap.add_argument("--committor-bins", type=int, default=20) + ap.add_argument("--tse-window", type=float, default=None, + help="half-width in Q of the TSE window around Q_TS (default: one bin)") + args = ap.parse_args(argv) + + trajs = load_trajectories(args.files, args.dt, args.qu, args.qf) + _, qref = qts_grid(args) + os.makedirs(args.out, exist_ok=True) + P = profile(trajs, args) + centers, iso = P["centers"], P["iso"] + with open(os.path.join(args.out, "committor.csv"), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["Q", "n_frames", "q_model_raw", "q_model_isotonic"]) + for row in zip(centers, P["n"], P["raw"], iso): + wr.writerow([f"{v:.6g}" for v in row]) + + A = attempts(trajs, qref, args.t0, args.include_initial) + p = success_prob(A["k"], A["done"]) + ok = np.isfinite(iso) + q_iface = float(np.interp(qref, centers[ok], iso[ok])) if ok.any() else np.nan + lams = lambdas_from(args) + qstars = np.round(np.arange(0.1, 0.91, 0.05), 3) + half = args.tse_window if args.tse_window else (args.qf - args.qu) / args.committor_bins + + with open(os.path.join(args.out, "ts_location.csv"), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["lambda", "r", "q_star", "Q_barrier", "Q_TS", "ts_set_by", "status"]) + for lam in lams: + r = tilted_p(p, lam) / p + for qs in sorted(set(qstars) | {args.barrier_q}): + qb = q_at(centers, iso, qs) + qts_, where = ts_location(centers, iso, r, qs) + status = ("barrier_before_interface" if qs < q_iface else + "ts_outside_sampled_range" if not np.isfinite(qts_) else + "ts_before_interface" if qts_ <= qref else "ok") + wr.writerow([f"{lam:.4g}", f"{r:.4g}", f"{qs:.3g}", f"{qb:.4g}", + f"{qts_:.4g}", where, status]) + + print(f"model TS (q = 0.5) at Q = {q_at(centers, iso, 0.5):.3f}; assumed barrier " + f"(q* = {args.barrier_q:.2f}) at Q = {q_at(centers, iso, args.barrier_q):.3f}; " + f"p = {p:.3f} at Q‡ = {qref:.3f}") + if args.barrier_q < q_iface: + print(f" WARNING: q* lies before the attempt interface (model q = {q_iface:.2f} " + "at Q‡); the tilt assumes the barrier is beyond Q‡.") + for lam in lams: + r = tilted_p(p, lam) / p + qts_, where = ts_location(centers, iso, r, args.barrier_q) + sel = np.abs(P["qv"] - qts_) <= half if np.isfinite(qts_) else np.zeros(P["qv"].size, bool) + name = f"tse_committor_lam{lam:.2f}_q{args.barrier_q:.2f}.csv" + with open(os.path.join(args.out, name), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["trajectory", "frame", "time", "Q", "excursion_outcome"]) + for i, f_, q_, o_ in zip(P["ti"][sel], P["fr"][sel], P["qv"][sel], P["oc"][sel]): + wr.writerow([trajs[i]["path"], f_, f"{f_ * trajs[i]['dt']:.6g}", + f"{q_:.6g}", int(o_)]) + print(f" lambda = {lam:.2f} (r = {r:.3f}): Q_TS = {qts_:.3f} set by {where:8s}" + f" -> {int(sel.sum())} frames in {name}") + + fig, axs = plt.subplots(1, 2, figsize=(11, 4)) + axs[0].plot(centers, P["raw"], "o", ms=3, color="0.5", label="model (raw)") + axs[0].plot(centers, iso, "k-", label="model (isotonic)") + grid = np.linspace(args.qu, args.qf, 400) + qm_grid = np.interp(grid, centers[ok], iso[ok]) + for lam in lams: + r = tilted_p(p, lam) / p + axs[0].plot(grid, corrected_committor(qm_grid, r, args.barrier_q), + label=f"corrected, lambda={lam:.2f}") + axs[0].axhline(0.5, color="k", ls=":", lw=1) + axs[0].axvline(qref, color="r", ls=":", lw=1, label="Q‡") + axs[0].set_xlabel("Q"); axs[0].set_ylabel("committor"); axs[0].legend(fontsize=8) + axs[0].set_title(f"missing barrier at model q* = {args.barrier_q:.2f}") + for lam in lams: + r = tilted_p(p, lam) / p + axs[1].plot(qstars, [ts_location(centers, iso, r, qs)[0] for qs in qstars], "o-", ms=3, + label=f"lambda = {lam:.2f}") + axs[1].plot(qstars, [q_at(centers, iso, qs) for qs in qstars], "k--", lw=1, + label="barrier location") + axs[1].axvspan(0, q_iface, color="0.9", label="before Q‡ (not allowed)") + axs[1].set_xlim(qstars[0], qstars[-1]) + axs[1].set_xlabel("assumed barrier location q* (model committor)") + axs[1].set_ylabel("Q_TS"); axs[1].set_title("TS location vs assumed barrier location") + axs[1].legend(fontsize=8) + fig.tight_layout(); fig.savefig(os.path.join(args.out, "ts_location.png"), dpi=150) + plt.close(fig) + print(f"\nWrote committor.csv, ts_location.csv/.png, tse_committor_*.csv to {args.out}/") + + +if __name__ == "__main__": + main() diff --git a/maxcal/core.py b/maxcal/core.py new file mode 100644 index 0000000..4d7dda1 --- /dev/null +++ b/maxcal/core.py @@ -0,0 +1,286 @@ +"""Shared machinery: trajectory parsing, attempt counting at an interface, the MaxCal +tilt, survival/KS statistics and the status codes used by all maxcal tools.""" +import argparse +import csv +import glob +import os +import sys +import warnings + +import numpy as np +from scipy import stats +from scipy.special import logsumexp + +# ----------------------------------------------------------------------------- I/O +def load_traj(path, dt_arg): + data = np.loadtxt(path, comments=("#", "@")) + if data.ndim == 1: + if dt_arg is None: + sys.exit(f"{path}: single column of Q, please pass --dt") + return data.astype(float), float(dt_arg) + t, q = data[:, 0], data[:, 1] + if dt_arg is not None: + return q.astype(float), float(dt_arg) + d = np.diff(t) + dt = float(np.median(d)) if d.size else 1.0 + if d.size and np.max(np.abs(d - dt)) > 1e-6 * abs(dt): + warnings.warn(f"{path}: non-uniform time spacing, using median dt={dt}") + return q.astype(float), dt + + +def parse_traj(q, qu, qf): + """Folding frame (first Q >= Qf, or None) and failed excursions [start, end, maxQ]. + An excursion is a run with Q >= Qu that starts from U and returns below Qu + before Qf. 'end' is the first frame back in U.""" + hit = np.flatnonzero(q >= qf) + fold = int(hit[0]) if hit.size else None + qq = q[:fold] if fold is not None else q + if qq.size == 0: + return fold, np.empty((0, 3)) + below = qq < qu + change = np.flatnonzero(np.diff(below.astype(np.int8))) + 1 + starts = np.r_[0, change] + ends = np.r_[change, qq.size] + maxq = np.maximum.reduceat(qq, starts) + # above-Qu runs that were entered from U (start > 0) and left back to U (end < size) + m = (~below[starts]) & (starts > 0) & (ends < qq.size) + return fold, np.column_stack([starts[m], ends[m], maxq[m]]).astype(float) + + +# ------------------------------------------------------------------ per-Q‡ attempts +def attempts(trajs, qts, t0, include_initial, qtse=None): + qtse = qts if qtse is None else qtse + rows = [] + fail_cyc, fail_init, succ, succ_init, pairs, tse = [], [], [], [], [], [] + for i, tr in enumerate(trajs): + dt, fold, F = tr["dt"], tr["fold"], tr["fails"] + f0 = int(np.ceil(t0 / dt)) if t0 > 0 else 0 + if fold is not None and fold < f0: + continue # folded during the discarded initial window + sel = (F[:, 2] >= qts) & (F[:, 1] > f0) if len(F) else np.zeros(0, bool) + ends = F[sel, 1].astype(int) + end_frame = fold if fold is not None else tr["n"] + bounds = np.r_[f0, ends] + segs = np.diff(bounds) * dt + if segs.size: + fail_init.append(segs[0]) + cyc = segs[1:] + fail_cyc.extend(cyc) + pairs.extend(zip(cyc[:-1], cyc[1:])) + done = fold is not None + if done: + last = (fold - bounds[-1]) * dt + (succ if ends.size else succ_init).append(last) + seg = tr["q"][bounds[-1]:fold] + b = np.flatnonzero(seg < qtse) + tse.append((i, int(bounds[-1] + (b[-1] + 1 if b.size else 0)))) + rows.append((i, ends.size, (end_frame - f0) * dt, done)) + idx = np.array([r[0] for r in rows], int) + k = np.array([r[1] for r in rows], int) + T = np.array([r[2] for r in rows], float) + done = np.array([r[3] for r in rows], bool) + + fail_pool = np.array(fail_cyc) + succ_pool = np.array(succ) + note = [] + if include_initial or fail_pool.size < 10: + if not include_initial and fail_pool.size < 10: + note.append("failure pool <10: initial segments included") + fail_pool = np.r_[fail_pool, fail_init] + if include_initial or succ_pool.size < 10: + if not include_initial and succ_pool.size < 10: + note.append("success pool <10: initial segments included") + succ_pool = np.r_[succ_pool, succ_init] + return dict(idx=idx, k=k, T=T, done=done, fail_pool=fail_pool, + succ_pool=succ_pool, pairs=np.array(pairs), tse=tse, note="; ".join(note)) + + +# --------------------------------------------------------------------- statistics +def success_prob(k, done): + return done.sum() / (done.sum() + k.sum()) + + +def log_weights(lams, k, done, p): + """Normalized log weights, shape (len(lams), N).""" + lams = np.atleast_1d(lams) + lc = -np.log1p(-p * (-np.expm1(-lams))) # log c + lw = np.outer(lc, k) + np.outer(lc - lams, done.astype(float)) + return lw - logsumexp(lw, axis=1, keepdims=True) + + +def tilted_p(p, lam): + return p * np.exp(-lam) / (1.0 - p * (-np.expm1(-lam))) + + +def cv_curve(lams, k, T, done, p): + """Weighted CV of completed folding times and N_eff (all trajectories).""" + lw = log_weights(lams, k, done, p) + w = np.exp(lw) + neff = 1.0 / np.sum(w ** 2, axis=1) + wc = w[:, done] + wc = wc / wc.sum(axis=1, keepdims=True) + Tc = T[done] + m = wc @ Tc + var = wc @ (Tc ** 2) - m ** 2 + return np.sqrt(np.clip(var, 0, None)) / m, neff + + +def first_crossing(x, y, level=1.0): + """Linear interpolation of first x where y reaches level from below.""" + if y[0] >= level: + return x[0] + j = np.flatnonzero(y >= level) + if j.size == 0: + return np.nan + j = j[0] + return x[j - 1] + (level - y[j - 1]) * (x[j] - x[j - 1]) / (y[j] - y[j - 1]) + + +def weighted_km(t, done, w): + o = np.argsort(t, kind="stable") + t, d, w = t[o], done[o], w[o] + at_risk = np.cumsum(w[::-1])[::-1] + S = np.cumprod(np.where(d, 1.0 - w / at_risk, 1.0)) + return t, S, d + + +def ks_exp_weighted(t, done, w): + """Sup distance between weighted KM survival and exponential with MLE tau.""" + tau = np.sum(w * t) / np.sum(w * done) + ts, S, d = weighted_km(t, done, w) + E = np.exp(-ts / tau) + Sprev = np.r_[1.0, S[:-1]] + D = np.max(np.maximum(np.abs(S - E), np.abs(Sprev - E))[d]) + return D, tau + + +_NULL = {} + + +def null_D(n, nsim=4000): + """Null distribution of the KS statistic for an exponential with fitted scale + (Lilliefors); scale-free, so simulated once per n.""" + n = int(max(n, 3)) + if n not in _NULL: + r = np.random.default_rng(12345) + _NULL[n] = np.sort(D_rows(r.exponential(size=(nsim, n)))) + return _NULL[n] + + +def D_rows(x): + """KS distance to fitted exponential, one sample per row (uncensored).""" + x = np.sort(x, axis=1) + n = x.shape[1] + F = 1.0 - np.exp(-x / x.mean(axis=1, keepdims=True)) + i = np.arange(1, n + 1) + return np.max(np.maximum(i / n - F, F - (i - 1) / n), axis=1) + + +def lilliefors_p(D, n): + null = null_D(n) + return (np.sum(null >= D) + 1) / (null.size + 1) + + +def geometric_test(k): + """Chi-square test that failed-attempt counts are geometric (independent attempts).""" + n = k.size + if n < 10: + return np.nan, 0 + p = n / (n + k.sum()) + obs, prob, tail, j = [], [], 1.0, 0 + while True: + pj = p * (1 - p) ** j + if n * pj < 5 or n * (tail - pj) < 5: + break + obs.append(np.sum(k == j)); prob.append(pj); tail -= pj; j += 1 + obs.append(np.sum(k >= j)); prob.append(tail) + if len(obs) < 3: + return np.nan, len(obs) + exp = n * np.array(prob) + chi2 = np.sum((np.array(obs) - exp) ** 2 / exp) + dof = len(obs) - 2 + return stats.chi2.sf(chi2, dof), len(obs) + + + +# ------------------------------------------------------------------ status flags +# Every NaN in summary.csv comes with a reason in one of these columns. +def geom_status(n, pval): + if n < 10: + return "too_few_trajectories" + return "too_few_bins" if not np.isfinite(pval) else "ok" + + +def lag1_status(pairs): + """pairs: (n, 2) array of consecutive failure-cycle durations within trajectories.""" + if len(pairs) < 10: + return "too_few_pairs" + if np.ptp(pairs[:, 0]) == 0 or np.ptp(pairs[:, 1]) == 0: + return "constant_cycles" # correlation undefined + return "ok" + + +def reweight_status(cv0, lam_star, neff, neff_min): + if cv0 >= 1: + return "cv_ge_1_at_lambda0" # already over-dispersed: a missing barrier can't explain it + if not np.isfinite(lam_star): + return "no_root" # CV never reaches 1: observed attempt counts too few + if not neff >= neff_min: + return "low_neff" + return "ok" + + +def stitch_status(lam_stitch, n_fail_pool, n_succ_pool, pool_note): + if n_fail_pool == 0 or n_succ_pool == 0: + return "empty_pool" # no failed attempts past this Q‡ (at/after the barrier?) + if not np.isfinite(lam_stitch): + return "no_pass" + return "ok_pool_fallback" if pool_note else "ok" # fallback: initial segments were used + + + +# --------------------------------------------------------------------- shared CLI +def add_common_args(ap, qts_help="reference Q‡ (default: middle of the scan grid)"): + ap.add_argument("files", nargs="+", help="trajectory files or glob patterns") + ap.add_argument("--qu", type=float, required=True, help="start basin: Q < Qu") + ap.add_argument("--qf", type=float, required=True, help="target: Q >= Qf (trajectories stop here)") + ap.add_argument("--dt", type=float, default=None, help="frame spacing (needed for 1-column files)") + ap.add_argument("--qts", type=float, default=None, help=qts_help) + ap.add_argument("--nqts", type=int, default=9, help="number of Q‡ values scanned in (Qu, Qf)") + ap.add_argument("--t0", type=float, default=0.0, help="discard an initial relaxation window") + ap.add_argument("--include-initial", action="store_true", + help="use the first segment of each trajectory in the stitching pools") + ap.add_argument("--alpha", type=float, default=0.05) + ap.add_argument("--cv-tol", type=float, default=0.1) + ap.add_argument("--seed", type=int, default=1) + ap.add_argument("--out", required=True, help="output directory") + return ap + + +def load_trajectories(patterns, dt_arg, qu, qf): + paths = sorted({p for pat in patterns for p in (glob.glob(pat) or [pat])}) + trajs = [] + for path in paths: + q, dt = load_traj(path, dt_arg) + fold, fails = parse_traj(q, qu, qf) + trajs.append(dict(path=path, q=q, dt=dt, n=q.size, fold=fold, fails=fails)) + if not trajs: + sys.exit("no trajectories found") + return trajs + + +def qts_grid(args): + """Scan grid inside (Qu, Qf), always containing the reference Q‡.""" + grid = np.linspace(args.qu, args.qf, args.nqts + 2)[1:-1] + qref = args.qts if args.qts is not None else grid[len(grid) // 2] + if not args.qu < qref < args.qf: + sys.exit("--qts must lie between Qu and Qf") + return np.unique(np.r_[grid, qref]), qref + + +def write_csv(path, cols, rows): + with open(path, "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(cols) + for r in rows: + wr.writerow([r[c] if isinstance(r[c], str) else f"{r[c]:.6g}" for c in cols]) diff --git a/maxcal_joint.py b/maxcal/joint.py similarity index 95% rename from maxcal_joint.py rename to maxcal/joint.py index 0abce1c..2db6e77 100644 --- a/maxcal_joint.py +++ b/maxcal/joint.py @@ -1,10 +1,10 @@ #!/usr/bin/env python3 """ -maxcal_joint.py - joint MaxCal analysis of forward (A->B) and backward (B->A) +maxcal-joint - joint MaxCal analysis of forward (A->B) and backward (B->A) first-passage trajectories: folding/unfolding or binding/unbinding. -Uses the single-direction machinery of maxcal_poisson.py (attempt counting, tilt, -stitching, Lilliefors test) and adds what only the pair of directions can give. +Uses the single-direction machinery of maxcal.core and maxcal.stitching (attempt counting, +tilt, stitching, Lilliefors test) and adds what only the pair of directions can give. --temperature-relation same Both sets sample the same ensemble. One barrier correction must explain both @@ -33,11 +33,11 @@ stop on reaching A. Example (folding, same temperature): - python maxcal_joint.py --fwd "fold/*.xvg" --bwd "unfold/*.xvg" \\ + maxcal-joint --fwd "fold/*.xvg" --bwd "unfold/*.xvg" \\ --qa 0.3 --qb 0.8 --qts-fwd 0.4 --qts-bwd 0.7 --qtse 0.55 \\ --temperature-relation same --dG -2.5 --out joint Binding (distance CV, same temperature, one ligand in a box of V nm^3): - python maxcal_joint.py --fwd "on/*.xvg" --bwd "off/*.xvg" --system binding \\ + maxcal-joint --fwd "on/*.xvg" --bwd "off/*.xvg" --system binding \\ --qa 2.0 --qb 0.6 --qts-fwd 1.4 --qts-bwd 0.8 --qtse 1.0 \\ --temperature-relation same --dG -8.0 --box-volume 343 --out joint """ @@ -53,7 +53,18 @@ import matplotlib.pyplot as plt # backend set to Agg in main(), not at import -import maxcal_poisson as mp +from types import SimpleNamespace + +from .core import (parse_traj, attempts, success_prob, tilted_p, geometric_test, + ks_exp_weighted, lilliefors_p, null_D, D_rows, weighted_km, load_traj) +from .stitching import stitch as _stitch, stitch_scan as _stitch_scan + +# the joint code was written against one flat module; keep that spelling +mp = SimpleNamespace(parse_traj=parse_traj, attempts=attempts, success_prob=success_prob, + tilted_p=tilted_p, geometric_test=geometric_test, + ks_exp_weighted=ks_exp_weighted, lilliefors_p=lilliefors_p, + null_D=null_D, D_rows=D_rows, weighted_km=weighted_km, + load_traj=load_traj, stitch=_stitch, stitch_scan=_stitch_scan) C_STANDARD = 0.602214076 # 1 M in molecules per nm^3 diff --git a/maxcal/reweight.py b/maxcal/reweight.py new file mode 100644 index 0000000..c21afb7 --- /dev/null +++ b/maxcal/reweight.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""maxcal-reweight - MaxCal reweighting of whole first-passage trajectories. + +Each trajectory keeps its own history and gets the weight w ∝ c^k of the attempt tilt +(README 2.3), so no Markov-at-interface assumption enters: this is the maximum-entropy +reweighting of the trajectory ensemble under a constraint on the mean number of failed +attempts. Useful for trajectory-level and route-level questions, for data with memory +(where stitching is not valid), and as a small-lambda cross-check on maxcal-stitch. + +It cannot create folding times longer than those observed: the weights saturate at +(1-p)^-k, N_eff falls as lambda grows, and on lag-dominated data the CV moves away from 1 +(README 2.4). Read the KS p-value together with CV and N_eff, and use maxcal-stitch for +the Poisson question. + +Outputs per Q‡: lambda* where the weighted CV reaches 1 (if it does) with a bootstrap +interval, N_eff and the KS p-value there, and the per-trajectory weights. + +Example: + maxcal-reweight "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.45 --out reweight_out +""" +import argparse +import csv +import os + +import numpy as np +from scipy import stats + +import matplotlib.pyplot as plt # backend set in main() + +from .core import (attempts, success_prob, log_weights, cv_curve, first_crossing, + ks_exp_weighted, weighted_km, lilliefors_p, geometric_test, geom_status, + lag1_status, reweight_status, add_common_args, load_trajectories, + qts_grid, write_csv) + + +def scan(trajs, qts, args, rng, lams): + """Reweighting at one attempt interface.""" + A = attempts(trajs, qts, args.t0, args.include_initial, args.qtse) + k, T, done = A["k"], A["T"], A["done"] + p = success_prob(k, done) + cv, neff = cv_curve(lams, k, T, done, p) + lam_star = first_crossing(lams, cv) + w0 = np.full(k.size, 1.0 / k.size) + D0, _ = ks_exp_weighted(T, done, w0) + out = dict(qts=qts, N=int(k.size), n_done=int(done.sum()), sum_k=int(k.sum()), + kmax=int(k.max()) if k.size else 0, p=p, cv0=cv[0], cv_lammax=cv[-1], + ks_p0=lilliefors_p(D0, k.size), lam_star=lam_star, note=A["note"]) + out["geom_p"], _ = geometric_test(k[done]) + out["geom_status"] = geom_status(int(done.sum()), out["geom_p"]) + pr = A["pairs"] + out["lag1_status"] = lag1_status(pr) + out["lag1_rho"], out["lag1_p"] = (stats.spearmanr(pr[:, 0], pr[:, 1]) + if out["lag1_status"] == "ok" else (np.nan, np.nan)) + + if np.isfinite(lam_star): + w = np.exp(log_weights(lam_star, k, done, p)[0]) + out["neff_star"] = 1.0 / np.sum(w ** 2) + D, _ = ks_exp_weighted(T, done, w) + out["ks_p_star"] = lilliefors_p(D, round(out["neff_star"])) + else: + w = w0 + out.update(neff_star=np.nan, ks_p_star=np.nan) + out["reweight_ok"] = bool(np.isfinite(lam_star) and out["neff_star"] >= args.neff_min) + + boots = [] + for _ in range(args.boot): + b = rng.integers(0, k.size, k.size) + if not done[b].any(): + continue + cvb, _ = cv_curve(lams, k[b], T[b], done[b], success_prob(k[b], done[b])) + boots.append(first_crossing(lams, cvb)) + boots = np.array(boots) + fin = boots[np.isfinite(boots)] + out["lam_lo"], out["lam_hi"] = (np.percentile(fin, [2.5, 97.5]) if fin.size + else (np.nan, np.nan)) + out["boot_noroot"] = float(np.mean(~np.isfinite(boots))) if boots.size else np.nan + out["reweight_status"] = reweight_status(out["cv0"], lam_star, out["neff_star"], + args.neff_min) + return out, A, w, cv, neff + + +def main(argv=None): + plt.switch_backend("Agg") + ap = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + add_common_args(ap) + ap.add_argument("--qtse", type=float, default=None, + help="surface for the TSE frames (last upward crossing before folding); " + "default: each Q‡") + ap.add_argument("--lam-max", type=float, default=10.0) + ap.add_argument("--nlam", type=int, default=201) + ap.add_argument("--boot", type=int, default=500, help="bootstrap resamples for lambda*") + ap.add_argument("--neff-min", type=float, default=30.0, + help="N_eff below which the reweighting is flagged") + args = ap.parse_args(argv) + + trajs = load_trajectories(args.files, args.dt, args.qu, args.qf) + print(f"{len(trajs)} trajectories, " + f"{sum(t['fold'] is None for t in trajs)} censored (never reach Qf={args.qf})") + os.makedirs(args.out, exist_ok=True) + rng = np.random.default_rng(args.seed) + lams = np.linspace(0.0, args.lam_max, args.nlam) + grid, qref = qts_grid(args) + + results = [] + for q in grid: + row, A, w, cv, neff = scan(trajs, q, args, rng, lams) + results.append(row) + if np.isclose(q, qref): + ref, ref_A, ref_w, ref_cv, ref_neff = row, A, w, cv, neff + cols = ["qts", "N", "n_done", "sum_k", "kmax", "p", "geom_p", "lag1_rho", "lag1_p", + "cv0", "cv_lammax", "ks_p0", "lam_star", "lam_lo", "lam_hi", "boot_noroot", + "neff_star", "ks_p_star", "reweight_ok", "geom_status", "lag1_status", + "reweight_status", "note"] + write_csv(os.path.join(args.out, "summary.csv"), cols, results) + + print(f"\n{'Q‡':>6} {'p':>6} {'CV0':>5} {'CV(max)':>8} {'lam*':>6} {'95% CI':>13} " + f"{'N_eff':>6} {'KSp*':>6} status") + for r in results: + ci = f"[{r['lam_lo']:.2f},{r['lam_hi']:.2f}]" if np.isfinite(r["lam_star"]) else "-" + print(f"{r['qts']:6.3f} {r['p']:6.3f} {r['cv0']:5.2f} {r['cv_lammax']:8.2f} " + f"{r['lam_star']:6.2f} {ci:>13} {r['neff_star']:6.1f} {r['ks_p_star']:6.3f}" + f" {r['reweight_status']}" + (" *ref" if np.isclose(r["qts"], qref) else "")) + if ref["reweight_status"] == "no_root": + print(f"\nreweighting: the weighted CV only reaches {ref['cv_lammax']:.2f}. The tilt can" + f" only reshuffle the observed attempt counts (max k = {ref['kmax']}) and the" + " weights saturate at (1-p)^-k, so the geometric tail of a higher barrier is" + " not in the data. Use maxcal-stitch.") + elif ref["reweight_status"] == "cv_ge_1_at_lambda0": + print("\nNOTE: CV >= 1 already at lambda = 0; a missing barrier does not explain the" + " deviation (look for intermediates or parallel routes).") + elif ref["reweight_status"] == "low_neff": + print(f"\nWARNING: N_eff = {ref['neff_star']:.1f} < {args.neff_min} at lambda*;" + " the reweighted ensemble rests on few trajectories.") + + with open(os.path.join(args.out, f"weights_qts{qref:.3f}.csv"), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["trajectory", "k_failed", "time", "completed", "weight_at_lambda_star"]) + for j, i in enumerate(ref_A["idx"]): + wr.writerow([trajs[i]["path"], ref_A["k"][j], f"{ref_A['T'][j]:.6g}", + int(ref_A["done"][j]), f"{ref_w[j]:.6g}"]) + pos = {i: j for j, i in enumerate(ref_A["idx"])} + with open(os.path.join(args.out, f"tse_frames_qts{qref:.3f}.csv"), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["trajectory", "frame", "time", "k_failed", "weight_at_lambda_star"]) + for i, fr in ref_A["tse"]: + j = pos[i] + wr.writerow([trajs[i]["path"], fr, f"{fr * trajs[i]['dt']:.6g}", + ref_A["k"][j], f"{ref_w[j]:.6g}"]) + + fig, ax = plt.subplots(figsize=(5.5, 4.2)) + x = np.linspace(0, 5, 200) + ax.semilogy(x, np.exp(-x), "k--", lw=1, label="exponential") + for wt, lab in [(np.full(ref_A["k"].size, 1.0 / ref_A["k"].size), "original")] + \ + ([(ref_w, f"reweighted, lambda* = {ref['lam_star']:.2f} kT")] + if np.isfinite(ref["lam_star"]) else []): + ts, S, _ = weighted_km(ref_A["T"], ref_A["done"], wt) + tau = np.sum(wt * ref_A["T"]) / np.sum(wt * ref_A["done"]) + ax.step(np.r_[0, ts / tau], np.r_[1, S], where="post", label=lab) + ax.set_xlim(0, 5); ax.set_ylim(1e-2, 1.05) + ax.set_xlabel("t / "); ax.set_ylabel("survival S(t)") + ax.set_title(f"Weighted survival, Q‡ = {qref:.3f}") + ax.legend(fontsize=8); fig.tight_layout() + fig.savefig(os.path.join(args.out, "survival.png"), dpi=150); plt.close(fig) + + fig, axs = plt.subplots(2, 1, figsize=(5.5, 6), sharex=True) + axs[0].plot(lams, ref_cv); axs[0].axhline(1, color="k", ls="--", lw=1) + axs[0].set_ylabel("weighted CV") + axs[1].plot(lams, ref_neff, color="C2") + axs[1].axhline(args.neff_min, color="r", ls=":", lw=1) + axs[1].set_ylabel("N_eff"); axs[1].set_xlabel("lambda (kT)") + for a in axs: + if np.isfinite(ref["lam_star"]): + a.axvline(ref["lam_star"], color="C1", lw=1) + axs[0].set_title("lambda* where the weighted CV reaches 1" + if np.isfinite(ref["lam_star"]) else "no root: CV never reaches 1") + fig.tight_layout(); fig.savefig(os.path.join(args.out, "lambda_scan.png"), dpi=150) + plt.close(fig) + print(f"\nWrote summary.csv, weights_*.csv, tse_frames_*.csv, survival.png, " + f"lambda_scan.png to {args.out}/") + + +if __name__ == "__main__": + main() diff --git a/maxcal/stitching.py b/maxcal/stitching.py new file mode 100644 index 0000000..0b354d0 --- /dev/null +++ b/maxcal/stitching.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python3 +"""maxcal-stitch - recover two-state (Poisson) kinetics by thinning barrier crossings. + +Each folding/binding event is rebuilt as a geometric(p') number of resampled failure +cycles plus one success segment (README 2.5). Reports, for every attempt interface Q‡ on +a scan grid: the attempt statistics and their independence tests, the smallest lambda whose +stitched first-passage times pass the Poisson criterion (lambda_min, a LOWER bound on the +missing barrier), and the (Q‡, lambda) decision map. + +Example: + maxcal-stitch "runs/q_*.xvg" --qu 0.3 --qf 0.8 --qts 0.4 --out stitch_out +""" +import argparse +import csv +import os + +import numpy as np +from scipy import stats + +import matplotlib.pyplot as plt # backend set in main() + +from .core import (attempts, success_prob, tilted_p, null_D, D_rows, lilliefors_p, + ks_exp_weighted, weighted_km, geometric_test, geom_status, lag1_status, + stitch_status, add_common_args, load_trajectories, qts_grid, write_csv) + + +def stitch(pp, cycles, succ, M, rng, kexact=500): + """Synthetic first-passage times: Geom(pp) failures of resampled cycles + one success.""" + k = rng.geometric(pp, size=M) - 1 + out = rng.choice(succ, size=M).astype(float) + small = k <= kexact + ks = k[small] + if ks.sum() > 0: + draws = rng.choice(cycles, size=int(ks.sum())) + out[small] += np.bincount(np.repeat(np.arange(ks.size), ks), + weights=draws, minlength=ks.size) + kb = k[~small] + if kb.size: # CLT for very long sums + out[~small] += rng.normal(kb * cycles.mean(), np.sqrt(kb) * cycles.std()) + return out + + +def stitch_scan(lams, p, A, n_sub_size, args, rng): + """Smallest lambda at which stitched times are Poisson (median KS p >= alpha, |CV-1| <= tol).""" + res = [] + lam_pass, streak = np.nan, 0 + if A["fail_pool"].size == 0 or A["succ_pool"].size == 0: + return lam_pass, res + for lam in lams: + pp = tilted_p(p, lam) + if (1 - pp) / pp > 1e7: + break + t = stitch(pp, A["fail_pool"], A["succ_pool"], args.nstitch, rng) + cv = t.std() / t.mean() + sub = rng.choice(t, size=(args.nsub, n_sub_size)) + null = null_D(n_sub_size) + pv = (np.sum(null[None, :] >= D_rows(sub)[:, None], axis=1) + 1) / (null.size + 1) + mp = float(np.median(pv)) + res.append((lam, cv, mp)) + ok = mp >= args.alpha and abs(cv - 1) <= args.cv_tol + if ok: + if streak == 0: + first = lam + streak += 1 + if streak >= 3: # stable: first of 3 consecutive passes + lam_pass = first + break + else: + streak = 0 + return lam_pass, res + + + +def ks_heatmap(trajs, qts_grid, lams, args, rng): + """Median stitched KS p-value and CV on a (Q‡, lambda) grid. Each cell stitches + args.nstitch folding times with the tilted success probability at that Q‡ and + tests subsamples of the original size, exactly as stitch_scan does.""" + ksp = np.full((qts_grid.size, lams.size), np.nan) + cv = np.full_like(ksp, np.nan) + for i, q in enumerate(qts_grid): + A = attempts(trajs, q, args.t0, args.include_initial) + if A["fail_pool"].size == 0 or A["succ_pool"].size == 0: + continue # empty_pool: NaN column + p = success_prob(A["k"], A["done"]) + n = A["k"].size + null = null_D(n) + for j, lam in enumerate(lams): + pp = tilted_p(p, lam) + if (1 - pp) / pp > 1e7: + break + t = stitch(pp, A["fail_pool"], A["succ_pool"], args.nstitch, rng) + sub = rng.choice(t, size=(args.nsub, n)) + pv = (np.sum(null[None, :] >= D_rows(sub)[:, None], axis=1) + 1) / (null.size + 1) + ksp[i, j], cv[i, j] = np.median(pv), t.std() / t.mean() + return ksp, cv + + +def write_heatmap(qts_grid, lams, ksp, cv, results, trajs, args): + from .committor import committor_frames, committor_profile, q_at + _, _, qv, oc = committor_frames(trajs, args.qu, args.qf) + centers, _, _, iso = committor_profile(qv, oc, args.qu, args.qf, 20) + com = dict(Q_barrier=q_at(centers, iso, args.barrier_q)) + passed = (ksp >= args.alpha) & (np.abs(cv - 1) <= args.cv_tol) + with open(os.path.join(args.out, "heatmap.csv"), "w", newline="") as fh: + wr = csv.writer(fh, lineterminator="\n") + wr.writerow(["qts", "lambda", "median_ks_p", "cv", "poisson_pass", "qts_valid"]) + for i, q in enumerate(qts_grid): + valid = bool(q < com["Q_barrier"]) if np.isfinite(com["Q_barrier"]) else True + for j, lam in enumerate(lams): + wr.writerow([f"{q:.4g}", f"{lam:.4g}", f"{ksp[i, j]:.4g}", f"{cv[i, j]:.4g}", + int(passed[i, j]), int(valid)]) + + from matplotlib.colors import LogNorm + fig, ax = plt.subplots(figsize=(7.5, 4.8)) + dq = np.diff(qts_grid).min() if qts_grid.size > 1 else 0.05 + dl = np.diff(lams).min() if lams.size > 1 else 0.5 + qe = np.r_[qts_grid - dq / 2, qts_grid[-1] + dq / 2] + le = np.r_[lams - dl / 2, lams[-1] + dl / 2] + im = ax.pcolormesh(qe, le, np.clip(ksp.T, 1e-4, 1), norm=LogNorm(1e-4, 1), cmap="viridis", + shading="flat") + fig.colorbar(im, ax=ax, label="median KS p (stitched)") + from matplotlib.patches import Rectangle + for i, j in zip(*np.nonzero(passed)): # hatch exactly the passing cells + ax.add_patch(Rectangle((qe[i], le[j]), qe[i + 1] - qe[i], le[j + 1] - le[j], fill=False, + hatch="//", edgecolor="white", lw=0, alpha=0.7)) + lm = [r["lam_stitch"] for r in results] + ax.plot([r["qts"] for r in results], lm, "w^-", ms=6, mec="k", label="λ_min(Q‡)") + if np.isfinite(com["Q_barrier"]): + ax.axvspan(com["Q_barrier"], qe[-1], color="0.2", alpha=0.45, lw=0, + label=f"Q‡ beyond assumed barrier (q*={args.barrier_q:.2f}): invalid") + ax.axvline(com["Q_barrier"], color="k", lw=1) + ax.set_xlim(qe[0], qe[-1]); ax.set_ylim(le[0], le[-1]) + ax.set_xlabel("attempt interface Q‡"); ax.set_ylabel("λ (kT)") + ax.set_title("Poisson decision map: hatched = passes (KS p ≥ α and |CV−1| ≤ tol)\n" + "the TS lies between Q‡ and Qf, so only Q‡ before the barrier is meaningful", + fontsize=9) + ax.legend(fontsize=7, loc="upper left") + fig.tight_layout(); fig.savefig(os.path.join(args.out, "heatmap.png"), dpi=150); plt.close(fig) + return passed + + + +def scan(trajs, qts, args, rng, lams): + """Attempt statistics and lambda_min at one interface.""" + A = attempts(trajs, qts, args.t0, args.include_initial) + k, T, done = A["k"], A["T"], A["done"] + p = success_prob(k, done) + Tc = T[done] + D0, _ = ks_exp_weighted(T, done, np.full(k.size, 1.0 / k.size)) + out = dict(qts=qts, N=int(k.size), n_done=int(done.sum()), sum_k=int(k.sum()), + kmax=int(k.max()) if k.size else 0, p=p, + frac_k0=float(np.mean(k[done] == 0)) if done.any() else np.nan, + cv0=float(Tc.std() / Tc.mean()) if Tc.size else np.nan, + ks_p0=lilliefors_p(D0, k.size), note=A["note"]) + out["geom_p"], _ = geometric_test(k[done]) + out["geom_status"] = geom_status(int(done.sum()), out["geom_p"]) + pr = A["pairs"] + out["lag1_status"] = lag1_status(pr) + out["lag1_rho"], out["lag1_p"] = (stats.spearmanr(pr[:, 0], pr[:, 1]) + if out["lag1_status"] == "ok" else (np.nan, np.nan)) + lam, rows = stitch_scan(lams, p, A, k.size, args, rng) + out["lam_stitch"] = lam + out["p_stitch"] = tilted_p(p, lam) if np.isfinite(lam) else np.nan + out["cv_stitch0"], out["ksp_stitch0"] = (rows[0][1], rows[0][2]) if rows else (np.nan, np.nan) + out["stitch_status"] = stitch_status(lam, A["fail_pool"].size, A["succ_pool"].size, A["note"]) + return out, A + + +def survival_plot(A, lam, path, qref): + fig, ax = plt.subplots(figsize=(5.5, 4.2)) + x = np.linspace(0, 5, 200) + ax.semilogy(x, np.exp(-x), "k--", lw=1, label="exponential") + w = np.full(A["k"].size, 1.0 / A["k"].size) + ts, S, _ = weighted_km(A["T"], A["done"], w) + tau = np.sum(w * A["T"]) / np.sum(w * A["done"]) + ax.step(np.r_[0, ts / tau], np.r_[1, S], where="post", label="original") + if np.isfinite(lam) and A["fail_pool"].size and A["succ_pool"].size: + p = success_prob(A["k"], A["done"]) + t = stitch(tilted_p(p, lam), A["fail_pool"], A["succ_pool"], 20000, + np.random.default_rng(0)) + tt = np.sort(t) / t.mean() + ax.step(tt, 1 - np.arange(1, tt.size + 1) / tt.size, where="post", + label=f"stitched, lambda = {lam:.2f} kT") + ax.set_xlim(0, 5); ax.set_ylim(1e-2, 1.05) + ax.set_xlabel("t / "); ax.set_ylabel("survival S(t)") + ax.set_title(f"Folding-time survival, Q‡ = {qref:.3f}") + ax.legend(fontsize=8); fig.tight_layout(); fig.savefig(path, dpi=150); plt.close(fig) + + +def main(argv=None): + plt.switch_backend("Agg") + ap = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + add_common_args(ap) + ap.add_argument("--lam-max", type=float, default=10.0, help="largest lambda (kT) scanned") + ap.add_argument("--nlam", type=int, default=201) + ap.add_argument("--nstitch", type=int, default=5000, help="synthetic times per lambda") + ap.add_argument("--nsub", type=int, default=200, help="KS subsamples (size = #trajectories)") + ap.add_argument("--heatmap-nlam", type=int, default=21, + help="lambda values in the (Q‡, lambda) decision map (0 disables)") + ap.add_argument("--heatmap-lam-max", type=float, default=5.0) + ap.add_argument("--barrier-q", type=float, default=0.5, + help="assumed barrier location (model committor value) used to mark the " + "valid Q‡ range in the decision map") + args = ap.parse_args(argv) + + trajs = load_trajectories(args.files, args.dt, args.qu, args.qf) + n_cens = sum(t["fold"] is None for t in trajs) + print(f"{len(trajs)} trajectories, {n_cens} censored (never reach Qf={args.qf})") + os.makedirs(args.out, exist_ok=True) + rng = np.random.default_rng(args.seed) + lams = np.linspace(0.0, args.lam_max, args.nlam) + grid, qref = qts_grid(args) + + results, ref_A = [], None + for q in grid: + row, A = scan(trajs, q, args, rng, lams) + results.append(row) + if np.isclose(q, qref): + ref_A, ref = A, row + cols = ["qts", "N", "n_done", "sum_k", "kmax", "frac_k0", "p", "geom_p", "lag1_rho", + "lag1_p", "cv0", "ks_p0", "cv_stitch0", "ksp_stitch0", "lam_stitch", "p_stitch", + "geom_status", "lag1_status", "stitch_status", "note"] + write_csv(os.path.join(args.out, "summary.csv"), cols, results) + + print(f"\n{'Q‡':>6} {'p':>6} {'geom_p':>7} {'CV0':>5} {'KSp0':>6} {'lam_min':>8} {'status':>12}") + for r in results: + print(f"{r['qts']:6.3f} {r['p']:6.3f} {r['geom_p']:7.3f} {r['cv0']:5.2f} " + f"{r['ks_p0']:6.3f} {r['lam_stitch']:8.2f} {r['stitch_status']:>12}" + + (" *ref" if np.isclose(r['qts'], qref) else "")) + if np.isfinite(ref["geom_p"]) and ref["geom_p"] < args.alpha: + print("\nWARNING: failed-attempt counts are not geometric -> attempts have memory;" + " Poisson statistics after tilting would be imposed, not recovered.") + if np.isfinite(ref["ksp_stitch0"]) and ref["ksp_stitch0"] >= args.alpha \ + and abs(ref["cv_stitch0"] - 1) <= args.cv_tol: + print("\nNOTE: already Poisson at lambda = 0 (initial segments removed): the original" + " deviation is mostly the initial relaxation, not a missing barrier.") + + survival_plot(ref_A, ref["lam_stitch"], os.path.join(args.out, "survival.png"), qref) + fig, ax = plt.subplots(figsize=(5.5, 3.8)) + ax.plot([r["qts"] for r in results], [r["lam_stitch"] for r in results], "s--") + ax.set_xlabel("Q‡"); ax.set_ylabel("lambda_min (kT)") + ax.set_title("robustness of lambda_min to the attempt interface") + fig.tight_layout(); fig.savefig(os.path.join(args.out, "robustness_qts.png"), dpi=150) + plt.close(fig) + + if args.heatmap_nlam > 0: + lams_h = np.linspace(0.0, args.heatmap_lam_max, args.heatmap_nlam) + ksp, cvh = ks_heatmap(trajs, grid, lams_h, args, rng) + passed = write_heatmap(grid, lams_h, ksp, cvh, results, trajs, args) + print(f"\n(Q‡, lambda) decision map: {int(passed.sum())}/{passed.size} cells pass" + " -> heatmap.png") + print(f"\nWrote summary.csv, survival.png, robustness_qts.png" + + (", heatmap.csv/.png" if args.heatmap_nlam > 0 else "") + f" to {args.out}/") + + +if __name__ == "__main__": + main() diff --git a/maxcal_target.py b/maxcal/target.py similarity index 98% rename from maxcal_target.py rename to maxcal/target.py index 6720504..589534e 100644 --- a/maxcal_target.py +++ b/maxcal/target.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 """ -maxcal_target.py - reweight binding/unbinding (or folding/unfolding) trajectories so that +maxcal-target - reweight binding/unbinding (or folding/unfolding) trajectories so that their first-passage times match experimental rates AND a Poisson (single-exponential) target, then use the weights for structural analysis. @@ -30,7 +30,7 @@ model's own time units (ps, ns, ...), in the order of the trajectories. Example: - python maxcal_target.py systems.csv --conc 0.017 --clock decrease-only --out target_out + maxcal-target systems.csv --conc 0.017 --clock decrease-only --out target_out """ import argparse import csv diff --git a/maxcal_poisson.py b/maxcal_poisson.py deleted file mode 100644 index b727398..0000000 --- a/maxcal_poisson.py +++ /dev/null @@ -1,803 +0,0 @@ -#!/usr/bin/env python3 -""" -maxcal_poisson.py - MaxCal barrier-tilt analysis of first-passage folding trajectories. - -Model assumption: the simulations (e.g. multi-eGO) sample structures correctly but -underestimate the barrier between U and F. The minimal (maximum-caliber) path -reweighting that raises the barrier at a dividing surface Q‡ multiplies the success -odds of every attempt by exp(-lambda). lambda is an effective log-odds shift -(it approaches DDF‡/kT only in the high-barrier limit; see README). For first-passage -paths (trajectories stopped at folding) this gives per-trajectory weights - - completed trajectory with k failed attempts : w ∝ c^(k+1) exp(-lambda) - censored trajectory with k failed attempts : w ∝ c^k - c = 1 / (1 - p (1 - exp(-lambda))) - -where p is the model success probability per attempt. An "attempt" at Q‡ is an -excursion out of U (Q < Qu) that gets past Q‡ (place Q‡ at the FOOT of the -missing barrier, on the U side - see README); it fails if it returns below Qu -before reaching Qf. - -For each Q‡ on a grid the script: - 1. counts failed attempts k_i per trajectory, - 2. tests attempt independence (k_i geometric? lag-1 correlation of cycle times), - 3. reweights: scans lambda, finds lambda* where the weighted CV of folding times = 1, - reports N_eff and a Lilliefors-type KS p-value vs an exponential, - 4. stitches: builds synthetic first-passage times from resampled cycles with the - tilted success probability, finds the smallest lambda giving Poisson statistics, - 5. bootstraps lambda* over trajectories, -and writes the transition-state frames (last upward crossing of --qtse, default Q‡) -with their weights. - -Input: one file per trajectory, either one column Q (then give --dt) or two columns -(time, Q). Lines starting with '#' or '@' (GROMACS .xvg) are ignored. -Trajectories are assumed to stop at folding (Q >= Qf); those that never reach Qf are -treated as right-censored. - -Example: - python maxcal_poisson.py "runs/q_*.xvg" --qu 0.3 --qf 0.8 --out results -""" -import argparse -import csv -import glob -import os -import sys -import warnings - -import numpy as np -from scipy import stats -from scipy.special import logsumexp - -import matplotlib.pyplot as plt # backend set to Agg in main(), not at import - - -# ----------------------------------------------------------------------------- I/O -def load_traj(path, dt_arg): - data = np.loadtxt(path, comments=("#", "@")) - if data.ndim == 1: - if dt_arg is None: - sys.exit(f"{path}: single column of Q, please pass --dt") - return data.astype(float), float(dt_arg) - t, q = data[:, 0], data[:, 1] - if dt_arg is not None: - return q.astype(float), float(dt_arg) - d = np.diff(t) - dt = float(np.median(d)) if d.size else 1.0 - if d.size and np.max(np.abs(d - dt)) > 1e-6 * abs(dt): - warnings.warn(f"{path}: non-uniform time spacing, using median dt={dt}") - return q.astype(float), dt - - -def parse_traj(q, qu, qf): - """Folding frame (first Q >= Qf, or None) and failed excursions [start, end, maxQ]. - An excursion is a run with Q >= Qu that starts from U and returns below Qu - before Qf. 'end' is the first frame back in U.""" - hit = np.flatnonzero(q >= qf) - fold = int(hit[0]) if hit.size else None - qq = q[:fold] if fold is not None else q - if qq.size == 0: - return fold, np.empty((0, 3)) - below = qq < qu - change = np.flatnonzero(np.diff(below.astype(np.int8))) + 1 - starts = np.r_[0, change] - ends = np.r_[change, qq.size] - maxq = np.maximum.reduceat(qq, starts) - # above-Qu runs that were entered from U (start > 0) and left back to U (end < size) - m = (~below[starts]) & (starts > 0) & (ends < qq.size) - return fold, np.column_stack([starts[m], ends[m], maxq[m]]).astype(float) - - -# ------------------------------------------------------------------ per-Q‡ attempts -def attempts(trajs, qts, t0, include_initial, qtse=None): - qtse = qts if qtse is None else qtse - rows = [] - fail_cyc, fail_init, succ, succ_init, pairs, tse = [], [], [], [], [], [] - for i, tr in enumerate(trajs): - dt, fold, F = tr["dt"], tr["fold"], tr["fails"] - f0 = int(np.ceil(t0 / dt)) if t0 > 0 else 0 - if fold is not None and fold < f0: - continue # folded during the discarded initial window - sel = (F[:, 2] >= qts) & (F[:, 1] > f0) if len(F) else np.zeros(0, bool) - ends = F[sel, 1].astype(int) - end_frame = fold if fold is not None else tr["n"] - bounds = np.r_[f0, ends] - segs = np.diff(bounds) * dt - if segs.size: - fail_init.append(segs[0]) - cyc = segs[1:] - fail_cyc.extend(cyc) - pairs.extend(zip(cyc[:-1], cyc[1:])) - done = fold is not None - if done: - last = (fold - bounds[-1]) * dt - (succ if ends.size else succ_init).append(last) - seg = tr["q"][bounds[-1]:fold] - b = np.flatnonzero(seg < qtse) - tse.append((i, int(bounds[-1] + (b[-1] + 1 if b.size else 0)))) - rows.append((i, ends.size, (end_frame - f0) * dt, done)) - idx = np.array([r[0] for r in rows], int) - k = np.array([r[1] for r in rows], int) - T = np.array([r[2] for r in rows], float) - done = np.array([r[3] for r in rows], bool) - - fail_pool = np.array(fail_cyc) - succ_pool = np.array(succ) - note = [] - if include_initial or fail_pool.size < 10: - if not include_initial and fail_pool.size < 10: - note.append("failure pool <10: initial segments included") - fail_pool = np.r_[fail_pool, fail_init] - if include_initial or succ_pool.size < 10: - if not include_initial and succ_pool.size < 10: - note.append("success pool <10: initial segments included") - succ_pool = np.r_[succ_pool, succ_init] - return dict(idx=idx, k=k, T=T, done=done, fail_pool=fail_pool, - succ_pool=succ_pool, pairs=np.array(pairs), tse=tse, note="; ".join(note)) - - -# --------------------------------------------------------------------- statistics -def success_prob(k, done): - return done.sum() / (done.sum() + k.sum()) - - -def log_weights(lams, k, done, p): - """Normalized log weights, shape (len(lams), N).""" - lams = np.atleast_1d(lams) - lc = -np.log1p(-p * (-np.expm1(-lams))) # log c - lw = np.outer(lc, k) + np.outer(lc - lams, done.astype(float)) - return lw - logsumexp(lw, axis=1, keepdims=True) - - -def tilted_p(p, lam): - return p * np.exp(-lam) / (1.0 - p * (-np.expm1(-lam))) - - -def cv_curve(lams, k, T, done, p): - """Weighted CV of completed folding times and N_eff (all trajectories).""" - lw = log_weights(lams, k, done, p) - w = np.exp(lw) - neff = 1.0 / np.sum(w ** 2, axis=1) - wc = w[:, done] - wc = wc / wc.sum(axis=1, keepdims=True) - Tc = T[done] - m = wc @ Tc - var = wc @ (Tc ** 2) - m ** 2 - return np.sqrt(np.clip(var, 0, None)) / m, neff - - -def first_crossing(x, y, level=1.0): - """Linear interpolation of first x where y reaches level from below.""" - if y[0] >= level: - return x[0] - j = np.flatnonzero(y >= level) - if j.size == 0: - return np.nan - j = j[0] - return x[j - 1] + (level - y[j - 1]) * (x[j] - x[j - 1]) / (y[j] - y[j - 1]) - - -def weighted_km(t, done, w): - o = np.argsort(t, kind="stable") - t, d, w = t[o], done[o], w[o] - at_risk = np.cumsum(w[::-1])[::-1] - S = np.cumprod(np.where(d, 1.0 - w / at_risk, 1.0)) - return t, S, d - - -def ks_exp_weighted(t, done, w): - """Sup distance between weighted KM survival and exponential with MLE tau.""" - tau = np.sum(w * t) / np.sum(w * done) - ts, S, d = weighted_km(t, done, w) - E = np.exp(-ts / tau) - Sprev = np.r_[1.0, S[:-1]] - D = np.max(np.maximum(np.abs(S - E), np.abs(Sprev - E))[d]) - return D, tau - - -_NULL = {} - - -def null_D(n, nsim=4000): - """Null distribution of the KS statistic for an exponential with fitted scale - (Lilliefors); scale-free, so simulated once per n.""" - n = int(max(n, 3)) - if n not in _NULL: - r = np.random.default_rng(12345) - _NULL[n] = np.sort(D_rows(r.exponential(size=(nsim, n)))) - return _NULL[n] - - -def D_rows(x): - """KS distance to fitted exponential, one sample per row (uncensored).""" - x = np.sort(x, axis=1) - n = x.shape[1] - F = 1.0 - np.exp(-x / x.mean(axis=1, keepdims=True)) - i = np.arange(1, n + 1) - return np.max(np.maximum(i / n - F, F - (i - 1) / n), axis=1) - - -def lilliefors_p(D, n): - null = null_D(n) - return (np.sum(null >= D) + 1) / (null.size + 1) - - -def geometric_test(k): - """Chi-square test that failed-attempt counts are geometric (independent attempts).""" - n = k.size - if n < 10: - return np.nan, 0 - p = n / (n + k.sum()) - obs, prob, tail, j = [], [], 1.0, 0 - while True: - pj = p * (1 - p) ** j - if n * pj < 5 or n * (tail - pj) < 5: - break - obs.append(np.sum(k == j)); prob.append(pj); tail -= pj; j += 1 - obs.append(np.sum(k >= j)); prob.append(tail) - if len(obs) < 3: - return np.nan, len(obs) - exp = n * np.array(prob) - chi2 = np.sum((np.array(obs) - exp) ** 2 / exp) - dof = len(obs) - 2 - return stats.chi2.sf(chi2, dof), len(obs) - - -def stitch(pp, cycles, succ, M, rng, kexact=500): - """Synthetic first-passage times: Geom(pp) failures of resampled cycles + one success.""" - k = rng.geometric(pp, size=M) - 1 - out = rng.choice(succ, size=M).astype(float) - small = k <= kexact - ks = k[small] - if ks.sum() > 0: - draws = rng.choice(cycles, size=int(ks.sum())) - out[small] += np.bincount(np.repeat(np.arange(ks.size), ks), - weights=draws, minlength=ks.size) - kb = k[~small] - if kb.size: # CLT for very long sums - out[~small] += rng.normal(kb * cycles.mean(), np.sqrt(kb) * cycles.std()) - return out - - -def stitch_scan(lams, p, A, n_sub_size, args, rng): - """Smallest lambda at which stitched times are Poisson (median KS p >= alpha, |CV-1| <= tol).""" - res = [] - lam_pass, streak = np.nan, 0 - if A["fail_pool"].size == 0 or A["succ_pool"].size == 0: - return lam_pass, res - for lam in lams: - pp = tilted_p(p, lam) - if (1 - pp) / pp > 1e7: - break - t = stitch(pp, A["fail_pool"], A["succ_pool"], args.nstitch, rng) - cv = t.std() / t.mean() - sub = rng.choice(t, size=(args.nsub, n_sub_size)) - null = null_D(n_sub_size) - pv = (np.sum(null[None, :] >= D_rows(sub)[:, None], axis=1) + 1) / (null.size + 1) - mp = float(np.median(pv)) - res.append((lam, cv, mp)) - ok = mp >= args.alpha and abs(cv - 1) <= args.cv_tol - if ok: - if streak == 0: - first = lam - streak += 1 - if streak >= 3: # stable: first of 3 consecutive passes - lam_pass = first - break - else: - streak = 0 - return lam_pass, res - - -# ------------------------------------------------------- committor and TS location -# The tilt fixes how much barrier is missing (p'/p) but not WHERE it sits. For a -# narrow missing barrier on a model isocommittor surface q_m = q* (README §2.10) the -# corrected committor is, exactly for diffusive dynamics away from the barrier, -# q'(x) = r q_m(x) on the U side (q_m < q*) -# q'(x) = 1 - r (1 - q_m(x)) on the F side (q_m > q*), r = p'/p, -# so the transition state moves to the barrier location whenever the jump across it -# straddles 1/2. q* (the barrier location) is an assumption, not an output. - -def committor_frames(trajs, qu, qf): - """Frames inside excursions out of U, labelled by the outcome of their excursion - (1 = reaches Qf before returning below Qu). For a frame x this outcome is a - sample of the committor q(x). Returns arrays (traj index, frame, Q, outcome).""" - ti, fr, qq, oo = [], [], [], [] - for i, tr in enumerate(trajs): - q, F = tr["q"], tr["fails"] - for s, e, _ in F: - s, e = int(s), int(e) - idx = np.arange(s, e) - ti.append(np.full(idx.size, i)); fr.append(idx); qq.append(q[idx]); oo.append(np.zeros(idx.size)) - f = tr["fold"] - if f is not None: - inU = np.flatnonzero(q[:f] < qu) - s = inU[-1] + 1 if inU.size else 0 - idx = np.arange(s, f) - ti.append(np.full(idx.size, i)); fr.append(idx); qq.append(q[idx]); oo.append(np.ones(idx.size)) - cat = lambda a, dt: np.concatenate(a).astype(dt) if a else np.zeros(0, dt) - return cat(ti, int), cat(fr, int), cat(qq, float), cat(oo, float) - - -def isotonic(y, w): - """Weighted non-decreasing fit (pool-adjacent-violators).""" - blocks = [] # [value, weight, length] - for yi, wi in zip(y, w): - blocks.append([yi, wi, 1]) - while len(blocks) > 1 and blocks[-2][0] > blocks[-1][0]: - v2, w2, n2 = blocks.pop(); v1, w1, n1 = blocks.pop() - wt = w1 + w2 - blocks.append([(v1 * w1 + v2 * w2) / wt if wt > 0 else 0.5 * (v1 + v2), wt, n1 + n2]) - return np.concatenate([np.full(n, v) for v, _, n in blocks]) - - -def committor_profile(qvals, outcome, qu, qf, nbins): - edges = np.linspace(qu, qf, nbins + 1) - b = np.clip(np.digitize(qvals, edges) - 1, 0, nbins - 1) - n = np.bincount(b, minlength=nbins).astype(float) - s = np.bincount(b, weights=outcome, minlength=nbins) - raw = np.where(n > 0, s / np.maximum(n, 1), np.nan) - ok = n > 0 - iso = np.full(nbins, np.nan) - iso[ok] = isotonic(raw[ok], n[ok]) - return 0.5 * (edges[1:] + edges[:-1]), n, raw, iso - - -def corrected_committor(qm, r, qstar): - qm = np.asarray(qm, float) - return np.where(qm < qstar, r * qm, 1.0 - r * (1.0 - qm)) - - -def q_at(centers, q_iso, level): - """Q where the (monotone) model committor reaches `level` (linear interpolation).""" - ok = np.isfinite(q_iso) - c, q = centers[ok], q_iso[ok] - if q.size == 0 or level < q[0] or level > q[-1]: - return np.nan - j = np.flatnonzero(q >= level)[0] - if j == 0 or q[j] == q[j - 1]: - return c[j] - return c[j - 1] + (level - q[j - 1]) * (c[j] - c[j - 1]) / (q[j] - q[j - 1]) - - -def ts_location(centers, q_iso, r, qstar): - """Location of the corrected transition state q' = 1/2, and which part of the - corrected committor puts it there ('barrier', 'U_side', 'F_side').""" - if r * qstar <= 0.5 <= 1.0 - r * (1.0 - qstar): - return q_at(centers, q_iso, qstar), "barrier" # the jump straddles 1/2 - if r * qstar > 0.5: # reached 1/2 before the barrier - return q_at(centers, q_iso, 0.5 / r), "U_side" - return q_at(centers, q_iso, 1.0 - 0.5 / r), "F_side" - - -# ------------------------------------------------------------------ status flags -# Every NaN in summary.csv comes with a reason in one of these columns. -def geom_status(n, pval): - if n < 10: - return "too_few_trajectories" - return "too_few_bins" if not np.isfinite(pval) else "ok" - - -def lag1_status(pairs): - """pairs: (n, 2) array of consecutive failure-cycle durations within trajectories.""" - if len(pairs) < 10: - return "too_few_pairs" - if np.ptp(pairs[:, 0]) == 0 or np.ptp(pairs[:, 1]) == 0: - return "constant_cycles" # correlation undefined - return "ok" - - -def reweight_status(cv0, lam_star, neff, neff_min): - if cv0 >= 1: - return "cv_ge_1_at_lambda0" # already over-dispersed: a missing barrier can't explain it - if not np.isfinite(lam_star): - return "no_root" # CV never reaches 1: observed attempt counts too few - if not neff >= neff_min: - return "low_neff" - return "ok" - - -def stitch_status(lam_stitch, n_fail_pool, n_succ_pool, pool_note): - if n_fail_pool == 0 or n_succ_pool == 0: - return "empty_pool" # no failed attempts past this Q‡ (at/after the barrier?) - if not np.isfinite(lam_stitch): - return "no_pass" - return "ok_pool_fallback" if pool_note else "ok" # fallback: initial segments were used - - -# --------------------------------------------------------------------------- main -def analyse(trajs, qts, args, rng, lams, full=False): - A = attempts(trajs, qts, args.t0, args.include_initial, args.qtse) - k, T, done = A["k"], A["T"], A["done"] - p = success_prob(k, done) - out = dict(qts=qts, N=k.size, n_done=int(done.sum()), sum_k=int(k.sum()), - frac_k0=float(np.mean(k[done] == 0)) if done.any() else np.nan, p=p, - note=A["note"]) - out["geom_p"], out["geom_bins"] = geometric_test(k[done]) - out["geom_status"] = geom_status(int(done.sum()), out["geom_p"]) - pr = A["pairs"] - out["lag1_status"] = lag1_status(pr) - out["lag1_rho"], out["lag1_p"] = (stats.spearmanr(pr[:, 0], pr[:, 1]) - if out["lag1_status"] == "ok" else (np.nan, np.nan)) - - cv, neff = cv_curve(lams, k, T, done, p) - lam_star = first_crossing(lams, cv) - out.update(cv0=cv[0], lam_star=lam_star) - w0 = np.full(k.size, 1.0 / k.size) - D0, _ = ks_exp_weighted(T, done, w0) - out["ks_p0"] = lilliefors_p(D0, k.size) - if np.isfinite(lam_star): - w = np.exp(log_weights(lam_star, k, done, p)[0]) - out["neff_star"] = 1.0 / np.sum(w ** 2) - D, _ = ks_exp_weighted(T, done, w) - out["ks_p_star"] = lilliefors_p(D, round(out["neff_star"])) - out["reweight_ok"] = out["neff_star"] >= args.neff_min - else: - w = w0 - out.update(neff_star=np.nan, ks_p_star=np.nan, reweight_ok=False) - - # bootstrap lambda* - boots = [] - for _ in range(args.boot): - b = rng.integers(0, k.size, k.size) - if not done[b].any(): - continue - cvb, _ = cv_curve(lams, k[b], T[b], done[b], success_prob(k[b], done[b])) - boots.append(first_crossing(lams, cvb)) - boots = np.array(boots) - fin = boots[np.isfinite(boots)] - out["lam_lo"], out["lam_hi"] = (np.percentile(fin, [2.5, 97.5]) if fin.size - else (np.nan, np.nan)) - out["boot_noroot"] = float(np.mean(~np.isfinite(boots))) if boots.size else np.nan - out["reweight_status"] = reweight_status(out["cv0"], lam_star, out["neff_star"], args.neff_min) - - lam_st, st_res = stitch_scan(lams, p, A, k.size, args, rng) - out["lam_stitch"] = lam_st - out["stitch_status"] = stitch_status(lam_st, A["fail_pool"].size, A["succ_pool"].size, - A["note"]) - out["cv_stitch0"], out["ksp_stitch0"] = (st_res[0][1], st_res[0][2]) if st_res else (np.nan, np.nan) - out["cv_lammax"] = cv[-1] - out["kmax"] = int(k.max()) if k.size else 0 - out["p_stitch"] = tilted_p(p, lam_st) if np.isfinite(lam_st) else np.nan - if full: - out.update(A=A, lams=lams, cv=cv, neff=neff, w=w, st_res=st_res) - return out - - -def ks_heatmap(trajs, qts_grid, lams, args, rng): - """Median stitched KS p-value and CV on a (Q‡, lambda) grid. Each cell stitches - args.nstitch folding times with the tilted success probability at that Q‡ and - tests subsamples of the original size, exactly as stitch_scan does.""" - ksp = np.full((qts_grid.size, lams.size), np.nan) - cv = np.full_like(ksp, np.nan) - for i, q in enumerate(qts_grid): - A = attempts(trajs, q, args.t0, args.include_initial) - if A["fail_pool"].size == 0 or A["succ_pool"].size == 0: - continue # empty_pool: NaN column - p = success_prob(A["k"], A["done"]) - n = A["k"].size - null = null_D(n) - for j, lam in enumerate(lams): - pp = tilted_p(p, lam) - if (1 - pp) / pp > 1e7: - break - t = stitch(pp, A["fail_pool"], A["succ_pool"], args.nstitch, rng) - sub = rng.choice(t, size=(args.nsub, n)) - pv = (np.sum(null[None, :] >= D_rows(sub)[:, None], axis=1) + 1) / (null.size + 1) - ksp[i, j], cv[i, j] = np.median(pv), t.std() / t.mean() - return ksp, cv - - -def write_heatmap(qts_grid, lams, ksp, cv, results, com, args): - passed = (ksp >= args.alpha) & (np.abs(cv - 1) <= args.cv_tol) - with open(os.path.join(args.out, "heatmap.csv"), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(["qts", "lambda", "median_ks_p", "cv", "poisson_pass", "qts_valid"]) - for i, q in enumerate(qts_grid): - valid = bool(q < com["Q_barrier"]) if np.isfinite(com["Q_barrier"]) else True - for j, lam in enumerate(lams): - wr.writerow([f"{q:.4g}", f"{lam:.4g}", f"{ksp[i, j]:.4g}", f"{cv[i, j]:.4g}", - int(passed[i, j]), int(valid)]) - - from matplotlib.colors import LogNorm - fig, ax = plt.subplots(figsize=(7.5, 4.8)) - dq = np.diff(qts_grid).min() if qts_grid.size > 1 else 0.05 - dl = np.diff(lams).min() if lams.size > 1 else 0.5 - qe = np.r_[qts_grid - dq / 2, qts_grid[-1] + dq / 2] - le = np.r_[lams - dl / 2, lams[-1] + dl / 2] - im = ax.pcolormesh(qe, le, np.clip(ksp.T, 1e-4, 1), norm=LogNorm(1e-4, 1), cmap="viridis", - shading="flat") - fig.colorbar(im, ax=ax, label="median KS p (stitched)") - from matplotlib.patches import Rectangle - for i, j in zip(*np.nonzero(passed)): # hatch exactly the passing cells - ax.add_patch(Rectangle((qe[i], le[j]), qe[i + 1] - qe[i], le[j + 1] - le[j], fill=False, - hatch="//", edgecolor="white", lw=0, alpha=0.7)) - lm = [r["lam_stitch"] for r in results] - ax.plot([r["qts"] for r in results], lm, "w^-", ms=6, mec="k", label="λ_min(Q‡)") - if np.isfinite(com["Q_barrier"]): - ax.axvspan(com["Q_barrier"], qe[-1], color="0.2", alpha=0.45, lw=0, - label=f"Q‡ beyond assumed barrier (q*={args.barrier_q:.2f}): invalid") - ax.axvline(com["Q_barrier"], color="k", lw=1) - ax.set_xlim(qe[0], qe[-1]); ax.set_ylim(le[0], le[-1]) - ax.set_xlabel("attempt interface Q‡"); ax.set_ylabel("λ (kT)") - ax.set_title("Poisson decision map: hatched = passes (KS p ≥ α and |CV−1| ≤ tol)\n" - "the TS lies between Q‡ and Qf, so only Q‡ before the barrier is meaningful", - fontsize=9) - ax.legend(fontsize=7, loc="upper left") - fig.tight_layout(); fig.savefig(os.path.join(args.out, "heatmap.png"), dpi=150); plt.close(fig) - return passed - - -def committor_tse(trajs, ref, qref, args): - """Model committor along Q, corrected committor and TS location for a set of lambda - values and barrier locations q*, TSE frames at the chosen --barrier-q.""" - ti, fr, qv, oc = committor_frames(trajs, args.qu, args.qf) - centers, n, raw, iso = committor_profile(qv, oc, args.qu, args.qf, args.committor_bins) - with open(os.path.join(args.out, "committor.csv"), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(["Q", "n_frames", "q_model_raw", "q_model_isotonic"]) - for row in zip(centers, n, raw, iso): - wr.writerow([f"{v:.6g}" for v in row]) - - p = ref["p"] - lam_min = ref["lam_stitch"] - if args.tse_lams: - lams = list(args.tse_lams) - else: - base = lam_min if np.isfinite(lam_min) else 0.0 - lams = [base, base + 1.0, base + 2.0] - # model committor at the attempt interface: the barrier must lie beyond it - ok = np.isfinite(iso) - q_iface = float(np.interp(qref, centers[ok], iso[ok])) if ok.any() else np.nan - qstars = np.round(np.arange(0.1, 0.91, 0.05), 3) - half = args.tse_window if args.tse_window else (args.qf - args.qu) / args.committor_bins - - with open(os.path.join(args.out, "ts_location.csv"), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(["lambda", "r=p'/p", "q_star", "Q_barrier", "Q_TS", "ts_set_by", "status"]) - for lam in lams: - r = tilted_p(p, lam) / p - for qs in sorted(set(qstars) | {args.barrier_q}): - qb = q_at(centers, iso, qs) - qts, where = ts_location(centers, iso, r, qs) - status = ("barrier_before_interface" if qs < q_iface else - "ts_outside_sampled_range" if not np.isfinite(qts) else - "ts_before_interface" if qts <= qref else "ok") - wr.writerow([f"{lam:.4g}", f"{r:.4g}", f"{qs:.3g}", f"{qb:.4g}", f"{qts:.4g}", - where, status]) - - print(f"\nCommittor-based TSE (missing barrier at model q* = {args.barrier_q:.2f}, " - f"Q = {q_at(centers, iso, args.barrier_q):.3f}; model TS q=0.5 at Q = " - f"{q_at(centers, iso, 0.5):.3f}):") - if args.barrier_q < q_iface: - print(f" WARNING: q* = {args.barrier_q} lies before the attempt interface " - f"(model q = {q_iface:.2f} at Q‡); the tilt assumes the barrier is beyond Q‡.") - for lam in lams: - r = tilted_p(p, lam) / p - qts, where = ts_location(centers, iso, r, args.barrier_q) - sel = np.abs(qv - qts) <= half if np.isfinite(qts) else np.zeros(qv.size, bool) - name = f"tse_committor_lam{lam:.2f}_q{args.barrier_q:.2f}.csv" - with open(os.path.join(args.out, name), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(["trajectory", "frame", "time", "Q", "excursion_outcome"]) - for i, f_, q_, o_ in zip(ti[sel], fr[sel], qv[sel], oc[sel]): - wr.writerow([trajs[i]["path"], f_, f"{f_ * trajs[i]['dt']:.6g}", f"{q_:.6g}", int(o_)]) - print(f" lambda = {lam:.2f} (p'/p = {r:.3f}): Q_TS = {qts:.3f} set by {where:8s} " - f"-> {int(sel.sum())} frames in {name}") - - fig, axs = plt.subplots(1, 2, figsize=(11, 4)) - axs[0].plot(centers, raw, "o", ms=3, color="0.5", label="model (raw)") - axs[0].plot(centers, iso, "k-", label="model (isotonic)") - grid = np.linspace(args.qu, args.qf, 400) - qm_grid = np.interp(grid, centers[ok], iso[ok]) - for lam in lams: - r = tilted_p(p, lam) / p - axs[0].plot(grid, corrected_committor(qm_grid, r, args.barrier_q), label=f"corrected, λ={lam:.2f}") - axs[0].axhline(0.5, color="k", ls=":", lw=1); axs[0].axvline(qref, color="r", ls=":", lw=1, label="Q‡") - axs[0].set_xlabel("Q"); axs[0].set_ylabel("committor"); axs[0].legend(fontsize=8) - axs[0].set_title(f"missing barrier at model q* = {args.barrier_q:.2f}") - for lam in lams: - r = tilted_p(p, lam) / p - axs[1].plot(qstars, [ts_location(centers, iso, r, qs)[0] for qs in qstars], "o-", ms=3, - label=f"λ = {lam:.2f}") - axs[1].plot(qstars, [q_at(centers, iso, qs) for qs in qstars], "k--", lw=1, label="barrier location") - axs[1].axvspan(0, q_iface, color="0.9", label="before Q‡ (not allowed)") - axs[1].set_xlim(qstars[0], qstars[-1]) - axs[1].set_xlabel("assumed barrier location q* (model committor)"); axs[1].set_ylabel("Q_TS") - axs[1].set_title("TS location vs assumed barrier location"); axs[1].legend(fontsize=8) - fig.tight_layout(); fig.savefig(os.path.join(args.out, "ts_location.png"), dpi=150); plt.close(fig) - return dict(centers=centers, iso=iso, q_iface=q_iface, - Q_barrier=q_at(centers, iso, args.barrier_q), Q_model_ts=q_at(centers, iso, 0.5)) - - -def main(): - plt.switch_backend("Agg") # command-line use: files only, no display - ap = argparse.ArgumentParser(description=__doc__, - formatter_class=argparse.RawDescriptionHelpFormatter) - ap.add_argument("files", nargs="+", help="trajectory files or glob patterns") - ap.add_argument("--qu", type=float, required=True, help="U basin: Q < Qu") - ap.add_argument("--qf", type=float, required=True, help="folded: Q >= Qf (trajectories stop here)") - ap.add_argument("--dt", type=float, default=None, help="frame spacing (needed for 1-column files)") - ap.add_argument("--qts", type=float, default=None, help="reference Q‡ for plots/TSE (default: grid middle)") - ap.add_argument("--qtse", type=float, default=None, - help="surface for TSE frames (last upward crossing before folding); default: each Q‡. Put it at the barrier top when Q‡ is at the barrier foot") - ap.add_argument("--nqts", type=int, default=9, help="number of Q‡ values scanned in (Qu, Qf)") - ap.add_argument("--t0", type=float, default=0.0, help="discard initial relaxation up to this time") - ap.add_argument("--lam-max", type=float, default=10.0, help="max lambda (effective barrier shift, kT) scanned") - ap.add_argument("--nlam", type=int, default=201) - ap.add_argument("--boot", type=int, default=500, help="bootstrap resamples for lambda*") - ap.add_argument("--nstitch", type=int, default=5000, help="synthetic times per lambda") - ap.add_argument("--nsub", type=int, default=200, help="KS subsamples (size = #trajectories)") - ap.add_argument("--alpha", type=float, default=0.05) - ap.add_argument("--cv-tol", type=float, default=0.1) - ap.add_argument("--neff-min", type=float, default=30.0) - ap.add_argument("--barrier-q", type=float, default=0.5, - help="location of the missing barrier, as a MODEL committor value q* " - "(default 0.5: the missing barrier sits on the model's own TS)") - ap.add_argument("--tse-lams", type=float, nargs="*", default=None, - help="lambda values for the committor-based TSE (default: lambda_min, " - "lambda_min+1, lambda_min+2)") - ap.add_argument("--committor-bins", type=int, default=20) - ap.add_argument("--heatmap-nlam", type=int, default=21, - help="number of lambda values in the (Q‡, lambda) KS heatmap (0 disables)") - ap.add_argument("--heatmap-lam-max", type=float, default=5.0, - help="largest lambda (kT) in the heatmap") - ap.add_argument("--tse-window", type=float, default=None, - help="half-width in Q of the TSE window around Q_TS (default: one bin)") - ap.add_argument("--include-initial", action="store_true", - help="use first segment of each trajectory in stitching pools") - ap.add_argument("--out", default="maxcal_out") - ap.add_argument("--seed", type=int, default=1) - args = ap.parse_args() - if not args.qu < args.qf: - sys.exit("need Qu < Qf") - - paths = sorted({p for pat in args.files for p in (glob.glob(pat) or [pat])}) - trajs = [] - for path in paths: - q, dt = load_traj(path, args.dt) - fold, fails = parse_traj(q, args.qu, args.qf) - trajs.append(dict(path=path, q=q, dt=dt, n=q.size, fold=fold, fails=fails)) - n_cens = sum(t["fold"] is None for t in trajs) - print(f"{len(trajs)} trajectories, {n_cens} censored (never reach Qf={args.qf})") - if n_cens: - print(" note: CV uses completed trajectories only; KM/KS handle censoring") - - os.makedirs(args.out, exist_ok=True) - rng = np.random.default_rng(args.seed) - lams = np.linspace(0.0, args.lam_max, args.nlam) - grid = np.linspace(args.qu, args.qf, args.nqts + 2)[1:-1] - qref = args.qts if args.qts is not None else grid[len(grid) // 2] - if not args.qu < qref < args.qf: - sys.exit("--qts must lie between Qu and Qf") - grid = np.unique(np.r_[grid, qref]) - - results = [analyse(trajs, q, args, rng, lams, full=np.isclose(q, qref)) for q in grid] - ref = next(r for r in results if np.isclose(r["qts"], qref)) - - # ---- summary table - cols = ["qts", "N", "n_done", "sum_k", "frac_k0", "p", "geom_p", "lag1_rho", "lag1_p", - "cv0", "ks_p0", "lam_star", "lam_lo", "lam_hi", "boot_noroot", "neff_star", - "ks_p_star", "reweight_ok", "cv_lammax", "kmax", "cv_stitch0", "ksp_stitch0", - "lam_stitch", "p_stitch", "geom_status", "lag1_status", "reweight_status", - "stitch_status", "note"] - with open(os.path.join(args.out, "summary.csv"), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(cols) - for r in results: - wr.writerow([r[c] if isinstance(r[c], str) else f"{r[c]:.6g}" for c in cols]) - - print(f"\n{'Q‡':>6} {'p':>6} {'geom_p':>7} {'CV0':>5} {'KSp0':>6} {'λ*(kT)':>7} " - f"{'95% CI':>13} {'Neff*':>6} {'KSp*':>6} {'λ_stitch':>8}") - for r in results: - ci = f"[{r['lam_lo']:.2f},{r['lam_hi']:.2f}]" if np.isfinite(r["lam_star"]) else "-" - print(f"{r['qts']:6.3f} {r['p']:6.3f} {r['geom_p']:7.3f} {r['cv0']:5.2f} {r['ks_p0']:6.3f} " - f"{r['lam_star']:7.2f} {ci:>13} {r['neff_star']:6.1f} {r['ks_p_star']:6.3f} " - f"{r['lam_stitch']:8.2f}" + (" *ref" if r is ref else "")) - - # ---- warnings for the reference surface - print(f"\nReference Q‡ = {qref:.3f} [geometric test: {ref['geom_status']}, " - f"lag-1: {ref['lag1_status']}, reweighting: {ref['reweight_status']}, " - f"stitching: {ref['stitch_status']}]") - if ref["note"]: - print(" " + ref["note"]) - if np.isfinite(ref["geom_p"]) and ref["geom_p"] < args.alpha: - print(" WARNING: failed-attempt counts are not geometric -> attempts have memory;" - " Poisson statistics after tilting would be imposed, not recovered.") - elif not np.isfinite(ref["geom_p"]): - print(" geometric test: too few distinct k values to test independence") - if ref["cv0"] >= 1: - print(" NOTE: CV >= 1 already at lambda=0; a missing barrier does not explain the" - " deviation (look for intermediates / parallel channels).") - if np.isfinite(ref["lam_star"]) and not ref["reweight_ok"]: - print(f" WARNING: N_eff={ref['neff_star']:.1f} < {args.neff_min} at lambda*;" - " trust the stitched estimate instead.") - if not np.isfinite(ref["lam_star"]): - print(f" reweighting: CV reaches only {ref['cv_lammax']:.2f} at lambda_max. Reweighting can only" - f" reshuffle the observed attempt counts (max k = {ref['kmax']}); the weights saturate at" - " (1-p)^-k, so the geometric tail of a higher barrier is not in the data." - " Use the stitching result.") - if np.isfinite(ref["cv_stitch0"]): - print(f" stitching at lambda=0 (initial segments removed): CV={ref['cv_stitch0']:.2f}," - f" median KS p={ref['ksp_stitch0']:.3f}") - if ref["ksp_stitch0"] >= args.alpha and abs(ref["cv_stitch0"] - 1) <= args.cv_tol: - print(" -> already Poisson without a barrier correction: the original deviation" - " is mostly the initial relaxation, not the missing barrier.") - - # ---- TSE frames - A, w = ref["A"], ref["w"] - pos = {i: j for j, i in enumerate(A["idx"])} - with open(os.path.join(args.out, f"tse_frames_qts{qref:.3f}_qtse{(args.qtse or qref):.3f}.csv"), "w", newline="") as fh: - wr = csv.writer(fh, lineterminator="\n") - wr.writerow(["trajectory", "frame", "time", "k_failed", "weight_at_lambda_star"]) - for i, fr in A["tse"]: - j = pos[i] - wr.writerow([trajs[i]["path"], fr, f"{fr * trajs[i]['dt']:.6g}", - A["k"][j], f"{w[j]:.6g}"]) - - # ---- plots - k, T, done = A["k"], A["T"], A["done"] - fig, ax = plt.subplots(figsize=(5.5, 4.2)) - x = np.linspace(0, 5, 200) - ax.semilogy(x, np.exp(-x), "k--", lw=1, label="exponential") - for wt, lab in [(np.full(k.size, 1.0 / k.size), "original")] + \ - ([(w, f"reweighted, λ*={ref['lam_star']:.2f} kT")] - if np.isfinite(ref["lam_star"]) else []): - ts, S, _ = weighted_km(T, done, wt) - tau = np.sum(wt * T) / np.sum(wt * done) - ax.step(np.r_[0, ts / tau], np.r_[1, S], where="post", label=lab) - if np.isfinite(ref["lam_stitch"]): - t = stitch(ref["p_stitch"], A["fail_pool"], A["succ_pool"], 20000, rng) - ts = np.sort(t) / t.mean() - ax.step(ts, 1 - np.arange(1, ts.size + 1) / ts.size, where="post", - label=f"stitched, λ={ref['lam_stitch']:.2f} kT") - ax.set_xlim(0, 5); ax.set_ylim(1e-2, 1.05) - ax.set_xlabel("t / ⟨t⟩"); ax.set_ylabel("survival S(t)") - ax.set_title(f"Folding-time survival, Q‡ = {qref:.3f}") - ax.legend(fontsize=8); fig.tight_layout() - fig.savefig(os.path.join(args.out, "survival.png"), dpi=150); plt.close(fig) - - fig, axs = plt.subplots(3, 1, figsize=(5.5, 7), sharex=True) - axs[0].plot(lams, ref["cv"]); axs[0].axhline(1, color="k", ls="--", lw=1) - axs[0].set_ylabel("weighted CV") - axs[1].plot(lams, ref["neff"]); axs[1].axhline(args.neff_min, color="r", ls=":", lw=1) - axs[1].set_ylabel("N_eff") - if ref["st_res"]: - s = np.array(ref["st_res"]) - axs[2].plot(s[:, 0], s[:, 2], "o-", ms=3, label="stitched (median KS p)") - axs[2].axhline(args.alpha, color="r", ls=":", lw=1) - axs[2].set_ylabel("KS p"); axs[2].set_xlabel("λ (kT)"); axs[2].legend(fontsize=8) - for a in axs: - if np.isfinite(ref["lam_star"]): - a.axvline(ref["lam_star"], color="g", lw=1) - fig.tight_layout(); fig.savefig(os.path.join(args.out, "lambda_scan.png"), dpi=150) - plt.close(fig) - - fig, ax = plt.subplots(figsize=(5.5, 3.8)) - q = np.array([r["qts"] for r in results]) - ls_ = np.array([r["lam_star"] for r in results]) - lo = np.array([r["lam_lo"] for r in results]); hi = np.array([r["lam_hi"] for r in results]) - ax.errorbar(q, ls_, yerr=[ls_ - lo, hi - ls_], fmt="o-", capsize=3, label="reweighting λ*") - ax.plot(q, [r["lam_stitch"] for r in results], "s--", label="stitching") - ax.set_xlabel("Q‡"); ax.set_ylabel("effective barrier shift λ (kT)") - ax.legend(fontsize=8); fig.tight_layout() - fig.savefig(os.path.join(args.out, "robustness_qts.png"), dpi=150); plt.close(fig) - - com = committor_tse(trajs, ref, qref, args) - if qref >= com["Q_barrier"]: - print(f" WARNING: reference Q‡ = {qref:.3f} is not before the assumed barrier " - f"(Q = {com['Q_barrier']:.3f}); the TS must lie between Q‡ and Qf.") - if args.heatmap_nlam > 0: - lams_h = np.linspace(0.0, args.heatmap_lam_max, args.heatmap_nlam) - ksp, cvh = ks_heatmap(trajs, grid, lams_h, args, rng) - passed = write_heatmap(grid, lams_h, ksp, cvh, results, com, args) - valid = grid < com["Q_barrier"] if np.isfinite(com["Q_barrier"]) else np.ones(grid.size, bool) - print(f"\n(Q‡, λ) heatmap: {int(passed[valid].sum())}/{int(passed[valid].size)} cells pass " - f"among the {int(valid.sum())} Q‡ values before the assumed barrier -> heatmap.png") - - print(f"\nWrote summary.csv, heatmap.csv/.png, tse_frames_*.csv, committor.csv, ts_location.csv, " - f"tse_committor_*.csv, ts_location.png, survival.png, " - f"lambda_scan.png, robustness_qts.png to {args.out}/") - - -if __name__ == "__main__": - main() diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb index 633910d..3040940 100644 --- a/notebooks/demo.ipynb +++ b/notebooks/demo.ipynb @@ -2,12 +2,12 @@ "cells": [ { "cell_type": "markdown", - "id": "a3561444", + "id": "22e8de74", "metadata": {}, "source": [ "# MaxCal barrier tilt: interactive demo\n", "\n", - "This notebook uses the test datasets to show, step by step, what `maxcal_poisson.py` does:\n", + "This notebook uses the test datasets to show, step by step, what the `maxcal` tools do (one section per executable):\n", "\n", "1. **Attempts.** Trajectories are decomposed into failed and successful attempts at an interface Q‡.\n", "2. **Reweighting.** Each trajectory gets the MaxCal weight $w \\propto c^{k}$; you can see what that does to the folding-time distribution, and why it saturates.\n", @@ -27,13 +27,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "3cc74304", + "id": "34c4ae35", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T22:59:59.472964Z", - "iopub.status.busy": "2026-09-18T22:59:59.472748Z", - "iopub.status.idle": "2026-09-18T23:00:00.353168Z", - "shell.execute_reply": "2026-09-18T23:00:00.352303Z" + "iopub.execute_input": "2026-09-19T06:27:54.858117Z", + "iopub.status.busy": "2026-09-19T06:27:54.857964Z", + "iopub.status.idle": "2026-09-19T06:27:55.712009Z", + "shell.execute_reply": "2026-09-19T06:27:55.711142Z" } }, "outputs": [ @@ -41,7 +41,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "using /home/claude/repo/maxcal_poisson.py\n", + "using /home/claude/repo/maxcal/__init__.py\n", "widgets: False\n" ] } @@ -56,16 +56,17 @@ "ROOT = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) if os.path.basename(os.getcwd()) == \"notebooks\" else os.getcwd()\n", "sys.path[:0] = [ROOT, os.path.join(ROOT, \"tests\")]\n", "import importlib\n", - "import maxcal_poisson as mp\n", - "import maxcal_joint as mj\n", + "import maxcal as mp # shared functions (attempts, stitch, cv_curve, ...)\n", + "from maxcal import joint as mj\n", "import langevin as L\n", "import synthetic as S\n", "# re-running this cell picks up code changes (e.g. after git pull / git am) without a restart\n", "for _mod in (mp, mj, L, S):\n", " importlib.reload(_mod)\n", - "_missing = [f for f in (\"committor_frames\", \"ts_location\", \"ks_heatmap\") if not hasattr(mp, f)]\n", + "_missing = [f for f in (\"committor_frames\", \"ts_location\", \"ks_heatmap\", \"stitch\")\n", + " if not hasattr(mp, f)]\n", "if _missing or not os.path.abspath(mp.__file__).startswith(ROOT):\n", - " raise ImportError(f\"maxcal_poisson imported from {mp.__file__} is not this repository's \"\n", + " raise ImportError(f\"maxcal imported from {mp.__file__} is not this repository's \"\n", " f\"current version (missing: {_missing}). Run `pip install -e .` from the \"\n", " f\"repository root and restart the kernel.\")\n", "print(\"using\", mp.__file__)\n", @@ -136,7 +137,7 @@ }, { "cell_type": "markdown", - "id": "6a5d5750", + "id": "842a6c6d", "metadata": {}, "source": [ "## 1. Data\n", @@ -149,13 +150,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "b9e1267e", + "id": "bff3c936", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:00.355083Z", - "iopub.status.busy": "2026-09-18T23:00:00.354451Z", - "iopub.status.idle": "2026-09-18T23:00:00.533788Z", - "shell.execute_reply": "2026-09-18T23:00:00.532975Z" + "iopub.execute_input": "2026-09-19T06:27:55.713532Z", + "iopub.status.busy": "2026-09-19T06:27:55.713336Z", + "iopub.status.idle": "2026-09-19T06:27:55.879819Z", + "shell.execute_reply": "2026-09-19T06:27:55.879186Z" } }, "outputs": [ @@ -195,13 +196,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "38531f5e", + "id": "47f12493", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:00.535528Z", - "iopub.status.busy": "2026-09-18T23:00:00.535017Z", - "iopub.status.idle": "2026-09-18T23:00:00.630023Z", - "shell.execute_reply": "2026-09-18T23:00:00.629269Z" + "iopub.execute_input": "2026-09-19T06:27:55.881142Z", + "iopub.status.busy": "2026-09-19T06:27:55.881000Z", + "iopub.status.idle": "2026-09-19T06:27:55.970073Z", + "shell.execute_reply": "2026-09-19T06:27:55.969461Z" } }, "outputs": [ @@ -228,7 +229,7 @@ }, { "cell_type": "markdown", - "id": "df419e04", + "id": "637ada2b", "metadata": {}, "source": [ "## 2. Attempts at Q‡\n", @@ -241,13 +242,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "5680a5f9", + "id": "b5f2992b", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:00.631355Z", - "iopub.status.busy": "2026-09-18T23:00:00.631216Z", - "iopub.status.idle": "2026-09-18T23:00:01.000579Z", - "shell.execute_reply": "2026-09-18T23:00:00.999884Z" + "iopub.execute_input": "2026-09-19T06:27:55.971486Z", + "iopub.status.busy": "2026-09-19T06:27:55.971042Z", + "iopub.status.idle": "2026-09-19T06:27:56.329567Z", + "shell.execute_reply": "2026-09-19T06:27:56.328757Z" } }, "outputs": [ @@ -299,7 +300,7 @@ }, { "cell_type": "markdown", - "id": "4061b684", + "id": "54353ec2", "metadata": {}, "source": [ "## 3. Reweighting: $w \\propto c^{k}$\n", @@ -314,13 +315,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "4a918486", + "id": "4d8f9083", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:01.002235Z", - "iopub.status.busy": "2026-09-18T23:00:01.001725Z", - "iopub.status.idle": "2026-09-18T23:00:01.858417Z", - "shell.execute_reply": "2026-09-18T23:00:01.857568Z" + "iopub.execute_input": "2026-09-19T06:27:56.331360Z", + "iopub.status.busy": "2026-09-19T06:27:56.330768Z", + "iopub.status.idle": "2026-09-19T06:27:57.136541Z", + "shell.execute_reply": "2026-09-19T06:27:57.135722Z" } }, "outputs": [ @@ -392,7 +393,7 @@ }, { "cell_type": "markdown", - "id": "ede05aab", + "id": "581ea234", "metadata": {}, "source": [ "## 4. Stitching: sampling the tilted ensemble\n", @@ -405,13 +406,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "4e1e7134", + "id": "89d5446b", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:01.859952Z", - "iopub.status.busy": "2026-09-18T23:00:01.859735Z", - "iopub.status.idle": "2026-09-18T23:00:02.602558Z", - "shell.execute_reply": "2026-09-18T23:00:02.601689Z" + "iopub.execute_input": "2026-09-19T06:27:57.138323Z", + "iopub.status.busy": "2026-09-19T06:27:57.137784Z", + "iopub.status.idle": "2026-09-19T06:27:57.773323Z", + "shell.execute_reply": "2026-09-19T06:27:57.772232Z" } }, "outputs": [ @@ -476,7 +477,7 @@ }, { "cell_type": "markdown", - "id": "87c25416", + "id": "d684ca55", "metadata": {}, "source": [ "## 5. Validation against a known answer\n", @@ -493,13 +494,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "d1868fd6", + "id": "bff8641e", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:02.604463Z", - "iopub.status.busy": "2026-09-18T23:00:02.603905Z", - "iopub.status.idle": "2026-09-18T23:00:06.077020Z", - "shell.execute_reply": "2026-09-18T23:00:06.076175Z" + "iopub.execute_input": "2026-09-19T06:27:57.775232Z", + "iopub.status.busy": "2026-09-19T06:27:57.774582Z", + "iopub.status.idle": "2026-09-19T06:27:57.873769Z", + "shell.execute_reply": "2026-09-19T06:27:57.873108Z" } }, "outputs": [ @@ -507,43 +508,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "model and ground-truth trajectories (slow only the first time; then cached):\n", - " simulating model (200 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 0.4 s (cached for next time)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " simulating truth_dB2 (200 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 1.0 s (cached for next time)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " simulating truth_dB3 (200 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 2.0 s (cached for next time)\n" + "model and ground-truth trajectories (slow only the first time; then cached):\n" ] }, { @@ -576,13 +541,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "25247079", + "id": "fd4ca497", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:06.078881Z", - "iopub.status.busy": "2026-09-18T23:00:06.078276Z", - "iopub.status.idle": "2026-09-18T23:00:06.495170Z", - "shell.execute_reply": "2026-09-18T23:00:06.494311Z" + "iopub.execute_input": "2026-09-19T06:27:57.875456Z", + "iopub.status.busy": "2026-09-19T06:27:57.874937Z", + "iopub.status.idle": "2026-09-19T06:27:58.259266Z", + "shell.execute_reply": "2026-09-19T06:27:58.258563Z" } }, "outputs": [ @@ -636,7 +601,7 @@ }, { "cell_type": "markdown", - "id": "c47791fc", + "id": "5f99a29f", "metadata": {}, "source": [ "### 5b. Original vs stitched CDF\n", @@ -651,13 +616,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "bd5f1f9e", + "id": "d063ca80", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:06.497048Z", - "iopub.status.busy": "2026-09-18T23:00:06.496469Z", - "iopub.status.idle": "2026-09-18T23:00:07.434220Z", - "shell.execute_reply": "2026-09-18T23:00:07.433391Z" + "iopub.execute_input": "2026-09-19T06:27:58.260518Z", + "iopub.status.busy": "2026-09-19T06:27:58.260386Z", + "iopub.status.idle": "2026-09-19T06:27:59.130540Z", + "shell.execute_reply": "2026-09-19T06:27:59.129755Z" } }, "outputs": [ @@ -735,7 +700,7 @@ }, { "cell_type": "markdown", - "id": "d6e214f8", + "id": "6743d285", "metadata": {}, "source": [ "## 6. Joint mode: forward and backward at the same temperature\n", @@ -750,44 +715,16 @@ { "cell_type": "code", "execution_count": 10, - "id": "a1fdec10", + "id": "17f157ea", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:07.435946Z", - "iopub.status.busy": "2026-09-18T23:00:07.435445Z", - "iopub.status.idle": "2026-09-18T23:00:08.961379Z", - "shell.execute_reply": "2026-09-18T23:00:08.960497Z" + "iopub.execute_input": "2026-09-19T06:27:59.131991Z", + "iopub.status.busy": "2026-09-19T06:27:59.131804Z", + "iopub.status.idle": "2026-09-19T06:27:59.444272Z", + "shell.execute_reply": "2026-09-19T06:27:59.443543Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " simulating joint_fwd (150 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 0.3 s (cached for next time)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " simulating joint_bwd_T1 (150 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 0.5 s (cached for next time)\n" - ] - }, { "data": { "image/png": "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", @@ -798,20 +735,6 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " simulating joint_bwd_T1.5 (150 trajectories)…\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " done in 0.3 s (cached for next time)\n" - ] - }, { "data": { "image/png": "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", @@ -859,7 +782,7 @@ }, { "cell_type": "markdown", - "id": "66610076", + "id": "b0d71b6e", "metadata": {}, "source": [ "## 7. Where is the transition state? (README §2.10)\n", @@ -877,13 +800,13 @@ { "cell_type": "code", "execution_count": 11, - "id": "4afaad4e", + "id": "2cc79f38", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:08.963375Z", - "iopub.status.busy": "2026-09-18T23:00:08.962814Z", - "iopub.status.idle": "2026-09-18T23:00:09.363094Z", - "shell.execute_reply": "2026-09-18T23:00:09.362198Z" + "iopub.execute_input": "2026-09-19T06:27:59.445978Z", + "iopub.status.busy": "2026-09-19T06:27:59.445479Z", + "iopub.status.idle": "2026-09-19T06:27:59.795302Z", + "shell.execute_reply": "2026-09-19T06:27:59.794552Z" } }, "outputs": [ @@ -967,7 +890,7 @@ }, { "cell_type": "markdown", - "id": "7b499fc3", + "id": "e9adfa1a", "metadata": {}, "source": [ "## 8. The (Q‡, λ) decision map\n", @@ -985,13 +908,13 @@ { "cell_type": "code", "execution_count": 12, - "id": "e6dfa1c8", + "id": "01589f6a", "metadata": { "execution": { - "iopub.execute_input": "2026-09-18T23:00:09.364972Z", - "iopub.status.busy": "2026-09-18T23:00:09.364413Z", - "iopub.status.idle": "2026-09-18T23:00:10.427066Z", - "shell.execute_reply": "2026-09-18T23:00:10.426217Z" + "iopub.execute_input": "2026-09-19T06:27:59.797090Z", + "iopub.status.busy": "2026-09-19T06:27:59.796574Z", + "iopub.status.idle": "2026-09-19T06:28:00.796996Z", + "shell.execute_reply": "2026-09-19T06:28:00.796024Z" } }, "outputs": [ @@ -1051,14 +974,16 @@ }, { "cell_type": "markdown", - "id": "440d152a", + "id": "27d466c2", "metadata": {}, "source": [ "## Where to go from here\n", "\n", - "- Run the command-line tools on these datasets and compare their `summary.csv` or `joint_summary.json` with what you see here:\n", + "- Run the command-line tools on these datasets and compare their `summary.csv` or `joint_summary.json` with what you see here (each step of this notebook is one executable: stitching, reweighting, committor/TS):\n", " ```bash\n", - " python maxcal_poisson.py \"data/*.xvg\" --qu 0.3 --qf 0.8 --qts 0.4\n", + " maxcal-stitch \"data/*.xvg\" --qu 0.3 --qf 0.8 --qts 0.4 --out stitch_out\n", + " maxcal-reweight \"data/*.xvg\" --qu 0.3 --qf 0.8 --qts 0.4 --out reweight_out\n", + " maxcal-committor \"data/*.xvg\" --qu 0.3 --qf 0.8 --qts 0.4 --out committor_out\n", " ```\n", "- Replace the Langevin trajectories with your own `Q(t)` files by loading them with `mp.load_traj` and `to_trajs`." ] diff --git a/notebooks/target_demo.ipynb b/notebooks/target_demo.ipynb new file mode 100644 index 0000000..4302a9d --- /dev/null +++ b/notebooks/target_demo.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5281042d", + "metadata": {}, + "source": [ + "# Matching experimental rates with a Poisson target\n", + "\n", + "`maxcal-target` reweights first-passage times so that they reproduce **experimental rate constants** and a **single-exponential (Poisson) shape**. The weights are the product: applied to structural observables, they show which trajectories — and which mechanisms — the experimental kinetics favour.\n", + "\n", + "This notebook uses the same dataset as the regression test (`tests/synthetic.py: write_rate_dataset`): twelve PDZ2-like systems (two peptides × WT + five mutants) with the experimental k_on/k_off of the reference measurements and model rates taken from a multi-eGO study, with seeded exponential times standing in for the real per-trajectory times. Point it at your own `systems.csv` to use real data.\n", + "\n", + "1. **Data** — experimental vs model rates.\n", + "2. **Clock calibration** — one global factor; what is left per system.\n", + "3. **Weights** — model, reweighted and target CDFs, per system and direction.\n", + "4. **Cost** — N_eff versus the needed change.\n", + "5. **Using the weights** — a structural observable, weighted vs unweighted.\n", + "6. **K_D** — the affinity scatter before and after reweighting.\n", + "\n", + "Sliders need `ipywidgets`; without it each interactive cell shows static figures. They recompute when released." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bc2d2d23", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:05.633163Z", + "iopub.status.busy": "2026-09-19T07:49:05.633026Z", + "iopub.status.idle": "2026-09-19T07:49:07.081157Z", + "shell.execute_reply": "2026-09-19T07:49:07.080250Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "widgets: False\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import os, sys, importlib, inspect\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ROOT = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) if os.path.basename(os.getcwd()) == \"notebooks\" else os.getcwd()\n", + "sys.path[:0] = [ROOT, os.path.join(ROOT, \"tests\")]\n", + "import maxcal.target as mt\n", + "import synthetic as S\n", + "for _m in (mt, S):\n", + " importlib.reload(_m)\n", + "if not hasattr(S, \"write_rate_dataset\"):\n", + " raise ImportError(\"tests/synthetic.py has no write_rate_dataset: update the repository \"\n", + " \"and restart the kernel\")\n", + "\n", + "try:\n", + " import ipywidgets as W\n", + " HAVE_WIDGETS = not os.environ.get(\"MAXCAL_DEMO_STATIC\")\n", + "except ImportError:\n", + " HAVE_WIDGETS = False\n", + "\n", + "def explore(fn, static, **controls):\n", + " if not HAVE_WIDGETS:\n", + " for kw in static:\n", + " fn(**kw)\n", + " return\n", + " defaults = {k: v.default for k, v in inspect.signature(fn).parameters.items()}\n", + " def widget(name, spec):\n", + " if isinstance(spec, list):\n", + " return W.Dropdown(options=spec, value=defaults[name], description=name)\n", + " lo, hi, step = spec\n", + " return W.FloatSlider(min=lo, max=hi, step=step, value=defaults[name], description=name,\n", + " continuous_update=False, style={\"description_width\": \"initial\"})\n", + " ws = {k: widget(k, v) for k, v in controls.items() if v is not None}\n", + " status, out = W.HTML(), W.Output()\n", + " def run(**kw):\n", + " status.value = \"computing…\"\n", + " with out:\n", + " out.clear_output(wait=True); fn(**kw)\n", + " status.value = \"\"\n", + " W.interactive_output(run, ws)\n", + " display(W.VBox([W.HBox(list(ws.values())), status, out]))\n", + "\n", + "plt.rcParams.update({\"figure.dpi\": 100, \"axes.grid\": True, \"grid.alpha\": 0.3})\n", + "CONC = 0.017 # M, peptide concentration in the simulations\n", + "print(\"widgets:\", HAVE_WIDGETS)" + ] + }, + { + "cell_type": "markdown", + "id": "7e2accd8", + "metadata": {}, + "source": [ + "## 1. The data\n", + "\n", + "Each system contributes 50 binding and 50 unbinding first-passage times (in ps) plus its experimental k_on and k_off. `maxcal-target` reads exactly this: a `systems.csv` pointing at one file of times per system and direction." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fa271ca1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:07.083318Z", + "iopub.status.busy": "2026-09-19T07:49:07.082647Z", + "iopub.status.idle": "2026-09-19T07:49:07.325017Z", + "shell.execute_reply": "2026-09-19T07:49:07.324071Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "system,kon_exp,koff_exp,bind_times,unbind_times\n", + "EQVSAV_A53G,2.78,43.0,times/EQVSAV_A53G_bind.dat,times/EQVSAV_A53G_unbind.dat \n", + "\n", + "system kon_exp koff_exp tau_bind (ps) tau_unbind (ps)\n", + "EQVSAV_A53G 2.78 43.0 637 769000\n", + "EQVSAV_L18A 2.20 13.8 560 909000\n", + "EQVSAV_L25A 1.69 37.7 612 312000\n", + "EQVSAV_T35G 3.10 81.0 446 435000\n", + "EQVSAV_V44A 3.30 30.0 595 714000\n", + "EQVSAV_WT 2.90 26.0 525 435000\n", + "EQVTAV_A53G 2.40 21.0 490 1250000\n", + "EQVTAV_L18A 2.40 10.4 520 1430000\n", + "EQVTAV_L25A 1.12 53.8 533 526000\n", + "EQVTAV_T35G 2.70 49.0 592 1000000\n", + "EQVTAV_V44A 2.70 23.0 532 1110000\n", + "EQVTAV_WT 2.60 22.0 391 909000\n" + ] + } + ], + "source": [ + "import tempfile\n", + "DATA = tempfile.mkdtemp()\n", + "SYSTEMS_CSV = S.write_rate_dataset(DATA, n=50, seed=7)\n", + "systems = mt.read_systems(SYSTEMS_CSV)\n", + "print(open(SYSTEMS_CSV).read().split(\"\\n\")[0])\n", + "print(open(SYSTEMS_CSV).read().split(\"\\n\")[1], \"\\n\")\n", + "print(f\"{'system':14s} {'kon_exp':>8s} {'koff_exp':>9s} {'tau_bind (ps)':>14s} {'tau_unbind (ps)':>16s}\")\n", + "for s in systems:\n", + " print(f\"{s['name']:14s} {s['kon']:8.2f} {s['koff']:9.1f} {s['t_bind'].mean():14.0f} \"\n", + " f\"{s['t_unbind'].mean():16.0f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9c4cd160", + "metadata": {}, + "source": [ + "## 2. Clock calibration\n", + "\n", + "The model is orders of magnitude faster than experiment, so comparing rates directly is meaningless. For every system and direction the script forms **A = k_model / k_exp** and fits **one global clock factor c** across all of them. What is left, **A/c**, is the per-system error the reweighting has to absorb.\n", + "\n", + "The choice of c is a free calibration and it matters, because slowing a sample down is cheap and speeding it up is not: for an exponential sample, changing the mean by a factor f keeps N_eff/N ≈ 2f − f², and **f = 2 is a hard limit**.\n", + "\n", + "- `geometric` — geometric mean of A;\n", + "- `decrease-only` — the largest A, so every system needs a slowdown;\n", + "- `balanced` (default) — maximises the worst-case N_eff." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21c61a83", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:07.327066Z", + "iopub.status.busy": "2026-09-19T07:49:07.326509Z", + "iopub.status.idle": "2026-09-19T07:49:07.521363Z", + "shell.execute_reply": "2026-09-19T07:49:07.520409Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "geometric c = 4.594e-08 factors 0.44–2.14 worst N_eff/N = -0.31\n", + "decrease-only c = 9.854e-08 factors 0.21–1.00 worst N_eff/N = 0.37\n", + "balanced c = 5.956e-08 factors 0.34–1.65 worst N_eff/N = 0.57\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A = mt.acceleration(systems, CONC, \"binding\")\n", + "names = [s[\"name\"] for s in systems]\n", + "clocks = {m: mt.choose_clock(A, m) for m in (\"geometric\", \"decrease-only\", \"balanced\")}\n", + "for m, c in clocks.items():\n", + " f = np.array([a / c for pair in A.values() for a in pair])\n", + " print(f\"{m:14s} c = {c:.3e} factors {f.min():.2f}–{f.max():.2f} \"\n", + " f\"worst N_eff/N = {min(mt.neff_fraction(x) for x in f):.2f}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(11, 3.8))\n", + "x = np.arange(len(names))\n", + "for k, (m, c) in enumerate(clocks.items()):\n", + " ax.plot(x, [A[n][0] / c for n in names], \"o-\", ms=4, label=f\"{m} (bind)\")\n", + " ax.plot(x, [A[n][1] / c for n in names], \"s--\", ms=4, label=f\"{m} (unbind)\")\n", + "ax.axhline(1, color=\"k\", lw=1); ax.axhline(2, color=\"r\", ls=\":\", lw=1)\n", + "ax.text(0.1, 2.05, \"hard limit for lengthening\", color=\"r\", fontsize=8)\n", + "ax.set_xticks(x); ax.set_xticklabels(names, rotation=45, ha=\"right\")\n", + "ax.set_ylabel(\"needed factor on ⟨t⟩\"); ax.legend(fontsize=7, ncol=3)\n", + "ax.set_title(\"what is left after the global clock\"); plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "55147db4", + "metadata": {}, + "source": [ + "## 3. The weights\n", + "\n", + "With the clock fixed, each system and direction has a fully specified target: an exponential whose mean is the experimental one in model time units. Two ways to get there:\n", + "\n", + "- **`target`** (default): w ∝ f_target/f_model, with f_model a gamma fitted to the times. Both the mean and the exponential shape are imposed, and a final tilt matches the mean exactly.\n", + "- **`mean`**: w ∝ exp(−θt), the maximum-entropy solution with only the mean constrained.\n", + "\n", + "Pick a system and watch the CDFs and the weights. `tail_gap` is the target mass beyond the longest observed time: the honest limit on how much slower the target can be." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e240df3d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:07.523412Z", + "iopub.status.busy": "2026-09-19T07:49:07.522790Z", + "iopub.status.idle": "2026-09-19T07:49:08.296771Z", + "shell.execute_reply": "2026-09-19T07:49:08.295902Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target unreachable with the 'mean' mode (outside the observed range)\n" + ] + } + ], + "source": [ + "CLOCK = mt.choose_clock(A, \"balanced\")\n", + "BY_NAME = {s[\"name\"]: s for s in systems}\n", + "\n", + "def show_system(system=\"EQVTAV_WT\", direction=0.0, mode=0.0):\n", + " s = BY_NAME[system]\n", + " d = \"bind\" if direction < 0.5 else \"unbind\"\n", + " t = s[\"t_bind\"] if d == \"bind\" else s[\"t_unbind\"]\n", + " a = A[system][0 if d == \"bind\" else 1]\n", + " tau_target = t.mean() * a / CLOCK\n", + " w = (mt.target_weights(t, tau_target) if mode < 0.5 else mt.mean_weights(t, tau_target))\n", + " if w is None:\n", + " print(\"target unreachable with the 'mean' mode (outside the observed range)\"); return\n", + " diag = mt.diagnostics(t, w, tau_target)\n", + " fig, axs = plt.subplots(1, 2, figsize=(11, 3.8))\n", + " o = np.argsort(t); ts = t[o]\n", + " axs[0].step(ts, np.arange(1, ts.size + 1) / ts.size, where=\"post\", color=\"k\", label=\"model\")\n", + " axs[0].step(ts, np.cumsum(w[o]), where=\"post\", color=\"C3\", label=\"reweighted\")\n", + " xx = np.logspace(np.log10(ts.min() / 2), np.log10(ts.max() * 3), 200)\n", + " axs[0].plot(xx, 1 - np.exp(-xx / tau_target), \"--\", color=\"C0\", label=\"target (exponential)\")\n", + " axs[0].set_xscale(\"log\"); axs[0].set_xlabel(f\"{d}ing time (ps)\"); axs[0].set_ylabel(\"CDF\")\n", + " axs[0].legend(fontsize=8)\n", + " axs[0].set_title(f\"⟨t⟩: model {t.mean():.0f} → target {tau_target:.0f} ps \"\n", + " f\"(factor {a / CLOCK:.2f})\", fontsize=9)\n", + " axs[1].semilogx(ts, w[o] * w.size, \"o\", ms=4, color=\"C3\")\n", + " axs[1].axhline(1, color=\"k\", lw=1)\n", + " axs[1].set_xlabel(f\"{d}ing time (ps)\"); axs[1].set_ylabel(\"weight / (1/N)\")\n", + " axs[1].set_title(f\"N_eff = {diag['neff']:.1f} of {t.size} max weight = \"\n", + " f\"{diag['w_max']:.3f} tail gap = {diag['tail_gap']:.3f}\", fontsize=9)\n", + " plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_system,\n", + " static=[dict(system=\"EQVTAV_WT\", direction=0.0, mode=0.0),\n", + " dict(system=\"EQVSAV_WT\", direction=1.0, mode=0.0),\n", + " dict(system=\"EQVSAV_WT\", direction=1.0, mode=1.0)],\n", + " system=names,\n", + " direction=(0.0, 1.0, 1.0) if HAVE_WIDGETS else None, # 0 = bind, 1 = unbind\n", + " mode=(0.0, 1.0, 1.0) if HAVE_WIDGETS else None) # 0 = target, 1 = mean" + ] + }, + { + "cell_type": "markdown", + "id": "1e797aad", + "metadata": {}, + "source": [ + "## 4. What the correction costs\n", + "\n", + "For an exponential sample the effective sample size after changing the mean by a factor f is N_eff/N ≈ 2f − f², independent of N. The points are the 24 system/direction pairs; the curve is that formula. Lengthening is expensive and impossible beyond f = 2, which is why the clock is chosen to avoid it." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "19ce20b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:08.298367Z", + "iopub.status.busy": "2026-09-19T07:49:08.298166Z", + "iopub.status.idle": "2026-09-19T07:49:08.454131Z", + "shell.execute_reply": "2026-09-19T07:49:08.453259Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f_grid = np.linspace(0.05, 1.95, 200)\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(f_grid, mt.neff_fraction(f_grid), \"k-\", label=\"2f − f² (exponential)\")\n", + "for clock_name, marker in ((\"balanced\", \"o\"), (\"decrease-only\", \"s\")):\n", + " c = clocks[clock_name]\n", + " fs, ne = [], []\n", + " for n in names:\n", + " for j, d in enumerate((\"bind\", \"unbind\")):\n", + " t = BY_NAME[n][\"t_bind\"] if d == \"bind\" else BY_NAME[n][\"t_unbind\"]\n", + " fac = A[n][j] / c\n", + " fs.append(fac)\n", + " ne.append(mt.diagnostics(t, mt.target_weights(t, t.mean() * fac),\n", + " t.mean() * fac)[\"neff\"] / t.size)\n", + " ax.plot(fs, ne, marker, ms=5, alpha=0.7, label=f\"{clock_name} clock\")\n", + "ax.set_xlabel(\"needed factor on ⟨t⟩\"); ax.set_ylabel(\"N_eff / N\"); ax.set_ylim(0, 1.05)\n", + "ax.legend(fontsize=8); ax.set_title(\"cost of the correction\"); plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "df313f52", + "metadata": {}, + "source": [ + "## 5. Using the weights on a structural observable\n", + "\n", + "This is the point of the exercise. For any per-trajectory descriptor O (encounter-complex lifetime, which contacts form first, how much of the mutated side-chain contact is present at the transition), compare Σ wᵢOᵢ with the plain average, and bootstrap over trajectories for an error bar.\n", + "\n", + "The descriptor here is **synthetic** — a quantity correlated with the binding time, standing in for something you would compute from the structures. With real data you would read `weights__.csv` and join it to your own analysis by trajectory index." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4a9a4deb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:08.456116Z", + "iopub.status.busy": "2026-09-19T07:49:08.455549Z", + "iopub.status.idle": "2026-09-19T07:49:09.153088Z", + "shell.execute_reply": "2026-09-19T07:49:09.152180Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def descriptor(t, rng):\n", + " # stand-in: \"fraction of native contacts at the first productive encounter\",\n", + " # lower for trajectories that take longer to bind\n", + " return np.clip(0.75 - 0.25 * np.log10(t / 400.0) + rng.normal(0, 0.05, t.size), 0, 1)\n", + "\n", + "def show_observable(system=\"EQVTAV_L25A\", nboot=200.0):\n", + " s = BY_NAME[system]\n", + " rng = np.random.default_rng(0)\n", + " t = s[\"t_bind\"]\n", + " O = descriptor(t, rng)\n", + " tau_target = t.mean() * A[system][0] / CLOCK\n", + " w = mt.target_weights(t, tau_target)\n", + " plain, wavg = O.mean(), float(np.sum(w * O))\n", + " bs_p, bs_w = [], []\n", + " for _ in range(int(nboot)):\n", + " b = rng.integers(0, t.size, t.size)\n", + " bs_p.append(O[b].mean())\n", + " wb = w[b] / w[b].sum()\n", + " bs_w.append(float(np.sum(wb * O[b])))\n", + " fig, axs = plt.subplots(1, 2, figsize=(11, 3.8))\n", + " axs[0].scatter(t, O, s=25, c=w * w.size, cmap=\"viridis\")\n", + " cb = plt.colorbar(axs[0].collections[0], ax=axs[0]); cb.set_label(\"weight / (1/N)\")\n", + " axs[0].set_xscale(\"log\"); axs[0].set_xlabel(\"binding time (ps)\")\n", + " axs[0].set_ylabel(\"descriptor\"); axs[0].set_title(f\"{system}: which trajectories count\", fontsize=9)\n", + " axs[1].bar([0, 1], [plain, wavg], yerr=[np.std(bs_p), np.std(bs_w)], capsize=4,\n", + " color=[\"0.6\", \"C3\"])\n", + " axs[1].set_xticks([0, 1]); axs[1].set_xticklabels([\"model (unweighted)\", \"reweighted\"])\n", + " axs[1].set_ylabel(\"⟨descriptor⟩\")\n", + " axs[1].set_title(f\"{wavg - plain:+.3f} shift, bootstrap sd {np.std(bs_w):.3f}\", fontsize=9)\n", + " plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_observable, static=[dict(system=\"EQVTAV_L25A\"), dict(system=\"EQVTAV_T35G\")],\n", + " system=names, nboot=(50.0, 500.0, 50.0) if HAVE_WIDGETS else None)" + ] + }, + { + "cell_type": "markdown", + "id": "818915ec", + "metadata": {}, + "source": [ + "## 6. Affinities before and after\n", + "\n", + "Matching both directions per system fixes K_D = k_off/k_on by construction, so the scatter against experiment collapses onto the diagonal. The interesting part is not this plot — it is that the weights doing so are mild (§4), i.e. the experimental affinities are reachable *within* the mechanisms the model already samples." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d7ddec03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T07:49:09.155211Z", + "iopub.status.busy": "2026-09-19T07:49:09.154614Z", + "iopub.status.idle": "2026-09-19T07:49:09.356001Z", + "shell.execute_reply": "2026-09-19T07:49:09.355046Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAHBCAYAAABjdGJeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUj5JREFUeJzt3XdYU2f/BvD7EKaGpYILKq5aURwIOIobRdBYR+uqiqu2VatVa6ettlatb2u1KnXQurWuV+zPUReCeyFqcY+KaEVBiEBAAZPz+8OSV8owSJKTkPtzXV6XOTk55xvQ3Hme85znEURRFEFERETlnpXUBRAREZFxMPSJiIgsBEOfiIjIQjD0iYiILARDn4iIyEIw9ImIiCwEQ5+IiMhCMPSJiIgsBEOfiIjIQjD0iaiQK1euoFWrVrC3t0ezZs2K3JaQkABBEHDu3Dmdjzt9+nTt8YrzMsclIt0InIaXiP6tf//+ePjwIZYvXw65XI7KlSsX2ubi4oKUlBRUqVIF1tbWOh1XpVIhJycHlStXBgAMGzYMjx49wrZt27T7qNXqUh+XiHTD/1FEVMjNmzfRvXt31KpVq8Rt1apVK9Vx5XI55HJ5ifvIZLJSH5eIdMPufSILtHv3bgQGBsLFxQWVK1dGjx49cPPmTQCAIAg4c+YMvvnmGwiCgOnTpxe57d/d8DExMRAEAVFRUfDz80OFChXQpk0bXL16VXve57v3p0+fjlWrVuH333+HIAgQBAExMTFFdu9fuHABISEhkMvlqFq1KoYMGYKHDx9qn9+yZQt8fHzg4OCAypUrIygoCFlZWQb/ORKZG4Y+kQXKysrCpEmTEBsbi6ioKFhZWaF3797QaDRISkpCo0aNMHnyZCQlJeGjjz4qcltxvvjiC8ydOxexsbGwtrbGiBEjitzvo48+Qr9+/dCtWzckJSUhKSkJbdq0KbTfo0eP0KlTJzRv3hyxsbHYvXs3Hjx4gH79+gEAkpKSMHDgQIwYMQKXL19GTEwM+vTpA165JCqM3ftEFqhv374FHi9fvhxubm64dOkSGjduDGtra8jlcm03u1wuL7Tt+Zb282bOnIn27dsDAD799FN0794dT548gb29fYH95HI5HBwckJOTU2J3/qJFi9C8eXPMmjWrQL2enp64du0aVCoVnj59ij59+mgvPfj4+JTyJ0JkGdjSJ7JA169fx8CBA1GnTh04OTnBy8sLAJCYmFjmYzdp0kT79+rVqwMAkpOTX/p458+fR3R0tHY8gFwux2uvvQbg2TiDpk2bonPnzvDx8cFbb72FiIgIKJXKsr0JonKKLX0iC6RQKFCrVi1ERESgRo0a0Gg0aNy4MXJzc8t8bBsbG+3fBUEAAGg0mpc+nkqlgkKhwJw5cwo9V716dchkMuzbtw/Hjh3D3r17sXDhQnzxxRc4efIkateu/dLnJSqP2NInsjCpqam4evUqpk6dis6dO6Nhw4aStYxtbW2hVqtL3MfX1xcXL16El5cX6tWrV+BPxYoVATz7cvH666/j66+/xtmzZ2Fra4vIyEhjvAUis8LQJ7Iwrq6uqFy5MpYtW4YbN27gwIEDmDRpkiS1eHl54c8//8TVq1fx8OFD5OXlFdpn7NixSEtLw8CBA3H69GncvHkTe/bswfDhw6FWq3Hy5EnMmjULsbGxSExMxNatW5GSkoKGDRtK8I6ITBtDn8jCWFlZYcOGDThz5gwaN26MiRMn4vvvv5eklnfeeQcNGjSAn58f3NzccPTo0UL71KhRA0ePHoVarUbXrl3h4+ODDz/8EC4uLrCysoKTkxMOHTqE0NBQvPrqq5g6dSrmzp2LkJAQCd4RkWnjjHxEREQWgi19IiIiC8HQJyIishAMfSIiIgvB0CciIrIQDH0iIiILYdEz8mk0Gty7dw+Ojo7amcOIiIjMjSiKyMzMRI0aNWBlVXx73qJD/969e/D09JS6DCIiIr24c+cOPDw8in3eokPf0dERwLMfkpOTk8TVEJWORqNBSkoK3NzcSvxmT0TlkyiK+OGHH9ClSxfUqVMHnp6e2lwrjkWHfn6XvpOTE0OfzI5Go8GTJ0/g5OTE0CeyMI8fP8bw4cOxceNGuLu7o1mzZgDwwkvVFh36RERE5ubevXt44403cPHiRWzZsgV9+/ZFRkaGTq9l6BMREZkJURTRvXt3pKSk4MiRI/D19S3V6xn6JVCr1UWu+kXSsbGxgUwmk7oMIiKjU6vVkMlkiIiIQM2aNVG9evVSH4OhXwyVSoW7d++C6xGZFkEQ4OHhAblcLnUpRERGIYoivv76a5w4cQI7duyAn5/fSx/LIkM/PDwc4eHhUKvVRT6vVqtx9+5dVKhQAW5ubryH30SIooiUlBTcvXsX9evXZ4ufiMq97OxsDB8+HJs2bcK3335b5s89i15aNyMjA87OzkhPTy8wev/Jkye4desWvLy84ODgIGGF9G+PHz9GQkICateuDXt7e6nLkZRGo0FycjLc3d05ep+oHPr777/xxhtv4PLly1izZg369OlT7L7F5dm/WWRLX1ds4Zse/k6IyFJERkYiOTkZR48e1d6SV1YMfT1TKpWIj4+HSqWCXC6Hj48PXF1dpS6LiIjMxOXLl9GwYUOMHTsWgwcPhouLi96OzT5BPVGr1di+fTsWLFiAmJgYnDlzBjExMViwYAG2b99e7PgBqe3YsQMdOnR44X4rV65Er169DF4PEZGl0mg0mD59Oho1aoQTJ05AEAS9Bj7Alr7e7Nq1C3FxcQCeDTh7fqhE/naFQiFJbUREZNqys7MxbNgwbN68GbNmzULLli0Nch629PVAqVRqg704cXFxUCqVZTqPIAiYOXMmWrZsCS8vL2zbtg2zZ8+Gn58f6tevj5iYGO2+a9asQZMmTdCkSRN0794df//9NwAgLy8PY8aMQf369REQEIDo6OgC51izZg1atmwJX19ftGvXDufPny9TzUREVLL79++jXbt22LlzJ7Zu3YrPPvvMYOOXGPp6EB8f/8JfkCAIiI+PL/O55HI5Tp48iV9//RWDBw9G9erVERsbi1mzZmHKlCkAgAsXLmDKlCn4448/8Oeff6JNmzYYNWoUAGDZsmW4evUqLl68iCNHjhT4snL06FH89ttvOHToEOLi4jBz5kwMGjSozDUTEVHxKlasiGrVquHo0aPo3bu3Qc/F7n09UKlUEAShxIl8BEGASqUq87n69+8PAPDz80NWVhYGDBgAAAgICMD169cBANHR0ejWrRtq1qwJABgzZgy++eYbqNVqREVFYejQobC1tQUAjBgxAr/++isA4Pfff8f58+cLdCulpaXh8ePHZa6biIgK2rx5M5o1a4b69etjx44dRjknW/p6IJfLXzhznyiKeplFLv/e9PwJGp5//PTp0yJfU1IvxPPPiaKIsLAwnDt3TvsnKSmJcxUQEemRRqPBtGnT0K9fP6xcudKo52bo64GPj49Ooe/j42OUejp27Ijdu3fj3r17AIAlS5agc+fOkMlkCAoKwtq1a5GXl4fc3FysWLFC+7qePXti7dq1SExMBPDsH2ZsbKxRaiYisgTZ2dno378/ZsyYgdmzZ+Pbb7816vktsnv/RdPwlparqyt8fX1LHMzn6+trtPv1GzdujO+//x7dunUDAHh6eiIiIgIA8M477+DChQvw9vaGq6sr2rZtizNnzgAA2rZti//85z/o3bs3nj59itzcXHTv3r1M8zwTEdEz+SvknT59Glu3bpXkNmhOw1vCNLylmepVrVZrb9sTBEF7jV8URfj6+iI0NJRzxevBy/xuyitOw0tkfvbs2YNq1aqhadOmej0up+E1MplMBoVCgcDAQM7IR0REWhs2bMCePXuwfPlyBAcHS1oLQ1/PXF1d0a5dO6nLICIiieUP2Pv2228xePBg5OXlae+ckgpDn4iISM+ysrIQFhaGrVu3Yvbs2fjkk09MYsEwhj4REZGe/fLLL9i9ezciIyPxxhtvSF2OFkf/EBER6UlaWhoAYNy4cTh37pxJBT7A0CciItKL9evXo1atWjh+/DhkMhnq1asndUmFMPQNQJOdjbTVq6HJzpa6FCIiMjCNRoOpU6fi7bffRu/evdG8eXOpSyoWQ98A0tasxYNZs5G2dp3Upby0UaNGFVqBryjTp0/Hhx9+WORz586dw4YNG17q/PnrGRARmbKsrCy8+eabmDVrFr777jusWrXKpOcQYejrmVqVhdR/Zr9LjYiAWpVlkPMUN8++vvzyyy/o2LFjmY5RltAnIjIH2dnZuHHjBiIjI01mhH5JGPp6ply3DpqsZ0GvUamgXL9eb8cWBAHTpk2Dv78/PvvsM2RmZuKdd95BQEAAmjRpgtGjRyM3NxfXrl3Dq6++CuDZtI9Vq1bF559/DgA4dOgQOnXqBADFvh4AOnTogG3btgEAkpKS0LVrV3h7e6Nr164YMGAApk+frq0rKSkJCoUC3t7e6NSpE9LS0pCcnIyvvvoK0dHRaNasGd577z0AwOnTp9GpUyf4+fmhefPm2Lx5s/Y4S5cuRf369dG8eXPMmzdPbz83IiJ9O3nyJP7++2+4ubnh7NmzJjdgrzgMfT3StvLzZzYWRb239mUyGU6fPo3vv/8ekydPRtu2bXHq1CmcP38eGo0GP/30E1599VXk5OQgMTERf/75J+rUqYOoqCgAwL59+xAUFAQAxb7+38aPH4/WrVvj0qVLWL16NWJiYgo8f/LkSaxcuRKXLl2Cu7s7li5dCnd3d3zzzTfo2LEjzp07hyVLluDRo0cYPXo01q1bh9jYWOzbtw+TJ0/G33//jQsXLmDatGk4dOgQzp49y+V8ichkrV+/Hu3bt9culmNOU6xb5H36+l5wJ9/zrfx8+a39KqPf0cs5RowYof37tm3bcPz4cfz4448AgMePH2v/8XXu3Bn79++HUqnEkCFDsGzZMjx69Aj79+/H/PnzX/j650VFReGHH34AAFSrVg09evQo8Hy3bt1QuXJlAEDr1q0RHx9fZO3Hjh3DX3/9hZCQkALbr169igsXLiAkJATVq1cHALz//vuYPXt2qX42RESGpNFo8OWXX2LWrFkYOnSo9rPUnFhk6I8dOxZjx47VLlCgD4Va+fn+ae27DhoEmbximc8jl8ufO7SI//73v9qu/OcFBQVhx44dUCqV+Omnn3D9+nVERkbi+vXr2lXzSnp9Sf59zer5QSsymazY8QaiKKJRo0Y4duxYoecuXLhQ4jmIiKQ2ePBgbNiwAXPmzMGUKVPM8nOK3ft6UlQrP5++r+3n69WrF+bMmaMNWaVSiRs3bgB41tKPiopCQkICXn31VQQFBeHrr79GYGCgtjVf0uuf16lTJ6xcuRIA8ODBA+zYsUOn+pycnJCenq593KZNG9y6dQv79+/Xbjt37hxyc3PRqVMn7N69G/fv3wcALFmypJQ/DSIiw+rRowe2bduGjz/+2CwDH2Do60Wxrfx8Bri2DwDz5s2Dg4MDmjVrhiZNmqBz585ISEgAAFStWhVVq1ZF69atAQDt27fHvXv30LlzZ51e/7yffvoJhw8fhre3N95++220bNkSLi4uL6yvc+fOyMnJQZMmTfDee+/B1dUVO3fuxKxZs9C0aVN4e3vj008/hUajQePGjTF9+nS0bdsWzZs3h52dnT5+REREZXLixAl89dVXAIBBgwahZ8+eEldUNoIoFpdU5V9x6w+Xds32tDVr8WDmTEAmA4r69ieKgFqNql98gUpDBuvzLRjF48ePYWNjA2tra6SmpqJVq1ZYu3YtWrZsafRaSvu7Kc80Gg2Sk5Ph7u4OKyt+fyfSt3Xr1mHkyJHw8/PDvn374ODgIHVJxSouz/7NIq/p61uFFr5wGThAp/3M0fXr1zF06FCIoojc3FyMGTNGksAnIjKG/Bn2Zs+ejWHDhmHJkiXlpveRoa8H9t7eqD5tmtRlGEyTJk1w7tw5qcsgIjKKpUuX4rvvvtPeGm2u1++LwtAvgQVf+TBZ/J0QkaHk5eXBxsYGI0eOhLe3N9q3by91SXrH0C+CjY0NBEFASkoK3NzcytW3PHMmiiJSUlIgCAJsbGykLoeIypHjx49j0KBB2LJlC1q0aFEuAx9g6BdJJpPBw8MDd+/eLXI0O0lHEAR4eHiY1QxYRGTa1q5di5EjRyIgIACvvPKK1OUYFEO/GHK5HPXr10deXp7UpdBzbGxsGPhEpBfPD9gbPnw4Fi9eXG4G7BWHoV8CmUzGgCEiKqeSk5OxcuVK/PDDD5g0aZJFXMpl6BMRkUVJTEyEo6MjqlWrhqtXr8LR0VHqkoyGM3oQEZHFOH78OPz9/TF58mQAsKjAByw09MPDw+Ht7Q1/f3+pSyEiIiNZs2YNOnTogAYNGmDOnDlSlyMJiwz9sWPH4tKlSzh9+rTUpRARkRFMnToVQ4cOxeDBg7F//364ublJXZIkLDL0iYjIslSpUgVz587FL7/8AltbW6nLkQwH8hERUbl0+/Zt7NmzB6NHj8aHH34odTkmgS19IiIqd44ePQp/f3/MmTMHKpVK6nJMBkOfiIjKlVWrVqFTp0547bXXcPLkScjlcqlLMhkMfSIiKjfWrl2LYcOGaQfsValSReqSTAqv6RMRkdkTRRGCIKBXr15Yvnw5hg0bZhEz7JUWW/pERGTWEhIS0KFDB1y7dg1yuRzDhw9n4BeDoU9ERGbryJEjCAgIwJ07d/D06VOpyzF5DH0iIjJLK1euRKdOndCwYUOcOnUK3t7eUpdk8hj6RERkdpKTkzFhwgQMHToU+/bt44A9HXEgHxERmY3MzEzIZDK4u7vj3Llz8PLy4vX7UmBLn4iIzEJCQgLatGmDcePGAQBq167NwC8lhj4REZm8I0eOwN/fH9nZ2fjoo4+kLsdsMfSJiMik5Q/Ya9SoEU6ePMkBe2XA0CciIpN27do1DBs2DHv37uWAvTJi6BMRkeQ02dlIW70amuxsAEBGRgZ27NgBAJg5cyaWLl1q0Uvi6otFjt4PDw9HeHg41Gq11KUQERGAtDVrkTJvHjRPcpDZJQg9e/bEvXv38Ndff8HZ2Vnq8soNQRRFUeoipJKRkQFnZ2ekp6fDyclJ6nKISkWj0SA5ORnu7u6wsmKnHZkvtSoLNzp0gEalQhyADx+mwNnFBdu3b0fDhg2lLs8s6Jpn/KQgIiJJKdetgyYrCwdVKgy7egUNKlfGyZMnGfgGwNAnIiLJqFVZSI2IAEQRTeztMapyZSyRO8LFzl7q0solhj4REUkm8Zdf8NmN63iQlwdXa2uMr+IGWXY2lOvXS11aucTQJyIiSVyPv4Dgzz7F/sxM3MnL+98ToojUiAioVVnSFVdOMfSJiMjoDh8+jNZtWuOJWo3fXqkFvwoVCjyvUanY2jcAhj4RERmVUqlE9+7dUU8QsLGWF+rY2RXeia19g2DoExGRUajVauTl5cHV1RWbP5yIZdVrwMXWFrC2LvxHJoMmMxPpkZFSl12uWOTkPEREZFwZGRkYOHAgvLy8EB4ejvYD+kMpe3G7s0ILXyNUZzkY+kREZFB//fUXevbsibt372LChAkAAHtvb1SfNk3iyiwPu/eJiMhgDh06hICAAOTk5ODEiRPo2rWr1CVZNIY+EREZzIYNG9CkSROcPHkSr732mtTlWDx27xMRkV6p1WqcP38evr6+mD9/PgRBgI2NjdRlEdjSJyIiPUpPT4dCoUD79u2RmpoKW1tbBr4JYUufiIj04ubNm1AoFLh37x7++9//onLlylKXRP/Clj4REZXZiRMnEBAQgLy8PA7YM2EMfSIiKrMaNWqga9euHLBn4hj6RET0Up4+fYqZM2ciLS0Nr7zyCn777TdUqlRJ6rKoBAx9IiIqtfT0dPTo0QPTpk3DoUOHpC6HdMSBfEREVCrPD9j7448/0KVLF6lLIh1ZZOiHh4cjPDwcarVa6lKIiMxKRkYGWrduDRcXF5w8eRINGjSQuiQqBUEURVHqIqSSkZEBZ2dnpKenw8nJSepyiEpFo9EgOTkZ7u7usLLilToyPFEUIQgCtm7dio4dO8LV1VXqkugfuuYZPymIiKhET58+xYcffohp/yyQ06dPHwa+mWLoExFRsfIH7C1atAjVqlWTuhwqI4u8pk9ERC9248YNKBQK3L9/H7t370ZQUJDUJVEZMfSJiKhIs2bNgkajwcmTJ/Hqq69KXQ7pAUOfiIgK+Pvvv1GzZk0sXLgQubm5vH5fjvCaPhERAXg2YG/ChAlo1KgR7t+/j4oVKzLwyxm29ImICI8ePcKAAQOwf/9+LFy4kIP2yimGPhGRhbtx4wZ69OiB5ORk7NmzB507d5a6JDIQhj4RkYXLy8uDs7Mztm/fjvr160tdDhkQr+kTEVmojRs3IisrCw0bNsSJEycY+BaAoU9EZGGePn2K8ePHY8CAAdi0aRMAQBAEiasiY2D3PhHRCyiVSsTHx0OlUkEul8PHx8dsR7U/evQI/fv3R1RUFBYvXozhw4dLXRIZEUOfiKgYarUau3btQlxcHARBgCAIEEUR0dHR8PX1RWhoKGQymdRl6iw7OxutW7fGgwcPsHfvXnTq1EnqksjIGPpERMXID3zg2Qpzzy9Kmr9doVBIUtvLqFChAsaMGYNu3brx+r2F4jV9IqIiKJVKbbAXJy4uDkql0kgVvbwlS5Zg0aJFAIAPPviAgW/BGPpEREWIj49/4eA2QRAQHx9vpIpK7+nTp/jggw/w/vvv4+bNm1KXQyaA3ftEREVQqVTaa/jFEQQBKpXKiFXpTqlUon///oiOjsaSJUvw7rvvSl0SmQCGPhFREeRyeYmBDzy7zi+Xy41UUelMmTIFsbGx2Lt3Lzp27Ch1OWQi2L1PRFQEHx8fnULfx8fHSBXpJjs7GwAwZ84cnDp1ioFPBTD0iYiK4OrqCl9f3xL38fX1Nan79X/++Wc0aNAASUlJqFy5MurVqyd1SWRiGPpERMUIDQ3VBr8gCLCystIO7su/T98UPH36FOPGjcPYsWPRp08fuLm5SV0SmShe0yciKoZMJoNCoUBgYKDJzsinVCrRr18/xMTEYOnSpRg9erTUJZEJY+gTEb2Aq6sr2rVrJ3UZRfrrr79w+fJlDtgjnTD0iYjM0IkTJ+Dr64sWLVrg5s2bsLOzk7okMgO8pk9EZGbCw8MRGBiIpUuXAgADn3TG0CciMhN5eXkYM2YMxo0bp51pj6g0LLJ7Pzw8HOHh4VCr1VKXQkSkkydPnqBHjx44ePAgli1bhnfeeUfqksgMCeKLZp8oxzIyMuDs7Iz09HQ4OTlJXQ5RqWg0GiQnJ8Pd3R1WVuy0K+9EUcRnn32Gbt26oUOHDlKXQyZG1zyzyJY+EZG52LdvH9LS0tC/f3989913UpdDZo7NAyIiExUeHo6QkBBs2LDhhVMCE+mCoU9EZGKeH7A3fvx4bNmy5YXL/BLpgt37REQmZvLkyYiIiEBERARGjRoldTlUjjD0iYhMhCiKEAQBH3/8Md58802TnQWQzBe794mITMDevXvh7++P1NRUeHh4MPDJIBj6RERGpMnORtrq1dD8s+69KIpYtGgRQkND4e7uDmtrdsCS4TD0iYiMKG3NWjyYNRtpa9dpB+x98MEHGD9+PLZv3w5nZ2epS6RyjF8piYiMRK3KQmpEBAAgNSICV+vVw8qVK/HLL79g5MiREldHloChT0RkJMp166DJysK9vDxUy8xEgxs3cOvWLVSrVk3q0shCsHufiMgI8lv5R1Uq9E64hbVpaUiNiICb3FHq0siCMPSJiIwgbe1arLpzB+/evYPmDg7o4+wMjUoF5fr1UpdGFoShT0RkYDmP0jHuy6mYnfwAQ10rIbymB+QyGSCKSI2IgFqVJXWJZCEY+kREBpb+22/Iys3FjGrV8LG7O2TPTanL1j4ZEwfyEREZyOXLl3Hn5k3U+vVX/Kda9aLnz/+nte86aBBk8orGL5IsClv6REQGsHv3brRq1QpfTpoEdWYmBGtroKg/Mhk0mZlIj4yUumSyAGzpExHpkSiKWLBgASZNmoSQkBAs/+orqP/444Wvq9DC1wjVkaVj6BMR6dGMGTMwbdo0fPTRR/juu+8gk8mAgACpyyICwNAnItKr/v37o1atWggLC5O6FKJCeE2fiKiMLl++jL59+0KlUqFBgwYMfDJZDH0iojLIH7B37do1PHr0SOpyiErE0Cci0kFRS+LOnz8f3bt3R7t27XDs2DF4eHhIXCVRyRj6REQ6eH5JXACIjY3FxIkTMXnyZGzbtg2OjpxDn0wfB/IREb3A80vi3l6yBC4DB8Lf3x9nz55Fs2bNpC2OqBTY0icieoH8JXFv5OSg94V4zB09GgAY+GR2GPpERCXIb+UfzMzEwMTbsBes4HfxIhfJIbPE0CciKkHa2rVYcScRY/++iwCHClhf6xXUyMvjIjlklhj6RETFUKuykBwRgYMqFYZXqoQFNWuiohWXxCXzxdAnIirCw4cPcei772CVnY2lHp6Y7MYlccn8cfQ+kQlQKpWIj4+HSqWCXC6Hj48PXF1dpS7LYl28eBGKHj1g8+ABtnq+AhsuiUvlBEOfSEJqtRq7du1CXFwcBEGAIAgQRRHR0dHw9fVFaGjoswVbyGh27dqFAQMGwNPFBT9Vrw4ra2ugmNDPXxK30pDBxi+U6CUw9IkklB/4wLMZ3kRR1D6Xv12hUEhSmyWKiIjAe++9hx49euCXqVPxdNeuF76GS+KSOWHoE0lEqVRqg704cXFxCAwMZFe/kTRr1gyffvopvvnmm2c9LP7+UpdEpFccyEckkfj4eAhFdRs/RxAExMfHG6kiy5SSkoLJkycjNzcX/v7+mDlzJi+pULnF0CeSiEql0in0VSqVkSqyPBcuXEBAQADWrFmDv/76S+pyiAyOoU8kEblcXuAaflFEUYRcLjdSRZZl586daNOmDRwdHXH69Gm89tprUpdEZHAWGfrh4eHw9vaGP6/XkYR8fHx0Cn0fHx8jVWQ5zp8/D4VCgY4dO+Lo0aOoVauW1CURGYVFhv7YsWNx6dIlnD59WupSyIK5urrC17fkkd++vr4cxKdHarUaANC0aVNERkYiMjKSS+KSRbHI0CcyFaGhodrgFwQBVlZW2uv8+ffpk36kpKSgY8eOWLNmDQDgjTfegJUVPwLJspT6lr1bt27h8OHDuH37NrKzs+Hm5obmzZujdevWsLe3N0SNROWWTCaDQqFAYGAgZ+QzoAsXLkChUCA7Oxv16tWTuhwiyegc+uvWrcNPP/2E2NhYVK1aFTVq1ICDgwPS0tJw8+ZN2Nvb4+2338Ynn3zC62NEpeTq6op27dpJXUa5tGPHDgwcOBB169ZFTEwMP5/IounUt9W8eXMsWLAAw4YNw+3bt5GUlIQzZ87gyJEjuHTpEjIyMvD7779Do9HAz88PmzdvNnTdRESFaLKzkbZ6NTTZ2c8eazSYMWMGgoKCcOTIEQY+WTxBfNHwYQB79uxBcHCwTgdMTU1FQkICWrRoUebiDC0jIwPOzs5IT0+Hk5OT1OUQlYpGo0FycjLc3d15bfofD5cuQ8q8eXD64APkdQ+Fl5cXlEolnJ2d+TOick3XPNMp9Msrhj6ZM4Z+QWpVFm506ICHjx5hwoP7yK5ZE/EXL3J2PbIIuuYZ594nonJBuW4drqSmYszdO8gRRazt1ZuBT/QvOoe+rv958u+DJSIyFrUqC//94XtMun0bnrY2WF3TAx5RUVCrskxqrXulUsm7NEhSOoe+KIqoVasWwsLC0Lx5c0PWRERUKsp162Cdk4u28or4tlp1VLSygkalgnL9elQZ/Y7U5UGtVmuXURYEAYIgQBRFREdHa+djsOReCX4ZMh6dr+nHxsbi119/xYYNG1C7dm2MGDECb7/9tln/YnhNn8wZr+kDOTk5WLJwIbr+tgHIyir0vJWjI+pFR0ve2t++fXuJyyj7+vpCoVAYsSLTUNyXIVEU+WWolHTNM50/Kfz8/LB48WIkJSVh0qRJiIyMhIeHBwYMGIB9+/bppWgiIl0lJyejc+fO+OSzz3ApLbXIffJb+1JSKpUlBj4AxMXFQalUGqki05Ef+MCz3mSNRqNdjyIuLg67du2SsrxyqdTNA3t7ewwePBhRUVG4cOECkpOT0a1bN6SlpRmiPiKiQuLj4xEQEIAb169jVd168LYrZjZQUURqRATUqsK9AMYSHx+v0xLK8fHxRqrINPDLkDReqk/w7t27+Pbbb9GlSxdcuXIFU6ZMYfc4ERnFlStX0KZNG7i6umLfZ5+jCQDIZIC1deE/Mhk0mZlIj4yUrF6VSqVT6KtUKiNVZBr4ZUgaOg/ky83NRWRkJH799VccPnwYISEhmD9/PkJCQnjNhYiMpkGDBvj2228xatQoyG7fhjL90QtfU6FFyasZGpJcLtdpCWW5XG6kikxD/pehkn42lvhlyNB0Dv3q1avD0dERYWFh+Pnnn+Hu7g4AyPrX4Bm2+IlI33JycvD++++jb9++6N69OyZMmPDsCW9vVJ82TdriXsDHxwfR0dEl7iOKInx8fIxUkWnglyFp6Ny9r1QqkZiYiBkzZqBBgwZwdXUt8MfFxcWsR/ITkWlKTk5Gp06dsH79emRmZkpdTqm5urpql08ujq+vr8V9fvr4+OgU+pb2ZcjQdG7pv+ibKhGRvv35559QKBTIzc3FwYMH0bJlS6lLeimhoaEAUOKtaZYm/8vQi25ltLQvQ4amt7n3nz59iidPnphVVwzv0ydzVt7v0xdFEf7+/lCr1fi///s/eHp6Sl1SmXESmoJ4n77+GGzBncTExCK3nz59Gh9++CHu3LlTukolxNAnc1ZeQl+TnY1HW7bA5c03YVWhAkRRRHp6OlxcXHD79m1UqVIFFSuazlS6pH/8MlR2Bltwx8vLq9jbLDg9LxGVVtqatUiZNw+aJzmQDx2Cd999F+fOnUNsbCxq1aoldXlkBK6urmjXrp3UZViEUof+2bNnCzxWq9W4efMmvvnmG4wfP15vhRFR+adWZSE1IgIAcPXnn/HRr7/i7PlzWL58OWxsbCSujqj8KXXoN23atNA2X19feHh4oE+fPhg6dKheCiOi8k+5bh00WVm48uQJxty8AU2FCmY9YI/I1OntQmClSpWQk5Ojr8MRUTmnbeWLIm7n5aKSTIaNXl7wa9RY6tKIyq1St/QzMjIKbXvw4AE+//xzTJgwocDzHBxHRMVJW7sWBx7cR/sKFRHs6ITOckdY5+aZzHK4ROVRqUfvW1lZFTmQL/8w+bdcCIIAtVqtnyoNhKP3yZyZ8+j9rIepGNTgVfxfWhrWer4C3woVtM+ZynK4RObEYKP3OUkPEZXF/fv3oWjTBvFKJX6oXqNA4AP/Ww6XrX0i/St16Ldv394QdRBZPEu4V/n27dtoGxiIJw8eYJXnK2ji4FB4p3+Ww3UdNIitfSI90yn0T5w4gVatWul0wOzsbNy6dQuNGjUqU2FElqK4Wcmio6PL3axkNWvWRPdGjdDP1g7V7O2B/FXWRBH4571DFLXL4VYaMljqkonKFZ0uBA4ZMgTBwcHYvHlzoVX18l26dAmff/456tatizNnzui1SKLyLD/wgWdjYzQajXaMTFxcHHbt2iVleWUmiiK+++47HD16FNbW1pj3449oMHgw0gMCcMPLCzfr1MZfdeviZp3auOHlhfSAADj37y/pcrhE5ZVOLf1Lly5h8eLFmDp1KgYNGoRXX30VNWrUgL29PZRKJa5cuQKVSoXevXtj7969XBWJSEdKpbLEBUeAZ8EfGBholl39T548wahRo7Bu3Tr88MMPeP3112Hv7Y0zfi0QZyUAXkXPuOfr6wuFt7eRqyUq/3QKfRsbG4wfPx7jx49HbGwsjhw5gtu3b+Px48do2rQpJk6ciI4dO6JSpUqGrpeoXImPj9d25xdHEATEx8eb3TSl9+/fR+/evXHu3Dls2LAB/fv3B1D+v+gQmbJSD+Tz8/ODn5+fIWohsjgqlUqn0FepVEasquxEUUSfPn1w+/ZtHDp0CP7+/trnyvMXHSJTV+rQJyL9kcvlJYYf8CxAzWnJ6qdPn8La2hpLlixB5cqVUbNmzQLPl9cvOkTmwLxm9CAqZ3x8fHQKfXMYJyOKImbOnIlOnTohNzcXTZo0KRT4QPn8okNkLhj6RBJydXWFr2/Jo9R9fX1N/tr2kydPMGTIEEydOhWdO3cucYW88vRFh8jcsHufSGKhoaEAUOg+fVEUtffpm7L79++jV69eOH/+PDZu3Ih+/fqVuH/+F52SBvOZwxcdInPE0CeSmEwmg0KhQGBgoFnOyLd7927cuXMHhw8f1nmQr7l/0SEyV6VacEej0WDlypXYunUrEhISIAgCateujTfffBNDhgwpciEeU8YFd8icSb3gzsWLF7Uzb6anp8PZ2bnUx7CEqYeJjEHXPNP5k0IURfTs2ROjRo3C33//DR8fHzRq1Ai3b9/GsGHD0Lt3b70UTkSmLX/Ano+PDw4cOAAALxX4wLOu/nbt2iE0NBTt2rVj4BMZmM7d+ytXrsShQ4cQFRWFjh07FnjuwIED6NWrF1avXo2hQ4fqvUgiMg2PHz/GqFGjsH79ekyfPr3QZwERmTadW/q//fYbPv/88yL/k3fq1Amffvop1q1bp9fiiMh0pKSkoGPHjoiMjMSmTZswbdo0s7ukR2TpdA79P//8E926dSv2+ZCQEJw/f14vRRGR6ZHL5ahevToOHz6Mt956S+pyiOgl6Ny9n5aWhqpVqxb7fNWqVaFUKvVSFBGZjq1bt6J+/frw8fFBZGSk1OUQURno3NJXq9Wwti7+O4JMJsPTp0/1UhQRSU8URXz77bfo27cvVqxYIXU5RKQHOrf0RVHEsGHDYGdnV+TzOTk5eiuKiKT1+PFjjBw5Er/99hu+/vprfPnll1KXRER6oHPoh4WFvXAfjtwnKh/69u2LmJgYbNq0idfvicqRUk3OUxp3795FjRo1JJk0RFecnIfMmSEn5zl48CDkcjlatGih1+MSkWHofXKe0vL29kZCQoKhDk9EerZlyxb0798farUa7du3Z+ATlUMGC30DdSAQkZ6JoohvvvkGb731FqysrJCXlyd1SURkIFxwh8iCPX78GMOHD8fGjRvxzTffYOrUqZxwh6gcY+gTWbC1a9fi//7v/7B582a8+eabUpdDRAbG0CeyQCkpKXBzc8OoUaPQsWNH1KtXT+qSiMgIDHZNn12ERKZp06ZNqF27Ng4cOABBEBj4RBZEr6GvUqm0f+dAPiLTIooivv76a/Tv3x8KhQKtW7eWuiQiMjKdQ3/evHklPp+ZmYng4GDt40uXLqFWrVovXxkR6U12djYGDBiA6dOnY8aMGVi/fj0cHBykLouIjEzna/qff/45KleuXOSse1lZWejWrRtSU1O12zw9PfVTIVEZKZVKxMfHQ6VSQS6Xw8fHB66urlKXZVS5ubm4efMmtmzZgr59+0pdDhFJROfQX7NmDYYMGQIXFxf07NlTuz0rKwvBwcFISUnBwYMHDVIk0ctQq9XYtWsX4uLiIAgCBEGAKIqIjo6Gr68vQkNDIZPJpC7ToGJjY1G5cmXUrl0bp06dMukZMonI8HT+BHjzzTexcOFCDBw4EDExMQD+18J/8OABYmJiUL16dUPVSVRq+YEPPLuerdFotGNN4uLisGvXLinLM7hNmzahbdu2+PrrrwGAgU9EpRvIN2rUKEybNg1vvPEGYmJiEBISgnv37iE6Oho1atQwVI1EpaZUKrWBX5y4uDgolUojVWQ8oihi+vTp6N+/P/r06YPFixdLXRIRmYhS36f/8ccfIy0tDZ07d4aXlxdiYmLg4eFhiNqIXlp8fLy2O784giAgPj4e7dq1M2Jlhjdy5EisWLECM2fOxGeffWYxt89y7AbRi+kc+n369Cnw2MbGBlWqVMGECRMKbN+6dat+KiuF3r17IyYmBp07d8aWLVuMfn4yPSqVSqfQf/420/JCoVCgR48ehf7Pllccu0GkO51D39nZucDjgQMH6r2YlzVhwgSMGDECq1atkroUMhFyufyFc0WIogi5XG6kigwrNjYWGzduxH/+8x/07t1b6nKM6t9jN57/vedvVygUktRGZGp0Dv0VK1YYso4y6dChg3ZwIREA+Pj4IDo6usR9RFGEj4+PkSoynI0bN2LEiBFo2rQpVCoVHB0dpS7JaHQduxEYGMiufiIYcBpeXR06dAgKhQI1atSAIAjYtm1boX3Cw8Ph5eUFe3t7tGzZEqdOnTJ+oWRWXF1d4evrW+I+vr6+Zh0EGo0GP/zwAwYNGoS+ffsiJibGogIf+N/YjZLkj90gIhNYcCcrKwtNmzbFiBEjirwGuXHjRkyaNAlLlixBy5YtMX/+fAQHB+Pq1atwd3cv1blycnKQk5OjfZyRkQHg2YenRqMp2xshk9OtWzeIooizZ88WuNYriiKaN2+Obt26mfXvfdWqVZg7dy6+/fZbfPrppxAEwazfz8vIzMzUaexGZmamxf1syLLo+u9b8tAPCQlBSEhIsc//+OOPeOeddzB8+HAAwJIlS7Bz504sX74cn376aanONXv2bO09y89LSUnBkydPSlc4mYWAgAB4e3sjISEBT548gb29Pby8vCCXywvMIGlOcnNzYWtriy5dumD16tXo3LkzUlJSpC5LEnZ2dnB0dHxh6NvZ2SE5OdmIlREZV2Zmpk77SR76JcnNzcWZM2fw2WefabdZWVkhKCgIx48fL/XxPvvsM0yaNEn7OCMjA56ennBzc4OTk5NeaibT4+7ujjp16khdhl6cPn0aAwYMwOrVq9G6dWsEBQXBzc3NYife8fX1xdGjR3Xaz8XFxfAFEUnE3t5ep/1MOvQfPnwItVqNqlWrFthetWpVXLlyRfs4KCgI58+fR1ZWFjw8PLB58+YiVxCzs7ODnZ1doe1WVlYW+6FJ5mPDhg0YPnw4mjVrhvr168PKygqCIFj0v99KlSrB19e3xMF8vr6+qFSpkhGrIjI+XT8DTDr0dbV//36pSyAyGI1Go10db/DgwYiIiIC9vT2vUf8jNDQUAArdpy+KovY+fSJ6xqRDv0qVKpDJZHjw4EGB7Q8ePEC1atUkqorIcDTZ2Xi0ZQtc3nwTVhUqAHh2W9qqVaswe/ZsfPLJJxYzw56uZDIZFAoFAgMDOSMf0QuYdOjb2tqiRYsWiIqKQq9evQA8a/VERUVh3Lhx0hZHpGea7GzcnTgJWQcPQvMkBzndQ2FtbY2qVavi4sWL5WYiIUNxdXUtd1MqE+mb5BcCVSoVzp07h3PnzgEAbt26hXPnziExMREAMGnSJERERGDVqlW4fPky3n//fWRlZWlH8xOVF6m/LkfWP8tTR8+bB38/P4wfPx4AGPhEpBeSt/RjY2PRsWNH7eP80fVhYWFYuXIl+vfvj5SUFHz11Ve4f/8+mjVrht27dxca3EdkjvK78x1DQpEaEQEA2JWRgS/uJ6FJ7dpYsGCBxBUSUXkiiC+aoLwcy8jIgLOzM9LT03nLHkni4dJlSJk3DxVatUL2iRP4+eFDLEp9iJ5OTphRrz4aHTwImbxika/VaDRITk6Gu7u7xY7eJ6JndM0zflIQSUStytK27rNPnAAAuFlbY2IVN8yuVh02WVlQrl8vZYlEVM5I3r0vhfDwcISHh0OtVktdClmg/C59dUYmNFlZSMrLw35VJoa4VsJb/5pAJjUiAq6DBhXb2iciKg1277N7n4zo+RH6gq0tzqWnY9zfd2ErCNjqVRvORaz77jZpEqqMfqfwsdi9T0T/YPc+kQl6foT+9ocpCLuTCE8bW2ys5VVk4APPWvtqVZYxyySicoqhT2Qkz1/D35OZgY+TkhDi6IiVnp6oYl38lTZNZibSIyONVSYRlWMWeU2fSAppK1ZAk5MDQRDQoaIcs6pVxxtOTkXPsJe/TRTh0MIXFVr4GrdYIiqXGPpERpCXkYHzixbikzt3MNW9Kl6zt0cvZ+eid7axgfMbPSHY2AAAXN96C/be3kaslojKK4Y+kREsHzESX9y8CVtBgNW/GvYiAAgCBJkMEEUgLw/2DV5DpSGDpSiViMoxhj6RgS1duBDjt/4Xje3t8VONmqhcxPX71EqV4Nm+nXbpZ3bnE5EhMPSJDOjRo0f45ONPEOLoiK+rVoNtEbfWCQCcMjJwp0MHtO3a1fhFEpHFYOgTGYBKpYJGo4GjtQ22eHqixj/rvBdFBGCblwchOhpg6BORATH0ifQsMTERPXv2xKuvvoolip6oaWUFEf9cuy+CACDFrQqsGzUyYpVEZIksMvQ5DS8ZyvHjx9G7d2/Y29vjyy+/RAWZDA59eiP+z/gSX/dX3boY2r27kaokIkvFaXg5DS/pybp16zBy5Ej4+flh69atcHd31z63fft2xMXFFftaX19fKBSKUp2P0/ASUT5Ow0tkZImJiRg4cCCioqIKBD4AhIaGwtf32Yh8QRBgZWWlvcbv6+uL0NBQo9dLRJaHLX229KkMVCoV9u3bh969eyP/v1JxA/YAQKlUIj4+HiqVCnK5HD4+PnB1dX2pc7OlT0T52NInMrDExEQEBgZi2LBhePjwIYQSRugD+g18IqKXYZED+YjKKn/AnoODA44ePYoqVaoUu69arcauXbsQFxen/WIgiiKio6O1XfuyYlbYIyLSJ7b0iUpp//796NChA+rXr49Tp06hcePGJe6fH/gAIIoiNBqN9lJAXFwcdu3aZfCaiYgAhj5Rqfn7++Pjjz/G/v374ebmVuK+SqWyxFH7wLPgVyqV+iyRiKhIDH0iHahUKowYMQJ//fUXnJ2dMWPGDO08+SWJj48v8To/8GzgX3x8yffxExHpA0Of6AVu376N119/HZs3b8atW7dK9VqVSqVT6KtUqrKUSESkE4Y+UQmOHTuGgIAAZGRk4Pjx4+jcuXOpXi+Xy/Giu2JFUYRcLi9LmUREOmHoExUjMzMTCoUCDRo00GnAXlF8fHx0Cn0fH5+XLZOISGcMfaJ/0Wg0yMnJgaOjI/bs2aPTgL3iuLq6amfiK46vry/v1ycio7DI0A8PD4e3tzf8/f2lLoVMTGZmJnr37o3Ro0cDAPz8/GBra1umY5Y0BW/16tUhCAIOHTrEEfxEZHCchpfT8NI/bt++DYVCgYSEBGzYsEHv8+Hnz8iXmZmJv//+G0lJSQUm6xFFsVST9XAaXiLKx2l4iUrh6NGj8Pf3h0qlwvHjxw2yAI6rqyvatWsHjUaDpKQkAJysh4iMi6FPBOD3339Hw4YNcerUKTRq1Mhg5+FkPUQkJYY+WSy1Wo2TJ08CAGbPno19+/aVOIe+PnCyHiKSEkOfLIImOxtpq1dDk50N4H8D9tq3b4+kpCTIZLIyD9jTBSfrISIpcZU9sghpa9YiZd48aJ7kQNW1CxQKBW7fvo3IyEhUr17daHVwsh4ikhJb+vRSlEolDh06hF27dpn87WZqVRZSIyIAAAfnz0eAvz+ys7Nx4sQJhISEGLUWTtZDRFJiS59KxRzXhleuWwdNVhYAwD0vD+3q1MGSnTsNfv2+KPmT9ZQ0mI+T9RCRobClT6VibmvDq1VZSF62DEsepiDl6VNUkckwUyPC1d5BsppKmqwn/4sTEZEhsKVPOtP1drPAwECTaane+fVXjL16FYeyVKhlY4sQJydoVCoo169HldHvSFKTTCaDQqFAYGAg4uPjoVKpIJfL4ePjYzI/NyIqnxj6pLP8281Kuiadf7tZu3btjFhZ0W5evISQTz9FUm4Ofq7pgXb5g+NEEakREXAdNAgyeUXJ6sufrIeIyFjYvU86M6fbzbKzsxH4+ut4on6K9a/U+l/g/yO/tU9EZEkY+qQzc7ndTBRF2GlETKtSBRtreaGenV1ROyE1IgJqVZbxCyQikghDn3Rm6rebqdVqTJkyBZMmTUJ6ZCTaW1vDxdYWsLYu/EcmgyYzE+mRkZLUSkQkBYu8ph8eHo7w8HCo1WqpSzErpny7WUZGBt5++23s2rULP/74Iyq08IXLwAEvfF2FFiWvdU9EVJ5waV0urVsqxd2nX9plYfXp1q1b6NmzJxITE7Fx40Z069bNqOeXCpfWJaJ8uuaZRbb06eWZ4u1mP/74o3aGvYYNG0pSAxGROWBLny19s3Xnzh14enoiJycHKpUKlStXlroko2JLn4jy6Zpn/KQgs6NWq/HRRx+hYcOGSExMhJ2dncUFPhHRy2D3PpmVjIwMDBo0CH/88QfmzZsHT09PqUsiIjIbDH0yG7du3YJCocDdu3exa9cuBAcHS10SEZFZYeiT2RBFEY6Ojjhx4gRee+01qcshIjI7vKZPJm/jxo1IT09HnTp1cOzYMQY+EdFLYuiTyVKr1Zg0aRIGDBiAdevWAcAL5/4nIqLisXufTFJGRgYGDhyI3bt3Y8GCBXj//felLomIyOwx9Mnk5OTk4PXXX8edO3fwxx9/oGvXrlKXRERULjD0yeTY2dlhwoQJCAwM5PV7IiI9YuiTyfj111/x8OFDfPLJJxg1apTU5RARlTscyEeSyx+wN2rUKCQmJr5w+V4iIno5bOmTpNLT0zFw4EDs3bsXixYtwtixY6UuiYio3GLok6S++uorHDt2DH/88Qe6dOkidTlEROWaRXbvh4eHw9vbG/7+/lKXYrGysrIAADNmzMCpU6cY+ERERmCRoT927FhcunQJp0+flroUixQREYG6devi9u3bcHJywquvvip1SUREFsEiQ5+k8fTpU0ycOBGjR49G3759UaNGDalLIiKyKLymT0aRnp6OAQMGYN++fRywR0QkEYY+GcXdu3dx8eJFDtgjIpIQQ58M6sSJE2jatCkaNWqE69evw87OTuqSiIgsFq/pk8EsW7YMbdu2xYIFCwCAgU9EJDGGPund06dPMWHCBLz77rsYPXo0Jk2aJHVJREQEdu+TnuXl5UGhUGD//v0IDw/HmDFjpC6JiIj+wZY+vTRNdjbSVq+GJjtbu83GxgatW7fG7t27GfhERCaGLX16aWlr1iJl3jxonuQgvn493L59G8OGDcO0adOkLo2IiIrAlj69FLUqC6kREQCA8Fkz0bVrV2zatIkr5BERmTC29OmlKNetQ65KhTkPHmDdIyVGdOiAJb//DkEQpC6NiIiKwdCnUstv5S9IScaGR0p85V4Vg1RZsMrJBWxspC6PiIiKwe59KrXUNWugycpCmGsl/OLpiQGurtCoVFCuXy91aUREVAKGPpXKvp070W7yJKTk5aGytTVaVqj47AlRRGpEBNSqLGkLJCKiYjH0SWdLlixBSM+eqCRYwbaIa/ds7RMRmTaGPr3Q06dP8cEHH+D999/HgMpVsNTDA84yWeEd2donIjJpDH16oQsXLmD58uX4YdgwfFGpEqytrYGi/shk0GRmIj0yUuqSiYioCBy9T8W6ffs2atasiWbNmiEhIQGOKSlQbt78wtdVaOFrhOqIiKi0GPpUpKioKLz11luYPHkyvvjiC7i5uQFubqjO2faIiMyWRXbvh4eHw9vbG/7+/lKXYpIWL16M4OBgBAQEYOzYsVKXQ0REeiKIFjxvakZGBpydnZGeng4nJyepy5GcWq3Ghx9+iEWLFmH8+PGYO3fus+v3ZJI0Gg2Sk5Ph7u4OKyuL/P5ORP/QNc/4iU5aVlZWyMnJwdKlSzF69GipyyEiIj1j6BOuXbuGGzduIDQ0FMuWLZO6HCIiMhD2CVq4qKgotGzZEl999RU0Go3U5RARkQEx9C3Yzz//jODgYLRs2RJRUVG8LkxEVM7xU95C/ec//8HYsWMxbtw47NixA87OzlKXREREBsZr+haqX79+qFKlCkaMGCF1KUREZCRs6VuQa9euoWfPnnj06BG8vLwY+EREFoahbyH279+Pli1b4vr163j06JHU5RARkQQY+hbg559/Rrdu3dCqVSucOHECXl5eUpdEREQSYOiXc/Hx8Rg3bhw++OADbN++nQP2iIgsGAfylVMZGRlwdHSEj48Pzp8/Dx8fH6lLIiIiibGlXw5dvXoVfn5++P777wGAgU9ERAAY+uXO3r170bJlS1hbW6Nv375Sl0NERCaEoV9OiKKIhQsXIjQ0FG3atMHx48dRt25dqcsiIiITwtAvJ0RRxP79+zF+/HgO2CMioiJxIJ+ZS0tLw40bNxAQEIAtW7bAxsZG6pKIiMhEMfTN2JUrV6BQKAAAly9fZuATEVGJ2L1vpvbu3YtWrVrB1tYWe/bsgbU1v78REVHJGPpmaNWqVQgJCdEO2KtTp47UJRERkRlg6JuhFi1a4JNPPsH27dvh5OQkdTlERGQmGPpmIjU1FePHj0d2djYaN26MWbNmQSaTSV0WERGZEYa+Gbh8+TJatmyJ9evX4+bNm1KXQ0REZoqhb+L27NmDVq1awc7ODqdOneKUukRE9NIY+ibs6tWr6N69OwIDAzlgj4iIyoz3eZkgtVoNmUyGBg0a4Pfff0e3bt14/Z6IiMqMLX0Tk5qaiqCgICxevBgA0L17dwY+ERHphUWGfnh4OLy9veHv7y91KQXkD9i7cOECGjduLHU5RERUzlhk6I8dOxaXLl3C6dOnpS5Fa/fu3WjVqhUcHBxw6tQptG3bVuqSiIionLHI0Dc1oihizpw5aNu2LY4ePYratWtLXRIREZVDHMgnodzcXNy5cwd169bFtm3bIJfLef2eiIgMhi19iaSmpqJr164ICgpCbm4unJ2dGfhERGRQbOlL4PLly1AoFEhPT0dkZCRsbW2lLomIiCwAW/pGtm/fPu2AvdOnTyMwMFDqkoiIyEIw9I2sYsWK6NKlC44dOwYvLy+pyyEiIgvC0DeC3NxczJ8/H3l5eWjTpg22bNkCR0dHqcsiIiILw9A3sIcPH6Jr1674+OOPERsbK3U5RERkwTiQz4AuXboEhUKBjIwMHDhwAK1bt5a6JCIismBs6RvIrVu30Lp1a1SoUIED9oiIyCQw9A3Ey8sLs2fP5oA9IiIyGQx9PcrNzcWoUaOwadMmCIKAMWPGcMAeERGZDIa+nqSkpCAoKAhr1qxBTk6O1OUQEREVwoF8enDhwgUoFApkZWXhwIEDeP3116UuiYiIqBCGfhmJoogxY8bAyckJMTExqFWrltQlERERFYmh/5JEUYRSqUSlSpWwYcMGODo68vo9ERGZNF7Tfwm5ubkYOXIkWrdujSdPnqBGjRoMfCIiMnls6ZdSSkoK+vbti5MnT2LZsmWwt7eXuiQiIiKdMPRLIX/AXnZ2NqKjo9GmTRupSyIiItIZQ78UEhMT4erqygF7RERklnhN/wVEUcTvv/8OjUaD0NBQnD59moFPRERmiaFfgpycHIwcORK9evXCgQMHAAAymUziqoiIiF4Ou/eLkZKSgj59+uDUqVNYvXo1goKCpC6JiIioTBj6Rbh37x5ef/11ZGdnIyYmhkviEhFRucDu/SJUq1YN/fr1w6lTpxj4RERUbjD0/yGKIn744Qfs27cPVlZWmDNnDgfsERFRucLQx7MBeyNGjMCUKVNw+vRpqcshIiIyCF7TB9CzZ0+cPXsWa9asweDBg6Uuh4iIyCAsOvRFUQQAXLt2DTt27EBAQAAyMjIkropINxqNBpmZmbC3t4eVFTvtiCxZfnbl51pxBPFFe5Rjd+/ehaenp9RlEBER6cWdO3fg4eFR7PMWHfoajQb37t2Do6MjBEGQupwC/P39JR9fYKwa9H0efR2vLMd52deW5nUZGRnw9PTEnTt34OTkVOpzkWn8P3sZplC3uX4+6POYpvQZIYoiMjMzUaNGjRJ7/iy6e9/KyqrEb0RSkslkkn+QG6sGfZ9HX8cry3Fe9rUv8zonJyfJ/62YK1P4f/YyTKFuc/180OcxTe0zwtnZ+YWv54VAEzV27FipSzBaDfo+j76OV5bjvOxrTeH3bknM9edtCnWb6+eDPo9pjp8RFt29T2TOMjIy4OzsjPT0dMlbfURkHtjSJzJTdnZ2mDZtGuzs7KQuhYjMBFv6REREFoItfSIiIgvB0CciIrIQDH0iIiILwdAnIiKyEAx9IiIiC8HQJyqnevfuDVdXV7z55ptSl0JEJoKhT1ROTZgwAatXr5a6DCIyIQx9onKqQ4cOcHR0lLoMIjIhDH0iE3To0CEoFArUqFEDgiBg27ZthfYJDw+Hl5cX7O3t0bJlS5w6dcr4hRKRWWHoE5mgrKwsNG3aFOHh4UU+v3HjRkyaNAnTpk1DXFwcmjZtiuDgYCQnJxu5UiIyJwx9IhMUEhKCb7/9Fr179y7y+R9//BHvvPMOhg8fDm9vbyxZsgQVKlTA8uXLjVwpEZkThj6RmcnNzcWZM2cQFBSk3WZlZYWgoCAcP35cwsqIyNQx9InMzMOHD6FWq1G1atUC26tWrYr79+9rHwcFBeGtt97Crl274OHhwS8ERARrqQsgIsPYv3+/1CUQkYlhS5/IzFSpUgUymQwPHjwosP3BgweoVq2aRFURkTlg6BOZGVtbW7Ro0QJRUVHabRqNBlFRUWjdurWElRGRqWP3PpEJUqlUuHHjhvbxrVu3cO7cOVSqVAmvvPIKJk2ahLCwMPj5+SEgIADz589HVlYWhg8fLmHVRGTqBFEURamLIKKCYmJi0LFjx0Lbw8LCsHLlSgDAokWL8P333+P+/fto1qwZFixYgJYtWxq5UiIyJwx9IiIiC8Fr+kRERBaCoU9ERGQhGPpEREQWgqFPRERkIRj6REREFoKhT0REZCEY+kRERBaCoU9ERGQhGPpEREQWgqFPVE4kJCRAEAScO3dO6lJe2sqVK+Hi4iJ1GSWKiopCw4YNoVarDXaOAQMGYO7cuQY7Plkuhj5ROeHp6YmkpCQ0btxY6lIwffp0NGvWzCDHFgQB27Zt0z7Oy8vDwIEDUbNmTVy4cEGn1+f/qVixIurXr49hw4bhzJkzOp3/448/xtSpUyGTyXSuediwYRAEAe+9916h58aOHQtBEDBs2DDttqlTp2LmzJlIT0/X+RxEumDoE5UDubm5kMlkqFatGqytLWfxzOzsbPTs2ROnT5/GkSNHdP7Cs2LFCiQlJeHixYsIDw+HSqVCy5YtsXr16hJfd+TIEdy8eRN9+/Ytda2enp7YsGEDHj9+rN325MkTrF+/Hq+88kqBfRs3boy6deti7dq1pT4PUUkY+kSloNFoMHv2bNSuXRsODg5o2rQptmzZAgAQRRFBQUEIDg5G/jpWaWlp8PDwwFdffQXg2ep5giBg586daNKkCezt7dGqVatCLdQjR46gbdu2cHBwgKenJ8aPH4+srCzt815eXpgxYwaGDh0KJycnjB49ulD3fv659uzZg+bNm8PBwQGdOnVCcnIy/vjjDzRs2BBOTk4YNGgQsrOzdXqPzx83KioKfn5+qFChAtq0aYOrV68CeNZF//XXX+P8+fPaFnX+yoA//vgjfHx8ULFiRXh6emLMmDFQqVQv9bt49OgRunTpgnv37uHIkSOoXbu2zq91cXFBtWrV4OXlha5du2LLli14++23MW7cOCiVymJft2HDBnTp0gX29vbabcOGDUOvXr0K7Pfhhx+iQ4cOBbb5+vrC09MTW7du1W7bunUrXnnlFTRv3rzQuRQKBTZs2KDzeyLSBUOfqBRmz56N1atXY8mSJbh48SImTpyIwYMH4+DBgxAEAatWrcLp06exYMECAMB7772HmjVrakM/35QpUzB37lycPn0abm5uUCgUyMvLAwDcvHkT3bp1Q9++ffHnn39i48aNOHLkCMaNG1fgGD/88AOaNm2Ks2fP4ssvvyy25unTp2PRokU4duwY7ty5g379+mH+/PlYv349du7cib1792LhwoU6vcfnffHFF5g7dy5iY2NhbW2NESNGAAD69++PyZMno1GjRkhKSkJSUhL69+8PALCyssKCBQtw8eJFrFq1CgcOHMDHH39c6t/D/fv30b59ewDAwYMHUa1atVIf498mTpyIzMxM7Nu3r9h9Dh8+DD8/v5c+x4gRI7BixQrt4+XLl2P48OFF7hsQEIBTp04hJyfnpc9HVIhIRDp58uSJWKFCBfHYsWMFto8cOVIcOHCg9vGmTZtEe3t78dNPPxUrVqwoXrt2TftcdHS0CEDcsGGDdltqaqro4OAgbty4UXu80aNHFzjH4cOHRSsrK/Hx48eiKIpirVq1xF69ehXY59atWyIA8ezZswXOtX//fu0+s2fPFgGIN2/e1G579913xeDgYJ3fY1HH3blzpwhAW9+0adPEpk2bFvej1Nq8ebNYuXJl7eMVK1aIzs7OJb4GgGhrayu+9tprYlZW1gvPUdTrIyMjC21//PixCECcM2dOsa91dnYWV69eXWBbWFiY+MYbbxTYNmHCBLF9+/aF9klOThbt7OzEhIQEMSEhQbS3txdTUlLEN954QwwLCytwjPPnz4sAxISEhNK+RaJiWc7FP6IyunHjBrKzs9GlS5cC23Nzcwt0z7711luIjIzEd999h8WLF6N+/fqFjtW6dWvt3ytVqoQGDRrg8uXLAIDz58/jzz//xLp167T7iKIIjUaDW7duoWHDhgCgc4uzSZMm2r9XrVoVFSpUQJ06dQpsO3XqVKne47+PW716dQBAcnJyoevTz9u/fz9mz56NK1euICMjA0+fPsWTJ0+QnZ2NChUq6PR+AKBHjx7Ytm0bli5diokTJ+r8upKI/1ySEQSh2H0eP35coGu/tNzc3NC9e3esXLkSoiiie/fuqFKlSpH7Ojg4AECBSy9EZcXQJ9JR/rXnnTt3ombNmgWes7Oz0/49OzsbZ86cgUwmw/Xr11/qPO+++y7Gjx9f6LnnA7VixYo6Hc/Gxkb7d0EQCjzO36bRaLTnBl78Hos6LgDtcYqSkJCAHj164P3338fMmTNRqVIlHDlyBCNHjkRubm6pQn/IkCHo2bMnRowYAVEUMWnSJJ1fW5z8L10ljQ2oUqVKidf885V0O9+IESO0l2rCw8OL3S8tLQ3Asy8KRPrC0CfSkbe3N+zs7JCYmKi9nlyUyZMnw8rKCn/88QdCQ0PRvXt3dOrUqcA+J06c0Aa4UqnEtWvXtC14X19fXLp0CfXq1TPcmymGru/xRWxtbQsF35kzZ6DRaDB37lxYWT0bTrRp06aXPkdYWBisrKwwfPhwaDQafPTRRy99LACYP38+nJycEBQUVOw+zZs3x6VLlwptf/DgQYHHf/31V7HH6NatG3JzcyEIAoKDg4vd78KFC/Dw8Ci2J4DoZTD0iXTk6OiIjz76CBMnToRGo0FgYCDS09Nx9OhRODk5ISwsDDt37sTy5ctx/Phx+Pr6YsqUKQgLC8Off/4JV1dX7bG++eYbVK5cGVWrVsUXX3yBKlWqaEeAf/LJJ2jVqhXGjRuHUaNGoWLFirh06RL27duHRYsWSf4edeHl5YVbt27h3Llz8PDwgKOjI+rVq4e8vDwsXLgQCoUCR48exZIlS8pU75AhQ2BlZYWwsDCIoogpU6bo9LpHjx7h/v37yMnJwbVr17B06VJs27YNq1evLnFyoODgYKxatarQ9pMnTyIiIgKdO3fGgQMHsGfPHtStWxe3bt0q1HMgk8m0vQol3et/+PBhdO3aVaf3Q6QzSUcUEJkZjUYjzp8/X2zQoIFoY2Mjurm5icHBweLBgwfF5ORksWrVquKsWbO0++fm5ootWrQQ+/XrJ4ri/wbBbd++XWzUqJFoa2srBgQEiOfPny9wnlOnToldunQR5XK5WLFiRbFJkybizJkztc/XqlVLnDdvXoHXFDeQT6lUavcpaqDcvwfdlfQeizvu2bNnRQDirVu3RFF8NiCwb9++oouLiwhAXLFihSiKovjjjz+K1atXFx0cHMTg4GBx9erVBY6l60C+fw/EW79+vSiTycTvvvuuxNfmvz7/j729vVi3bl0xLCxMPHPmzAtfm5qaKtrb24tXrlzRbgsLCxM7deokBgcHa3+fq1evFh0dHcX3339fu8+/B/s9798D+R4/fiw6OzuLx48ff2FNRKUhiOI/o1eIyOBiYmLQsWNHKJVKk59uloo2ZcoUZGRkYOnSpQCe3af/6NGjArMEltXixYsRGRmJvXv36u2YRADv0yciKpUvvvgCtWrVKnHQYlnZ2NgUmDuBSF8Y+kRUbsyaNQtyubzIPyEhIXo5h4uLCz7//HPtYERDGDVqFBo0aGCw45PlYvc+EZUbaWlp2lvd/s3BwaHQbYhEloahT0REZCHYvU9ERGQhGPpEREQWgqFPRERkIRj6REREFoKhT0REZCEY+kRERBaCoU9ERGQh/h9sa8wxiJ4gPgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean |log10 K_D error|: model 0.19 -> reweighted 0.00\n" + ] + } + ], + "source": [ + "kd_exp, kd_model, kd_rw = [], [], []\n", + "for n in names:\n", + " s = BY_NAME[n]\n", + " kd_exp.append(s[\"koff\"] / s[\"kon\"])\n", + " kon_m, koff_m = mt.model_rates(s, CONC, \"binding\")\n", + " kd_model.append(koff_m / kon_m * 1.0) # model K_D in uM (clock cancels)\n", + " fb, fu = A[n][0] / CLOCK, A[n][1] / CLOCK\n", + " kon_rw = kon_m / fb\n", + " koff_rw = koff_m / fu\n", + " kd_rw.append(koff_rw / kon_rw)\n", + "kd_exp, kd_model, kd_rw = map(np.array, (kd_exp, kd_model, kd_rw))\n", + "fig, ax = plt.subplots(figsize=(5.2, 4.6))\n", + "lim = [0.5 * min(kd_exp.min(), kd_model.min()), 2 * max(kd_exp.max(), kd_model.max())]\n", + "ax.plot(lim, lim, \"k--\", lw=1)\n", + "ax.scatter(kd_exp, kd_model, s=40, label=\"model\", color=\"0.5\")\n", + "ax.scatter(kd_exp, kd_rw, s=40, label=\"reweighted\", color=\"C3\", marker=\"^\")\n", + "ax.set_xscale(\"log\"); ax.set_yscale(\"log\"); ax.set_xlim(lim); ax.set_ylim(lim)\n", + "ax.set_xlabel(\"experimental K_D (µM)\"); ax.set_ylabel(\"K_D (µM)\")\n", + "ax.legend(fontsize=8); ax.set_title(\"affinities\", fontsize=10)\n", + "plt.tight_layout(); plt.show()\n", + "print(\"mean |log10 K_D error|: model %.2f -> reweighted %.2f\"\n", + " % (np.mean(np.abs(np.log10(kd_model / kd_exp))), np.mean(np.abs(np.log10(kd_rw / kd_exp)))))" + ] + }, + { + "cell_type": "markdown", + "id": "c28df7b0", + "metadata": {}, + "source": [ + "## Running it on your own data\n", + "\n", + "```bash\n", + "maxcal-target systems.csv --conc 0.017 --clock balanced --out target_out\n", + "```\n", + "\n", + "`systems.csv` needs `system,kon_exp,koff_exp,bind_times,unbind_times`; each times file holds one first-passage time per line, in model time units, in trajectory order. The outputs are `summary.csv` (clock residuals and diagnostics), `weights__.csv` (what you join to your structural analysis), `calibration.png` and the CDF panels.\n", + "\n", + "Caveats worth repeating: the clock is assumed shared across systems (check the spread of the residual factors); reweighting shifts the weights of mechanisms the model already samples and cannot invent new ones; and a low N_eff means the experimental kinetics are *not* reachable that way, which is itself a result about the model." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 95b8936..98e218c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "maxcal" -version = "0.1.0" +version = "0.2.0" description = "Maximum-caliber correction of underestimated barriers in first-passage trajectories (two-state kinetics, TSE)" readme = "README.md" requires-python = ">=3.9" @@ -15,12 +15,14 @@ test = ["pytest>=7", "nbformat", "nbclient", "ipykernel"] demo = ["jupyterlab", "ipywidgets>=8"] [project.scripts] -maxcal-poisson = "maxcal_poisson:main" -maxcal-joint = "maxcal_joint:main" -maxcal-target = "maxcal_target:main" +maxcal-stitch = "maxcal.stitching:main" +maxcal-reweight = "maxcal.reweight:main" +maxcal-committor = "maxcal.committor:main" +maxcal-joint = "maxcal.joint:main" +maxcal-target = "maxcal.target:main" [tool.setuptools] -py-modules = ["maxcal_poisson", "maxcal_joint", "maxcal_target"] +packages = ["maxcal"] [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/tests/conftest.py b/tests/conftest.py index 1994f8b..8043973 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -4,7 +4,7 @@ import pytest HERE = os.path.dirname(os.path.abspath(__file__)) -sys.path.insert(0, os.path.join(HERE, os.pardir)) # maxcal_poisson.py +sys.path.insert(0, os.path.join(HERE, os.pardir)) # the maxcal package sys.path.insert(0, HERE) # langevin.py diff --git a/tests/regtest/reference_reweight.csv b/tests/regtest/reference_reweight.csv new file mode 100644 index 0000000..0719ad9 --- /dev/null +++ b/tests/regtest/reference_reweight.csv @@ -0,0 +1,7 @@ +qts,N,n_done,sum_k,kmax,p,geom_p,lag1_rho,lag1_p,cv0,cv_lammax,ks_p0,lam_star,lam_lo,lam_hi,boot_noroot,neff_star,ks_p_star,reweight_ok,geom_status,lag1_status,reweight_status,note +0.383333,100,100,286,12,0.259067,0.241822,-0.0816005,0.329201,0.805936,0.540971,0.00124969,nan,nan,nan,1,nan,nan,0,ok,ok,no_root, +0.4,100,100,244,11,0.290698,0.478363,-0.0134009,0.887968,0.805936,0.535583,0.00124969,nan,nan,nan,1,nan,nan,0,ok,ok,no_root, +0.466667,100,100,123,8,0.44843,0.914989,-0.0628215,0.70789,0.805936,0.464694,0.00124969,nan,nan,nan,1,nan,nan,0,ok,ok,no_root, +0.55,100,100,57,4,0.636943,0.475826,nan,nan,0.805936,0.495261,0.00124969,nan,nan,nan,1,nan,nan,0,ok,too_few_pairs,no_root, +0.633333,100,100,25,2,0.8,nan,nan,nan,0.805936,0.618446,0.00124969,nan,nan,nan,1,nan,nan,0,too_few_bins,too_few_pairs,no_root,failure pool <10: initial segments included +0.716667,100,100,11,1,0.900901,nan,nan,nan,0.805936,0.649382,0.00124969,nan,nan,nan,1,nan,nan,0,too_few_bins,too_few_pairs,no_root,failure pool <10: initial segments included diff --git a/tests/regtest/reference_stitching.csv b/tests/regtest/reference_stitching.csv new file mode 100644 index 0000000..93d934c --- /dev/null +++ b/tests/regtest/reference_stitching.csv @@ -0,0 +1,7 @@ +qts,N,n_done,sum_k,kmax,frac_k0,p,geom_p,lag1_rho,lag1_p,cv0,ks_p0,cv_stitch0,ksp_stitch0,lam_stitch,p_stitch,geom_status,lag1_status,stitch_status,note +0.383333,100,100,286,12,0.21,0.259067,0.241822,-0.0816005,0.329201,0.805936,0.00124969,0.903173,0.0852287,0,0.259067,ok,ok,ok, +0.4,100,100,244,11,0.24,0.290698,0.478363,-0.0134009,0.887968,0.805936,0.00124969,0.969838,0.0976006,0,0.290698,ok,ok,ok, +0.466667,100,100,123,8,0.44,0.44843,0.914989,-0.0628215,0.70789,0.805936,0.00124969,0.901548,0.0157461,0.45,0.341411,ok,ok,ok, +0.55,100,100,57,4,0.62,0.636943,0.475826,nan,nan,0.805936,0.00124969,0.901021,0.0389903,0.4,0.540441,ok,too_few_pairs,ok, +0.633333,100,100,25,2,0.77,0.8,nan,nan,nan,0.805936,0.00124969,0.764772,0.000249938,2.35,0.276137,too_few_bins,too_few_pairs,ok_pool_fallback,failure pool <10: initial segments included +0.716667,100,100,11,1,0.89,0.900901,nan,nan,nan,0.805936,0.00124969,0.563381,0.000249938,3.5,0.215392,too_few_bins,too_few_pairs,ok_pool_fallback,failure pool <10: initial segments included diff --git a/tests/regtest/reference_summary.csv b/tests/regtest/reference_summary.csv deleted file mode 100644 index 6811836..0000000 --- a/tests/regtest/reference_summary.csv +++ /dev/null @@ -1,6 +0,0 @@ -qts,N,n_done,sum_k,frac_k0,p,geom_p,lag1_rho,lag1_p,cv0,ks_p0,lam_star,lam_lo,lam_hi,boot_noroot,neff_star,ks_p_star,reweight_ok,cv_lammax,kmax,cv_stitch0,ksp_stitch0,lam_stitch,p_stitch,geom_status,lag1_status,reweight_status,stitch_status,note -0.383333,100,100,286,0.21,0.259067,0.241822,-0.0816005,0.329201,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.540971,12,0.938403,0.0847288,0,0.259067,ok,ok,no_root,ok, -0.466667,100,100,123,0.44,0.44843,0.914989,-0.0628215,0.70789,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.464694,8,0.884336,0.0366158,0.4,0.352741,ok,ok,no_root,ok, -0.55,100,100,57,0.62,0.636943,0.475826,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.495261,4,0.876319,0.0228693,0.6,0.490531,ok,too_few_pairs,no_root,ok, -0.633333,100,100,25,0.77,0.8,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.618446,2,0.765308,0.000249938,2.3,0.286242,too_few_bins,too_few_pairs,no_root,ok_pool_fallback,failure pool <10: initial segments included -0.716667,100,100,11,0.89,0.900901,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.649382,1,0.551963,0.000249938,3.35,0.24182,too_few_bins,too_few_pairs,no_root,ok_pool_fallback,failure pool <10: initial segments included diff --git a/tests/regtest/reference_target.csv b/tests/regtest/reference_target.csv new file mode 100644 index 0000000..7d54b19 --- /dev/null +++ b/tests/regtest/reference_target.csv @@ -0,0 +1,25 @@ +system,direction,N,tau_model,tau_target,needed_factor,N_eff,N_eff_expected,weighted_mean,ks_D,ks_p,max_weight,tail_gap +EQVSAV_A53G,bind,50,637,355.292,0.5578,40.47,40.22,355.292,0.0898,0.8751,0.03328,0.000869 +EQVSAV_A53G,unbind,50,769000,390490,0.5078,38.8,37.89,390490,0.1297,0.4876,0.03338,0.000149 +EQVSAV_L18A,bind,50,560,448.959,0.8017,46.09,48.03,448.959,0.08432,0.8719,0.03812,0.00786 +EQVSAV_L18A,unbind,50,909000,1.21674e+06,1.339,44.89,44.27,1.21674e+06,0.08056,0.9094,0.04972,0.027 +EQVSAV_L25A,bind,50,612,584.444,0.955,47.28,49.9,584.444,0.06406,0.9838,0.02473,0.000849 +EQVSAV_L25A,unbind,50,312000,445387,1.428,37.62,40.86,445387,0.1777,0.1606,0.05676,0.131 +EQVSAV_T35G,bind,50,446,318.616,0.7144,47.07,45.92,318.616,0.1197,0.4744,0.02509,0.000528 +EQVSAV_T35G,unbind,50,435000,207297,0.4765,38.48,36.3,207297,0.1749,0.1736,0.03247,7.94e-05 +EQVSAV_V44A,bind,50,595,299.306,0.503,38.36,37.65,299.306,0.1136,0.6685,0.03385,0.000168 +EQVSAV_V44A,unbind,50,714000,559703,0.7839,47.16,47.66,559702,0.09257,0.7811,0.0242,0.00342 +EQVSAV_WT,bind,50,525,340.59,0.6487,43.72,43.83,340.59,0.1116,0.6042,0.03094,0.000326 +EQVSAV_WT,unbind,50,435000,645811,1.485,42.97,38.26,645811,0.09519,0.7959,0.04452,0.0181 +EQVTAV_A53G,bind,50,490,411.546,0.8399,49.07,48.72,411.546,0.06973,0.9576,0.02198,3.97e-05 +EQVTAV_A53G,unbind,50,1.25e+06,799575,0.6397,44.75,43.51,799575,0.1159,0.5431,0.02649,0.000417 +EQVTAV_L18A,bind,50,520,411.546,0.7914,46.64,47.83,411.546,0.1412,0.2789,0.02469,0.0152 +EQVTAV_L18A,unbind,50,1.43e+06,1.61453e+06,1.129,47.57,49.17,1.61453e+06,0.07169,0.9511,0.04203,0.00905 +EQVTAV_L25A,bind,50,533,881.884,1.655,37.9,28.58,881.884,0.08952,0.8943,0.07211,0.0146 +EQVTAV_L25A,unbind,50,526000,312102,0.5933,43.28,41.73,312102,0.08344,0.9013,0.02841,6.34e-05 +EQVTAV_T35G,bind,50,592,365.819,0.6179,42.75,42.7,365.819,0.1232,0.4935,0.03364,0.000305 +EQVTAV_T35G,unbind,50,1e+06,342675,0.3427,32.43,28.4,342675,0.09959,0.8778,0.04149,6.39e-09 +EQVTAV_V44A,bind,50,532,365.819,0.6876,45.02,45.12,365.819,0.1448,0.2746,0.02721,0.00234 +EQVTAV_V44A,unbind,50,1.11e+06,730047,0.6577,42.81,44.14,730047,0.09068,0.84,0.0331,0.00419 +EQVTAV_WT,bind,50,391,379.889,0.9716,49.93,49.96,379.889,0.08226,0.86,0.02212,0.0182 +EQVTAV_WT,unbind,50,909000,763231,0.8396,48.41,48.71,763231,0.06771,0.9697,0.02578,0.00535 diff --git a/tests/synthetic.py b/tests/synthetic.py index de53804..e8fa56f 100644 --- a/tests/synthetic.py +++ b/tests/synthetic.py @@ -40,3 +40,46 @@ def write_reweight_set(outdir, n0=200, n3=40, f=0.25, T0=50, TS=20, TL=200, seed np.savetxt(os.path.join(outdir, f"s_{i:03d}.xvg"), np.column_stack([np.arange(q.size, dtype=float), q]), fmt="%.6f") return specs + + +# --------------------------------------------------------------- rate-target dataset +# Twelve PDZ2-like systems: experimental kon/koff from Gianni et al. as tabulated in the +# multi-eGO PDZ2 paper, and model mean binding/unbinding times derived from that paper's +# Table 1 (kon in uM^-1 s^-1, koff in s^-1, model taus in ps). The trajectories +# themselves are exponential samples with those means: enough to exercise the clock fit, +# the weights and their diagnostics reproducibly. +PDZ2_LIKE = { + "EQVTAV_WT": (2.6, 22.0, 391.0, 909_000.0), + "EQVTAV_L18A": (2.4, 10.4, 520.0, 1_430_000.0), + "EQVTAV_L25A": (1.12, 53.8, 533.0, 526_000.0), + "EQVTAV_T35G": (2.7, 49.0, 592.0, 1_000_000.0), + "EQVTAV_V44A": (2.7, 23.0, 532.0, 1_110_000.0), + "EQVTAV_A53G": (2.4, 21.0, 490.0, 1_250_000.0), + "EQVSAV_WT": (2.9, 26.0, 525.0, 435_000.0), + "EQVSAV_L18A": (2.2, 13.8, 560.0, 909_000.0), + "EQVSAV_L25A": (1.69, 37.7, 612.0, 312_000.0), + "EQVSAV_T35G": (3.1, 81.0, 446.0, 435_000.0), + "EQVSAV_V44A": (3.3, 30.0, 595.0, 714_000.0), + "EQVSAV_A53G": (2.78, 43.0, 637.0, 769_000.0), +} + + +def write_rate_dataset(outdir, n=50, seed=7): + """Times files plus the systems.csv that maxcal-target reads.""" + import csv + os.makedirs(os.path.join(outdir, "times"), exist_ok=True) + rows = [] + for i, (name, (kon, koff, tb, tu)) in enumerate(sorted(PDZ2_LIKE.items())): + for direction, tau in (("bind", tb), ("unbind", tu)): + rng = np.random.default_rng([seed, i, 0 if direction == "bind" else 1]) + x = rng.exponential(tau, n) + x *= tau / x.mean() # exact mean, as the paper's fits report + np.savetxt(os.path.join(outdir, "times", f"{name}_{direction}.dat"), x, fmt="%.6f") + rows.append(dict(system=name, kon_exp=kon, koff_exp=koff, + bind_times=f"times/{name}_bind.dat", + unbind_times=f"times/{name}_unbind.dat")) + path = os.path.join(outdir, "systems.csv") + with open(path, "w", newline="") as fh: + wr = csv.DictWriter(fh, fieldnames=list(rows[0]), lineterminator="\n") + wr.writeheader(); wr.writerows(rows) + return path diff --git a/tests/test_committor.py b/tests/test_committor.py index d89df1c..b08a84f 100644 --- a/tests/test_committor.py +++ b/tests/test_committor.py @@ -6,7 +6,7 @@ import numpy as np import pytest -import maxcal_poisson as m +import maxcal as m import langevin as L QU, QF, QTS, M_BUMP, SIG = 0.3, 0.8, 0.40, 0.55, 0.06 diff --git a/tests/test_joint.py b/tests/test_joint.py index 42cf05c..104ddd9 100644 --- a/tests/test_joint.py +++ b/tests/test_joint.py @@ -1,9 +1,9 @@ -"""Unit tests and fast end-to-end checks for maxcal_joint.py.""" +"""Unit tests and fast end-to-end checks for maxcal.joint.""" import numpy as np import pytest -import maxcal_joint as mj -import maxcal_poisson as mp +from maxcal import joint as mj +import maxcal as mp from langevin import run_many QA, QB, QTSE = 0.3, 0.8, 0.55 diff --git a/tests/test_joint_validation.py b/tests/test_joint_validation.py index 01f3a98..9cbff33 100644 --- a/tests/test_joint_validation.py +++ b/tests/test_joint_validation.py @@ -18,8 +18,8 @@ import numpy as np import pytest -import maxcal_joint as mj -import maxcal_poisson as mp +from maxcal import joint as mj +import maxcal as mp import langevin as L from langevin import run_many diff --git a/tests/test_notebook.py b/tests/test_notebook.py index 717dd7f..1e71388 100644 --- a/tests/test_notebook.py +++ b/tests/test_notebook.py @@ -1,5 +1,6 @@ -"""The demo notebook must run top to bottom (slow: pytest --runslow). -Executed in static mode (MAXCAL_DEMO_STATIC=1), exactly as the committed copy is rendered.""" +"""The demo notebooks must run top to bottom (slow: pytest --runslow). +Executed in static mode (MAXCAL_DEMO_STATIC=1), exactly as the committed copies are +rendered.""" import os import pytest @@ -11,14 +12,16 @@ pytest.importorskip("ipykernel") HERE = os.path.dirname(os.path.abspath(__file__)) -NB = os.path.join(HERE, os.pardir, "notebooks", "demo.ipynb") +NB_DIR = os.path.join(HERE, os.pardir, "notebooks") -def test_demo_notebook_executes(monkeypatch): +@pytest.mark.parametrize("name,min_figures", [("demo.ipynb", 10), ("target_demo.ipynb", 5)]) +def test_demo_notebook_executes(monkeypatch, name, min_figures): monkeypatch.setenv("MAXCAL_DEMO_STATIC", "1") + NB = os.path.join(NB_DIR, name) nb = nbformat.read(NB, as_version=4) nbclient.NotebookClient(nb, timeout=600, kernel_name="python3", resources={"metadata": {"path": os.path.dirname(NB)}}).execute() n_fig = sum(1 for c in nb.cells if c.cell_type == "code" for o in c.outputs if "data" in o and "image/png" in o["data"]) - assert n_fig >= 10 + assert n_fig >= min_figures diff --git a/tests/test_regtest.py b/tests/test_regtest.py index 6dd7667..1829f01 100644 --- a/tests/test_regtest.py +++ b/tests/test_regtest.py @@ -1,5 +1,5 @@ -"""Regression test: full CLI run on a seeded Langevin data set, compared to a stored -reference summary. To regenerate the reference after an intended change: +"""Regression test: the three command-line tools on a seeded Langevin data set, compared +to stored reference summaries. Regenerate after an intended change with MAXCAL_UPDATE_REF=1 pytest tests/test_regtest.py """ @@ -15,113 +15,118 @@ from langevin import write_dataset HERE = os.path.dirname(os.path.abspath(__file__)) -SCRIPT = os.path.join(HERE, os.pardir, "maxcal_poisson.py") -REF = os.path.join(HERE, "regtest", "reference_summary.csv") -CLI = ["--qu", "0.3", "--qf", "0.8", "--nqts", "5", "--boot", "50", - "--nstitch", "2000", "--nsub", "100", "--seed", "11"] - -# deterministic columns (data + fixed-seed null): tight tolerance -EXACT = ["qts", "N", "n_done", "sum_k", "frac_k0", "p", "geom_p", "cv0", "ks_p0", - "lam_star", "neff_star", "cv_lammax", "kmax"] -# stochastic but seeded columns: loose tolerance, robust to RNG-algorithm changes -LOOSE = {"cv_stitch0": 0.08, "lam_stitch": 0.5} -# reason codes for NaNs: must match exactly -STATUS = ["geom_status", "lag1_status", "reweight_status"] -# stitch_status depends on the stochastic pass/fail near the threshold only through -# "ok" vs "no_pass"; pool availability is deterministic -POOL_STATUS = "stitch_status" +ROOT = os.path.join(HERE, os.pardir) +REF = os.path.join(HERE, "regtest") +COMMON = ["--qu", "0.3", "--qf", "0.8", "--qts", "0.40", "--nqts", "5", "--seed", "11"] - -def check_nan_reasons(row): - """Every NaN in a summary row must come with a non-ok reason code.""" - nan = lambda c: row[c] in ("", "nan") - assert nan("geom_p") == (row["geom_status"] != "ok"), row - assert nan("lag1_rho") == (row["lag1_status"] != "ok"), row - if nan("lam_star"): - assert row["reweight_status"] == "no_root", row - if nan("lam_stitch"): - assert row["stitch_status"] in ("empty_pool", "no_pass"), row +# deterministic columns (data + fixed-seed nulls): tight tolerance +EXACT = {"stitch": ["qts", "N", "n_done", "sum_k", "kmax", "frac_k0", "p", "geom_p", + "cv0", "ks_p0"], + "reweight": ["qts", "N", "sum_k", "p", "cv0", "cv_lammax", "ks_p0", "lam_star", + "neff_star"]} +LOOSE = {"stitch": {"cv_stitch0": 0.08, "lam_stitch": 0.5}, "reweight": {}} +STATUS = ["geom_status", "lag1_status"] def read(path): with open(path) as fh: - rows = list(csv.DictReader(fh)) - return rows + return list(csv.DictReader(fh)) def as_float(v): return float(v) if v not in ("", "nan") else np.nan +def check_nan_reasons(row): + """Every NaN in a summary row must come with a non-ok reason code.""" + nan = lambda c: row.get(c, "") in ("", "nan") + assert nan("geom_p") == (row["geom_status"] != "ok"), row + assert nan("lag1_rho") == (row["lag1_status"] != "ok"), row + if "reweight_status" in row and nan("lam_star"): + assert row["reweight_status"] == "no_root", row + if "stitch_status" in row and nan("lam_stitch"): + assert row["stitch_status"] in ("empty_pool", "no_pass"), row + + @pytest.fixture(scope="module") def run(tmp_path_factory): d = tmp_path_factory.mktemp("regtest") - write_dataset(str(d / "data"), n=100, seed=2024) - out = d / "out" - r = subprocess.run([sys.executable, SCRIPT, str(d / "data" / "q_*.xvg"), - "--out", str(out)] + CLI, capture_output=True, text=True) - assert r.returncode == 0, r.stderr - return out, r.stdout + data = str(d / "data") + write_dataset(data, n=100, seed=2024) + pattern = os.path.join(data, "q_*.xvg") + out = {} + for tool, extra in (("stitching", ["--nstitch", "2000", "--nsub", "100"]), + ("reweight", ["--boot", "50"]), + ("committor", [])): + o = d / tool + r = subprocess.run([sys.executable, "-m", f"maxcal.{tool}", pattern, + "--out", str(o)] + COMMON + extra, + capture_output=True, text=True, cwd=ROOT) + assert r.returncode == 0, r.stderr + out[tool] = o + return out def test_outputs_exist(run): - out, _ = run - for f in ["summary.csv", "survival.png", "lambda_scan.png", "robustness_qts.png", - "committor.csv", "ts_location.csv", "ts_location.png", "heatmap.csv", "heatmap.png"]: - assert (out / f).exists(), f - assert list(out.glob("tse_frames_qts*.csv")) - assert list(out.glob("tse_committor_lam*_q0.50.csv")) - com = read(out / "committor.csv") + for tool, files in (("stitching", ["summary.csv", "survival.png", "robustness_qts.png", + "heatmap.csv", "heatmap.png"]), + ("reweight", ["summary.csv", "survival.png", "lambda_scan.png"]), + ("committor", ["committor.csv", "ts_location.csv", "ts_location.png"])): + for f in files: + assert (run[tool] / f).exists(), f"{tool}/{f}" + assert list(run["reweight"].glob("weights_qts*.csv")) + assert list(run["reweight"].glob("tse_frames_qts*.csv")) + assert list(run["committor"].glob("tse_committor_lam*_q0.50.csv")) + + +def test_physics_sanity(run): + rows = read(run["stitching"] / "summary.csv") + for r in rows: + assert int(r["N"]) == 100 and int(r["n_done"]) == 100 # all fold, none censored + assert 0.0 < float(r["p"]) <= 1.0 + check_nan_reasons(r) + assert np.all(np.diff([float(r["p"]) for r in rows]) > 0), "p must grow with Q‡" + for r in read(run["reweight"] / "summary.csv"): + check_nan_reasons(r) + + com = read(run["committor"] / "committor.csv") iso = np.array([as_float(r["q_model_isotonic"]) for r in com]) iso = iso[np.isfinite(iso)] assert np.all(np.diff(iso) >= 0) and 0 <= iso.min() and iso.max() <= 1 - ts = read(out / "ts_location.csv") - # default assumption (barrier on the model TS): the TS does not move with lambda + ts = read(run["committor"] / "ts_location.csv") at_default = [float(r["Q_TS"]) for r in ts if float(r["q_star"]) == 0.5] - assert np.ptp(at_default) < 1e-9 - hm = read(out / "heatmap.csv") - assert len(hm) == 5 * 21 # --nqts 5, default 21 lambdas + assert np.ptp(at_default) < 1e-9 # barrier on the model TS: TS does not move + + hm = read(run["stitching"] / "heatmap.csv") + assert len(hm) == 6 * 21 # 5 grid values + --qts ksp = np.array([as_float(r["median_ks_p"]) for r in hm]) assert np.all((ksp[np.isfinite(ksp)] > 0) & (ksp[np.isfinite(ksp)] <= 1)) - # Q‡ columns flagged valid are exactly those before the assumed barrier (model TS here) - valid_q = sorted({float(r["qts"]) for r in hm if r["qts_valid"] == "1"}) - assert valid_q and max(valid_q) < 0.56 + valid = sorted({float(r["qts"]) for r in hm if r["qts_valid"] == "1"}) + assert valid and max(valid) < 0.56 - -def test_physics_sanity(run): - out, stdout = run - rows = read(out / "summary.csv") - for r in rows: - assert int(r["N"]) == 100 and int(r["n_done"]) == 100 # all fold, none censored - assert 0.0 < float(r["p"]) <= 1.0 - p = [float(r["p"]) for r in rows] - assert np.all(np.diff(p) > 0), "success probability must grow as Q‡ approaches Qf" - ref = rows[len(rows) // 2] - assert np.isfinite(as_float(ref["lam_stitch"])), "stitching must reach Poisson statistics" - for r in rows: - check_nan_reasons(r) - tse = read(next(out.glob("tse_frames_qts*.csv"))) + tse = read(next(run["reweight"].glob("tse_frames_qts*.csv"))) assert len(tse) == 100 assert sum(float(t["weight_at_lambda_star"]) for t in tse) == pytest.approx(1.0, abs=1e-4) -def test_against_reference(run): - out, _ = run - new = os.path.join(out, "summary.csv") +@pytest.mark.parametrize("tool", ["stitching", "reweight"]) +def test_against_reference(run, tool): + new = os.path.join(run[tool], "summary.csv") + ref = os.path.join(REF, f"reference_{tool}.csv") if os.environ.get("MAXCAL_UPDATE_REF"): - os.makedirs(os.path.dirname(REF), exist_ok=True) - shutil.copy(new, REF) + os.makedirs(REF, exist_ok=True) + shutil.copy(new, ref) pytest.skip("reference updated") - assert os.path.exists(REF), "no reference; run with MAXCAL_UPDATE_REF=1" - got, exp = read(new), read(REF) + assert os.path.exists(ref), f"no reference for {tool}; run with MAXCAL_UPDATE_REF=1" + got, exp = read(new), read(ref) assert len(got) == len(exp) + key = "stitch" if tool == "stitching" else "reweight" for g, e in zip(got, exp): - for c in EXACT: - np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), rtol=1e-5, - atol=1e-9, equal_nan=True, err_msg=f"{c} @ Q‡={e['qts']}") + for c in EXACT[key]: + np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), rtol=1e-5, atol=1e-9, + equal_nan=True, err_msg=f"{c} @ Q‡={e['qts']}") for c in STATUS: - assert g[c] == e[c], f"{c} @ Q‡={e['qts']}: {g[c]} != {e[c]}" - assert (g[POOL_STATUS] == "empty_pool") == (e[POOL_STATUS] == "empty_pool") - for c, tol in LOOSE.items(): + assert g[c] == e[c], f"{c} @ Q‡={e['qts']}" + for c, tol in LOOSE[key].items(): np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), atol=tol, equal_nan=True, err_msg=f"{c} @ Q‡={e['qts']}") diff --git a/tests/test_reweight_path.py b/tests/test_reweight_path.py index 3ae22e2..23becf2 100644 --- a/tests/test_reweight_path.py +++ b/tests/test_reweight_path.py @@ -9,9 +9,9 @@ import numpy as np import pytest -import maxcal_poisson as m +import maxcal as m from synthetic import write_reweight_set -from test_regtest import SCRIPT, check_nan_reasons +from test_regtest import ROOT, check_nan_reasons QU, QF, QTS = 0.3, 0.8, 0.45 @@ -21,10 +21,10 @@ def run(tmp_path_factory): d = tmp_path_factory.mktemp("reweight") specs = write_reweight_set(str(d / "data")) out = d / "out" - r = subprocess.run([sys.executable, SCRIPT, str(d / "data" / "s_*.xvg"), + r = subprocess.run([sys.executable, "-m", "maxcal.reweight", str(d / "data" / "s_*.xvg"), "--qu", str(QU), "--qf", str(QF), "--qts", str(QTS), "--nqts", "1", - "--boot", "100", "--nstitch", "1000", "--nsub", "50", "--seed", "3", - "--out", str(out)], capture_output=True, text=True) + "--boot", "100", "--seed", "3", "--out", str(out)], + capture_output=True, text=True, cwd=ROOT) assert r.returncode == 0, r.stderr with open(out / "summary.csv") as fh: rows = {round(float(x["qts"]), 3): x for x in csv.DictReader(fh)} @@ -59,7 +59,7 @@ def test_weighted_cv_is_one_at_lambda_star(run): def test_tse_weights_follow_the_tilt(run): out, rows, _, _ = run lam = float(rows[QTS]["lam_star"]) - with open(next(out.glob(f"tse_frames_qts{QTS:.3f}*.csv"))) as fh: + with open(next(out.glob(f"weights_qts{QTS:.3f}.csv"))) as fh: tse = list(csv.DictReader(fh)) w = np.array([float(t["weight_at_lambda_star"]) for t in tse]) k = np.array([int(t["k_failed"]) for t in tse]) @@ -75,7 +75,6 @@ def test_statuses_explain_nans_beyond_attempts(run): assert r["geom_status"] == "too_few_bins" assert r["lag1_status"] == "too_few_pairs" assert r["reweight_status"] == "no_root" - assert r["stitch_status"] == "empty_pool" assert rows[QTS]["lag1_status"] == "constant_cycles" # identical cycles by construction for row in rows.values(): check_nan_reasons(row) diff --git a/tests/test_target.py b/tests/test_target.py index 850288e..95667ed 100644 --- a/tests/test_target.py +++ b/tests/test_target.py @@ -6,7 +6,7 @@ import pytest from scipy import stats -import maxcal_target as mt +from maxcal import target as mt # ------------------------------------------------------------------------ weights diff --git a/tests/test_target_regtest.py b/tests/test_target_regtest.py new file mode 100644 index 0000000..4c6bcb1 --- /dev/null +++ b/tests/test_target_regtest.py @@ -0,0 +1,76 @@ +"""Regression test for maxcal-target on a seeded 12-system (PDZ2-like) dataset. + + MAXCAL_UPDATE_REF=1 pytest tests/test_target_regtest.py # regenerate the reference +""" +import csv +import os +import shutil +import subprocess +import sys + +import numpy as np +import pytest + +from synthetic import write_rate_dataset +from test_regtest import ROOT, REF, read, as_float + +# everything here is deterministic given the seeded times: compare tightly +EXACT = ["needed_factor", "tau_model", "tau_target", "N_eff", "weighted_mean", "ks_D", + "max_weight", "tail_gap"] + + +@pytest.fixture(scope="module") +def run(tmp_path_factory): + d = tmp_path_factory.mktemp("target_regtest") + systems = write_rate_dataset(str(d)) + out = d / "out" + r = subprocess.run([sys.executable, "-m", "maxcal.target", systems, "--conc", "0.017", + "--clock", "balanced", "--out", str(out)], + capture_output=True, text=True, cwd=ROOT) + assert r.returncode == 0, r.stderr + return out, r.stdout + + +def test_outputs_and_sanity(run): + out, stdout = run + for f in ["summary.csv", "calibration.png", "cdf_bind.png", "cdf_unbind.png"]: + assert (out / f).exists(), f + rows = read(out / "summary.csv") + assert len(rows) == 24 # 12 systems x 2 directions + for r in rows: + assert int(r["N"]) == 50 + assert 0 < float(r["N_eff"]) <= 50 + # the weights hit the experimental mean exactly, and match the exponential shape + assert float(r["weighted_mean"]) == pytest.approx(float(r["tau_target"]), rel=1e-5) # CSV is written with %.6g + assert float(r["ks_D"]) < 0.2 + factors = np.array([float(r["needed_factor"]) for r in rows]) + assert 0.2 < factors.min() and factors.max() < 2.0 # a mild, reachable correction + assert np.all(np.array([float(r["N_eff"]) for r in rows]) > 20) + assert "clock factor" in stdout + + +def test_clock_is_consistent_across_systems(run): + """One global clock: the needed factors are k_model/k_exp divided by a single c, + so the spread of their logarithms is the model's own per-system error.""" + out, _ = run + rows = read(out / "summary.csv") + lf = np.log([float(r["needed_factor"]) for r in rows]) + assert abs(lf.mean()) < 0.6 and lf.std() < 0.6 + + +def test_against_reference(run): + out, _ = run + new = os.path.join(out, "summary.csv") + ref = os.path.join(REF, "reference_target.csv") + if os.environ.get("MAXCAL_UPDATE_REF"): + os.makedirs(REF, exist_ok=True) + shutil.copy(new, ref) + pytest.skip("reference updated") + assert os.path.exists(ref), "no reference; run with MAXCAL_UPDATE_REF=1" + got, exp = read(new), read(ref) + assert len(got) == len(exp) + for g, e in zip(got, exp): + assert (g["system"], g["direction"]) == (e["system"], e["direction"]) + for c in EXACT: + np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), rtol=1e-5, atol=1e-12, + equal_nan=True, err_msg=f"{c} @ {e['system']} {e['direction']}") diff --git a/tests/test_unit.py b/tests/test_unit.py index c093706..52e2181 100644 --- a/tests/test_unit.py +++ b/tests/test_unit.py @@ -1,8 +1,8 @@ -"""Unit tests for maxcal_poisson.py (run with: pytest -q tests/).""" +"""Unit tests for the shared maxcal machinery (run with: pytest -q tests/).""" import numpy as np import pytest -import maxcal_poisson as m +import maxcal as m QU, QF = 0.3, 0.8 diff --git a/tests/test_validation.py b/tests/test_validation.py index 8748a6a..e73770d 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -21,7 +21,7 @@ import pytest from scipy import stats -import maxcal_poisson as m +import maxcal as m from langevin import run_many QU, QF = 0.3, 0.8