diff --git a/.gitignore b/.gitignore index e84f6796..a96d2ae3 100644 --- a/.gitignore +++ b/.gitignore @@ -42,6 +42,7 @@ testfile* *.ipynb !CAMBdemo.ipynb !ScalEqs.ipynb +!docs/SPk_demo.ipynb *.dll *.a *.o diff --git a/.vscode/settings.json b/.vscode/settings.json index efcf0467..8dd25021 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -116,4 +116,8 @@ }, "python-envs.defaultEnvManager": "ms-python.python:venv", "python-envs.defaultPackageManager": "ms-python.python:pip", + "fortran.linter.includePaths": [ + "${workspaceFolder}/fortran/Releaselib", + "${workspaceFolder}/forutils/Releaselib" + ] } diff --git a/camb/__init__.py b/camb/__init__.py index 138edc6c..960f7dad 100644 --- a/camb/__init__.py +++ b/camb/__init__.py @@ -43,6 +43,6 @@ from .initialpower import InitialPowerLaw, SplinedInitialPower from .mathutils import threej from .model import CAMBparams, TransferParams -from .nonlinear import Halofit +from .nonlinear import Halofit, SPkNonLinear from .reionization import ExpReionization, TanhReionization from .results import CAMBdata, ClTransferData, MatterTransferData diff --git a/camb/nonlinear.py b/camb/nonlinear.py index b6d17732..08b7bb6c 100644 --- a/camb/nonlinear.py +++ b/camb/nonlinear.py @@ -1,9 +1,10 @@ -from ctypes import POINTER, byref, c_double, c_int +import math +from ctypes import POINTER, byref, c_bool, c_double, c_int import numpy as np from numpy.ctypeslib import ndpointer -from .baseconfig import F2003Class, fortran_class, numpy_1d +from .baseconfig import AllocatableObject, CAMBValueError, F2003Class, fortran_class, numpy_1d class NonLinearModel(F2003Class): @@ -93,6 +94,171 @@ def set_params( self.HMCode_logT_AGN = HMCode_logT_AGN +@fortran_class +class SPkNonLinear(NonLinearModel): + """ + SP(k) baryon suppression model applied on top of a base non-linear model. + + References: + - SP(k) model: `arXiv:2305.09710 `_, + `MNRAS 523, 2247 (2023) `_ + - pyspk implementation details and mode definitions: + https://github.com/jemme07/pyspk + + The base model is evaluated first (Halofit by default), then SP(k) + suppression is applied to CAMB's non-linear ratio as + + ``sqrt(P_NL/P_L) -> sqrt(P_NL/P_L) * sqrt(SPk_suppression)``. + + Notes: + - SP(k) calibration is defined for ``0 <= z <= 3`` and ``k <= 12 h/Mpc``. + Outside these ranges, behavior follows the Fortran implementation. + - SP(k) cannot be combined with HMCode baryon-feedback modes + (for example ``halofit_version='mead2020_feedback'``). + """ + + _fields_ = ( + ("BaseModel", AllocatableObject(NonLinearModel)), + ("SPk_feedback", c_bool, "Enable SP(k) suppression"), + ("SPk_SO", c_int, "SP(k) spherical overdensity (200 or 500)"), + ( + "SPk_relation_kind", + c_int, + "SP(k) relation kind: 1=power_law, 2=cosmo_power_law, 3=double_power_law", + ), + ("SPk_fb_a", c_double, "Power-law relation normalization"), + ("SPk_fb_pow", c_double, "Power-law relation exponent"), + ("SPk_fb_pivot", c_double, "Power-law relation pivot mass [M_sun]"), + ("SPk_alpha", c_double, "Relation alpha parameter (kinds 2/3)"), + ("SPk_beta", c_double, "Relation beta parameter (kinds 2/3)"), + ("SPk_gamma", c_double, "Relation gamma parameter (kinds 2/3)"), + ("SPk_epsilon", c_double, "Relation epsilon parameter (kind 3)"), + ("SPk_m_pivot", c_double, "Relation pivot mass [M_sun] (kind 3)"), + ) + + _fortran_class_module_ = "SPkNonLinear" + _fortran_class_name_ = "TSPkNonLinear" + + def __init__(self, **kwargs): + super().__init__() + self.BaseModel = Halofit() + self.set_params(**kwargs) + + def _validate(self): + if self.SPk_SO not in (200, 500): + raise CAMBValueError("SPk_SO must be 200 or 500") + if self.SPk_relation_kind not in (1, 2, 3): + raise CAMBValueError( + "SPk_relation_kind must be 1 (power_law), 2 (cosmo_power_law), or 3 (double_power_law)" + ) + if self.SPk_relation_kind == 1 and self.SPk_fb_pivot <= 0: + raise CAMBValueError("SPk_fb_pivot must be > 0 for power_law relation") + if self.SPk_relation_kind == 3 and self.SPk_m_pivot <= 0: + raise CAMBValueError("SPk_m_pivot must be > 0 for double_power_law relation") + + if self.SPk_feedback and isinstance(self.BaseModel, Halofit): + if isinstance(self.BaseModel.halofit_version, str): + halofit_version_int = halofit_version_names[self.BaseModel.halofit_version] + else: + halofit_version_int = int(self.BaseModel.halofit_version) + if halofit_version_int == halofit_version_names[halofit_mead2020_feedback]: + raise CAMBValueError( + "SP(k) is not compatible with halofit_version='mead2020_feedback'. " + "Use halofit_version='mead2020' (or another non-feedback option) when enabling SPk_feedback." + ) + + hmcode_2015_2016_versions = { + halofit_version_names[halofit_mead], + halofit_version_names[halofit_mead2015], + halofit_version_names[halofit_mead2016], + } + if halofit_version_int in hmcode_2015_2016_versions and ( + (not math.isclose(self.BaseModel.HMCode_A_baryon, 3.13, rel_tol=0.0, abs_tol=1e-12)) + or (not math.isclose(self.BaseModel.HMCode_eta_baryon, 0.603, rel_tol=0.0, abs_tol=1e-12)) + ): + raise CAMBValueError( + "SP(k) cannot be combined with HMCode_A_baryon/HMCode_eta_baryon baryonic corrections in HMCode 2015/2016" + ) + + def set_params( + self, + base_model=None, + SPk_feedback=False, + SPk_SO=200, + SPk_relation_kind=1, + SPk_fb_a=1.0, + SPk_fb_pow=0.0, + SPk_fb_pivot=1.0, + SPk_alpha=0.0, + SPk_beta=0.0, + SPk_gamma=0.0, + SPk_epsilon=0.0, + SPk_m_pivot=1.0, + ): + """ + Set SP(k) model and relation parameters. + + References: + - SP(k) model: `arXiv:2305.09710 `_, + `MNRAS 523, 2247 (2023) `_ + - For mode details and examples, see https://github.com/jemme07/pyspk + + SP(k) modes: + + - ``1`` (``power_law``): + ``f_b/(Omega_b/Omega_m) = a * (M_SO/M_pivot)^b`` + where ``a=SPk_fb_a``, ``b=SPk_fb_pow``, ``M_pivot=SPk_fb_pivot``. + + - ``2`` (``cosmo_power_law``; redshift-dependent power law): + ``f_b/(Omega_b/Omega_m) = (exp(alpha)/100) * (M_500c/1e14 M_sun)^(beta-1) * (E(z)/E(0.3))^gamma`` + where ``alpha=SPk_alpha``, ``beta=SPk_beta``, ``gamma=SPk_gamma``. + + - ``3`` (``double_power_law``; redshift-dependent double power law): + ``f_b/(Omega_b/Omega_m) = 0.5 * epsilon * ((M_500c/M_pivot)^alpha + (M_500c/M_pivot)^beta) * (E(z)/E(0.3))^gamma`` + where ``epsilon=SPk_epsilon``, ``alpha=SPk_alpha``, ``beta=SPk_beta``, + ``gamma=SPk_gamma``, ``M_pivot=SPk_m_pivot``. + + Parameter definitions: + + :param base_model: Base non-linear model instance to wrap. + If None, keeps current base model (default Halofit). + :param SPk_feedback: If True, apply SP(k) suppression on top of the base model. + :param SPk_SO: Spherical overdensity calibration. Allowed values: 200 or 500. + :param SPk_relation_kind: Relation type. + Allowed values: 1 (power_law), 2 (cosmo_power_law), 3 (double_power_law). + :param SPk_fb_a: Power-law normalization. + :param SPk_fb_pow: Power-law exponent. + :param SPk_fb_pivot: Power-law pivot mass in solar masses. + :param SPk_alpha: Alpha parameter. + :param SPk_beta: Beta parameter. + :param SPk_gamma: Gamma parameter. + :param SPk_epsilon: Epsilon parameter. + :param SPk_m_pivot: Pivot mass in solar masses. + :return: Self, for fluent configuration. + :raises CAMBValueError: If relation or pivot constraints are invalid, + or if configuration is incompatible with the selected Halofit + baryon-feedback mode. + """ + if base_model is not None: + self.BaseModel = base_model + elif self.BaseModel is None: + self.BaseModel = Halofit() + + self.SPk_feedback = SPk_feedback + self.SPk_SO = SPk_SO + self.SPk_relation_kind = SPk_relation_kind + self.SPk_fb_a = SPk_fb_a + self.SPk_fb_pow = SPk_fb_pow + self.SPk_fb_pivot = SPk_fb_pivot + self.SPk_alpha = SPk_alpha + self.SPk_beta = SPk_beta + self.SPk_gamma = SPk_gamma + self.SPk_epsilon = SPk_epsilon + self.SPk_m_pivot = SPk_m_pivot + self._validate() + return self + + @fortran_class class SecondOrderPK(NonLinearModel): """ diff --git a/camb/tests/camb_test.py b/camb/tests/camb_test.py index 2c58fb12..4439d315 100644 --- a/camb/tests/camb_test.py +++ b/camb/tests/camb_test.py @@ -248,7 +248,7 @@ def testBackground(self): # Test BBN consistency, base_plikHM_TT_lowTEB best fit model pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0) - self.assertAlmostEqual(pars.YHe, 0.2458, 5) + self.assertAlmostEqual(float(pars.YHe), 0.2458, 5) data.calc_background(pars) self.assertAlmostEqual(data.cosmomc_theta(), 0.0104090741, 7) self.assertAlmostEqual(data.get_derived_params()["kd"], 0.14055, 4) @@ -256,13 +256,13 @@ def testBackground(self): pars.set_cosmology( H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0, bbn_predictor=bbn.BBN_table_interpolator() ) - self.assertAlmostEqual(pars.YHe, 0.2458, 5) + self.assertAlmostEqual(float(pars.YHe), 0.2458, 5) self.assertAlmostEqual(pars.get_Y_p(), bbn.BBN_table_interpolator().Y_p(0.022242, 0), 5) # test massive sterile models as in Planck papers pars.set_cosmology(H0=68.0, ombh2=0.022305, omch2=0.11873, mnu=0.06, nnu=3.073, omk=0, meffsterile=0.013) self.assertAlmostEqual(pars.omnuh2, 0.00078, 5) - self.assertAlmostEqual(pars.YHe, 0.246218, 5) + self.assertAlmostEqual(float(pars.YHe), 0.246218, 5) self.assertAlmostEqual(pars.N_eff, 3.073, 4) data.calc_background(pars) @@ -959,3 +959,28 @@ def test_quintessence(self): camb.get_background(pars) results = camb.get_results(pars) self.assertAlmostEqual(results.get_derived_params()["thetastar"], 1.044341764253, delta=1e-5) + + def testSPkNonLinearClassSelection(self): + pars = camb.CAMBparams() + pars.set_classes(non_linear_model="SPkNonLinear") + self.assertEqual(pars.NonLinearModel.__class__.__name__, "SPkNonLinear") + + pars.set_cosmology(H0=67.5, ombh2=0.02237, omch2=0.12, mnu=0.06) + pars.InitPower.set_params(As=2.1e-9, ns=0.965) + pars.set_matter_power(redshifts=[0.5], kmax=3.0) + pars.NonLinear = model.NonLinear_both + pars.NonLinearModel.BaseModel.set_params(halofit_version="mead2020") + pars.NonLinearModel.set_params( + SPk_feedback=True, + SPk_SO=200, + SPk_relation_kind=1, + SPk_fb_a=0.4, + SPk_fb_pow=0.2, + SPk_fb_pivot=1e14, + ) + + data = camb.get_results(pars) + k, z, pk = data.get_matter_power_spectrum(minkh=1e-2, maxkh=1.0, npoints=8) + self.assertEqual(len(z), 1) + self.assertTrue(np.all(np.isfinite(k))) + self.assertTrue(np.all(np.isfinite(pk))) diff --git a/camb/tests/spk_test.py b/camb/tests/spk_test.py new file mode 100644 index 00000000..802bf14d --- /dev/null +++ b/camb/tests/spk_test.py @@ -0,0 +1,259 @@ +import os +import sys +import tempfile +import unittest +import warnings + +import numpy as np + +try: + import camb +except ImportError: + sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))) + import camb + +try: + import pyspk +except ImportError: + pyspk = None + + +class _CambEFunc: + def __init__(self, results): + self._results = results + self._h0 = results.Params.H0 + + def efunc(self, z): + z_arr = np.asarray(z, dtype=float) + flat = z_arr.reshape(-1) + vals = np.array([self._results.hubble_parameter(float(zz)) / self._h0 for zz in flat], dtype=float) + vals = vals.reshape(z_arr.shape) + if np.isscalar(z): + return float(vals) + return vals + + +class SPkTest(unittest.TestCase): + def _capture_c_stdout(self, call): + saved_fd = os.dup(1) + try: + with tempfile.TemporaryFile(mode="w+b") as tmp: + os.dup2(tmp.fileno(), 1) + call() + tmp.flush() + tmp.seek(0) + out = tmp.read().decode("utf-8", errors="replace") + finally: + os.dup2(saved_fd, 1) + os.close(saved_fd) + return out + + def _get_pk(self, model_obj, z=0.5): + pars = camb.CAMBparams() + pars.set_cosmology(H0=67.5, ombh2=0.02237, omch2=0.12, mnu=0.06) + pars.InitPower.set_params(As=2.1e-9, ns=0.965) + # Use dense transfer sampling to reduce interpolation noise in reference comparisons. + pars.set_matter_power(redshifts=[z], kmax=6.0, k_per_logint=100) + pars.NonLinear = camb.model.NonLinear_both + pars.NonLinearModel = model_obj + results = camb.get_results(pars) + k, _z, pk = results.get_matter_power_spectrum(minkh=1e-2, maxkh=5.0, npoints=28) + return k, pk[0], results + + def _get_pk_range(self, model_obj, z=0.125, kmax=12.0, npoints=400): + pars = camb.CAMBparams() + pars.set_cosmology(H0=67.5, ombh2=0.02237, omch2=0.12, mnu=0.06) + pars.InitPower.set_params(As=2.1e-9, ns=0.965) + pars.set_matter_power(redshifts=[z], kmax=kmax, k_per_logint=100) + pars.NonLinear = camb.model.NonLinear_both + pars.NonLinearModel = model_obj + results = camb.get_results(pars) + k, _z, pk = results.get_matter_power_spectrum(minkh=1e-4, maxkh=kmax, npoints=npoints) + return k, pk[0], results + + def _assert_relation_match(self, relation_kind, z=0.5, so=200, rtol=1e-5, atol=1e-8, **kwargs): + base = camb.Halofit() + base.set_params(halofit_version="mead2020") + k, pk_base, results = self._get_pk(base, z=z) + + spk = camb.SPkNonLinear() + spk.BaseModel.set_params(halofit_version="mead2020") + spk.set_params(SPk_feedback=True, SPk_SO=so, SPk_relation_kind=relation_kind, **kwargs) + _, pk_spk, _ = self._get_pk(spk, z=z) + + cosmo = _CambEFunc(results) + pyspk_kwargs = { + "SO": so, + "z": z, + "k_array": k, + "errors": False, + } + if relation_kind == 1: + pyspk_kwargs.update( + { + "fb_a": kwargs["SPk_fb_a"], + "fb_pow": kwargs["SPk_fb_pow"], + "fb_pivot": kwargs["SPk_fb_pivot"], + } + ) + elif relation_kind == 2: + pyspk_kwargs.update( + { + "alpha": kwargs["SPk_alpha"], + "beta": kwargs["SPk_beta"], + "gamma": kwargs["SPk_gamma"], + "cosmo": cosmo, + } + ) + elif relation_kind == 3: + pyspk_kwargs.update( + { + "epsilon": kwargs["SPk_epsilon"], + "alpha": kwargs["SPk_alpha"], + "beta": kwargs["SPk_beta"], + "gamma": kwargs["SPk_gamma"], + "m_pivot": kwargs["SPk_m_pivot"], + "cosmo": cosmo, + } + ) + else: + raise ValueError("Unknown relation kind") + + k_ref, sup_ref = pyspk.sup_model(**pyspk_kwargs) + measured_sup = pk_spk / pk_base + + self.assertTrue(np.allclose(k_ref, k, rtol=0, atol=0)) + self.assertTrue(np.allclose(measured_sup, sup_ref, rtol=rtol, atol=atol)) + + def test_spk_invalid_params(self): + model = camb.SPkNonLinear() + with self.assertRaises(camb.CAMBValueError): + model.set_params(SPk_SO=300) + with self.assertRaises(camb.CAMBValueError): + model.set_params(SPk_relation_kind=99) + with self.assertRaises(camb.CAMBValueError): + model.set_params(SPk_relation_kind=1, SPk_fb_pivot=0.0) + + def test_spk_disabled_matches_base(self): + base = camb.Halofit() + base.set_params(halofit_version="mead2020") + k_base, pk_base, _ = self._get_pk(base) + + spk = camb.SPkNonLinear() + spk.BaseModel.set_params(halofit_version="mead2020") + spk.set_params(SPk_feedback=False) + k_spk, pk_spk, _ = self._get_pk(spk) + + self.assertTrue(np.allclose(k_base, k_spk, rtol=0, atol=0)) + self.assertTrue(np.allclose(pk_base, pk_spk, rtol=2e-12, atol=1e-14)) + + @unittest.skipIf(pyspk is None, "pyspk not installed") + def test_spk_power_law_matches_reference(self): + self._assert_relation_match( + relation_kind=1, + z=0.5, + so=200, + rtol=1e-6, + atol=1e-9, + SPk_fb_a=0.4, + SPk_fb_pow=0.2, + SPk_fb_pivot=1e14, + ) + + @unittest.skipIf(pyspk is None, "pyspk not installed") + def test_spk_cosmo_power_law_matches_reference(self): + self._assert_relation_match( + relation_kind=2, + z=1.0, + so=500, + rtol=1e-6, + atol=1e-9, + SPk_alpha=3.4, + SPk_beta=1.0, + SPk_gamma=0.15, + ) + + @unittest.skipIf(pyspk is None, "pyspk not installed") + def test_spk_double_power_law_matches_reference(self): + self._assert_relation_match( + relation_kind=3, + z=1.5, + so=200, + rtol=1e-6, + atol=1e-9, + SPk_epsilon=0.55, + SPk_alpha=0.2, + SPk_beta=0.9, + SPk_gamma=0.1, + SPk_m_pivot=1e14, + ) + + @unittest.skipIf(pyspk is None, "pyspk not installed") + def test_spk_high_k_boundary_continuity(self): + base = camb.Halofit() + base.set_params(halofit_version="mead2020") + k, pk_base, _ = self._get_pk_range(base, z=0.125, kmax=12.0, npoints=400) + + spk = camb.SPkNonLinear() + spk.BaseModel.set_params(halofit_version="mead2020") + spk.set_params( + SPk_feedback=True, + SPk_SO=200, + SPk_relation_kind=1, + SPk_fb_a=0.4, + SPk_fb_pow=0.3, + SPk_fb_pivot=1e14, + ) + _, pk_spk, _ = self._get_pk_range(spk, z=0.125, kmax=12.0, npoints=400) + + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", + message=r"Scales with k_max > k_ny = 8\.0 \[h/Mpc\] may not be accurately reproduced by the model\.", + category=UserWarning, + ) + _, sup_ref = pyspk.sup_model( + SO=200, + z=0.125, + fb_a=0.4, + fb_pow=0.3, + fb_pivot=1e14, + k_array=k, + errors=False, + ) + measured_sup = pk_spk / pk_base + rel = np.abs(measured_sup / sup_ref - 1.0) + + self.assertLess(float(np.max(rel[k <= 12.0])), 1e-4) + + def test_spk_out_of_range_warnings(self): + pars = camb.CAMBparams() + pars.set_cosmology(H0=67.5, ombh2=0.02237, omch2=0.12, mnu=0.06) + pars.InitPower.set_params(As=2.1e-9, ns=0.965) + pars.set_matter_power(redshifts=[4.0, 1.0], kmax=20.0, k_per_logint=100) + pars.NonLinear = camb.model.NonLinear_both + + spk = camb.SPkNonLinear() + spk.BaseModel.set_params(halofit_version="mead2020") + spk.set_params( + SPk_feedback=True, + SPk_SO=200, + SPk_relation_kind=1, + SPk_fb_a=0.4, + SPk_fb_pow=0.3, + SPk_fb_pivot=1e14, + ) + pars.NonLinearModel = spk + + camb.set_feedback_level(1) + try: + output = self._capture_c_stdout(lambda: camb.get_results(pars)) + finally: + camb.set_feedback_level(0) + + self.assertIn("WARNING: SP(k) skipped outside calibrated redshift range.", output) + self.assertIn("WARNING: SP(k) input k exceeds calibrated range; clamping to k_max=", output) + + +if __name__ == "__main__": + unittest.main() diff --git a/docs/SPk_demo.ipynb b/docs/SPk_demo.ipynb new file mode 100644 index 00000000..db4299e5 --- /dev/null +++ b/docs/SPk_demo.ipynb @@ -0,0 +1,331 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2c84399d", + "metadata": {}, + "source": [ + "# SP(k) Baryon Suppression Demo\n", + "\n", + "This notebook compares non-linear matter power with and without SP(k), then validates the SP(k) suppression curve against `pyspk`.\n", + "\n", + "## What this notebook does\n", + "1. Build a baseline non-linear model (`mead2020`) and an SP(k)-enabled model with the same cosmology.\n", + "2. Plot the full spectra and the suppression ratio.\n", + "3. Compare CAMB SP(k) vs `pyspk` suppression and show relative error.\n", + "\n", + "## Notes\n", + "- SP(k) should not be combined with HMCode baryon-feedback models (e.g. `halofit_version='mead2020_feedback'`)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b82be437", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using CAMB 1.6.7 installed at /Users/jaimesalcido/CAMB/camb\n", + "Using pyspk 2.0.0\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "import os\n", + "import warnings\n", + "\n", + "import numpy as np\n", + "import pyspk\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import camb\n", + "from camb import model\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "print(f\"Using CAMB {camb.__version__} installed at {os.path.dirname(camb.__file__)}\")\n", + "print(f\"Using pyspk {pyspk.__version__}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e37d95d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "redshifts: [0. 0.125 1. ]\n", + "k_per_logint: 50\n" + ] + } + ], + "source": [ + "# Cosmology + k/z sampling\n", + "minkh, maxkh, npoints = 1e-4, 12.0, 400\n", + "z_samples = [0.0, 0.125, 1.0]\n", + "\n", + "k_per_logint = 50\n", + "\n", + "# Baseline non-linear model (HMCode, no SPk)\n", + "pars_base = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.965)\n", + "pars_base.set_matter_power(redshifts=z_samples, kmax=maxkh, k_per_logint=k_per_logint, silent=True)\n", + "pars_base.NonLinear = model.NonLinear_both\n", + "pars_base.NonLinearModel = camb.Halofit()\n", + "pars_base.NonLinearModel.set_params(halofit_version=\"mead2020\")\n", + "\n", + "results_base = camb.get_results(pars_base)\n", + "kh0, z0, pk0 = results_base.get_matter_power_spectrum(minkh=minkh, maxkh=maxkh, npoints=npoints)\n", + "\n", + "# SP(k) on top of the same base model\n", + "pars_spk = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.965)\n", + "pars_spk.set_matter_power(redshifts=z_samples, kmax=maxkh, k_per_logint=k_per_logint, silent=True)\n", + "pars_spk.NonLinear = model.NonLinear_both\n", + "\n", + "spk_model = camb.SPkNonLinear()\n", + "spk_model.BaseModel.set_params(halofit_version=\"mead2020\")\n", + "spk_model.set_params(\n", + " SPk_feedback=True,\n", + " SPk_SO=200,\n", + " SPk_relation_kind=1,\n", + " SPk_fb_a=0.4,\n", + " SPk_fb_pow=0.3,\n", + " SPk_fb_pivot=1e14,\n", + ")\n", + "pars_spk.NonLinearModel = spk_model\n", + "\n", + "results_spk = camb.get_results(pars_spk)\n", + "kh1, z1, pk1 = results_spk.get_matter_power_spectrum(minkh=minkh, maxkh=maxkh, npoints=npoints)\n", + "\n", + "assert np.allclose(kh0, kh1)\n", + "assert np.allclose(z0, z1)\n", + "z = np.array(z0)\n", + "print(\"redshifts:\", z)\n", + "print(\"k_per_logint:\", k_per_logint)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "942282a9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 385, + "width": 1189 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot non-linear vs non-linear+SP(k)\n", + "from matplotlib.lines import Line2D\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n", + "linestyles = [\"-\", \"--\", \":\", \"-.\"]\n", + "\n", + "for i, redshift in enumerate(z):\n", + " ls = linestyles[i % len(linestyles)]\n", + " ax[0].loglog(kh0, pk0[i, :], color=\"C3\", ls=ls)\n", + " ax[0].loglog(kh1, pk1[i, :], color=\"C0\", ls=ls)\n", + "ax[0].set_xlabel(\"k/h Mpc\")\n", + "ax[0].set_ylabel(\"P(k) [(Mpc/h)^3]\")\n", + "ax[0].set_title(\"Non-linear matter power\")\n", + "\n", + "model_handles = [\n", + " Line2D([], [], color=\"C3\", lw=2, label=\"non-linear\"),\n", + " Line2D([], [], color=\"C0\", lw=2, label=\"non-linear + SP(k)\"),\n", + "]\n", + "redshift_handles = [\n", + " Line2D([], [], color=\"k\", lw=2, ls=linestyles[i % len(linestyles)], label=f\"z={float(redshift):g}\")\n", + " for i, redshift in enumerate(z)\n", + "]\n", + "leg_model = ax[0].legend(handles=model_handles, loc=\"lower left\")\n", + "ax[0].add_artist(leg_model)\n", + "ax[0].legend(handles=redshift_handles, title=\"Redshift\", loc=\"upper right\")\n", + "\n", + "for i, redshift in enumerate(z):\n", + " ls = linestyles[i % len(linestyles)]\n", + " ax[1].semilogx(kh0, pk1[i, :] / pk0[i, :], ls=ls, label=f\"z={float(redshift):g}\")\n", + "ax[1].axhline(1.0, color=\"k\", lw=1)\n", + "ax[1].set_xlabel(\"k/h Mpc\")\n", + "ax[1].set_ylabel(\"P_nl(SPk) / P_nl\")\n", + "ax[1].set_title(\"Suppression ratio\")\n", + "ax[1].legend(loc=\"lower left\")\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "b3b2d97c", + "metadata": {}, + "source": [ + "## Interpreting the validation plot\n", + "\n", + "- Top panel: suppression factor from CAMB SP(k) and `pyspk` (should overlap closely).\n", + "- Bottom panel: relative error, defined as `CAMB / pyspk - 1`, shown on a ±1% axis.\n", + "- Vertical dashed line at `k=8 h/Mpc`: approximate `pyspk` Nyquist reference." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "69a98f59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max relative error between CAMB SP(k) and pyspk:\n", + "z=0: k<=8 -> 4.41e-06, k<=12 -> 1.05e-04\n", + "z=0.125: k<=8 -> 3.66e-06, k<=12 -> 8.42e-05\n", + "z=1: k<=8 -> 9.76e-07, k<=12 -> 1.52e-06\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 701, + "width": 875 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "# Verify suppression factor against pyspk and show implementation error\n", + "pyspk_sup_list = []\n", + "for redshift in z:\n", + " k_pyspk, sup_pyspk = pyspk.sup_model(\n", + " SO=200,\n", + " z=float(redshift),\n", + " fb_a=0.4,\n", + " fb_pow=0.3,\n", + " fb_pivot=1e14,\n", + " k_array=kh0,\n", + " errors=False,\n", + " verbose=False,\n", + " )\n", + " assert np.allclose(k_pyspk, kh0)\n", + " pyspk_sup_list.append(sup_pyspk)\n", + "\n", + "k_compare_max = 12.0\n", + "mask_plot = kh0 <= k_compare_max\n", + "\n", + "fig2, (ax2, ax3) = plt.subplots(\n", + " 2,\n", + " 1,\n", + " figsize=(10, 8),\n", + " sharex=True,\n", + " gridspec_kw={\"height_ratios\": [3, 1], \"hspace\": 0.12},\n", + ")\n", + "colors = [\"C0\", \"C1\", \"C2\"]\n", + "camb_handles = []\n", + "pyspk_handle = None\n", + "\n", + "for i, redshift in enumerate(z):\n", + " color = colors[i % len(colors)]\n", + " camb_sup = pk1[i, :] / pk0[i, :]\n", + " py_sup = pyspk_sup_list[i]\n", + " valid = mask_plot & np.isfinite(camb_sup) & np.isfinite(py_sup) & (np.abs(py_sup) > 1e-30)\n", + "\n", + " (line_camb,) = ax2.semilogx(\n", + " kh0[valid], camb_sup[valid], color=color, ls=\"-\", lw=2, label=f\"CAMB SP(k), z={float(redshift):g}\"\n", + " )\n", + " camb_handles.append(line_camb)\n", + "\n", + " if pyspk_handle is None:\n", + " (pyspk_handle,) = ax2.semilogx(kh0[valid], py_sup[valid], color=\"k\", ls=\":\", lw=1.5, alpha=0.8, label=\"pyspk\")\n", + " else:\n", + " ax2.semilogx(kh0[valid], py_sup[valid], color=\"k\", ls=\":\", lw=1.5, alpha=0.8, label=None)\n", + "\n", + " ratio_err = camb_sup[valid] / py_sup[valid] - 1.0\n", + " ax3.semilogx(kh0[valid], ratio_err, color=color, ls=\"-\", lw=1.8, label=f\"z={float(redshift):g}\")\n", + "\n", + "ax2.axhline(1.0, color=\"k\", lw=1, alpha=0.4)\n", + "ax2.set_ylabel(\"Suppression factor\")\n", + "ax2.set_title(\"SP(k) suppression: CAMB vs pyspk\")\n", + "if pyspk_handle is not None:\n", + " ax2.legend(handles=[*camb_handles, pyspk_handle], loc=\"lower left\", fontsize=9)\n", + "else:\n", + " ax2.legend(loc=\"lower left\", fontsize=9)\n", + "\n", + "ax3.axhline(0.0, color=\"k\", lw=1, alpha=0.5)\n", + "ax3.set_xlabel(\"k/h Mpc\")\n", + "ax3.set_ylabel(\"CAMB/pyspk - 1\")\n", + "ax3.set_ylim(-0.01, 0.01)\n", + "ax3.set_title(\"Relative error (±1%)\")\n", + "\n", + "# Reference marker: pyspk Nyquist limit\n", + "ax2.axvline(8.0, color=\"gray\", lw=1, ls=\"--\", alpha=0.6)\n", + "ax3.axvline(8.0, color=\"gray\", lw=1, ls=\"--\", alpha=0.6)\n", + "ax2.text(\n", + " 8.0 * 0.5,\n", + " 0.98,\n", + " \"SP(k) k_Ny~8\",\n", + " color=\"gray\",\n", + " fontsize=9,\n", + " bbox=dict(facecolor=\"white\", edgecolor=\"gray\", alpha=0.8, boxstyle=\"round,pad=0.2\"),\n", + ")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "print(\"Max relative error between CAMB SP(k) and pyspk:\")\n", + "for i, redshift in enumerate(z):\n", + " camb_sup = pk1[i, :] / pk0[i, :]\n", + " py_sup = pyspk_sup_list[i]\n", + " valid8 = (kh0 <= 8.0) & np.isfinite(camb_sup) & np.isfinite(py_sup) & (np.abs(py_sup) > 1e-30)\n", + " valid12 = (kh0 <= 12.0) & np.isfinite(camb_sup) & np.isfinite(py_sup) & (np.abs(py_sup) > 1e-30)\n", + " rel8 = np.max(np.abs(camb_sup[valid8] / py_sup[valid8] - 1.0))\n", + " rel12 = np.max(np.abs(camb_sup[valid12] / py_sup[valid12] - 1.0))\n", + " print(f\"z={float(redshift):g}: k<=8 -> {rel8:.2e}, k<=12 -> {rel12:.2e}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/nonlinear.rst b/docs/source/nonlinear.rst index fe3fcd3a..4a823afb 100644 --- a/docs/source/nonlinear.rst +++ b/docs/source/nonlinear.rst @@ -1,6 +1,24 @@ Non-linear models ================================== +SP(k) model notes +----------------- + +The ``SPkNonLinear`` model wraps a base non-linear prescription (Halofit by +default) and applies SP(k) suppression multiplicatively to CAMB's non-linear +ratio. + +The implementation follows the calibrated SP(k) range. In practice: + +- outside calibrated redshift range, SP(k) is not applied for that slice +- above calibrated ``k``, suppression is evaluated at calibrated ``k_max`` + +When ``FeedbackLevel > 0``, CAMB prints one-time warnings for these out-of-range +cases. + +SP(k) should not be combined with HMCode baryon-feedback modes (for example +``halofit_version='mead2020_feedback'``). + .. autoclass:: camb.nonlinear.NonLinearModel :members: @@ -8,6 +26,10 @@ Non-linear models :show-inheritance: :members: +.. autoclass:: camb.nonlinear.SPkNonLinear + :show-inheritance: + :members: + .. autoclass:: camb.nonlinear.ExternalNonLinearRatio :show-inheritance: :members: diff --git a/fortran/Makefile_main b/fortran/Makefile_main index 745c6477..aacfdf0b 100644 --- a/fortran/Makefile_main +++ b/fortran/Makefile_main @@ -5,7 +5,7 @@ POWERSPECTRUM_FILES ?= InitialPower REIONIZATION_FILES ?= reionization RECOMBINATION_FILES ?= recfast -NONLINEAR_FILES ?= halofit SecondOrderPK ExternalNonLinearRatio +NONLINEAR_FILES ?= halofit spk_model SPkNonLinear SecondOrderPK ExternalNonLinearRatio DARKENERGY_FILES ?= DarkEnergyFluid DarkEnergyPPF PowellMinimize DarkEnergyQuintessence BISPECTRUM ?= SeparableBispectrum diff --git a/fortran/SPkNonLinear.f90 b/fortran/SPkNonLinear.f90 new file mode 100644 index 00000000..939cb77f --- /dev/null +++ b/fortran/SPkNonLinear.f90 @@ -0,0 +1,187 @@ +module SPkNonLinear +! Wrapper non-linear model: apply SP(k) suppression on top of a base non-linear model. +use results +use NonLinear, only: THalofit, halofit_mead, halofit_mead2015, halofit_mead2016, halofit_mead2020_feedback +use SPkModel +use config +implicit none +private + +type, extends(TNonLinearModel) :: TSPkNonLinear + class(TNonLinearModel), allocatable :: BaseModel + logical :: SPk_feedback = .false. + integer :: SPk_SO = 200 + integer :: SPk_relation_kind = SPk_rel_power_law + real(dl) :: SPk_fb_a = 1.0_dl + real(dl) :: SPk_fb_pow = 0.0_dl + real(dl) :: SPk_fb_pivot = 1.0_dl + real(dl) :: SPk_alpha = 0.0_dl + real(dl) :: SPk_beta = 0.0_dl + real(dl) :: SPk_gamma = 0.0_dl + real(dl) :: SPk_epsilon = 0.0_dl + real(dl) :: SPk_m_pivot = 1.0_dl +contains + procedure :: Init => TSPkNonLinear_Init + procedure :: ReadParams => TSPkNonLinear_ReadParams + procedure :: GetNonLinRatios => TSPkNonLinear_GetNonLinRatios + procedure, nopass :: PythonClass => TSPkNonLinear_PythonClass + procedure, nopass :: SelfPointer => TSPkNonLinear_SelfPointer + procedure, private :: ValidateConfig => TSPkNonLinear_ValidateConfig +end type TSPkNonLinear + +public TSPkNonLinear + +contains + +function TSPkNonLinear_PythonClass() +character(LEN=:), allocatable :: TSPkNonLinear_PythonClass + +TSPkNonLinear_PythonClass = 'SPkNonLinear' + +end function TSPkNonLinear_PythonClass + +subroutine TSPkNonLinear_SelfPointer(cptr, P) +use iso_c_binding +Type(c_ptr) :: cptr +Type(TSPkNonLinear), pointer :: PType +class(TPythonInterfacedClass), pointer :: P + +call c_f_pointer(cptr, PType) +P => PType + +end subroutine TSPkNonLinear_SelfPointer + +subroutine TSPkNonLinear_Init(this, State) +class(TSPkNonLinear) :: this +class(TCAMBdata), target :: State + +if (.not. allocated(this%BaseModel)) allocate(THalofit::this%BaseModel) +this%Min_kh_nonlinear = this%BaseModel%Min_kh_nonlinear +call this%BaseModel%Init(State) + +end subroutine TSPkNonLinear_Init + +subroutine TSPkNonLinear_ReadParams(this, Ini) +use IniObjects +class(TSPkNonLinear) :: this +class(TIniFile), intent(in) :: Ini + +if (.not. allocated(this%BaseModel)) allocate(THalofit::this%BaseModel) +call this%BaseModel%ReadParams(Ini) + +this%SPk_feedback = Ini%Read_Logical('SPk_feedback', .false.) +this%SPk_SO = Ini%Read_Int('SPk_SO', 200) +this%SPk_relation_kind = Ini%Read_Int('SPk_relation_kind', SPk_rel_power_law) +this%SPk_fb_a = Ini%Read_Double('SPk_fb_a', 1.0_dl) +this%SPk_fb_pow = Ini%Read_Double('SPk_fb_pow', 0.0_dl) +this%SPk_fb_pivot = Ini%Read_Double('SPk_fb_pivot', 1.0_dl) +this%SPk_alpha = Ini%Read_Double('SPk_alpha', 0.0_dl) +this%SPk_beta = Ini%Read_Double('SPk_beta', 0.0_dl) +this%SPk_gamma = Ini%Read_Double('SPk_gamma', 0.0_dl) +this%SPk_epsilon = Ini%Read_Double('SPk_epsilon', 0.0_dl) +this%SPk_m_pivot = Ini%Read_Double('SPk_m_pivot', 1.0_dl) + +end subroutine TSPkNonLinear_ReadParams + +subroutine TSPkNonLinear_ValidateConfig(this) +class(TSPkNonLinear), intent(in) :: this + +if (this%SPk_SO /= 200 .and. this%SPk_SO /= 500) then + call MpiStop('SP(k): SPk_SO must be 200 or 500') +end if +if (this%SPk_relation_kind < SPk_rel_power_law .or. this%SPk_relation_kind > SPk_rel_double_power_law) then + call MpiStop('SP(k): SPk_relation_kind must be 1 (power_law), 2 (cosmo_power_law), or 3 (double_power_law)') +end if + +if (this%SPk_relation_kind == SPk_rel_power_law) then + if (this%SPk_fb_pivot <= 0.0_dl) call MpiStop('SP(k): SPk_fb_pivot must be > 0 for power_law relation') +end if +if (this%SPk_relation_kind == SPk_rel_double_power_law) then + if (this%SPk_m_pivot <= 0.0_dl) call MpiStop('SP(k): SPk_m_pivot must be > 0 for double_power_law relation') +end if + +select type (base => this%BaseModel) +type is (THalofit) + if (this%SPk_feedback .and. base%halofit_version == halofit_mead2020_feedback) then + call MpiStop('SP(k) is not compatible with halofit_version=mead2020_feedback') + end if + if (this%SPk_feedback .and. & + (base%halofit_version == halofit_mead .or. base%halofit_version == halofit_mead2015 .or. base%halofit_version == halofit_mead2016) .and. & + (abs(base%HMcode_A_baryon - 3.13_dl) > 1e-12_dl .or. abs(base%HMcode_eta_baryon - 0.603_dl) > 1e-12_dl)) then + call MpiStop('SP(k) cannot be combined with HMCode_A_baryon/HMCode_eta_baryon baryonic corrections in HMCode 2015/2016') + end if +class default + continue +end select + +end subroutine TSPkNonLinear_ValidateConfig + +subroutine TSPkNonLinear_GetNonLinRatios(this, State, CAMB_Pk) +class(TSPkNonLinear) :: this +class(TCAMBdata) :: State +type(MatterPowerData), target :: CAMB_Pk +integer :: itf, i +real(dl) :: rk, spk_sup, spk_href, spk_eratio +logical, save :: warned_spk_z_outside = .false. +logical, save :: warned_spk_k_clamped = .false. + +if (.not. allocated(this%BaseModel)) allocate(THalofit::this%BaseModel) + +call this%ValidateConfig() +call this%BaseModel%GetNonLinRatios(State, CAMB_Pk) + +if (.not. this%SPk_feedback) return + +select type (State) +class is (CAMBdata) + if (this%SPk_relation_kind == SPk_rel_cosmo_power_law .or. this%SPk_relation_kind == SPk_rel_double_power_law) then + spk_href = State%Hofz(0.3_dl) + else + spk_href = 1.0_dl + end if +class default + call MpiStop('SP(k): unsupported state type for Hofz evaluation') +end select + +do itf = 1, CAMB_Pk%num_z + if (CAMB_Pk%redshifts(itf) < SPk_calibrated_z_min .or. CAMB_Pk%redshifts(itf) > SPk_calibrated_z_max) then + if (FeedbackLevel > 0 .and. .not. warned_spk_z_outside) then + write(*,'(A,F8.3,A,F6.2,A,F6.2,A)') 'WARNING: SP(k) skipped outside calibrated redshift range. z=', & + CAMB_Pk%redshifts(itf), ', calibrated range=[', SPk_calibrated_z_min, ',', SPk_calibrated_z_max, '].' + warned_spk_z_outside = .true. + end if + cycle + end if + select type (State) + class is (CAMBdata) + if (this%SPk_relation_kind == SPk_rel_cosmo_power_law .or. this%SPk_relation_kind == SPk_rel_double_power_law) then + spk_eratio = State%Hofz(CAMB_Pk%redshifts(itf)) / spk_href + else + spk_eratio = 1.0_dl + end if + class default + call MpiStop('SP(k): unsupported state type for Hofz evaluation') + end select + do i = 1, CAMB_Pk%num_k + rk = exp(CAMB_Pk%log_kh(i)) + if (rk > this%Min_kh_nonlinear) then + if (rk < SPk_calibrated_k_min) cycle + if (rk > SPk_calibrated_k_max) then + if (FeedbackLevel > 0 .and. .not. warned_spk_k_clamped) then + write(*,'(A,F8.3,A,F6.2,A)') 'WARNING: SP(k) input k exceeds calibrated range; clamping to k_max=', & + rk, ' -> ', SPk_calibrated_k_max, ' h/Mpc.' + warned_spk_k_clamped = .true. + end if + end if + spk_sup = SPk_Suppression(this%SPk_SO, min(rk, SPk_calibrated_k_max), CAMB_Pk%redshifts(itf), & + this%SPk_relation_kind, this%SPk_fb_a, this%SPk_fb_pow, this%SPk_fb_pivot, & + this%SPk_alpha, this%SPk_beta, this%SPk_gamma, & + this%SPk_epsilon, this%SPk_m_pivot, spk_eratio) + CAMB_Pk%nonlin_ratio(i, itf) = CAMB_Pk%nonlin_ratio(i, itf) * sqrt(spk_sup) + end if + end do +end do + +end subroutine TSPkNonLinear_GetNonLinRatios + +end module SPkNonLinear diff --git a/fortran/spk_model.f90 b/fortran/spk_model.f90 new file mode 100644 index 00000000..193472db --- /dev/null +++ b/fortran/spk_model.f90 @@ -0,0 +1,102 @@ +module SPkModel +use precision +implicit none +private + +real(dl), parameter, public :: SPk_calibrated_z_min = 0.0_dl +real(dl), parameter, public :: SPk_calibrated_z_max = 3.0_dl +real(dl), parameter, public :: SPk_calibrated_k_min = 1e-12_dl +real(dl), parameter, public :: SPk_calibrated_k_max = 12.0_dl +real(dl), parameter, public :: SPk_min_suppression = 1e-6_dl + +integer, parameter, public :: SPk_rel_power_law = 1 +integer, parameter, public :: SPk_rel_cosmo_power_law = 2 +integer, parameter, public :: SPk_rel_double_power_law = 3 + +public :: SPk_Suppression + +contains + +pure function SPk_Poly2(x, c0, c1, c2) result(y) +real(dl), intent(in) :: x, c0, c1, c2 +real(dl) :: y + +y = c2 * x * x + c1 * x + c0 + +end function SPk_Poly2 + +pure subroutine SPk_GetParams(SO, z, spk_a_out, spk_b_out, spk_g_out, lambda_a, lambda_b, mu_a, mu_b, mu_c, nu_a, nu_b, nu_c) +integer, intent(in) :: SO +real(dl), intent(in) :: z +real(dl), intent(out) :: spk_a_out, spk_b_out, spk_g_out, lambda_a, lambda_b, mu_a, mu_b, mu_c, nu_a, nu_b, nu_c +real(dl) :: x + +x = 1.0_dl + z + +if (SO == 500) then + spk_a_out = SPk_Poly2(x, 14.783423122120318_dl, -0.999062404857228_dl, 0.12062854541689262_dl) + spk_b_out = SPk_Poly2(x, 14.620528368613265_dl, -0.9136466201011957_dl, 0.10835389086945699_dl) + spk_g_out = SPk_Poly2(x, 0.9671320682693298_dl, -0.03185388045484575_dl, 0.02650236152450093_dl) + lambda_a = SPk_Poly2(x, 0.019349810078190303_dl, -0.007410668383424459_dl, 0.0008334762393555539_dl) + lambda_b = SPk_Poly2(x, 2.9566773924238143_dl, 0.6205340408676114_dl, -0.001928273640110775_dl) + mu_a = SPk_Poly2(x, 0.715853343781141_dl, -0.19276613600825665_dl, 0.04948240117059147_dl) + mu_b = SPk_Poly2(x, 3.385355123440431_dl, 0.9658906605139421_dl, -0.06825861100375574_dl) + mu_c = SPk_Poly2(x, 4.457257708010122_dl, -2.191853871334233_dl, 0.45457701107254733_dl) + nu_a = SPk_Poly2(x, 478.86477329610375_dl, 429.88795783439946_dl, 249.25655627821902_dl) + nu_b = SPk_Poly2(x, -11.227459319819815_dl, -0.5581080204509223_dl, 0.4489962047114509_dl) + nu_c = SPk_Poly2(x, 3.499449440557995_dl, -0.08488559389068073_dl, -0.0923847866118189_dl) +else + spk_a_out = SPk_Poly2(x, 15.24311120000861_dl, -1.2436699435560352_dl, 0.14837558774401766_dl) + spk_b_out = SPk_Poly2(x, 14.969187892657688_dl, -1.0993025612653198_dl, 0.12905587245129102_dl) + spk_g_out = SPk_Poly2(x, 0.8000441576980428_dl, -0.01715621131893159_dl, 0.06131887249968379_dl) + lambda_a = SPk_Poly2(x, 0.02178116280689233_dl, -0.0077564325654746955_dl, 0.0007915576054589781_dl) + lambda_b = SPk_Poly2(x, 3.0878286643613437_dl, 0.4529677646796634_dl, 0.001552571083240605_dl) + mu_a = SPk_Poly2(x, 0.6930259177449359_dl, -0.16913553700233935_dl, 0.04263185199898842_dl) + mu_b = SPk_Poly2(x, 3.161914061444856_dl, 0.8616834297321924_dl, 0.011346427353554053_dl) + mu_c = SPk_Poly2(x, 5.532188503256583_dl, -3.0864672185252537_dl, 0.5083422518560442_dl) + nu_a = SPk_Poly2(x, 413.00988701513904_dl, 311.63957063032285_dl, 37.89105940901369_dl) + nu_b = SPk_Poly2(x, -11.243859405779181_dl, -0.34421412616421965_dl, 0.3343548325485801_dl) + nu_c = SPk_Poly2(x, 3.476463891168505_dl, -0.018333059687988575_dl, -0.08276237963970698_dl) +end if + +end subroutine SPk_GetParams + +pure function SPk_Suppression(SO, kh, z, relation_kind, fb_a, fb_pow, fb_pivot, rel_alpha, rel_beta, rel_gamma, & + rel_epsilon, rel_m_pivot, e_ratio) result(sup) +integer, intent(in) :: SO, relation_kind +real(dl), intent(in) :: kh, z, fb_a, fb_pow, fb_pivot +real(dl), intent(in) :: rel_alpha, rel_beta, rel_gamma, rel_epsilon, rel_m_pivot +real(dl), intent(in) :: e_ratio +real(dl) :: sup +real(dl) :: spk_a, spk_b, spk_g +real(dl) :: lambda_a, lambda_b, mu_a, mu_b, mu_c, nu_a, nu_b, nu_c +real(dl) :: best_mass, m_opt, fb, x, x0, x1, x2 +real(dl) :: e_ratio_eff + +call SPk_GetParams(SO, z, spk_a, spk_b, spk_g, lambda_a, lambda_b, mu_a, mu_b, mu_c, nu_a, nu_b, nu_c) + +best_mass = spk_a - (spk_a - spk_b) * (kh ** spk_g) +m_opt = 10.0_dl ** best_mass +e_ratio_eff = max(e_ratio, SPk_calibrated_k_min) + +select case (relation_kind) +case (SPk_rel_cosmo_power_law) + fb = (exp(rel_alpha) / 100.0_dl) * ((m_opt / 1.0e14_dl) ** (rel_beta - 1.0_dl)) * (e_ratio_eff ** rel_gamma) +case (SPk_rel_double_power_law) + fb = 0.5_dl * rel_epsilon * (((m_opt / rel_m_pivot) ** rel_alpha) + ((m_opt / rel_m_pivot) ** rel_beta)) * & + (e_ratio_eff ** rel_gamma) +case default + fb = fb_a * ((m_opt / fb_pivot) ** fb_pow) +end select + +x = log10(kh) +x0 = 1.0_dl + lambda_a * exp(lambda_b * x) +x1 = mu_a + ((1.0_dl - mu_a) / (1.0_dl + exp(mu_b * x + mu_c))) +x2 = nu_a * exp(-0.5_dl * ((x - nu_b) / nu_c) ** 2) + +sup = x0 - (x0 - x1) * exp(-x2 * fb) +sup = max(sup, SPk_min_suppression) + +end function SPk_Suppression + +end module SPkModel diff --git a/pyproject.toml b/pyproject.toml index f70afc38..9ea34d24 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,9 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "camb" -authors = [ - { name = "Antony Lewis" }, -] +authors = [{ name = "Antony Lewis" }] description = "Code for Anisotropies in the Microwave Background" keywords = ['cosmology', 'CAMB', 'CMB'] readme = "docs/README_pypi.rst" @@ -26,13 +24,17 @@ classifiers = [ "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", ] -dependencies = [ - "numpy>=1.22", "scipy>=1.0", "sympy>=1.0", "packaging>=24.2" -] +dependencies = ["numpy>=1.22", "scipy>=1.0", "sympy>=1.0", "packaging>=24.2"] [project.optional-dependencies] -docs = ["sphinx>=4.0", "sphinx_rtd_theme>=1.0", "sphinxcontrib-jquery", "sphinx_markdown_builder", "jupytext"] -dev = ["ruff>=0.11.0", "pre-commit>=3.0.0"] +docs = [ + "sphinx>=4.0", + "sphinx_rtd_theme>=1.0", + "sphinxcontrib-jquery", + "sphinx_markdown_builder", + "jupytext", +] +dev = ["ruff>=0.11.0", "pre-commit>=3.0.0", "pyspk>=2.0.0"] [project.scripts] camb = "camb._command_line:run_command_line" @@ -70,6 +72,30 @@ docstring-code-format = true [tool.flake8] select = [ - "E713", "E704", "E703", "E714", "E741", "E10", "E11", "E20", "E22", "E23", "E25", "E27", - "E301", "E302", "E304", "E9", "F405", "F406", "F5", "F6", "F7", "F8", "W1", "W2", "W3", "W6" + "E713", + "E704", + "E703", + "E714", + "E741", + "E10", + "E11", + "E20", + "E22", + "E23", + "E25", + "E27", + "E301", + "E302", + "E304", + "E9", + "F405", + "F406", + "F5", + "F6", + "F7", + "F8", + "W1", + "W2", + "W3", + "W6", ]