from __future__ import annotations import hashlib from dataclasses import dataclass, field from pathlib import Path import numpy as np import pandas as pd from pandas.io.common import infer_compression from .assets import asset_path from .config import MAX_MSPRIME_RATE, Config from .utils import loguniform @dataclass class PiecewiseRateMap: chrom: str position: np.ndarray rate: np.ndarray rate_unit: str = "per_bp_per_generation" rate_unit_before: str = "per_bp" rate_unit_after: str = "per_bp_per_generation" mean_rate_before_scaling: float = 0.0 mean_rate_after_scaling: float = 0.0 scaling_method: str = "identity" source_format: str = "unknown" @property def length(self) -> float: return float(self.position[-1]) if len(self.position) else 0.0 def _validate_piecewise_rate_map(rate_map: PiecewiseRateMap) -> None: position = np.asarray(rate_map.position) rate = np.asarray(rate_map.rate) if position.ndim != 1 or rate.ndim != 1: raise ValueError(f"Empirical map on {rate_map.chrom} must use one-dimensional arrays") if len(position) != len(rate) + 1 or len(rate) == 0: raise ValueError( f"Empirical map on {rate_map.chrom} must have one more position than rate" ) if not np.all(np.isfinite(position)) or not np.all(np.isfinite(rate)): raise ValueError(f"Empirical map on {rate_map.chrom} contains non-finite values") if np.any(np.diff(position) <= 0): raise ValueError(f"Empirical map positions on {rate_map.chrom} must be strictly increasing") @dataclass class EmpiricalMapStore: rec_maps: dict[str, PiecewiseRateMap] = field(default_factory=dict) mut_maps: dict[str, PiecewiseRateMap] = field(default_factory=dict) metadata: dict[str, dict] = field(default_factory=dict) _common_span_cache: dict[str, tuple[float, float]] = field( default_factory=dict, repr=False, ) _usable_chrom_cache: dict[float, tuple[str, ...]] = field( default_factory=dict, repr=False, ) def common_chroms(self, min_len: int) -> list[str]: cache_key = float(min_len) cached = self._usable_chrom_cache.get(cache_key) if cached is not None: return list(cached) chroms = sorted(set(self.rec_maps) & set(self.mut_maps), key=_chrom_sort_key) usable: list[str] = [] for chrom in chroms: try: self.common_slice_start_bounds(chrom, min_len) except ValueError: continue usable.append(chrom) self._usable_chrom_cache[cache_key] = tuple(usable) return usable def common_slice_start_bounds(self, chrom: str, length: int) -> tuple[float, float]: """Return the inclusive start-coordinate range usable by both maps.""" if chrom not in self.rec_maps or chrom not in self.mut_maps: raise ValueError(f"Chromosome {chrom!r} is not present in both empirical maps") if length <= 0: raise ValueError("Slice length must be positive") cached_span = self._common_span_cache.get(chrom) if cached_span is None: rec_map = self.rec_maps[chrom] mut_map = self.mut_maps[chrom] _validate_piecewise_rate_map(rec_map) _validate_piecewise_rate_map(mut_map) cached_span = ( max(float(rec_map.position[0]), float(mut_map.position[0])), min(float(rec_map.position[-1]), float(mut_map.position[-1])), ) self._common_span_cache[chrom] = cached_span common_left, common_right = cached_span latest_start = common_right - float(length) if latest_start < common_left: raise ValueError( f"Chromosome {chrom!r} has only {common_right - common_left:g} bp " f"shared between empirical maps, shorter than requested slice {length:g} bp" ) return common_left, latest_start def is_available(self, min_len: int) -> bool: return bool(self.common_chroms(min_len)) def _chrom_sort_key(chrom: str) -> tuple[int, str]: clean = chrom.lower().removeprefix("chr") return (int(clean), clean) if clean.isdigit() else (10_000, clean) def _canonical_chrom(value) -> str: text = str(value).strip() if text.lower().startswith("chr"): text = text[3:] return f"chr{text}" def _read_table_maybe_gzip( path: str, *, compression: str | None = None, ) -> pd.DataFrame: kwargs = dict(sep=r"\s+", comment="#", header=None, dtype=str) if compression is None: if path.endswith(".gz"): kwargs["compression"] = "gzip" elif not isinstance(compression, str) or not compression: raise ValueError(f"Unsupported empirical-map compression: {compression}") else: kwargs["compression"] = None if compression == "none" else compression return pd.read_csv(path, **kwargs) def _inferred_map_compression(path: Path) -> str: """Match the legacy filename-based pandas decompression semantics.""" path_text = str(path) if path_text.endswith(".gz"): return "gzip" inferred = infer_compression(path_text, "infer") return str(inferred) if inferred is not None else "none" ROULETTE_RAW_TO_PER_GEN = 1.015e-7 RECOMB_CM_PER_MB_TO_PER_BP = 1.0e-8 # A published map has a resolution of its own, coarser than the truth. OBSERVED_CELL_BP = (1_000.0, 20_000.0) RECOMB_MAP_UNITS = {"per_bp", "cM_per_Mb"} MUT_MAP_UNITS = {"per_bp", "relative", "roulette_raw"} def _finite_mean(rates: np.ndarray) -> float: finite = np.asarray(rates, dtype=np.float64) finite = finite[np.isfinite(finite)] return float(np.mean(finite)) if len(finite) else 0.0 def _scale_rates( rates: np.ndarray, baseline_rate: float | None, map_kind: str, input_unit: str, scale_to_baseline: bool, ) -> tuple[np.ndarray, dict]: if map_kind == "recombination" and input_unit not in RECOMB_MAP_UNITS: raise ValueError(f"Unsupported recombination map unit: {input_unit}") if map_kind == "mutation" and input_unit not in MUT_MAP_UNITS: raise ValueError(f"Unsupported mutation map unit: {input_unit}") before_mean = _finite_mean(rates) fill = baseline_rate if baseline_rate is not None else 1e-8 rates = np.nan_to_num(rates.astype(np.float64, copy=False), nan=fill, posinf=fill, neginf=0.0) method = "identity" if map_kind == "recombination": if input_unit == "cM_per_Mb": rates = rates * RECOMB_CM_PER_MB_TO_PER_BP method = "cM_per_Mb_to_per_bp_per_generation" elif input_unit == "roulette_raw": rates = rates * ROULETTE_RAW_TO_PER_GEN method = "roulette_raw_to_per_bp_per_generation" if scale_to_baseline and baseline_rate is not None: mean_after_conversion = _finite_mean(rates) if mean_after_conversion > 0: rates = rates * (float(baseline_rate) / mean_after_conversion) method += "+mean_to_baseline" elif input_unit == "relative": if baseline_rate is None: raise ValueError("relative mutation maps require a baseline mutation rate") positive_mean = _finite_mean(rates[rates > 0]) if scale_to_baseline: if positive_mean <= 0: raise ValueError("relative mutation map has no positive rates to normalize") rates = rates * (float(baseline_rate) / positive_mean) method = "relative_mean_to_baseline" else: rates = rates * float(baseline_rate) method = "relative_multiplier_to_baseline" rates = np.clip(rates, 0.0, None) if len(rates) and np.nanmax(rates) > MAX_MSPRIME_RATE: raise ValueError( f"{map_kind} map rates look too large for msprime per-bp per-generation rates; " "set --recomb-map-unit/--mut-map-unit explicitly so rates can be converted" ) after_mean = _finite_mean(rates) info = { "rate_unit_before": input_unit, "rate_unit_after": "per_bp_per_generation", "mean_rate_before_scaling": before_mean, "mean_rate_after_scaling": after_mean, "scaling_method": method, } return rates, info def _piecewise_from_points( chrom: str, pos: np.ndarray, rate_points: np.ndarray, baseline_rate: float | None, map_kind: str, input_unit: str, scale_to_baseline: bool, ) -> PiecewiseRateMap: pos = np.asarray(pos) rate_points = np.asarray(rate_points) if pos.ndim != 1 or rate_points.ndim != 1 or len(pos) != len(rate_points): raise ValueError(f"Point map on {chrom} has incompatible position/rate arrays") if not np.all(np.isfinite(pos)) or not np.all(np.isfinite(rate_points)): raise ValueError(f"Point map on {chrom} contains non-finite values") order = np.argsort(pos) pos = pos[order].astype(np.float64, copy=False) rate_points = rate_points[order].astype(np.float64, copy=False) keep = np.concatenate([[True], np.diff(pos) > 0]) pos = pos[keep] rate_points = rate_points[keep] if len(pos) == 0: raise ValueError(f"No numeric positions for empirical map chromosome {chrom}") if len(pos) > 1: left_step = pos[1] - pos[0] right_step = pos[-1] - pos[-2] boundaries = np.concatenate( [ [max(0.0, pos[0] - left_step / 2.0)], (pos[:-1] + pos[1:]) / 2.0, [pos[-1] + max(1.0, right_step / 2.0)], ] ) else: step = 1_000.0 boundaries = np.array([max(0.0, pos[0] - step / 2.0), pos[0] + step / 2.0], dtype=np.float64) rates, scaling = _scale_rates(rate_points, baseline_rate, map_kind, input_unit, scale_to_baseline) return PiecewiseRateMap( chrom=chrom, position=boundaries.astype(np.float64), rate=rates.astype(np.float64), rate_unit=scaling["rate_unit_after"], **scaling, source_format="point_centers", ) def _piecewise_from_intervals( chrom: str, starts: np.ndarray, ends: np.ndarray, rates: np.ndarray, baseline_rate: float | None, map_kind: str, input_unit: str, scale_to_baseline: bool, ) -> PiecewiseRateMap: starts = np.asarray(starts) ends = np.asarray(ends) rates = np.asarray(rates) if ( starts.ndim != 1 or ends.ndim != 1 or rates.ndim != 1 or len(starts) != len(ends) or len(starts) != len(rates) ): raise ValueError(f"Interval map on {chrom} has incompatible start/end/rate arrays") if ( not np.all(np.isfinite(starts)) or not np.all(np.isfinite(ends)) or not np.all(np.isfinite(rates)) ): raise ValueError(f"Interval map on {chrom} contains non-finite values") order = np.argsort(starts) starts = starts[order].astype(np.float64, copy=False) ends = ends[order].astype(np.float64, copy=False) rates = rates[order].astype(np.float64, copy=False) keep = ends > starts starts = starts[keep] ends = ends[keep] rates = rates[keep] if len(starts) == 0: raise ValueError(f"No valid intervals for empirical map chromosome {chrom}") rates, scaling = _scale_rates(rates, baseline_rate, map_kind, input_unit, scale_to_baseline) filler = baseline_rate if baseline_rate is not None else float(np.nanmedian(rates)) positions = [0.0] out_rates: list[float] = [] current = 0.0 for start, end, rate in zip(starts, ends, rates): start = float(start) end = float(end) if end <= current: continue if start > current: out_rates.append(float(filler)) positions.append(start) current = start if end > current: out_rates.append(float(rate)) positions.append(end) current = end positions_arr = np.asarray(positions, dtype=np.float64) rates_arr = np.asarray(out_rates, dtype=np.float64) keep = np.concatenate([[True], np.diff(positions_arr) > 0]) positions_arr = positions_arr[keep] if len(rates_arr) != len(positions_arr) - 1: rates_arr = rates_arr[: len(positions_arr) - 1] return PiecewiseRateMap( chrom=chrom, position=positions_arr, rate=rates_arr.astype(np.float64), rate_unit=scaling["rate_unit_after"], **scaling, source_format="bed_intervals", ) def load_empirical_rate_table( path: str, baseline_rate: float | None = None, map_kind: str = "generic", rate_unit: str = "per_bp", scale_to_baseline: bool = True, *, compression: str | None = None, ) -> dict[str, PiecewiseRateMap]: """Load BED-like or position-rate maps, preserving chromosome boundaries. Canonical input is a BED-like interval table with columns: chrom, start, end, rate. Coordinates are 0-based half-open intervals and rate is per bp per generation unless rate_unit explicitly says otherwise. Legacy point-center maps are accepted and converted to interval boundaries with midpoint cuts. Missing interval gaps are filled with baseline_rate so the returned map can be passed to msprime after slicing. """ df = _read_table_maybe_gzip(path, compression=compression) maps: dict[str, PiecewiseRateMap] = {} if df.shape[1] >= 4: chrom_col = df.iloc[:, 0].map(_canonical_chrom) starts = pd.to_numeric(df.iloc[:, 1], errors="coerce") ends = pd.to_numeric(df.iloc[:, 2], errors="coerce") rates = pd.to_numeric(df.iloc[:, 3], errors="coerce") parsed = pd.DataFrame({"chrom": chrom_col, "start": starts, "end": ends, "rate": rates}).dropna() for chrom, sub in parsed.groupby("chrom", sort=False): maps[str(chrom)] = _piecewise_from_intervals( str(chrom), sub["start"].to_numpy(), sub["end"].to_numpy(), sub["rate"].to_numpy(), baseline_rate, map_kind, rate_unit, scale_to_baseline, ) elif df.shape[1] == 3: chrom_col = df.iloc[:, 0].map(_canonical_chrom) pos = pd.to_numeric(df.iloc[:, 1], errors="coerce") rates = pd.to_numeric(df.iloc[:, 2], errors="coerce") parsed = pd.DataFrame({"chrom": chrom_col, "pos": pos, "rate": rates}).dropna() for chrom, sub in parsed.groupby("chrom", sort=False): maps[str(chrom)] = _piecewise_from_points( str(chrom), sub["pos"].to_numpy(), sub["rate"].to_numpy(), baseline_rate, map_kind, rate_unit, scale_to_baseline, ) elif df.shape[1] == 2: pos = pd.to_numeric(df.iloc[:, 0], errors="coerce") rates = pd.to_numeric(df.iloc[:, 1], errors="coerce") parsed = pd.DataFrame({"pos": pos, "rate": rates}).dropna() maps["__single__"] = _piecewise_from_points( "__single__", parsed["pos"].to_numpy(), parsed["rate"].to_numpy(), baseline_rate, map_kind, rate_unit, scale_to_baseline, ) else: raise ValueError(f"Cannot parse empirical map: {path}") if not maps: raise ValueError(f"Empirical map has no usable numeric rows: {path}") return maps def _load_empirical_rate_table_cached( path: str | Path, baseline_rate: float | None, map_kind: str, rate_unit: str, scale_to_baseline: bool, ) -> dict[str, PiecewiseRateMap]: from . import config as config_module from .map_cache import load_or_build_rate_maps parser_path = Path(path).expanduser() if not parser_path.is_absolute(): parser_path = Path.cwd() / parser_path resolved_source = parser_path.resolve(strict=True) compression = _inferred_map_compression(parser_path) parse_parameters = { "parser": "load_empirical_rate_table", "compression": compression, "baseline_rate": baseline_rate, "map_kind": map_kind, "rate_unit": rate_unit, "scale_to_baseline": scale_to_baseline, } return load_or_build_rate_maps( source_path=resolved_source, parse_parameters=parse_parameters, related_code_paths={ "empirical_maps_parser": Path(__file__), "rate_validation_config": Path(config_module.__file__), }, builder=lambda snapshot: load_empirical_rate_table( str(snapshot), baseline_rate, map_kind=map_kind, rate_unit=rate_unit, scale_to_baseline=scale_to_baseline, compression=compression, ), map_class=PiecewiseRateMap, ) def _source_file_provenance(path: str | Path) -> dict[str, int | str]: source = Path(path).expanduser().resolve(strict=True) before = source.stat() digest = hashlib.sha256() with source.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) after = source.stat() identity_before = ( before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, ) identity_after = ( after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, ) if identity_before != identity_after: raise ValueError(f"Empirical map changed while recording provenance: {source}") return { "source_size_bytes": int(after.st_size), "source_sha256": digest.hexdigest(), } def _summarize_maps(path: str, maps: dict[str, PiecewiseRateMap], requested_unit: str) -> dict: methods = sorted({m.scaling_method for m in maps.values()}) formats = sorted({m.source_format for m in maps.values()}) before = [m.mean_rate_before_scaling for m in maps.values()] after = [m.mean_rate_after_scaling for m in maps.values()] return { "path": path, **_source_file_provenance(path), "requested_rate_unit": requested_unit, "rate_unit_before": requested_unit, "rate_unit_after": "per_bp_per_generation", "mean_rate_before_scaling": float(np.mean(before)) if before else 0.0, "mean_rate_after_scaling": float(np.mean(after)) if after else 0.0, "scaling_method": "+".join(methods) if methods else "unknown", "source_formats": formats, "n_chromosomes": len(maps), "chromosomes": sorted(maps, key=_chrom_sort_key), } def _resolve_map_path(path: str) -> Path | None: if not path: return None resolved = asset_path(path) return resolved if resolved.exists() else None def load_empirical_maps(cfg: Config) -> EmpiricalMapStore: store = EmpiricalMapStore() recomb_path = _resolve_map_path(cfg.recomb_map) mut_path = _resolve_map_path(cfg.mut_map) if recomb_path is not None: print(f"[maps] loading empirical recombination map: {recomb_path}") store.rec_maps = _load_empirical_rate_table_cached( recomb_path, cfg.baseline_rec, map_kind="recombination", rate_unit=cfg.recomb_map_unit, scale_to_baseline=False, ) store.metadata["recombination"] = _summarize_maps(str(recomb_path), store.rec_maps, cfg.recomb_map_unit) if mut_path is not None: print(f"[maps] loading empirical mutation map: {mut_path}") store.mut_maps = _load_empirical_rate_table_cached( mut_path, cfg.baseline_mu, map_kind="mutation", rate_unit=cfg.mut_map_unit, scale_to_baseline=cfg.mut_map_scale_to_baseline, ) store.metadata["mutation"] = _summarize_maps(str(mut_path), store.mut_maps, cfg.mut_map_unit) return store def slice_piecewise_map( rng: np.random.Generator, rate_map: PiecewiseRateMap, length: int, obs_noise_sigma: float, baseline_rate: float, start: float | None = None, *, validate_input: bool = True, ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]: """Slice a rate map, optionally at an explicit source-map coordinate. Omitting ``start`` preserves the original random-slice API. Passing it lets callers use the exact same genomic interval for multiple empirical maps. """ if validate_input: _validate_piecewise_rate_map(rate_map) global_pos = rate_map.position global_rate = rate_map.rate if length <= 0: raise ValueError("Slice length must be positive") min_start = float(global_pos[0]) max_start = float(global_pos[-1]) - float(length) if max_start < min_start: raise ValueError( f"Empirical map on {rate_map.chrom} spans only " f"{float(global_pos[-1]) - min_start:g} bp, shorter than requested slice {length:g} bp" ) if start is None: start = min_start if max_start == min_start else float(rng.uniform(min_start, max_start)) else: start = float(start) if not np.isfinite(start): raise ValueError("Slice start must be finite") if start < min_start or start > max_start: raise ValueError( f"Slice start {start:g} is outside the valid range " f"[{min_start:g}, {max_start:g}] for {rate_map.chrom}" ) end = start + length internal_boundaries = global_pos[(global_pos > start) & (global_pos < end)] absolute_interval_starts = np.concatenate( [np.array([start], dtype=np.float64), internal_boundaries.astype(np.float64, copy=False)] ) rate_indices = np.searchsorted(global_pos, absolute_interval_starts, side="right") - 1 rate_indices = np.clip(rate_indices, 0, len(global_rate) - 1) rate = global_rate[rate_indices].copy() pos = np.concatenate( [ np.array([0.0], dtype=np.float64), internal_boundaries.astype(np.float64, copy=False) - start, np.array([float(length)], dtype=np.float64), ] ) true_rate = np.clip(rate, baseline_rate * 1e-4, baseline_rate * 500) # The observed map is what the model is handed and is expected to trust. # It is re-binned onto a grid of its own before the noise is applied, for # two reasons. Returning it on the true breakpoints handed over every # boundary of the true map exactly, and noised only the intensities, when # a published map is uncertain about where the hotspots are as much as # about how strong they are. And a real map reports the average rate in # its own bins, which also smooths a hotspot it did not resolve. obs_cell = float(loguniform(rng, *OBSERVED_CELL_BP)) obs_pos = np.arange(0.0, float(length) + obs_cell, obs_cell) if len(obs_pos) < 2: obs_pos = np.array([0.0, float(length)], dtype=np.float64) obs_pos[-1] = float(length) cumulative = np.concatenate(([0.0], np.cumsum(true_rate * np.diff(pos)))) obs_rate = np.diff(np.interp(obs_pos, pos, cumulative)) / np.diff(obs_pos) # Centred so the multiplier has mean one. With a zero location a lognormal # has mean exp(sigma^2 / 2), so the observed map integral sat above the # truth in every row, and nw_log10 divides the segregating count by exactly # that integral. from .maps import observed_noise_multiplier obs_rate = obs_rate * observed_noise_multiplier( rng, obs_rate.shape[0], obs_cell, obs_noise_sigma, true_rates=obs_rate ) obs_rate = np.clip(obs_rate, baseline_rate * 1e-5, baseline_rate * 1000) meta = { "chrom": rate_map.chrom, "slice_start_bp": start, "slice_end_bp": end, "rate_unit": rate_map.rate_unit, "rate_unit_before": rate_map.rate_unit_before, "rate_unit_after": rate_map.rate_unit_after, "mean_rate_before_scaling": rate_map.mean_rate_before_scaling, "mean_rate_after_scaling": rate_map.mean_rate_after_scaling, "scaling_method": rate_map.scaling_method, "source_format": rate_map.source_format, "observed_cell_bp": obs_cell, "observed_noise_sigma": float(obs_noise_sigma), } return ( pos.astype(np.float64), true_rate.astype(np.float64), obs_pos.astype(np.float64), obs_rate.astype(np.float64), meta, )