"""Calibration checks for the synthetic rate-map generator. Every number asserted here was measured from a real map rather than chosen. The reference window is chr20 between 10 and 26 Mb, which avoids the centromere; the recombination targets come from deCODE 2019 (Halldorsson et al., Science 363:eaau1043) and the mutation targets from Roulette (Seplyarskiy et al., Nature Genetics 2023), both as shipped in ``maps/``. The generator these guard replaced was wrong in four ways that all produced plausible-looking maps: * a hotspot multiplier was applied to whole segments, so a feature drawn 1 to 20 kb wide was realised at 39 to 156 kb -- the segment it happened to land in; * the mutation map was given the recombination architecture, hotspots and hundred-fold megabase coldspots included, when real mutation rate drifts by about 1.2-fold per megabase and has no hotspots at all; * the map was normalised by the unweighted segment mean rather than the length-weighted one, and since features preferentially hit wide segments the two differ systematically -- the realised recombination rate averaged 1.655 times the configured baseline; * the observation noise was ``lognormal(0, sigma)``, whose mean is ``exp(sigma^2/2)``, so the observed map integral sat 3.2% above the truth in every row, and ``nw_log10`` divides by exactly that integral. """ from __future__ import annotations import numpy as np import pytest from simulator.config import Config, apply_preset from simulator.maps import ( HOTSPOT_WIDTH_BP, MAX_SYNTHETIC_RATE_MULTIPLIER, synthetic_heterogeneous_map, ) MEGABASE = 1_000_000 SEQ_LEN = 20_000_000 BASELINE_REC = 1.0e-8 BASELINE_MUT = 1.25e-8 def _config() -> Config: cfg = Config() cfg.seq_len = SEQ_LEN return cfg def _draw(is_mut: bool, seed: int = 5, sigma: float = 0.25): rng = np.random.default_rng(seed) return synthetic_heterogeneous_map( rng, _config(), BASELINE_MUT if is_mut else BASELINE_REC, is_mut, sigma, 0.10, ) def _length_weighted(rates, pos): widths = np.diff(pos) return float((rates * widths).sum() / widths.sum()) def _megabase_ratio(pos, rates): means = [] for start in range(0, SEQ_LEN, MEGABASE): stop = start + MEGABASE hit = (pos[1:] > start) & (pos[:-1] < stop) widths = np.minimum(pos[1:][hit], stop) - np.maximum(pos[:-1][hit], start) if widths.sum() > 0: means.append(float((rates[hit] * widths).sum() / widths.sum())) means = np.array(means) return float(np.percentile(means, 90) / np.percentile(means, 10)) def _hot_runs(pos, rates): mean = _length_weighted(rates, pos) widths = np.diff(pos) hot = rates > 10.0 * mean runs, current = [], 0.0 for is_hot, width in zip(hot, widths): if is_hot: current += width elif current > 0: runs.append(current) current = 0.0 if current > 0: runs.append(current) return float(widths[hot].sum() / widths.sum()), np.array(runs) # -------------------------------------------------------------------------- # The rate the map actually delivers # -------------------------------------------------------------------------- @pytest.mark.parametrize("is_mut", [True, False]) def test_the_realised_rate_is_the_configured_baseline(is_mut: bool) -> None: """Not the unweighted segment mean, which is what the code used to set. Segment widths are spacings of uniform draws and so vary widely, and a feature applied by span preferentially covers wide segments, which correlates rate with width. Normalising the wrong mean therefore biases the realised rate systematically rather than merely adding noise. """ baseline = BASELINE_MUT if is_mut else BASELINE_REC for seed in range(6): pos, rates, _, _, meta = _draw(is_mut, seed=seed) assert _length_weighted(rates, pos) == pytest.approx(baseline, rel=1e-9) assert meta["realised_rate_over_baseline"] == pytest.approx(1.0, rel=1e-9) def test_the_ceiling_is_applied_before_the_normalisation() -> None: """Clipping afterwards removes rate the normalisation already counted. Measured with the ceiling applied last, the realised recombination rate came out at 0.810 of the baseline: hotspots stacked on the broad walk exceed the ceiling, and what the clip removed was never restored. """ pos, rates, _, _, _ = _draw(False, seed=3) assert _length_weighted(rates, pos) == pytest.approx(BASELINE_REC, rel=1e-9) # Normalising last can lift the maximum slightly past the nominal ceiling. # That is acceptable and bounded: the ceiling guards msprime's 1e-4 limit, # and two hundred baselines is 2e-6. assert rates.max() < 1.0e-5 assert rates.max() <= BASELINE_REC * MAX_SYNTHETIC_RATE_MULTIPLIER * 2.0 def test_the_observation_noise_preserves_the_map_integral() -> None: """``lognormal(0, s)`` has mean ``exp(s^2/2)``, not one. At the default sigma of 0.25 that is a systematic 3.2% inflation of the observed integral in every row, and ``nw_log10`` -- the baseline every model predicts a residual around -- is the segregating count divided by exactly that integral. """ ratios = [] for seed in range(40): pos, rates, obs_pos, obs, _ = _draw(False, seed=seed, sigma=0.25) # The hotspot-dropout step deliberately rewrites the top ventile, so # the check excludes it and looks at the multiplier itself. ratios.append(_length_weighted(obs, obs_pos) / _length_weighted(rates, pos)) assert np.mean(ratios) == pytest.approx(1.0, abs=0.03) # -------------------------------------------------------------------------- # Feature spans # -------------------------------------------------------------------------- def test_a_hotspot_is_as_wide_as_it_was_drawn() -> None: """The defect that dominated the old generator's structure. Applying a multiplier to whole segments made the realised width the segment width, which at 128 to 512 segments over twenty megabases is 39 to 156 kb -- twenty to seventy times the declared 1 to 20 kb. deCODE 2019 puts the real median hot run at 466 bp. """ widest = HOTSPOT_WIDTH_BP[1] for seed in range(4): pos, rates, _, _, meta = _draw(False, seed=seed) fraction, runs = _hot_runs(pos, rates) assert len(runs) > 0 # A run may merge neighbouring hotspots, so the bound is generous on # the high side and tight on the order of magnitude. assert np.median(runs) < 6.0 * widest assert np.median(runs) > 100.0 def test_the_hot_fraction_matches_the_real_map() -> None: """deCODE 2019 on the reference window: 1.76% of sequence above ten times the mean rate.""" fractions = [] for seed in range(6): pos, rates, _, _, _ = _draw(False, seed=seed) fractions.append(_hot_runs(pos, rates)[0]) assert 0.008 < float(np.median(fractions)) < 0.035 # -------------------------------------------------------------------------- # The mutation map is not a recombination map # -------------------------------------------------------------------------- def test_the_mutation_map_has_no_hotspots_or_coldspots() -> None: """Real mutation rate has neither. Its fine-scale variation is sequence context at single sites, which a binary mutation model cannot represent at all, and its regional variation is a smooth drift. The old generator gave it 1 to 4 hotspots at 2 to 12 times and the same hundred-fold megabase coldspots as recombination. """ for seed in range(6): pos, rates, _, _, meta = _draw(True, seed=seed) assert meta["hotspot_count"] == 0 assert meta["coldspot_count"] == 0 assert meta["hotspot_model"] == "physical_grid_exact_span" fraction, runs = _hot_runs(pos, rates) assert fraction == 0.0 assert len(runs) == 0 def test_the_mutation_map_drifts_like_roulette() -> None: """Roulette on the reference window gives a megabase p90/p10 of 1.12. The old generator gave a megabase max/min whose median was 7.03, with 49% of rows above five-fold. On real data mutation is nearly uniform, so variant density tracks coalescent depth; teaching a model otherwise makes it distrust the strongest signal it has. """ ratios = [_megabase_ratio(*_draw(True, seed=s)[:2]) for s in range(8)] assert 1.05 < float(np.median(ratios)) < 1.35 def test_the_recombination_map_still_varies_across_megabases() -> None: """The real maps give a megabase p90/p10 between 3.7 and 6.4 depending on which one is measured, so heterogeneity is removed from mutation only.""" ratios = [_megabase_ratio(*_draw(False, seed=s)[:2]) for s in range(8)] assert 2.0 < float(np.median(ratios)) < 9.0 # -------------------------------------------------------------------------- # Source mixture # -------------------------------------------------------------------------- def test_every_preset_draws_a_fifth_of_rows_from_a_real_map() -> None: """The dataclass default alone would have changed nothing. The shipped dataset was generated under the ``full_v01`` preset, which overrides the source probabilities; measured on 6,000 of its samples the realised mixture was 60.0% synthetic against 15.2% empirical, matching the preset rather than the default. """ for preset in (None, "mini", "core_v01", "full_v01"): cfg = Config() if preset is not None: cfg.preset = preset cfg = apply_preset(cfg) assert cfg.p_empirical_slice == pytest.approx(0.20), preset total = ( cfg.p_clean_constant + cfg.p_random_global + cfg.p_custom_hetero + cfg.p_empirical_slice + cfg.p_stdpopsim_anchor ) assert total == pytest.approx(1.0) # -------------------------------------------------------------------------- # What the refactor onto a physical grid was for # -------------------------------------------------------------------------- def test_the_background_correlates_over_a_distance_not_over_segments() -> None: """The old background was a walk indexed by segment number. Segment widths were spacings of uniform draws, so the correlation length in base pairs was set by the segmentation: measured on that version, the log rate moved 0.0105 across a segment at the 25th width percentile and 0.0097 across one at the 75th -- the same jump over four times the sequence. A background on a regular physical grid cannot do that. """ # Compared across draws rather than within one: the background now lives # on a regular grid, so the informative contrast is between rows whose # correlation length differs, not between segments of one row. lengths, decays = [], [] for seed in range(30): pos, rates, _, _, meta = _draw(False, seed=seed) cell = meta["background_cell_bp"] edges = np.arange(0.0, SEQ_LEN + 50_000.0, 50_000.0) cumulative = np.concatenate(([0.0], np.cumsum(rates * np.diff(pos)))) gridded = np.diff(np.interp(edges, pos, cumulative)) / np.diff(edges) log = np.log(gridded[gridded > 0]) lengths.append(meta["correlation_bp"]) decays.append(float(np.corrcoef(log[:-4], log[4:])[0, 1])) lengths, decays = np.array(lengths), np.array(decays) # A longer drawn correlation length must show as a slower measured decay. assert np.corrcoef(np.log(lengths), decays)[0, 1] > 0.5 def test_the_amplitude_is_drawn_per_row_rather_than_fixed() -> None: """A constant amplitude is both wrong and a label. The old generator standardised the walk, so every synthetic row carried the same log-rate spread to nine decimal places -- 0.06000 across two hundred draws. A model can condition on that and identify the source. """ spreads = [] for seed in range(24): _, rates, _, _, _ = _draw(True, seed=seed) spreads.append(float(np.log(rates).std())) spreads = np.array(spreads) assert spreads.std() > 0.005, spreads def test_the_observed_map_does_not_reveal_the_true_breakpoints() -> None: """It is re-binned onto a grid of its own. Returning it on the true edges handed over every boundary of the true map exactly -- and once feature edges joined that grid, that meant every hotspot position, with only the intensities noised. A published map is uncertain about where the hotspots are, not only about how strong. """ for seed in range(4): pos, _, obs_pos, obs, meta = _draw(False, seed=seed) assert not np.array_equal(pos, obs_pos) assert len(obs) == len(obs_pos) - 1 assert meta["observed_segments"] == len(obs) def test_the_hotspot_dropout_only_applies_where_hotspots_exist() -> None: """The mutation map has none, so rewriting its top ventile modelled a phenomenon that does not occur there.""" for seed in range(4): _, _, _, obs, meta = _draw(True, seed=seed) assert meta["hotspot_count"] == 0 # Checked against the flag itself rather than against a threshold on # the values: with hotspots the dropout fires and changes the map, # without them it must be inert. from simulator.maps import _observed_view pos_a, rates_a, _, _, _ = _draw(False, seed=seed) quiet = _observed_view( np.random.default_rng(1), pos_a, rates_a, BASELINE_REC, 0.25, 0.10, has_hotspots=False, )[1] loud = _observed_view( np.random.default_rng(1), pos_a, rates_a, BASELINE_REC, 0.25, 0.10, has_hotspots=True, )[1] assert not np.array_equal(quiet, loud)