scripts/07_wright_fisher_simulation.py

import os
import json
import numpy as np
import pandas as pd
from scipy.stats import mannwhitneyu, spearmanr, ttest_ind

RESULTS_DIR = "results"

# Population parameters (S. cerevisiae, Lynch et al. 2008)
NE = 10000
MU = 1e-9       # per bp per generation
GENERATIONS = 1000
REPLICATES = 100
SEED = 42

# Selection coefficients derived from NEM-based dN/dS proxy (2.377)
# s = (omega - 1) / (omega + 1) / (2 * Ne)
DNDS_CODING = 2.377
S_CODING = (DNDS_CODING - 1) / (DNDS_CODING + 1) / (2 * NE)
S_REGULATORY = S_CODING * 3      # 3-fold stronger on regulatory sequences

DRUG_EFFLUX_GENES = {
    "PDR5", "PDR10", "PDR11", "PDR12", "PDR15", "PDR18", "SNQ2", "YOR1", "YCF1"
}


def load_nem_data():
    path = os.path.join(RESULTS_DIR, "nem_comprehensive_summary.csv")
    if not os.path.exists(path):
        raise FileNotFoundError(f"{path} not found. Run 02_nem_analysis.py first.")
    nem_df = pd.read_csv(path)
    gene_df = (
        nem_df[nem_df["region"] == "promoter"]
        .groupby("gene")
        .agg(nem_density=("nem_density_per_kb", "mean"),
             total_nems=("nem_count", "sum"))
        .reset_index()
    )
    gene_df["is_drug_efflux"] = gene_df["gene"].isin(DRUG_EFFLUX_GENES)
    return gene_df


def wright_fisher_step(freq, s, Ne, mu):
    fitness = 1 + s * freq
    mean_w = np.mean(fitness)
    freq_after_selection = freq * (1 + s) / mean_w
    freq_after_mutation = freq_after_selection + mu * (1 - 2 * freq_after_selection)
    freq_after_drift = np.random.binomial(
        2 * Ne, np.clip(freq_after_mutation, 0, 1)
    ) / (2 * Ne)
    return np.clip(freq_after_drift, 0, 1)


def simulate_gene(nem_density, nem_density_min, nem_density_max,
                  Ne=NE, mu=MU, generations=GENERATIONS,
                  replicates=REPLICATES, rng=None):
    if rng is None:
        rng = np.random.default_rng(SEED)

    # Scale selection coefficient by NEM density relative to gene set
    nem_range = nem_density_max - nem_density_min
    if nem_range > 0:
        constraint = (nem_density - nem_density_min) / nem_range
    else:
        constraint = 0.5
    s = -S_REGULATORY * constraint

    trajectories = np.zeros((replicates, generations))
    for rep in range(replicates):
        freq = float(rng.uniform(0.3, 0.7))
        for gen in range(generations):
            fitness = 1 + s * freq
            mean_w = fitness  # single locus
            freq = freq * (1 + s) / mean_w
            freq += mu * (1 - 2 * freq)
            freq = float(np.random.binomial(2 * Ne, np.clip(freq, 0, 1))) / (2 * Ne)
            trajectories[rep, gen] = freq

    return trajectories


def main():
    rng = np.random.default_rng(SEED)
    np.random.seed(SEED)

    gene_df = load_nem_data()
    nem_min = gene_df["nem_density"].min()
    nem_max = gene_df["nem_density"].max()

    print(f"Simulating {len(gene_df)} genes × {REPLICATES} replicates × "
          f"{GENERATIONS} generations...")

    trajectory_records = []
    final_freq_records = []

    for _, row in gene_df.iterrows():
        gene = row["gene"]
        trajectories = simulate_gene(
            row["nem_density"], nem_min, nem_max,
            rng=rng
        )
        mean_traj = trajectories.mean(axis=0)
        std_traj = trajectories.std(axis=0)
        final_freqs = trajectories[:, -1]

        for gen in range(0, GENERATIONS, 50):
            trajectory_records.append({
                "gene": gene,
                "generation": gen,
                "mean_freq": round(float(mean_traj[gen]), 4),
                "std_freq": round(float(std_traj[gen]), 4),
                "is_drug_efflux": bool(row["is_drug_efflux"]),
                "nem_density": round(float(row["nem_density"]), 2),
            })

        final_freq_records.append({
            "gene": gene,
            "mean_final_freq": round(float(final_freqs.mean()), 4),
            "std_final_freq": round(float(final_freqs.std()), 4),
            "is_drug_efflux": bool(row["is_drug_efflux"]),
            "nem_density": round(float(row["nem_density"]), 2),
            "selection_coefficient": round(
                float(-S_REGULATORY * max(0, (row["nem_density"] - nem_min) / max(nem_max - nem_min, 1e-9))),
                8
            ),
        })

    traj_df = pd.DataFrame(trajectory_records)
    final_df = pd.DataFrame(final_freq_records)

    traj_df.to_csv(os.path.join(RESULTS_DIR, "wf_trajectories.csv"), index=False)
    final_df.to_csv(os.path.join(RESULTS_DIR, "wf_final_frequencies.csv"), index=False)

    # Category comparison: drug efflux vs other
    drug_final = final_df[final_df["is_drug_efflux"]]["mean_final_freq"].values
    other_final = final_df[~final_df["is_drug_efflux"]]["mean_final_freq"].values
    t_stat, p_ttest = ttest_ind(drug_final, other_final)
    delta = float(np.mean(other_final) - np.mean(drug_final))

    # NEM density vs final frequency correlation
    rho_nem, p_nem = spearmanr(final_df["nem_density"], final_df["mean_final_freq"])

    summary = {
        "parameters": {
            "Ne": NE,
            "mu_per_bp_per_gen": MU,
            "generations": GENERATIONS,
            "replicates": REPLICATES,
            "dnds_proxy_coding": DNDS_CODING,
            "s_coding": float(S_CODING),
            "s_regulatory": float(S_REGULATORY),
            "regulatory_to_coding_ratio": 3.0,
        },
        "results": {
            "drug_efflux_mean_final_freq": round(float(np.mean(drug_final)), 4),
            "drug_efflux_std_final_freq": round(float(np.std(drug_final)), 4),
            "other_mean_final_freq": round(float(np.mean(other_final)), 4),
            "other_std_final_freq": round(float(np.std(other_final)), 4),
            "freq_delta": round(delta, 4),
            "ttest_t": round(float(t_stat), 3),
            "ttest_p": float(p_ttest),
            "nem_freq_spearman_rho": round(float(rho_nem), 4),
            "nem_freq_spearman_p": float(p_nem),
        },
    }

    with open(os.path.join(RESULTS_DIR, "wf_simulation_summary.json"), "w") as f:
        json.dump(summary, f, indent=2)

    print(f"Drug efflux mean freq: {np.mean(drug_final):.4f}  "
          f"Other: {np.mean(other_final):.4f}  "
          f"Δ={delta:.4f}  t={t_stat:.3f}  p={p_ttest:.4f}")
    print(f"NEM density vs final freq: rho={rho_nem:.4f}  p={p_nem:.4f}")


if __name__ == "__main__":
    main()