classy-szfast 0.0.3__py3-none-any.whl

classy_szfast/pks_and_sigmas.py

@@ -0,0 +1,150 @@
+from .utils import *
+from .config import *
+from scipy.interpolate import RectBivariateSpline
+
+
+# this code is adapted from cobaya
+class PowerSpectrumInterpolator(RectBivariateSpline):
+    r"""
+    2D spline interpolation object (scipy.interpolate.RectBivariateSpline)
+    to evaluate matter power spectrum as function of z and k.
+
+    *This class is adapted from CAMB's own P(k) interpolator, by Antony Lewis;
+    it's mostly interface-compatible with the original.*
+
+    :param z: values of z for which the power spectrum was evaluated.
+    :param k: values of k for which the power spectrum was evaluated.
+    :param P_or_logP: Values of the power spectrum (or log-values, if logP=True).
+    :param logP: if True (default: False), log of power spectrum are given and used
+        for the underlying interpolator.
+    :param logsign: if logP is True, P_or_logP is log(logsign*Pk)
+    :param extrap_kmax: if set, use power law extrapolation beyond kmax up to
+        extrap_kmax; useful for tails of integrals.
+    """
+
+    def __init__(self, z, k, P_or_logP, extrap_kmin=1e-5, extrap_kmax=1e2, logP=False,
+                 logsign=1):
+        self.islog = logP
+        #  Check order
+        z, k = (np.atleast_1d(x) for x in [z, k])
+        if len(z) < 4:
+            raise ValueError('Require at least four redshifts for Pk interpolation.'
+                             'Consider using Pk_grid if you just need a small number'
+                             'of specific redshifts (doing 1D splines in k yourself).')
+        z, k, P_or_logP = np.array(z), np.array(k), np.array(P_or_logP)
+        i_z = np.argsort(z)
+        i_k = np.argsort(k)
+        self.logsign = logsign
+        self.z, self.k, P_or_logP = z[i_z], k[i_k], P_or_logP[i_z, :][:, i_k]
+        self.zmin, self.zmax = self.z[0], self.z[-1]
+        self.extrap_kmin, self.extrap_kmax = extrap_kmin, extrap_kmax
+        logk = np.log(self.k)
+        # Start from extrap_kmin using a (log,log)-linear extrapolation
+        if extrap_kmin and extrap_kmin < self.input_kmin:
+            if not logP:
+                raise ValueError('extrap_kmin must use logP')
+            logk = np.hstack(
+                [np.log(extrap_kmin),
+                 np.log(self.input_kmin) * 0.1 + np.log(extrap_kmin) * 0.9, logk])
+            logPnew = np.empty((P_or_logP.shape[0], P_or_logP.shape[1] + 2))
+            logPnew[:, 2:] = P_or_logP
+            diff = (logPnew[:, 3] - logPnew[:, 2]) / (logk[3] - logk[2])
+            delta = diff * (logk[2] - logk[0])
+            logPnew[:, 0] = logPnew[:, 2] - delta
+            logPnew[:, 1] = logPnew[:, 2] - delta * 0.9
+            P_or_logP = logPnew
+        # Continue until extrap_kmax using a (log,log)-linear extrapolation
+        if extrap_kmax and extrap_kmax > self.input_kmax:
+            if not logP:
+                raise ValueError('extrap_kmax must use logP')
+            logk = np.hstack(
+                [logk, np.log(self.input_kmax) * 0.1 + np.log(extrap_kmax) * 0.9,
+                 np.log(extrap_kmax)])
+            logPnew = np.empty((P_or_logP.shape[0], P_or_logP.shape[1] + 2))
+            logPnew[:, :-2] = P_or_logP
+            diff = (logPnew[:, -3] - logPnew[:, -4]) / (logk[-3] - logk[-4])
+            delta = diff * (logk[-1] - logk[-3])
+            logPnew[:, -1] = logPnew[:, -3] + delta
+            logPnew[:, -2] = logPnew[:, -3] + delta * 0.9
+            P_or_logP = logPnew
+        super().__init__(self.z, logk, P_or_logP)
+
+    @property
+    def input_kmin(self):
+        """Minimum k for the interpolation (not incl. extrapolation range)."""
+        return self.k[0]
+
+    @property
+    def input_kmax(self):
+        """Maximum k for the interpolation (not incl. extrapolation range)."""
+        return self.k[-1]
+
+    @property
+    def kmin(self):
+        """Minimum k of the interpolator (incl. extrapolation range)."""
+        if self.extrap_kmin is None:
+            return self.input_kmin
+        return self.extrap_kmin
+
+    @property
+    def kmax(self):
+        """Maximum k of the interpolator (incl. extrapolation range)."""
+        if self.extrap_kmax is None:
+            return self.input_kmax
+        return self.extrap_kmax
+
+    def check_ranges(self, z, k):
+        """Checks that we are not trying to extrapolate beyond the interpolator limits."""
+        z = np.atleast_1d(z).flatten()
+        min_z, max_z = min(z), max(z)
+        if min_z < self.zmin and not np.allclose(min_z, self.zmin):
+            print(
+                              f"Not possible to extrapolate to z={min(z)} "
+                              f"(minimum z computed is {self.zmin}).")
+        if max_z > self.zmax and not np.allclose(max_z, self.zmax):
+            print(
+                              f"Not possible to extrapolate to z={max(z)} "
+                              f"(maximum z computed is {self.zmax}).")
+        k = np.atleast_1d(k).flatten()
+        min_k, max_k = min(k), max(k)
+        if min_k < self.kmin and not np.allclose(min_k, self.kmin):
+            raise print(
+                              f"Not possible to extrapolate to k={min(k)} 1/Mpc "
+                              f"(minimum k possible is {self.kmin} 1/Mpc).")
+        if max_k > self.kmax and not np.allclose(max_k, self.kmax):
+            print(
+                              f"Not possible to extrapolate to k={max(k)} 1/Mpc "
+                              f"(maximum k possible is {self.kmax} 1/Mpc).")
+
+    def P(self, z, k, grid=None):
+        """
+        Get the power spectrum at (z,k).
+        """
+        self.check_ranges(z, k)
+        if grid is None:
+            grid = not np.isscalar(z) and not np.isscalar(k)
+        if self.islog:
+            return self.logsign * np.exp(self(z, np.log(k), grid=grid, warn=False))
+        else:
+            return self(z, np.log(k), grid=grid, warn=False)
+
+    def logP(self, z, k, grid=None):
+        """
+        Get the log power spectrum at (z,k). (or minus log power spectrum if
+        islog and logsign=-1)
+        """
+        self.check_ranges(z, k)
+        if grid is None:
+            grid = not np.isscalar(z) and not np.isscalar(k)
+        if self.islog:
+            return self(z, np.log(k), grid=grid, warn=False)
+        else:
+            return np.log(self(z, np.log(k), grid=grid, warn=False))
+
+    def __call__(self, *args, warn=True, **kwargs):
+        if warn:
+            print(
+                "Do not call the instance directly. Use instead methods P(z, k) or "
+                "logP(z, k) to get the (log)power spectrum. (If you know what you are "
+                "doing, pass warn=False)")
+        return super().__call__(*args, **kwargs)

classy_szfast/suppress_warnings.py

@@ -0,0 +1,10 @@
+import warnings
+from contextlib import contextmanager
+
+@contextmanager
+def suppress_warnings():
+    warnings.filterwarnings("ignore")
+    try:
+        yield
+    finally:
+        warnings.resetwarnings()

classy_szfast/utils.py

@@ -0,0 +1,62 @@
+import numpy as np
+from datetime import datetime
+import multiprocessing
+import time
+import functools
+import re
+from pkg_resources import resource_filename
+import os
+from scipy import optimize
+from scipy.integrate import quad
+from scipy.interpolate import interp1d
+import math
+from numpy import linalg as LA
+import mcfit
+from mcfit import P2xi
+import cosmopower
+# import classy_sz as csz
+
+
+
+from scipy.interpolate import LinearNDInterpolator
+from scipy.interpolate import CloughTocher2DInterpolator
+
+kb = 1.38064852e-23 #m2 kg s-2 K-1
+clight = 299792458. #m/s
+hplanck=6.62607004e-34 #m2 kg / s
+firas_T0 = 2.728 #pivot temperature used in the Max Lkl Analysis
+firas_T0_bf = 2.725 #best-fitting temperature
+
+Tcmb_uk = 2.7255e6
+
+G_newton = 6.674e-11
+rho_crit_over_h2_in_GeV_per_cm3 = 1.0537e-5
+
+
+nu_21_cm_in_GHz =  1./21.1*clight*1.e2/1.e9
+x_21_cm = hplanck*nu_21_cm_in_GHz/kb/firas_T0_bf*1.e9
+
+kappa_c = 2.1419 # 4M_2-3M_c see below eq. 9b of https://arxiv.org/pdf/1506.06582.pdf
+
+beta_mu = 2.1923
+
+G1 = np.pi**2./6
+G2 = 2.4041
+G3 = np.pi**4/15.
+a_rho = G2/G3
+alpha_mu = 2.*G1/3./G2 # = 1/beta_mu = π^2/18ζ(3) see eq. 4.15 CUSO lectures.
+
+z_mu_era = 3e5
+z_y_era = 5e4
+z_reio_min = 6
+z_reio_max = 25
+z_recombination_min = 800
+z_recombination_max = 1500
+
+# Physical constants
+# ------------------
+# Light speed
+class Const:
+    c_km_s = 299792.458  # speed of light
+    h_J_s = 6.626070040e-34  # Planck's constant
+    kB_J_K = 1.38064852e-23  # Boltzmann constant

classy_szfast-0.0.3.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: classy_szfast
+Version: 0.0.3
+Summary: The accelerator of the class_sz code from https://github.com/CLASS-SZ
+Home-page: https://github.com/CLASS-SZ/classy_szfast
+Download-URL: https://github.com/CLASS-SZ/classy_szfast
+Author: Boris Bolliet, Ola Kusiak
+Author-email: bb667@cam.ac.uk, akk2175@columbia.edu
+Maintainer-email: Boris Bolliet <bb667@cam.ac.uk>
+Project-URL: Homepage, https://github.com/CLASS-SZ
+Project-URL: GitHub, https://github.com/CLASS-SZ
+Description-Content-Type: text/markdown
+Requires-Dist: tensorflow ==2.13.0
+Requires-Dist: tensorflow-probability ==0.21.0
+Requires-Dist: cosmopower
+Requires-Dist: mcfit
+

classy_szfast-0.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+classy_szfast/__init__.py,sha256=Mp1HvqeZ9_XmjVkqljBe8qG8vxpDzQt-CzQDlZFmOIU,247
+classy_szfast/classy_sz.py,sha256=AUCJsWFOTUH1zadbfBcCS8coHLKNEvSlvAUV5DQ3xQ0,25834
+classy_szfast/classy_szfast.py,sha256=gpiGm3WLStyhiT-b-s8wUvlxCcdqjMZkVqpVhszkJ0M,32433
+classy_szfast/config.py,sha256=JwRAmdVL44ftwuJyrtuP6tZKmQC_yMJ-WdPustaFIWY,102
+classy_szfast/cosmopower.py,sha256=O9Jorm7st-z7CKLXgAIrIZmVZx5rS2xjiUtkEIDrkpo,7010
+classy_szfast/cosmosis_classy_szfast_interface.py,sha256=zAnxvFtn73a5yS7jgs59zpWFEYKCIQyraYPs5hQ4Le8,11483
+classy_szfast/pks_and_sigmas.py,sha256=drtuujE1HhlrYY1hY92DyY5lXlYS1uE15MSuVI4uo6k,6625
+classy_szfast/suppress_warnings.py,sha256=6wIBml2Sj9DyRGZlZWhuA9hqvpxqrNyYjuz6BPK_a6E,202
+classy_szfast/utils.py,sha256=ZZxujm1yBM0KIeVVLOuoNqUVkXIZt817QDi7U_Fz_IM,1462
+classy_szfast/custom_bias/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classy_szfast/custom_bias/custom_bias.py,sha256=53RbMAawCurKuI44nqk6fTTkQbbuJDcZpK0YhNQS3j8,486
+classy_szfast/custom_profiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classy_szfast/custom_profiles/custom_profiles.py,sha256=4LZwb2XoqwCyWNmW2s24Z7AJdmgVdaRG7yYaBYe-d9Q,1188
+classy_szfast-0.0.3.dist-info/METADATA,sha256=lW_89kHfdNOBwjA4r0Y2iPa8YO-VdEYTrdp1Y-viyog,651
+classy_szfast-0.0.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+classy_szfast-0.0.3.dist-info/top_level.txt,sha256=hRgqpilUck4lx2KkaWI2y9aCDKqF6pFfGHfNaoPFxv0,14
+classy_szfast-0.0.3.dist-info/RECORD,,

classy_szfast-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

classy_szfast-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+classy_szfast