From 4d6cdc8219ab0b8cdd620804d8d9c886c2d5670d Mon Sep 17 00:00:00 2001 From: "niko.sarcevic" Date: Mon, 26 Jan 2026 02:00:10 -0500 Subject: [PATCH 1/3] added mead20 scripts to baryons module --- pyccl/baryons/__init__.py | 1 + pyccl/baryons/mead20.py | 357 ++++++++++++++++++ pyccl/baryons/mead20_hmcode/__init__.py | 0 pyccl/baryons/mead20_hmcode/mead20_utils.py | 389 ++++++++++++++++++++ 4 files changed, 747 insertions(+) create mode 100644 pyccl/baryons/mead20.py create mode 100644 pyccl/baryons/mead20_hmcode/__init__.py create mode 100644 pyccl/baryons/mead20_hmcode/mead20_utils.py diff --git a/pyccl/baryons/__init__.py b/pyccl/baryons/__init__.py index 344b2bf61..59dd4c979 100644 --- a/pyccl/baryons/__init__.py +++ b/pyccl/baryons/__init__.py @@ -2,3 +2,4 @@ from .schneider15 import * from .baccoemu_baryons import * from .vandaalen19 import * +from .mead20 import * diff --git a/pyccl/baryons/mead20.py b/pyccl/baryons/mead20.py new file mode 100644 index 000000000..c88418b35 --- /dev/null +++ b/pyccl/baryons/mead20.py @@ -0,0 +1,357 @@ +"""Mead et al. 2020 HMCode baryonic feedback model.""" + +from __future__ import annotations + +__all__ = ("BaryonsMead20",) + +from copy import deepcopy +from typing import Any +from numpy.typing import NDArray + +import numpy as np + +from ..cosmology import Cosmology +from ..pk2d import Pk2D +from .baryons_base import Baryons +from .mead20_hmcode.mead20_utils import ( + _cosmo_signature, + _make_internal_camb_cosmology, + _raise_if_already_hmcode_feedback, + _raise_if_baryons_already_attached, + _resolve_pk_is_log, + _apply_boost_to_pk_arr, + _to_2d_na_nk, + _safe_pos_ratio, + _restore_input_ndim, +) + +FloatArray = NDArray[np.floating[Any]] +CosmoCacheKey = tuple[ + int, str, bool, float, int | None, str | None, float, float | None, + float | None, str +] + + +class BaryonsMead20(Baryons): + """Mead20 HMCode baryonic feedback model using CAMB as the backend. + + This model constructs a scale- and redshift-dependent boost factor from + CAMB's HMCode implementation, and applies it multiplicatively to an input + nonlinear matter power spectrum. + + The boost is defined as the ratio of a feedback run to a dark-matter-only + HMCode run evaluated with consistent CAMB settings. + + Notes + ----- + Do not attach this model if the input cosmology already requests HMCode + feedback through CAMB, or if baryonic effects are already attached. + + CAMB defaults for HMCode parameters are: + + - ``HMCode_logT_AGN = 7.8`` (used only when + ``halofit_version="mead2020_feedback"``), + - ``HMCode_A_baryon = 3.13`` and ``HMCode_eta_baryon = 0.603`` + (used only for ``"mead"``/``"mead2015"``/``"mead2016"``). + + For HMCode-2020 (``"mead2020"`` / ``"mead2020_feedback"``), CAMB ignores + ``HMCode_A_baryon`` and ``HMCode_eta_baryon``; they are kept as optional + inputs for API completeness. + + Args: + HMCode_logT_AGN (:obj:`float`): HMCode feedback strength parameter. + HMCode_A_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + HMCode_eta_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + kmax (:obj:`float`): Maximum k used in the internal CAMB evaluation + (in units of Mpc^-1). + lmax (:obj:`int` or :obj:`None`): Optional CAMB ell limit for internal + calculations. + dark_energy_model (:obj:`str` or :obj:`None`): Optional CAMB dark + energy model name for internal calculations. + halofit_version_feedback (:obj:`str`): CAMB halofit/HMCode version used + for the feedback spectrum. + halofit_version_dmo (:obj:`str`): CAMB halofit/HMCode version used for + the dark-matter-only spectrum. + camb_overrides (:obj:`dict` or :obj:`None`): Extra CAMB settings to + apply to the internal cosmologies. + cache_cosmologies (:obj:`bool`): If True, reuse internal cosmologies + across calls when inputs and settings match. + """ + name = "mead20_hmcode" + __repr_attrs__ = __eq_attrs__ = ( + "HMCode_logT_AGN", + "HMCode_A_baryon", + "HMCode_eta_baryon", + "kmax", + "lmax", + "dark_energy_model", + "halofit_version_feedback", + "halofit_version_dmo", + "camb_overrides", + "cache_cosmologies", + ) + + _cosmo_cache: dict[CosmoCacheKey, Cosmology] + + def __init__( + self, + *, + HMCode_logT_AGN: float = 7.8, + HMCode_A_baryon: float | None = None, + HMCode_eta_baryon: float | None = None, + kmax: float = 20.0, + lmax: int | None = None, + dark_energy_model: str | None = None, + halofit_version_feedback: str = "mead2020_feedback", + halofit_version_dmo: str = "mead2020", + camb_overrides: dict[str, Any] | None = None, + cache_cosmologies: bool = True, + ) -> None: + """Initialize the Mead20 HMCode baryonic feedback model.""" + self.HMCode_logT_AGN = float(HMCode_logT_AGN) + self.HMCode_A_baryon = ( + None if HMCode_A_baryon is None else float(HMCode_A_baryon) + ) + self.HMCode_eta_baryon = ( + None if HMCode_eta_baryon is None else float(HMCode_eta_baryon) + ) + self.kmax = float(kmax) + self.lmax = None if lmax is None else int(lmax) + self.dark_energy_model = ( + None if dark_energy_model is None else str(dark_energy_model) + ) + self.halofit_version_feedback = str(halofit_version_feedback) + self.halofit_version_dmo = str(halofit_version_dmo) + self.camb_overrides = ( + deepcopy(camb_overrides) if camb_overrides else {} + ) + self.cache_cosmologies = bool(cache_cosmologies) + + # {(sig, halofit_version, include_feedback): Cosmology} + self._cosmo_cache = {} + + def _get_internal_cosmo( + self, + cosmo: Cosmology, + *, + halofit_version: str, + include_feedback: bool, + ) -> Cosmology: + """Return an internal CAMB-backed Cosmology for the requested settings. + + This helper builds a CAMB-based cosmology that matches the input + parameters but forces a consistent CAMB pipeline. When caching is + enabled, previously constructed internal cosmologies are reused. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Baseline cosmology. + halofit_version (:obj:`str`): CAMB halofit/HMCode version string. + include_feedback (:obj:`bool`): Whether to include HMCode feedback. + + Returns: + :class:`~pyccl.cosmology.Cosmology`: Internal CAMB-backed + cosmology. + + """ + if not self.cache_cosmologies: + return _make_internal_camb_cosmology( + cosmo, + halofit_version=halofit_version, + include_feedback=include_feedback, + kmax=self.kmax, + HMCode_logT_AGN=self.HMCode_logT_AGN, + HMCode_A_baryon=self.HMCode_A_baryon, + HMCode_eta_baryon=self.HMCode_eta_baryon, + lmax=self.lmax, + dark_energy_model=self.dark_energy_model, + camb_overrides=self.camb_overrides, + ) + + key: CosmoCacheKey = ( + _cosmo_signature(cosmo), + str(halofit_version), + bool(include_feedback), + float(self.kmax), + int(self.lmax) if self.lmax is not None else None, + ( + str(self.dark_energy_model) + if self.dark_energy_model is not None + else None + ), + float(self.HMCode_logT_AGN), + ( + float(self.HMCode_A_baryon) + if self.HMCode_A_baryon is not None + else None + ), + ( + float(self.HMCode_eta_baryon) + if self.HMCode_eta_baryon is not None + else None + ), + repr(self.camb_overrides), + ) + + cached = self._cosmo_cache.get(key) + if cached is None: + cached = _make_internal_camb_cosmology( + cosmo, + halofit_version=halofit_version, + include_feedback=include_feedback, + kmax=self.kmax, + HMCode_logT_AGN=self.HMCode_logT_AGN, + HMCode_A_baryon=self.HMCode_A_baryon, + HMCode_eta_baryon=self.HMCode_eta_baryon, + lmax=self.lmax, + dark_energy_model=self.dark_energy_model, + camb_overrides=self.camb_overrides, + ) + self._cosmo_cache[key] = cached + return cached + + def boost_factor( + self, + cosmo: Cosmology, + k: float | FloatArray, + a: float | FloatArray, + ) -> float | FloatArray: + """Compute the Mead20 HMCode boost factor B(k, a). + + The boost is defined as the ratio of the nonlinear matter power + spectrum computed with HMCode feedback enabled to the corresponding + dark-matter-only HMCode spectrum, evaluated on the requested + (k,a) grid. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Baseline cosmology. + k (:obj:`float` or `array`): Wavenumber in Mpc^-1. + a (:obj:`float` or `array`): Scale factor. + + Returns: + :obj:`float` or `array`: Boost factor with shape matching inputs. + + Raises: + ValueError: If baryonic effects are already attached to ``cosmo`` + or if CAMB HMCode feedback is already enabled on the input + cosmology. + FloatingPointError: If the computed boost is not finite and + positive. + """ + _raise_if_baryons_already_attached(cosmo) + _raise_if_already_hmcode_feedback(cosmo) + + a_use = np.atleast_1d(a).astype(float) # (na,) + k_use = np.atleast_1d(k).astype(float) # (nk,) + na, nk = a_use.size, k_use.size + + cosmo_fb = self._get_internal_cosmo( + cosmo, + halofit_version=self.halofit_version_feedback, + include_feedback=True, + ) + cosmo_dmo = self._get_internal_cosmo( + cosmo, + halofit_version=self.halofit_version_dmo, + include_feedback=False, + ) + + p_fb = _to_2d_na_nk( + cosmo_fb.nonlin_matter_power(k_use, a_use), na, nk, name="P_fb" + ) + p_dmo = _to_2d_na_nk( + cosmo_dmo.nonlin_matter_power(k_use, a_use), na, nk, name="P_dmo" + ) + + boost2d = _safe_pos_ratio(p_fb, p_dmo, name="BaryonsMead20") + return _restore_input_ndim(boost2d, a=a, k=k) + + def _include_baryonic_effects( + self, + cosmo: Cosmology, + pk: Pk2D, + ) -> Pk2D: + """Apply the Mead20 boost to a Pk2D instance. + + This modifies the tabulated values of the input power spectrum by + applying the boost factor on the same (a, k) grid, preserving the + log or linear representation of the input Pk2D. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Cosmology used to + compute the boost factor on the Pk2D grid. + pk (:class:`~pyccl.Pk2D`): Input power spectrum to be modified. + + Returns: + :class:`~pyccl.Pk2D`: New Pk2D with baryonic effects applied. + + Raises: + RuntimeError: If the boost cannot be matched to the Pk2D grid. + """ + a_arr, lk_arr, pk_arr_in = pk.get_spline_arrays() + k_arr = np.exp(lk_arr) + + boost = self.boost_factor(cosmo, k_arr, a_arr) + if boost.shape != pk_arr_in.shape: + raise RuntimeError( + f"Boost shape {boost.shape} does not match " + f"pk shape {pk_arr_in.shape}." + ) + + boost_safe = np.where(np.isfinite(boost) & (boost > 0.0), boost, 1.0) + boost_safe = np.clip(boost_safe, 1e-6, 1e6) + + is_log = _resolve_pk_is_log(pk) + pk_out = _apply_boost_to_pk_arr(pk_arr_in, boost_safe, is_log=is_log) + + return Pk2D( + a_arr=a_arr, + lk_arr=lk_arr, + pk_arr=pk_out, + is_logp=is_log, + extrap_order_lok=pk.extrap_order_lok, + extrap_order_hik=pk.extrap_order_hik, + ) + + def include_baryonic_effects( + self, + cosmo: Cosmology, + pk: Pk2D, + ) -> Pk2D: + """Return a baryon-modified Pk2D using a CAMB HMCode baseline. + + This method constructs an internal CAMB HMCode dark-matter-only + baseline and applies the Mead20 boost to that baseline. The ``pk`` + argument is accepted for API compatibility but is not used as the + baseline spectrum. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Baseline cosmology. + pk (:class:`~pyccl.Pk2D`): Ignored baseline Pk2D provided for API + compatibility. + + Returns: + :class:`~pyccl.Pk2D`: Baryon-modified nonlinear matter power + spectrum. + + Raises: + ValueError: If baryonic effects are already attached to ``cosmo`` + or if CAMB HMCode feedback is already enabled on the input + cosmology. + """ + _raise_if_baryons_already_attached(cosmo) + _raise_if_already_hmcode_feedback(cosmo) + + # Build internal CAMB HMCode-DMO cosmology (forced CAMB backend) + cosmo_dmo = self._get_internal_cosmo( + cosmo, + halofit_version=self.halofit_version_dmo, + include_feedback=False, + ) + + # Always use the internal HMCode DMO Pk2D baseline + pk_dmo = cosmo_dmo.get_nonlin_power() + + # Apply boost (this preserves *all* your is_log recovery logic) + return self._include_baryonic_effects(cosmo_dmo, pk_dmo) diff --git a/pyccl/baryons/mead20_hmcode/__init__.py b/pyccl/baryons/mead20_hmcode/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pyccl/baryons/mead20_hmcode/mead20_utils.py b/pyccl/baryons/mead20_hmcode/mead20_utils.py new file mode 100644 index 000000000..4eae4743e --- /dev/null +++ b/pyccl/baryons/mead20_hmcode/mead20_utils.py @@ -0,0 +1,389 @@ +"""Utility functions for Mead20 baryon model.""" + +from __future__ import annotations + +from typing import Any +from copy import deepcopy +from numpy.typing import NDArray + +import numpy as np +from ...cosmology import Cosmology + +FloatArray = NDArray[np.floating[Any]] + +_EPS = 1e-300 + + +def _cosmo_signature(cosmo: Cosmology) -> int: + """Build a cache key for a Cosmology instance. + + This returns a reproducible integer based on the cosmology parameters, to + support memoization of internally constructed CAMB cosmologies. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Cosmology to summarize. + + Returns: + :obj:`int`: Hash-like signature suitable for caching. + """ + return hash(repr(cosmo.to_dict())) + + +def _raise_if_already_hmcode_feedback(cosmo: Cosmology) -> None: + """Raise if the input cosmology already enables HMCode feedback in CAMB. + + BaryonsMead20 builds an internal CAMB HMCode ratio. If the input cosmology + is already configured to request HMCode feedback, applying this model would + double-count baryonic effects. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Cosmology to validate. + + Raises: + ValueError: If CAMB HMCode feedback is already requested. + """ + cfg = cosmo.to_dict() + if cfg.get("matter_power_spectrum") != "camb": + return + camb = (cfg.get("extra_parameters") or {}).get("camb", + {}) or {} + hf = str(camb.get("halofit_version", "")).lower() + if "feedback" in hf: + raise ValueError( + "BaryonsMead20: input cosmology already requests CAMB HMCode " + "baryonic feedback " + f"(halofit_version={camb.get('halofit_version')!r}). " + "Do not also attach BaryonsMead20 as `baryonic_effects`." + ) + + +def _raise_if_baryons_already_attached(cosmo: Cosmology) -> None: + """Raise if the input cosmology already has baryonic effects attached. + + This prevents stacking multiple baryonic prescriptions on the same + cosmology, which is not supported by this model. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Cosmology to validate. + + Raises: + ValueError: If baryonic effects are already present on ``cosmo``. + """ + if getattr(cosmo, "baryons", None) is not None: + raise ValueError( + "BaryonsMead20: input cosmology already has" + " baryonic_effects attached. " + "Do not stack baryonic models." + ) + + +def _build_internal_camb_kwargs( + cosmo: Cosmology, + *, + halofit_version: str, + include_feedback: bool, + kmax: float, + HMCode_logT_AGN: float, + HMCode_A_baryon: float | None, + HMCode_eta_baryon: float | None, + lmax: int | None, + dark_energy_model: str | None, + camb_overrides: dict[str, Any] | None, +) -> dict[str, Any]: + """Build kwargs for an internal CAMB-backed Cosmology. + + The returned dictionary is derived from the input cosmology parameters, but + is adjusted so an internal CAMB pipeline can be evaluated consistently. + This is used to compute the HMCode ratio with and without feedback. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Baseline cosmology. + halofit_version (:obj:`str`): CAMB halofit/HMCode version string. + include_feedback (:obj:`bool`): Whether to enable baryonic feedback. + kmax (:obj:`float`): Maximum wavenumber for internal CAMB evaluation. + HMCode_logT_AGN (:obj:`float`): AGN feedback strength parameter. + HMCode_A_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + HMCode_eta_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + lmax (:obj:`int` or :obj:`None`): Optional CAMB ell limit. + dark_energy_model (:obj:`str` or :obj:`None`): Optional CAMB DE model. + camb_overrides (:obj:`dict` or :obj:`None`): Extra CAMB settings. + + Returns: + :obj:`dict`: Keyword arguments for constructing a Cosmology. + """ + kwargs = deepcopy(cosmo.to_dict()) + + # Force CAMB pipeline for internal eval + kwargs["transfer_function"] = "boltzmann_camb" + kwargs["matter_power_spectrum"] = "camb" + + # Avoid recursion/double-baryonization inside internal cosmology + kwargs["baryonic_effects"] = None + + extra = deepcopy(kwargs.get("extra_parameters", {})) or {} + camb = deepcopy(extra.get("camb", {})) or {} + + # Required: choose HMCode variant + camb["halofit_version"] = str(halofit_version) + + # kmax policy: never reduce user kmax + if "kmax" in camb: + camb["kmax"] = float(max(float(camb["kmax"]), float(kmax))) + else: + camb["kmax"] = float(kmax) + + # Optional CAMB params: don't stomp user values + if lmax is not None and "lmax" not in camb: + camb["lmax"] = int(lmax) + if dark_energy_model is not None and "dark_energy_model" not in camb: + camb["dark_energy_model"] = str(dark_energy_model) + + # Optional HMCode params: don't stomp user values + if HMCode_A_baryon is not None and "HMCode_A_baryon" not in camb: + camb["HMCode_A_baryon"] = float(HMCode_A_baryon) + if HMCode_eta_baryon is not None and "HMCode_eta_baryon" not in camb: + camb["HMCode_eta_baryon"] = float(HMCode_eta_baryon) + + # Feedback strength: override on purpose for feedback; remove for dmo + if include_feedback: + camb["HMCode_logT_AGN"] = float(HMCode_logT_AGN) + else: + camb.pop("HMCode_logT_AGN", None) + + # Escape hatch wins + for kk, vv in (camb_overrides or {}).items(): + camb[kk] = vv + + extra["camb"] = camb + kwargs["extra_parameters"] = extra + return kwargs + + +def _make_internal_camb_cosmology( + cosmo: Cosmology, + *, + halofit_version: str, + include_feedback: bool, + kmax: float, + HMCode_logT_AGN: float, + HMCode_A_baryon: float | None, + HMCode_eta_baryon: float | None, + lmax: int | None, + dark_energy_model: str | None, + camb_overrides: dict[str, Any] | None, +) -> Cosmology: + """Construct an internal CAMB-backed Cosmology. + + This helper creates a Cosmology that matches the input parameters but is + configured to evaluate the CAMB nonlinear power required by HMCode. + + Args: + cosmo (:class:`~pyccl.cosmology.Cosmology`): Baseline cosmology. + halofit_version (:obj:`str`): CAMB halofit/HMCode version string. + include_feedback (:obj:`bool`): Whether to enable baryonic feedback. + kmax (:obj:`float`): Maximum wavenumber for internal CAMB evaluation. + HMCode_logT_AGN (:obj:`float`): AGN feedback strength parameter. + HMCode_A_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + HMCode_eta_baryon (:obj:`float` or :obj:`None`): Optional HMCode + parameter. + lmax (:obj:`int` or :obj:`None`): Optional CAMB ell limit. + dark_energy_model (:obj:`str` or :obj:`None`): Optional CAMB DE model. + camb_overrides (:obj:`dict` or :obj:`None`): Extra CAMB settings. + + Returns: + :class:`~pyccl.cosmology.Cosmology`: Internal CAMB-backed cosmology. + """ + from ...cosmology import Cosmology # local import to avoid cycles + + kwargs = _build_internal_camb_kwargs( + cosmo, + halofit_version=halofit_version, + include_feedback=include_feedback, + kmax=kmax, + HMCode_logT_AGN=HMCode_logT_AGN, + HMCode_A_baryon=HMCode_A_baryon, + HMCode_eta_baryon=HMCode_eta_baryon, + lmax=lmax, + dark_energy_model=dark_energy_model, + camb_overrides=camb_overrides, + ) + return Cosmology(**kwargs) + + +def _resolve_pk_is_log(pk: Any) -> bool: + """Decide whether a P(k) object should be treated as log(P). + + This inspects common Pk2D-like attributes to infer whether the stored power + spectrum values are in log space or linear space. + + Args: + pk: Power spectrum container (e.g. :class:`~pyccl.Pk2D` or similar). + + Returns: + :obj:`bool`: True if values should be interpreted as log(P). + """ + psp_is_log = bool(getattr(getattr(pk, "psp", None), "is_log", False)) + pk_is_logp = getattr(pk, "is_logp", None) + return bool(pk_is_logp) if pk_is_logp is not None else psp_is_log + + +def _ensure_log_pk_arr( + pk_arr: FloatArray, + *, + absurd_log_threshold: float = 200.0, +) -> FloatArray: + """Return an array that can be safely interpreted as log(P). + + This is used to robustly handle inputs where the log/linear convention may + be inconsistent, so downstream operations that assume log(P) remain stable. + + Args: + pk_arr (:obj:`array`): Power spectrum values. + absurd_log_threshold (:obj:`float`): Heuristic threshold used to + identify inconsistent log labeling. + + Returns: + :obj:`array`: Values suitable for log-space operations. + """ + # Heuristic: true log(P) rarely has max >> O(10..100) so + # if it does, it's likely linear. + if float(np.nanmax(pk_arr)) > absurd_log_threshold: + return np.log(np.maximum(pk_arr, _EPS)) + return pk_arr + + +def _apply_boost_to_pk_arr( + pk_arr_in: FloatArray, + boost: FloatArray, + *, + is_log: bool, +) -> FloatArray: + """Apply a multiplicative boost to a power spectrum array. + + The boost is applied in a way that respects whether the input power values + are stored in linear space or log space. + + Args: + pk_arr_in (:obj:`array`): Input power spectrum values. + boost (:obj:`array`): Multiplicative correction factor. + is_log (:obj:`bool`): Whether ``pk_arr_in`` is in log space. + + Returns: + :obj:`array`: Boosted power spectrum values. + """ + pk_arr = np.array(pk_arr_in, copy=True) + + if is_log: + pk_arr = _ensure_log_pk_arr(pk_arr) + return pk_arr + np.log(boost) + return pk_arr * boost + + +def _to_2d_na_nk( + p: FloatArray, + na: int, + nk: int, + *, + name: str, +) -> FloatArray: + """Normalize a power spectrum grid to shape (na, nk). + + This enforces the expected 2D layout for arrays tabulated on (a, k) grids + and provides a clear error if the input is incompatible. + + Args: + p (:obj:`array`): Input array. + na (:obj:`int`): Expected number of scale-factor samples. + nk (:obj:`int`): Expected number of k samples. + name (:obj:`str`): Label used in error messages. + + Returns: + :obj:`array`: View or copy with shape (na, nk). + + Raises: + RuntimeError: If the input array cannot be reshaped or transposed + into (na, nk). + """ + p = np.asarray(p) + if p.shape == (na, nk): + return p + if p.shape == (nk, na): + return p.T + raise RuntimeError(f"Unexpected {name} shape {p.shape};" + f" expected {(na, nk)} or {(nk, na)}") + + +def _safe_pos_ratio( + num: FloatArray, + den: FloatArray, + *, + name: str, +) -> FloatArray: + """Compute a positive, finite ratio with basic validation. + + This helper divides ``num`` by ``den`` while guarding against tiny + denominators. It also checks that the result is finite and strictly + positive, which is required when building multiplicative boosts. + + Args: + num (:obj:`array`): Numerator values. + den (:obj:`array`): Denominator values. + name (:obj:`str`): Label used in error messages. + + Returns: + :obj:`array`: Elementwise ratio ``num/den``. + + Raises: + FloatingPointError: If the ratio contains non-finite values or is not + strictly positive. + """ + den = np.asarray(den) + num = np.asarray(num) + + abs_den = np.abs(den) + sgn_den = np.sign(den) + sgn_den = np.where(sgn_den == 0.0, 1.0, sgn_den) + + den_safe = np.where(abs_den > _EPS, den, sgn_den * _EPS) + out = num / den_safe + + if not np.all(np.isfinite(out)): + raise FloatingPointError(f"{name}: non-finite ratio encountered.") + if np.any(out <= 0): + raise FloatingPointError(f"{name}: non-positive ratio encountered.") + return out + + +def _restore_input_ndim( + out2d: FloatArray, + *, + a: float | FloatArray, + k: float | FloatArray, +) -> float | FloatArray: + """Restore output shape to match scalar and 1D input conventions. + + Many public CCL functions accept ``a`` and ``k`` as scalars or arrays. This + helper converts a 2D (na, nk) output back to the corresponding scalar, 1D, + or 2D shape implied by the original inputs. + + Args: + out2d (:obj:`array`): Output tabulated on an (a, k) grid. + a (:obj:`float` or `array`): Original scale-factor input. + k (:obj:`float` or `array`): Original wavenumber input. + + Returns: + :obj:`float` or `array`: Output with dimensions matching inputs. + """ + a_is_scalar = np.ndim(a) == 0 + k_is_scalar = np.ndim(k) == 0 + + if a_is_scalar and k_is_scalar: + return float(out2d[0, 0]) + if a_is_scalar: + return out2d[0, :] + if k_is_scalar: + return out2d[:, 0] + return out2d From 4251d0153b394e15aea8555c01731da372f913cb Mon Sep 17 00:00:00 2001 From: "niko.sarcevic" Date: Mon, 26 Jan 2026 02:00:38 -0500 Subject: [PATCH 2/3] added unit tests for mead20 --- pyccl/tests/test_baryons_mead20.py | 274 +++++++++++++++++ .../tests/test_baryons_mead20_mead20_utils.py | 285 ++++++++++++++++++ 2 files changed, 559 insertions(+) create mode 100644 pyccl/tests/test_baryons_mead20.py create mode 100644 pyccl/tests/test_baryons_mead20_mead20_utils.py diff --git a/pyccl/tests/test_baryons_mead20.py b/pyccl/tests/test_baryons_mead20.py new file mode 100644 index 000000000..af5cfba91 --- /dev/null +++ b/pyccl/tests/test_baryons_mead20.py @@ -0,0 +1,274 @@ +"""Unit tests for ``pyccl.baryons.mead20.BaryonsMead20``.""" + +from __future__ import annotations + +import numpy as np +import pytest + +import pyccl.baryons.mead20 as m + + +class _FakePk2D: + """Minimal Pk2D-like object for tests (no C splines).""" + + def __init__( + self, + *, + a_arr, + lk_arr, + pk_arr, + is_logp=False, + extrap_order_lok=1, + extrap_order_hik=2, + ): + self._a = np.asarray(a_arr, float) + self._lk = np.asarray(lk_arr, float) + self._pk = np.asarray(pk_arr, float) + self.is_logp = bool(is_logp) + self.extrap_order_lok = int(extrap_order_lok) + self.extrap_order_hik = int(extrap_order_hik) + + def get_spline_arrays(self): + return self._a, self._lk, self._pk + + +class _FakeCosmology: + """Minimal Cosmology-like object for tests.""" + + def __init__(self, *, nonlin_fn=None, pk2d=None, d=None, baryons=None): + self._nonlin_fn = nonlin_fn + self._pk2d = pk2d + self._d = dict(d or {}) + self.baryons = baryons + + def to_dict(self): + return dict(self._d) + + def nonlin_matter_power(self, k, a): + if self._nonlin_fn is None: + raise RuntimeError("nonlin_matter_power not configured.") + return self._nonlin_fn(np.asarray(k), np.asarray(a)) + + def get_nonlin_power(self): + if self._pk2d is None: + raise RuntimeError("get_nonlin_power not configured.") + return self._pk2d + + +def _cosmo_sig_constant(_cosmo): + """Return a deterministic signature for caching tests.""" + return 12345 + + +def _const_grid(value, na, nk): + """Return a (na, nk) grid filled with a constant value.""" + return np.full((na, nk), float(value)) + + +def _make_nonlin_fn(value): + """Return nonlin power fn that matches requested (a, k) grid shape.""" + + def fn(k, a): + a = np.atleast_1d(a) + k = np.atleast_1d(k) + return np.full((a.size, k.size), float(value)) + + return fn + + +def test_init_sets_attributes() -> None: + """Test that constructor stores parameters with correct coercions.""" + b = m.BaryonsMead20( + HMCode_logT_AGN=7.9, + HMCode_A_baryon=3.0, + HMCode_eta_baryon=None, + kmax=12.0, + lmax=100, + dark_energy_model="ppf", + camb_overrides={"kmax": 999.0}, + cache_cosmologies=False, + ) + assert b.HMCode_logT_AGN == 7.9 + assert b.HMCode_A_baryon == 3.0 + assert b.HMCode_eta_baryon is None + assert b.kmax == 12.0 + assert b.lmax == 100 + assert b.dark_energy_model == "ppf" + assert b.camb_overrides == {"kmax": 999.0} + assert b.cache_cosmologies is False + + +def test_get_internal_cosmo_no_cache_rebuilds(monkeypatch) -> None: + """Test that disabling caching rebuilds internal cosmologies.""" + calls = [] + + def fake_make(_cosmo, **kwargs): + calls.append(dict(kwargs)) + return _FakeCosmology() + + monkeypatch.setattr(m, "_make_internal_camb_cosmology", fake_make) + + b = m.BaryonsMead20(cache_cosmologies=False) + base = _FakeCosmology() + + c1 = b._get_internal_cosmo( + base, halofit_version="v", include_feedback=True + ) + c2 = b._get_internal_cosmo( + base, halofit_version="v", include_feedback=True + ) + + assert c1 is not c2 + assert len(calls) == 2 + + +def test_get_internal_cosmo_cache_reuses(monkeypatch) -> None: + """Test that caching reuses the same internal cosmology object.""" + monkeypatch.setattr(m, "_cosmo_signature", _cosmo_sig_constant) + + made = [] + + def fake_make(_cosmo, **_kwargs): + out = _FakeCosmology() + made.append(out) + return out + + monkeypatch.setattr(m, "_make_internal_camb_cosmology", fake_make) + + b = m.BaryonsMead20(cache_cosmologies=True) + base = _FakeCosmology() + + c1 = b._get_internal_cosmo( + base, halofit_version="v", include_feedback=False + ) + c2 = b._get_internal_cosmo( + base, halofit_version="v", include_feedback=False + ) + + assert c1 is c2 + assert len(made) == 1 + + +def test_boost_factor_returns_ratio(monkeypatch) -> None: + """Test that boost_factor returns P_fb / P_dmo on the (a, k) grid.""" + + def fake_make(_cosmo, *, include_feedback, **_kwargs): + val = 2.0 if include_feedback else 1.0 + return _FakeCosmology(nonlin_fn=_make_nonlin_fn(val)) + + monkeypatch.setattr(m, "_make_internal_camb_cosmology", fake_make) + + b = m.BaryonsMead20(cache_cosmologies=False) + + out = b.boost_factor( + _FakeCosmology(), + k=np.array([1.0, 2.0, 3.0]), + a=np.array([0.5, 1.0]), + ) + + assert out.shape == (2, 3) + assert np.allclose(out, 2.0) + + +def test_boost_factor_restores_scalar_shapes(monkeypatch) -> None: + """Test that scalar inputs restore scalar/1D outputs correctly.""" + + def fake_make(_cosmo, *, include_feedback, **_kwargs): + val = 4.0 if include_feedback else 2.0 + return _FakeCosmology(nonlin_fn=_make_nonlin_fn(val)) + + monkeypatch.setattr(m, "_make_internal_camb_cosmology", fake_make) + + b = m.BaryonsMead20(cache_cosmologies=False) + + out1 = b.boost_factor(_FakeCosmology(), k=np.array([1.0, 2.0, 3.0]), a=1.0) + assert out1.shape == (3,) + assert np.allclose(out1, 2.0) + + out2 = b.boost_factor(_FakeCosmology(), k=1.0, a=np.array([0.5, 1.0])) + assert out2.shape == (2,) + assert np.allclose(out2, 2.0) + + out3 = b.boost_factor(_FakeCosmology(), k=1.0, a=1.0) + assert isinstance(out3, float) + assert out3 == 2.0 + + +def test__include_baryonic_effects_shape_mismatch_raises(monkeypatch) -> None: + """Test that boost/Pk2D shape mismatch raises RuntimeError.""" + b = m.BaryonsMead20() + + def fake_boost(_cosmo, _k, _a): + return np.ones((99, 99)) + + b.boost_factor = fake_boost + + a = np.array([0.5, 1.0]) + lk = np.log(np.array([1.0, 2.0, 3.0])) + pk = _FakePk2D(a_arr=a, lk_arr=lk, pk_arr=np.ones((2, 3)), is_logp=False) + + with pytest.raises(RuntimeError, match=r"Boost shape"): + b._include_baryonic_effects(_FakeCosmology(), pk) + + +def test__include_baryonic_effects_log_mode(monkeypatch) -> None: + """Test that log(P) stays log(P) when boost is applied.""" + monkeypatch.setattr(m, "Pk2D", _FakePk2D) + + b = m.BaryonsMead20() + + def fake_boost(_cosmo, _k, _a): + return np.full((2, 3), 2.0) + + b.boost_factor = fake_boost + + a = np.array([0.5, 1.0]) + lk = np.log(np.array([1.0, 2.0, 3.0])) + pk_in = np.log(np.full((2, 3), 5.0)) + pk = _FakePk2D(a_arr=a, lk_arr=lk, pk_arr=pk_in, is_logp=True) + + out = b._include_baryonic_effects(_FakeCosmology(), pk) + _, _, pk_out = out.get_spline_arrays() + + assert out.is_logp is True + assert np.allclose(pk_out, pk_in + np.log(2.0)) + + +def test_include_baryonic_effects_uses_internal_dmo_baseline( + monkeypatch +) -> None: + """Test that include_baryonic_effects uses internal DMO baseline.""" + # It sohuld not use Pk + monkeypatch.setattr(m, "Pk2D", _FakePk2D) + + b = m.BaryonsMead20(cache_cosmologies=False) + + a = np.array([0.5, 1.0]) + lk = np.log(np.array([1.0, 2.0, 3.0])) + + pk_dmo = _FakePk2D(a_arr=a, lk_arr=lk, pk_arr=np.full((2, 3), 7.0)) + internal_dmo = _FakeCosmology(pk2d=pk_dmo) + + def fake_get_internal(_cosmo, *, include_feedback, **_kwargs): + if include_feedback: + return _FakeCosmology(nonlin_fn=_make_nonlin_fn(2.0)) + return internal_dmo + + monkeypatch.setattr(b, "_get_internal_cosmo", fake_get_internal) + + captured = {"cosmo": None, "pk": None} + + def fake_include(cosmo, pk): + captured["cosmo"] = cosmo + captured["pk"] = pk + return pk + + monkeypatch.setattr(b, "_include_baryonic_effects", fake_include) + + pk_user = _FakePk2D(a_arr=a, lk_arr=lk, pk_arr=np.full((2, 3), 999.0)) + + out = b.include_baryonic_effects(_FakeCosmology(), pk_user) + + assert out is pk_dmo + assert captured["cosmo"] is internal_dmo + assert captured["pk"] is pk_dmo diff --git a/pyccl/tests/test_baryons_mead20_mead20_utils.py b/pyccl/tests/test_baryons_mead20_mead20_utils.py new file mode 100644 index 000000000..65997c300 --- /dev/null +++ b/pyccl/tests/test_baryons_mead20_mead20_utils.py @@ -0,0 +1,285 @@ +"""Unit tests for ``pyccl.baryons.mead20_hmcode.mead20_utils``.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from pyccl.baryons.mead20_hmcode import mead20_utils as u + + +class _FakeCosmology: + """Test stub for Cosmology with only the fields mead20_utils touches.""" + def __init__(self, d: dict, *, baryons=None): + self._d = d + self.baryons = baryons + + def to_dict(self) -> dict: + return dict(self._d) + + +def test_cosmo_signature_equal_for_same_cosmo() -> None: + """Test that identical cosmology dicts produce identical signatures.""" + c1 = _FakeCosmology({"Omega_c": 0.25, "h": 0.7}) + c2 = _FakeCosmology({"Omega_c": 0.25, "h": 0.7}) + assert u._cosmo_signature(c1) == u._cosmo_signature(c2) + + +def test_cosmo_signature_diff_for_diff_cosmo() -> None: + """Test that different cosmology dicts produce different signatures.""" + c1 = _FakeCosmology({"Omega_c": 0.25, "h": 0.7}) + c2 = _FakeCosmology({"Omega_c": 0.26, "h": 0.7}) + assert u._cosmo_signature(c1) != u._cosmo_signature(c2) + + +def test_raise_if_already_hmcode_feedback_noop_if_not_camb() -> None: + """Test that non-CAMB power spectrum settings do not trigger a raise.""" + cosmo = _FakeCosmology({"matter_power_spectrum": "halofit"}) + u._raise_if_already_hmcode_feedback(cosmo) # no raise + + +def test_raise_if_already_hmcode_feedback_raises_if_fback_in_halofit_version( +) -> None: + """Test that CAMB halofit_version containing feedback raises ValueError.""" + cosmo = _FakeCosmology( + { + "matter_power_spectrum": "camb", + "extra_parameters": {"camb": + {"halofit_version": "mead2020_feedback"} + }, + } + ) + with pytest.raises(ValueError): + u._raise_if_already_hmcode_feedback(cosmo) + + +def test_raise_if_baryons_already_attached() -> None: + """Test that an attached baryon model triggers a ValueError.""" + cosmo = _FakeCosmology({"Omega_c": 0.25}, baryons=object()) + with pytest.raises(ValueError): + u._raise_if_baryons_already_attached(cosmo) + + +def test_build_internal_camb_kwargs_forces_camb_pipeline_and_disables_baryons( + +) -> None: + """Test that internal kwargs force CAMB and disable baryonic_effects.""" + cosmo = _FakeCosmology( + { + "transfer_function": "eisenstein_hu", + "matter_power_spectrum": "halofit", + "baryonic_effects": "something", + "extra_parameters": {}, + } + ) + + kw = u._build_internal_camb_kwargs( + cosmo, + halofit_version="mead2020", + include_feedback=False, + kmax=10.0, + HMCode_logT_AGN=7.8, + HMCode_A_baryon=None, + HMCode_eta_baryon=None, + lmax=None, + dark_energy_model=None, + camb_overrides=None, + ) + + assert kw["transfer_function"] == "boltzmann_camb" + assert kw["matter_power_spectrum"] == "camb" + assert kw["baryonic_effects"] is None + assert kw["extra_parameters"]["camb"]["halofit_version"] == "mead2020" + # include_feedback=False should ensure HMCode_logT_AGN not present + assert "HMCode_logT_AGN" not in kw["extra_parameters"]["camb"] + + +def test_build_internal_camb_kwargs_kmax_never_decreases_user_value() -> None: + """Test that internal kmax never reduces an existing CAMB kmax setting.""" + cosmo = _FakeCosmology( + { + "extra_parameters": {"camb": {"kmax": 50.0}}, + } + ) + kw = u._build_internal_camb_kwargs( + cosmo, + halofit_version="mead2020", + include_feedback=False, + kmax=20.0, + HMCode_logT_AGN=7.8, + HMCode_A_baryon=None, + HMCode_eta_baryon=None, + lmax=None, + dark_energy_model=None, + camb_overrides=None, + ) + assert kw["extra_parameters"]["camb"]["kmax"] == 50.0 + + +def test_build_internal_camb_kwargs_does_not_stomp_optional_user_params( + +) -> None: + """Test that user CAMB options are preserved when already set.""" + cosmo = _FakeCosmology( + { + "extra_parameters": { + "camb": { + "lmax": 123, + "dark_energy_model": "fluid", + "HMCode_A_baryon": 3.0, + "HMCode_eta_baryon": 0.6, + } + } + } + ) + kw = u._build_internal_camb_kwargs( + cosmo, + halofit_version="mead2020", + include_feedback=True, + kmax=20.0, + HMCode_logT_AGN=7.8, + HMCode_A_baryon=9.0, + HMCode_eta_baryon=9.0, + lmax=999, + dark_energy_model="ppf", + camb_overrides=None, + ) + camb = kw["extra_parameters"]["camb"] + assert camb["lmax"] == 123 + assert camb["dark_energy_model"] == "fluid" + assert camb["HMCode_A_baryon"] == 3.0 + assert camb["HMCode_eta_baryon"] == 0.6 + # include_feedback=True must force HMCode_logT_AGN + assert camb["HMCode_logT_AGN"] == 7.8 + + +def test_build_internal_camb_kwargs_overrides_win() -> None: + """Test that camb_overrides entries take precedence over derived values.""" + cosmo = _FakeCosmology({"extra_parameters": {"camb": {"kmax": 5.0}}}) + kw = u._build_internal_camb_kwargs( + cosmo, + halofit_version="mead2020", + include_feedback=True, + kmax=20.0, + HMCode_logT_AGN=7.8, + HMCode_A_baryon=None, + HMCode_eta_baryon=None, + lmax=None, + dark_energy_model=None, + camb_overrides={"kmax": 999.0, "new_param": 1}, + ) + camb = kw["extra_parameters"]["camb"] + assert camb["kmax"] == 999.0 + assert camb["new_param"] == 1 + + +def test_ensure_log_pk_arr_converts_absurd_values() -> None: + """Test that absurdly large values are treated as linear and logged.""" + pk_lin = np.array([1.0, 10.0, 1e300], dtype=float) + out = u._ensure_log_pk_arr(pk_lin, absurd_log_threshold=200.0) + assert np.all(np.isfinite(out)) + assert np.allclose(out[:-1], np.log(pk_lin[:-1])) + + +def test_apply_boost_linear() -> None: + """Test that boosts multiply directly when the input spectrum is linear.""" + pk = np.array([2.0, 3.0], dtype=float) + boost = np.array([10.0, 0.5], dtype=float) + out = u._apply_boost_to_pk_arr(pk, boost, is_log=False) + assert np.allclose(out, pk * boost) + + +def test_apply_boost_log() -> None: + """Test that boosts add in log-space when the input spectrum is log(P).""" + pk_log = np.log(np.array([2.0, 3.0], dtype=float)) + boost = np.array([10.0, 0.5], dtype=float) + out = u._apply_boost_to_pk_arr(pk_log, boost, is_log=True) + assert np.allclose(out, pk_log + np.log(boost)) + + +def test_to_2d_na_nk_accepts_transpose() -> None: + """Test that (nk, na) inputs are transposed to (na, nk).""" + na, nk = 2, 3 + p = np.arange(na * nk, dtype=float).reshape(nk, na) + out = u._to_2d_na_nk(p, na, nk, name="P") + assert out.shape == (na, nk) + assert np.allclose(out, p.T) + + +def test_to_2d_na_nk_raises_on_bad_shape() -> None: + """Test that incompatible shapes raise a RuntimeError.""" + with pytest.raises(RuntimeError): + u._to_2d_na_nk(np.zeros((2, 2)), na=2, nk=3, name="P") + + +def test_safe_pos_ratio_handles_tiny_den_and_requires_positive() -> None: + """Test that ratios handle tiny denominators and enforce positivity.""" + num = np.array([1.0, 2.0], dtype=float) + den = np.array([0.0, 1e-400], dtype=float) # both tiny + out = u._safe_pos_ratio(num, den, name="T") + assert np.all(np.isfinite(out)) + assert np.all(out > 0.0) + + with pytest.raises(FloatingPointError): + u._safe_pos_ratio(np.array([-1.0]), np.array([1.0]), name="T") + + +def test_restore_input_ndim() -> None: + """Test that output shapes match scalar/array conventions for a and k.""" + out2d = np.arange(6, dtype=float).reshape(2, 3) + + # a scalar, k array -> (nk,) + out = u._restore_input_ndim(out2d, a=1.0, k=np.array([1.0, 2.0, 3.0])) + assert out.shape == (3,) + + # a array, k scalar -> (na,) + out = u._restore_input_ndim(out2d, a=np.array([0.5, 1.0]), k=2.0) + assert out.shape == (2,) + + # both scalars -> float + out = u._restore_input_ndim(out2d, a=1.0, k=2.0) + assert isinstance(out, float) + + +def test_raise_if_already_hmcode_feedback_raises_case_insensitive() -> None: + """Test that feedback detection in halofit_version is case-insensitive.""" + cosmo = _FakeCosmology( + { + "matter_power_spectrum": "camb", + "extra_parameters": {"camb": + {"halofit_version": "MeAd2020_FeedBack"}}, + } + ) + with pytest.raises(ValueError): + u._raise_if_already_hmcode_feedback(cosmo) + + +def test_raise_if_already_hmcode_feedback_noop_for_camb_without_feedback( + +) -> None: + """Test that CAMB without 'feedback' in halofit_version does not raise.""" + cosmo = _FakeCosmology( + { + "matter_power_spectrum": "camb", + "extra_parameters": {"camb": {"halofit_version": "mead2020"}}, + } + ) + u._raise_if_already_hmcode_feedback(cosmo) # no raise + + +def test_raise_if_already_hmcode_feedback_message_includes_version( + +) -> None: + """Test that raised error message includes the halofit_version value.""" + cosmo = _FakeCosmology( + { + "matter_power_spectrum": "camb", + "extra_parameters": {"camb": + {"halofit_version": "mead2020_feedback"}}, + } + ) + with pytest.raises( + ValueError, + match=r"halofit_version=.*mead2020_feedback" + ): + u._raise_if_already_hmcode_feedback(cosmo) From 24862a4ed41b269c71da1f5d494915b7b6ab57f0 Mon Sep 17 00:00:00 2001 From: "niko.sarcevic" Date: Mon, 26 Jan 2026 02:01:14 -0500 Subject: [PATCH 3/3] added exampel notebooks for mead20 --- .../examples/baryons_mead20.ipynb | 200 ++++++ .../examples/baryons_module.ipynb | 576 ++++++++++++++++++ 2 files changed, 776 insertions(+) create mode 100644 pyccl/baryons/mead20_hmcode/examples/baryons_mead20.ipynb create mode 100644 pyccl/baryons/mead20_hmcode/examples/baryons_module.ipynb diff --git a/pyccl/baryons/mead20_hmcode/examples/baryons_mead20.ipynb b/pyccl/baryons/mead20_hmcode/examples/baryons_mead20.ipynb new file mode 100644 index 000000000..97bee0a83 --- /dev/null +++ b/pyccl/baryons/mead20_hmcode/examples/baryons_mead20.ipynb @@ -0,0 +1,200 @@ +{ + "cells": [ + { + "metadata": { + "collapsed": true + }, + "cell_type": "markdown", + "source": [ + "# HMCode-2020 baryonic feedback model\n", + "\n", + "This notebook explores the [Mead et al. (2020)](https://arxiv.org/abs/2009.01858) baryonic feedback\n", + "prescription as implemented in `HMCode-2020` via\n", + " [CAMB](https://camb.readthedocs.io/en/latest/_modules/camb/nonlinear.html) and exposed through the `BaryonsMead20` module in pyCCL.\n", + "\n", + "Unlike baryonic halo models that explicitly decompose matter into multiple components (dark matter, gas, stars) and build the power spectrum from their auto- and cross-correlations, `HMCode` is a phenomenological modification of the nonlinear matter power spectrum. Baryonic effects are encoded through a small number of effective parameters that alter halo structure and clustering in a way calibrated against hydrodynamical simulations.\n", + "\n", + "In `HMCode-2020`, baryonic feedback is incorporated directly into the nonlinear matter power spectrum computation, and its impact can be summarized as a scale- and redshift-dependent boost factor\n", + "\n", + "$B(k,a) = \\frac{P^{\\rm HMCode}(k,a)}{P^{\\rm DMO}(k, a)}$,\n", + "\n", + "defined relative to a dark-matter-only (DMO) baseline computed with otherwise identical settings.\n", + "\n", + "### What this notebook does\n", + "\n", + "Rather than exposing internal halo-model ingredients, this notebook focuses on how the effective `HMCode` feedback parameters translate into changes in the matter power spectrum. We use the `BaryonsMead20` class to construct boost factors and apply them to nonlinear power spectra computed with a CAMB backend.\n", + "\n", + "Specifically, we explore:\n", + "\n", + "- Feedback strength $T_{\\rm AGN}$\n", + "\n", + " The primary baryonic parameter in `HMCode-2020`, controlling the strength\n", + " of AGN feedback. Increasing $T_{\\rm AGN}$ generally leads to stronger\n", + " suppression of power on intermediate and small scales.\n", + "\n", + "- Redshift dependence (scale factor $a$)\n", + "\n", + " We evaluate the boost at several scale factors to illustrate how baryonic suppression evolves with cosmic time.\n", + "\n", + "- Numerical convergence $k_{\\max}$\n", + "\n", + " We vary the maximum wavenumber used in the internal CAMB evaluation to verify that the resulting boost factors are stable and not driven by numerical cutoffs.\n", + "\n", + "\n", + "Each subplot therefore corresponds to a fixed combination of redshift and numerical settings, while sweeping over the feedback strength parameter. This layout allows us to disentangle physical sensitivity (how baryons suppress or enhance power) from numerical choices required for stable and accurate evaluation.\n", + "\n", + "### Scope and interpretation\n", + "\n", + "This notebook is intended as a diagnostic and visualization tool:\n", + "\n", + "* to illustrate how to access and interpret HMCode parameters within `pyCCL`,\n", + "* to build intuition for how HMCode-2020 responds to changes in feedback\n", + "strength, and\n", + "* to assess the redshift dependence of baryonic suppression,\n", + "\n", + "It does not attempt to interpret HMCode parameters in terms of individual physical components (gas, stars, or profiles), nor does it prescribe a fiducial calibration. Instead, it provides a transparent way to understand how this widely used effective baryonic model modifies the nonlinear matter power spectrum in practice.\n" + ], + "id": "90fff541da61003c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T06:57:42.681290Z", + "start_time": "2026-01-26T06:57:42.370136Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cmasher as cmr\n", + "\n", + "import pyccl as ccl\n", + "from pyccl.baryons import BaryonsMead20\n" + ], + "id": "5553c8b489fcb400", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T06:57:42.685711Z", + "start_time": "2026-01-26T06:57:42.681921Z" + } + }, + "cell_type": "code", + "source": [ + "# basic input parameters\n", + "cosmo = ccl.CosmologyVanillaLCDM() # ccl Cosmology object\n", + "k_grid = np.logspace(-3, 1.5, 300) # wavenumber grid; in [1/Mpc]\n", + "a_list = np.array([1.0, 0.8, 0.5]) # scale factors grid\n", + "\n", + "kmax_list = [10.0, 20.0, 50.0] # max wavenumber feedback parameter; in [1/Mpc]\n", + "logT_list = [7.2, 7.6, 7.8, 8.0, 8.3] # feedback parameter; in log10[K]\n" + ], + "id": "eff98ce232903775", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T06:58:07.284052Z", + "start_time": "2026-01-26T06:57:42.686036Z" + } + }, + "cell_type": "code", + "source": [ + "# colors: one per logT curve (consistent across all panels)\n", + "colors = cmr.take_cmap_colors(\n", + " \"cmr.pride\",\n", + " len(logT_list),\n", + " cmap_range=(0.25, 0.75),\n", + ")\n", + "\n", + "nrows = len(a_list)\n", + "ncols = len(kmax_list)\n", + "\n", + "fig, axes = plt.subplots(\n", + " nrows, ncols,\n", + " figsize=(5 * ncols, 4 * nrows),\n", + ")\n", + "axes = np.atleast_2d(axes)\n", + "\n", + "for i, a in enumerate(a_list):\n", + " for j, kmax in enumerate(kmax_list):\n", + " ax = axes[i, j]\n", + "\n", + " ax.axhline(1.0, lw=2.0, ls=\"-\", c=\"darkgray\")\n", + "\n", + " for c, logT in zip(colors, logT_list):\n", + " bary = BaryonsMead20(HMCode_logT_AGN=logT, kmax=kmax)\n", + " boost = bary.boost_factor(cosmo, k_grid, a)\n", + "\n", + " ax.semilogx(\n", + " k_grid, boost,\n", + " color=c,\n", + " lw=3,\n", + " label=rf\"$\\log_{{10}}T_{{\\rm AGN}}={logT}$\",\n", + " )\n", + "\n", + " ax.tick_params(direction=\"in\", which=\"both\")\n", + " ax.legend(fontsize=12, frameon=True, loc=2)\n", + " text = rf\"$a={a:.2f}$\" + \"\\n\" + rf\"$k_{{\\max}}={kmax:g}\\,\\mathrm{{Mpc}}^{{-1}}$\"\n", + " ax.text(0.001, 0.8, text, fontsize=13)\n", + "\n", + "# axis labels only on outer edges\n", + "for ax in axes[:, 0]:\n", + " ax.set_ylabel(r\"$B(k,a)$\", fontsize=15)\n", + "for ax in axes[-1, :]:\n", + " ax.set_xlabel(r\"$k\\ [{\\rm Mpc}^{-1}]$\", fontsize=15)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "# optionally save the figure\n", + "# plt.savefig(\"baryons_mead20.pdf\", bbox_inches=\"tight\", dpi=300)\n", + "\n", + "plt.show()\n" + ], + "id": "4b362374642ddbf8", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 3 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (ccl3)", + "language": "python", + "name": "ccl3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyccl/baryons/mead20_hmcode/examples/baryons_module.ipynb b/pyccl/baryons/mead20_hmcode/examples/baryons_module.ipynb new file mode 100644 index 000000000..1c72bded1 --- /dev/null +++ b/pyccl/baryons/mead20_hmcode/examples/baryons_module.ipynb @@ -0,0 +1,576 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e09fdb6-2987-4e9f-82c3-2a408c5c65a6", + "metadata": {}, + "source": [ + "# Baryonic Effects on the Nonlinear Matter Power Spectrum\n", + "\n", + "Baryonic processes such as gas cooling, star formation, and feedback from supernovae and active galactic nuclei modify the clustering of matter on small and intermediate scales. These effects redistribute mass within halos and lead to characteristic scale-dependent deviations from a gravity-only prediction of the matter power spectrum.\n", + "\n", + "In this notebook, we compare several **baryonic prescriptions and\n", + "emulators** by examining their impact on the nonlinear matter power spectrum\n", + " at redshift $z=0$. All results are shown as ratios\n", + "\n", + "$F(k) = \\frac{P_{\\mathrm{model}}(k)}{P_{\\mathrm{nlin}}(k)}$,\n", + "\n", + "where $P_{\\mathrm{nlin}}(k)$ is the same nonlinear reference spectrum in\n", + "all cases. This normalization isolates baryonic effects and enables a direct comparison between different modeling approaches, independent of differences in the underlying nonlinear gravity treatment.\n", + "\n", + "The models considered span halo-model–based baryonification schemes, simulation-calibrated correction models, and emulators designed to reproduce hydrodynamical simulation results. The comparison highlights both the scale and magnitude of baryonic modifications predicted by each approach.\n", + "\n", + "\n", + "More generally, `pyCCL` provides a user-friendly and modular interface for baryonic\n", + "corrections, making it straightforward to experiment with different baryon models\n", + "and to generate baryon-boosted matter power spectra with minimal changes to the code.\n", + "This flexibility enables quick comparisons across modeling approaches and\n", + "parameter\n", + "choices within a consistent framework.\n", + "\n", + "\n", + "\n", + "This notebook serves as an example of how to use the\n", + "[baryonic models package](https://ccl.readthedocs.io/en/latest/api/pyccl.baryons.html),\n", + "as implemented in `pyCCL`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "31c25dbb-27df-4b30-8e50-bbf7fc5e4fac", + "metadata": {}, + "source": [ + "## Preliminary Definitions\n", + "\n" + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:32.279252Z", + "start_time": "2026-01-26T02:29:31.924691Z" + } + }, + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import ScalarFormatter\n", + "import numpy as np\n", + "import cmasher as cmr\n", + "import pyccl as ccl\n", + "print(f\"I am using pyCCL version {ccl.__version__}\")\n" + ], + "id": "7b2f1bebdf153ec3", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I am using pyCCL version 3.2.2.dev12+gba7a7d4ab\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "We only need three ingredients to explore baryonic models in CCL:\n", + "- a cosmology,\n", + "- a wavenumber grid,\n", + "- and a scale factor.\n", + "\n", + "We compute the gravity-only nonlinear power spectrum here simply as a reference,\n", + "so baryonic effects can be shown as a suppression or boost relative to the no-baryons case." + ], + "id": "52d61bb275ede69c" + }, + { + "cell_type": "code", + "id": "2b9dc02a-a995-46c6-80e3-922950266043", + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:32.515135Z", + "start_time": "2026-01-26T02:29:32.284549Z" + } + }, + "source": [ + "cosmo = ccl.CosmologyVanillaLCDM() # cosmology object\n", + "k_grid = np.logspace(-3, 1, 100) # wavenumber\n", + "a = 1. # scale factor a z=0\n", + "# construct the nonlinear power spectrum with no baryonic effects\n", + "pk_nlin = ccl.nonlin_matter_power(cosmo, k_grid, a)" + ], + "outputs": [], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "ffab7a3d-c13c-460d-bcb7-9c7a941c8b26", + "metadata": {}, + "source": "## Power Spectra $P_k$ Computation" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Schneider et al. 2015: Baryon Correction Model\n", + "\n", + "The Baryon Correction Model (BCM) applies baryonic effects as a scale- and redshift-dependent\n", + "multiplicative correction to a gravity-only nonlinear matter power spectrum.\n", + "We compute the baryon-modified $P(k)$ using the Schneider et al. (2015) prescription\n", + "(see [Schneider et al. 2015](https://arxiv.org/abs/1510.06034)).\n", + "To see the detailed implementation in `pyCCL`, call `help(ccl.BaryonsSchneider15)`.\n" + ], + "id": "e17886a8ffdfbef6" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:32.527056Z", + "start_time": "2026-01-26T02:29:32.519136Z" + } + }, + "cell_type": "code", + "source": [ + "# instantiate the BCM (Schneider+15) baryon model\n", + "bcm = ccl.baryons.BaryonsSchneider15()\n", + "\n", + "# apply BCM to a baseline nonlinear P(k)\n", + "bcm_bary = bcm.include_baryonic_effects(\n", + " cosmo=cosmo,\n", + " pk=cosmo.get_nonlin_power()\n", + ")\n", + "\n", + "# evaluate the baryon-corrected P(k,a) on our (k,a) grid\n", + "pk_bcm = bcm_bary(k_grid, a)\n" + ], + "id": "2cfc2843fbe19265", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Van Daalen et al. (2019) baryonic boost\n", + "\n", + "[Van Daalen et al. (2019)](https://arxiv.org/abs/1906.00968) provide a library of hydrodynamical vs.\n", + "collisionless (DMO) matter power spectra from `OWLS`, `cosmo-OWLS`, and\n", + "`BAHAMAS`, and an empirical prescription for the baryonic modification of the matter power spectrum.\n", + "\n", + "To see the detailed implementation in `pyCCL`, call `help(ccl.BaryonsVanDaalen19)`.\n" + ], + "id": "6bb855b4a91d14e" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:32.533140Z", + "start_time": "2026-01-26T02:29:32.528016Z" + } + }, + "cell_type": "code", + "source": [ + "# instantiate the van Daalen et al. (2019) baryon model\n", + "vd = ccl.baryons.BaryonsvanDaalen19()\n", + "\n", + "# apply the van Daalen baryonic correction to a baseline nonlinear P(k)\n", + "vd_bary = vd.include_baryonic_effects(\n", + " cosmo=cosmo,\n", + " pk=cosmo.get_nonlin_power()\n", + ")\n", + "\n", + "# evaluate the baryon-corrected P(k,a) on our (k,a) grid\n", + "pk_vd = vd_bary(k_grid, a)\n" + ], + "id": "bca11168fddb9b03", + "outputs": [], + "execution_count": 4 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Mead et al. (2020): HMCode\n", + "\n", + "HMCode provides a nonlinear matter power spectrum that incorporates baryonic\n", + "feedback through an effective halo-model prescription.\n", + "We compute the nonlinear $P(k)$ using HMCode as implemented in CAMB\n", + "(see [Mead et al. 2020](https://arxiv.org/abs/2009.01858)).\n", + "To see the detailed implementation in pyCCL, call `help(ccl.CosmologyVanillaLCDM)`.\n" + ], + "id": "d033c21ff8ed0fd4" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:33.315446Z", + "start_time": "2026-01-26T02:29:32.533599Z" + } + }, + "cell_type": "code", + "source": [ + "# instantiate Mead20\n", + "mead = ccl.baryons.BaryonsMead20(HMCode_logT_AGN=7.8)\n", + "\n", + "# apply the Mead20 baryonic correction to a baseline nonlinear P(k)\n", + "mead_bary = mead.include_baryonic_effects(\n", + " cosmo=cosmo,\n", + " pk=cosmo.get_nonlin_power(),\n", + ")\n", + "\n", + "# evaluate the baryon-corrected P(k,a) on our (k,a) grid\n", + "pk_mead = mead_bary(k_grid, a)\n" + ], + "id": "66296ccbe5f6748a", + "outputs": [], + "execution_count": 5 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Arico et al. (2020): BACCOemu\n", + "\n", + "BACCOemu provides fast, high-accuracy predictions for the nonlinear matter power spectrum using an emulator trained on suites of simulations. It builds on a baryonification approach, where particles in dark-matter-only simulations are displaced to mimic the impact of baryonic feedback, achieving percent-level agreement with hydrodynamical simulations across its validated range (see [Aricò+20](https://arxiv.org/abs/2011.15018)).\n", + "\n", + "Implementation note (CCL): `include_baryonic_effects` is not compatible with\n", + " BACCOemu in our setup because it attempts to apply the correction across\n", + " the full internal $(k, a)$ spline support of the reference `Pk2D`, while BACCOemu is only defined on a more limited $(k, a)$ domain. This range mismatch causes failures/invalid extrapolation, so BACCOemu must be queried directly on the $(k,a)$ grid we use.\n", + " To see the detailed implementation in `pyCCL`, call `help(ccl.BaccoemuBaryons)`.\n" + ], + "id": "fdddebd114a5eff8" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:37.888224Z", + "start_time": "2026-01-26T02:29:33.351703Z" + } + }, + "cell_type": "code", + "source": [ + "# instantiate the BACCOemu baryonification-based emulator (Aricò+20)\n", + "bacco = ccl.BaccoemuBaryons()\n", + "\n", + "# baseline ΛCDM cosmology used to generate the reference nonlinear P(k)\n", + "cosmo_bacco = ccl.CosmologyVanillaLCDM()\n", + "\n", + "# evaluate directly on our (k, a) grid because its valid domain is limited\n", + "bacco_boost = bacco.boost_factor(cosmo_bacco, k_grid, a)\n", + "\n", + "# compute the baseline nonlinear matter power spectrum on the same grid\n", + "pk_ref = cosmo_bacco.nonlin_matter_power(k_grid, a)\n", + "\n", + "# apply the BACCOemu boost on-grid to obtain the baryon-corrected P(k,a)\n", + "pk_bacco = pk_ref * bacco_boost\n" + ], + "id": "db0c39ac18beec71", + "outputs": [], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Moran et al. (2022): Mira–Titan DMO Emulator\n", + "\n", + "The Mira–Titan emulator provides a high-precision prediction for the dark-matter-only nonlinear matter power spectrum, calibrated on a large suite of N-body simulations.\n", + "We start by computing the dark-matter-only (DMO) $P(k)$ from the Mira–Titan\n", + "emulator.\n", + "\n", + "For more information about Mira–Titan, see [Heitmann+ 16](https://arxiv.org/abs/1601.00326) and [Moran+ 22](https://arxiv.org/abs/2203.05591). To\n", + "see the detailed implementation in pyCCL, call `help(ccl.CosmicemuMTIVPk)`." + ], + "id": "db441f8c64bff4fc" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:38.218894Z", + "start_time": "2026-01-26T02:29:37.898807Z" + } + }, + "cell_type": "code", + "source": [ + "# Initialize the Mira–Titan IV emulator (DMO nonlinear P(k) model)\n", + "mt = ccl.CosmicemuMTIVPk(\"tot\")\n", + "\n", + "# Build a vanilla ΛCDM cosmology that uses the emulator for the nonlinear power spectrum\n", + "cosmo_mt = ccl.CosmologyVanillaLCDM(matter_power_spectrum=mt)\n", + "\n", + "# Evaluate the (DMO) nonlinear matter power spectrum on our k-grid at scale factor a\n", + "pk_mt = cosmo_mt.nonlin_matter_power(k_grid, a)\n" + ], + "id": "f69c7a34a0151085", + "outputs": [], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "e8a93a6d-33a8-47dc-b347-212210d029ec", + "metadata": {}, + "source": [ + "## Plot results\n", + "\n", + "We now compare a set of baryonic prescriptions by plotting the ratio\n", + "\n", + "$F(k)\\equiv \\frac{P_\\mathrm{model}(k)}{P_\\mathrm{nlin}(k)}$\n", + "\n", + "as a function of wavenumber.\n", + "The gray line at $F(k)=1$ marks the gravity-only nonlinear baseline,\n", + " so departures from unity directly show the scale-dependent suppression or\n", + " enhancement induced by each baryonic model.\n" + ] + }, + { + "cell_type": "code", + "id": "3607216c-3c55-463d-bec1-6e3c64336cef", + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:38.495678Z", + "start_time": "2026-01-26T02:29:38.245692Z" + } + }, + "source": [ + "# List of pk data and their labels (first-author surname + year)\n", + "# This convention is consistent with ccl naming\n", + "pk_data = [\n", + " #(pk_fed/pk_nlin, \"Fedeli14\"),\n", + "\n", + " (pk_bcm/pk_nlin, \"Schneider15\"),\n", + " (pk_vd/pk_nlin, \"VanDaalen19\"),\n", + " (pk_mead/pk_nlin, \"Mead20\"),\n", + " (pk_bacco/pk_nlin, \"Aricò21\"),\n", + " (pk_mt/pk_nlin, \"Moran22\"),\n", + "]\n", + "\n", + "# take colors from the cmasher colormap\n", + "# note: you can also use any matplotlib colormap here\n", + "# e.g. pass \"viridis\" instead of \"cmr.pride\"\n", + "colors = cmr.take_cmap_colors(\"cmr.pride\",\n", + " len(pk_data),\n", + " cmap_range=(0.25, 0.75))\n", + "\n", + "plt.figure(figsize=(7, 5))\n", + "\n", + "# reference line for pk_baryons / pk_nonlin = 1\n", + "plt.semilogx(k_grid, [1]*len(k_grid), c=\"darkgray\", lw=3)\n", + "\n", + "# loop over the pk data and colors to plot them\n", + "for (pk, label), color in zip(pk_data, colors):\n", + " plt.semilogx(k_grid, pk, c=color, label=label, lw=4)\n", + "\n", + "\n", + "x_label = r\"$k \\; \\mathrm{[Mpc^{-1}]}$\"\n", + "y_label = r\"$F(k)\\equiv P_\\mathrm{model}(k) \\; / \\; P_\\mathrm{nlin}(k)$\"\n", + "\n", + "plt.xlabel(x_label, fontsize=15)\n", + "plt.ylabel(y_label, fontsize=15)\n", + "\n", + "plt.gca().tick_params(direction='in', which='both')\n", + "plt.gca().yaxis.set_major_formatter(ScalarFormatter(useOffset=False))\n", + "\n", + "plt.legend(frameon=False, fontsize=14, ncol=1, loc=3,\n", + " title=\"Model:\", title_fontsize=14)\n", + "\n", + "plt.show()\n" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 8 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:38.505561Z", + "start_time": "2026-01-26T02:29:38.499137Z" + } + }, + "cell_type": "code", + "source": [ + "# We now also need to confirm that the HMCode implementation in CAMB\n", + "# is consistent with the Mead20 baryonic correction above.\n", + "# To do this, we build a cosmology that sources the nonlinear P(k) from CAMB\n", + "# with the HMCode baryonic feedback enabled." + ], + "id": "d79e74c0f6f425af", + "outputs": [], + "execution_count": 9 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:38.811869Z", + "start_time": "2026-01-26T02:29:38.506092Z" + } + }, + "cell_type": "code", + "source": [ + "# build a ΛCDM cosmology that sources the nonlinear P(k) from CAMB\n", + "cosmo_hmcode = ccl.CosmologyVanillaLCDM(\n", + " matter_power_spectrum=\"camb\", # delegate P_nl(k,a) to CAMB\n", + " extra_parameters={\n", + " \"camb\": {\n", + " \"kmax\": 20.0, # CAMB internal k_max (1/Mpc) used for its P(k) tables\n", + " \"halofit_version\": \"mead2020_feedback\", # HMCode / Mead+20 feedback prescription\n", + " \"HMCode_logT_AGN\": 7.8, # AGN feedback strength parameter (higher = stronger feedback)\n", + " }\n", + " },\n", + ")\n", + "\n", + "# evaluate the HMCode-modified nonlinear matter power spectrum on our (k,a) grid\n", + "pk_hmcode = cosmo_hmcode.nonlin_matter_power(k_grid, a)\n" + ], + "id": "c0ce3b90888d2646", + "outputs": [], + "execution_count": 10 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-26T02:29:39.010331Z", + "start_time": "2026-01-26T02:29:38.812218Z" + } + }, + "cell_type": "code", + "source": [ + "pk_check = [\n", + " (pk_hmcode / pk_nlin, \"Mead20-OLD\", \"-\"),\n", + " (pk_mead / pk_nlin, \"Mead20-NEW\", \"--\"),\n", + "]\n", + "\n", + "# 3 colors: left panel uses [0] and [2], right panel uses [1]\n", + "colors3 = cmr.take_cmap_colors(\n", + " \"cmr.pride\",\n", + " 3,\n", + " cmap_range=(0.25, 0.75),\n", + ")\n", + "c_old, c_mid, c_new = colors3[0], colors3[1], colors3[2]\n", + "\n", + "pk_old = pk_check[0][0]\n", + "pk_new = pk_check[1][0]\n", + "frac_diff = (pk_new - pk_old) / pk_old\n", + "\n", + "fig, (ax0, ax1) = plt.subplots(\n", + " 1, 2, figsize=(13, 5), sharex=True, constrained_layout=True\n", + ")\n", + "\n", + "# left plot: pk ratios\n", + "ax0.semilogx(k_grid, np.ones_like(k_grid), c=\"darkgray\", lw=3, zorder=0)\n", + "\n", + "left_colors = [c_old, c_new]\n", + "for (pk, label, ls), color in zip(pk_check, left_colors):\n", + " ax0.semilogx(k_grid, pk, c=color, ls=ls, lw=4, label=label)\n", + "\n", + "ax0.set_xlabel(r\"$k \\; \\mathrm{[Mpc^{-1}]}$\", fontsize=15)\n", + "ax0.set_ylabel(r\"$F(k)\\equiv P_\\mathrm{model}(k)\\,/\\,P_\\mathrm{nlin}(k)$\", fontsize=15)\n", + "ax0.tick_params(direction=\"in\", which=\"both\")\n", + "ax0.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))\n", + "ax0.legend(frameon=False, fontsize=14, loc=3, title=\"Model:\", title_fontsize=14)\n", + "\n", + "# right plot: fractional difference\n", + "ax1.semilogx(k_grid, np.zeros_like(k_grid), c=\"darkgray\", lw=3, zorder=0)\n", + "ax1.semilogx(k_grid, frac_diff, c=c_mid, lw=4)\n", + "\n", + "ax1.set_xlabel(r\"$k \\; \\mathrm{[Mpc^{-1}]}$\", fontsize=15)\n", + "ax1.set_ylabel(r\"$(\\mathrm{NEW}-\\mathrm{OLD})/\\mathrm{OLD}$\", fontsize=15)\n", + "ax1.tick_params(direction=\"in\", which=\"both\")\n", + "ax1.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))\n", + "\n", + "plt.show()\n" + ], + "id": "7defddf942126205", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 11 + } + ], + "metadata": { + "hide_input": false, + "kernelspec": { + "display_name": "Python (ccl3)", + "language": "python", + "name": "ccl3" + }, + "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.11.5" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}