Blame for generator/code/simulator/noise.py

from __future__ import annotations

import numpy as np

from .config import Config
from .utils import loguniform


def noise_params_for_sample(rng: np.random.Generator, cfg: Config, source: str) -> dict:
    if source == "clean_constant_map":
        return {
            "profile": "clean",
            "genotype_error": 0.0,
            "false_variant_rate_per_bp": 0.0,
            "missing_rate": 0.0,
            "phase_switch_rate_per_het": 0.0,
            "phase_switch_model": "diploid_pair_switch_per_heterozygous_site",
        }
    ge = rng.uniform(cfg.genotype_error_min, cfg.genotype_error_max)
    fv = loguniform(
        rng, cfg.false_variant_rate_per_bp_min, cfg.false_variant_rate_per_bp_max
    )
    mr = rng.uniform(cfg.missing_rate_min, cfg.missing_rate_max)
    ps_het = rng.uniform(
        cfg.phase_switch_rate_per_het_min, cfg.phase_switch_rate_per_het_max
    )
    return {
        "profile": "mild_noise",
        "genotype_error": float(ge),
        "false_variant_rate_per_bp": float(fv),
        "missing_rate": float(mr),
        "phase_switch_rate_per_het": float(ps_het),
        "phase_switch_model": "diploid_pair_switch_per_heterozygous_site",
    }


def apply_phase_switch_errors(
    G: np.ndarray,
    positions_bp: np.ndarray,
    rng: np.random.Generator,
    switch_rate_per_het: float,
) -> tuple[np.ndarray, dict]:
    """Swap the two haplotypes of a diploid downstream of a switch point.

    Switches are drawn per heterozygous site rather than per base pair.  That
    is where the error actually arises: a phasing algorithm decides the
    relative phase of consecutive heterozygous sites, and at a homozygous site
    there is no decision to get wrong.  Published switch-error rates for
    statistical phasing are quoted the same way, 0.5% to 2% of adjacent
    heterozygous pairs.

    The previous version drew from a Poisson process in physical distance at
    up to 0.05 per megabase, which gave 1.7 switches per diploid over twenty
    megabases where the literature implies about a hundred, and which spent
    switches on sequence with no heterozygous site to express them.

    This is not dead code even though the six-state encoding the current model
    reads is a dosage and dosage is invariant under the swap.  What is stored
    is sixty-four packed haplotypes, so the swap changes the data on disk --
    56,414 haplotype calls at the old rate -- and any phased consumer sees it.
    """

    X = np.empty_like(G, dtype=np.uint8, order="K", subok=True)
    np.greater(G, 0, out=X)
    stats = {
        "phase_switch_count": 0,
        "phase_switch_pair_count": 0,
        "phaseable_pair_count": int(X.shape[1] // 2),
        "phase_switch_heterozygous_sites": 0,
    }
    if X.shape[0] < 2 or X.shape[1] < 2 or switch_rate_per_het <= 0:
        return X, stats
    if len(np.asarray(positions_bp)) != X.shape[0]:
        raise ValueError("positions_bp length must match genotype variant count")

    probability = float(np.clip(switch_rate_per_het, 0.0, 1.0))
    for left in range(0, X.shape[1] - 1, 2):
        heterozygous = X[:, left] != X[:, left + 1]
        n_het = int(heterozygous.sum())
        stats["phase_switch_heterozygous_sites"] += n_het
        if n_het < 2:
            continue
        # A switch can only occur between two heterozygous sites, so the draws
        # live on those sites and the state is carried forward to every site
        # after the first one that flipped -- homozygous sites included, since
        # the haplotypes are swapped there too even though it is unobservable.
        het_index = np.flatnonzero(heterozygous)
        switches = rng.random(n_het) < probability
        switches[0] = False
        if not switches.any():
            continue
        parity_at_het = np.cumsum(switches) % 2 == 1
        # Carry each heterozygous site's parity forward to the sites after it.
        # Homozygous sites are swapped too: the swap is unobservable there, but
        # the haplotypes really are exchanged from the switch point onward.
        preceding = np.searchsorted(het_index, np.arange(X.shape[0]), side="right") - 1
        forward = np.where(preceding >= 0, parity_at_het[np.clip(preceding, 0, None)], False)
        stats["phase_switch_count"] += int(switches.sum())
        stats["phase_switch_pair_count"] += 1
        a = X[forward, left].copy()
        X[forward, left] = X[forward, left + 1]
        X[forward, left + 1] = a
    return X, stats


def flat_index_dtype(n_cells: int) -> np.dtype:
    """The narrowest unsigned type that can address ``n_cells`` genotype calls.

    A row's missing calls are stored as flat offsets into its (variants,
    haplotypes) matrix.  That product is small for a short sequence and a small
    sample and passes four billion for a long one with many haplotypes, so the
    width is a property of the row rather than of the format.  Which width was
    used travels with the data in ``missing_storage``.
    """

    return np.dtype(np.uint32 if n_cells <= np.iinfo(np.uint32).max else np.uint64)


def _sample_flat_indices(rng: np.random.Generator, n: int, p: float) -> np.ndarray:
    dtype = flat_index_dtype(max(int(n), 0))
    if n <= 0 or p <= 0:
        return np.zeros(0, dtype=dtype)
    k = int(rng.binomial(int(n), float(np.clip(p, 0.0, 1.0))))
    if k == 0:
        return np.zeros(0, dtype=dtype)
    idx = rng.choice(int(n), size=k, replace=False)
    idx.sort()
    return idx.astype(dtype, copy=False)


def add_false_variants(
    G: np.ndarray,
    positions_bp: np.ndarray,
    rng: np.random.Generator,
    sequence_length: int,
    rate_per_bp: float,
) -> tuple[np.ndarray, np.ndarray, dict]:
    """Insert sites that are not real, the way a caller does.

    Every other noise channel here rearranges variants that exist.  Real
    sequencing manufactures them: a miscalled base at a position where nobody
    actually varies produces a site that looks like a variant and is carried by
    exactly one sample, because two independent errors at one position are rare.

    Without this the mixture gets the low end of the frequency spectrum
    backwards.  Flipping a call at a singleton site moves it up far more often
    than down -- sixty-three zeros against one one -- so the existing noise
    *depletes* singletons, by a measured 12.2%, while real data is enriched in
    them.  Singletons sit on the shortest terminal branches, which is the most
    recent slice of the genealogy, so a model calibrated on a depleted spectrum
    reads a real dataset's surplus as a larger recent effective size.

    The rate spans four orders of magnitude on purpose.  What survives calling
    is a property of the pipeline, not of biology -- a hard-filtered callset and
    a raw one differ by orders of magnitude -- so the point is to cover the
    range and record which was drawn, not to pick one.
    """

    if rate_per_bp <= 0.0 or sequence_length <= 0:
        return G, positions_bp, {"false_variant_count": 0}
    expected = float(rate_per_bp) * float(sequence_length)
    count = int(rng.poisson(expected))
    if count <= 0:
        return G, positions_bp, {"false_variant_count": 0}

    n_haplotypes = G.shape[1] if G.size else 0
    if n_haplotypes <= 0:
        return G, positions_bp, {"false_variant_count": 0}
    new_positions = rng.uniform(0.0, float(sequence_length), size=count)
    rows = np.zeros((count, n_haplotypes), dtype=G.dtype if G.size else np.uint8)
    rows[np.arange(count), rng.integers(0, n_haplotypes, size=count)] = 1

    positions = np.concatenate([np.asarray(positions_bp, dtype=np.float64), new_positions])
    genotypes = np.concatenate(
        [G if G.size else np.zeros((0, n_haplotypes), dtype=rows.dtype), rows]
    )
    order = np.argsort(positions, kind="stable")
    return genotypes[order], positions[order], {"false_variant_count": int(count)}


def apply_genotype_noise(
    G: np.ndarray,
    positions_bp: np.ndarray,
    rng: np.random.Generator,
    noise: dict,
) -> tuple[np.ndarray, np.ndarray, dict]:
    if G.size == 0:
        stats = {"phase_switch_count": 0, "phase_switch_pair_count": 0, "phaseable_pair_count": 0}
        return G.astype(np.uint8), np.zeros(0, dtype=flat_index_dtype(G.size)), stats

    ge = float(noise.get("genotype_error", 0.0))
    mr = float(noise.get("missing_rate", 0.0))
    phase_rate = float(noise.get("phase_switch_rate_per_het", 0.0))
    X, stats = apply_phase_switch_errors(G, positions_bp, rng, phase_rate)
    flat = X.reshape(-1)
    if ge > 0:
        flip_idx = _sample_flat_indices(rng, flat.size, ge)
        flat[flip_idx] = 1 - flat[flip_idx]
    missing_flat_idx = _sample_flat_indices(rng, flat.size, mr)
    if len(missing_flat_idx):
        flat[missing_flat_idx] = 0
    return X, missing_flat_idx, stats


def pack_haplotypes(G: np.ndarray, n_haplotypes: int) -> np.ndarray:
    if G.shape[1] != n_haplotypes:
        raise ValueError(f"Expected H={n_haplotypes}, got {G.shape[1]}")
    packed_input = G if G.dtype == np.uint8 else G.astype(np.uint8)
    return np.packbits(packed_input, axis=1, bitorder="little")