lsstdesc-crow 1.0.2__py3-none-any.whl

crow/__init__.py

@@ -0,0 +1,11 @@
+"""Module that contains the cluster model classes."""
+
+from .cluster_modules import completeness_models, kernel, mass_proxy, purity_models
+from .cluster_modules.abundance import ClusterAbundance
+from .cluster_modules.shear_profile import ClusterShearProfile
+from .properties import ClusterProperty
+from .recipes.binned_exact import ExactBinnedClusterRecipe
+from .recipes.binned_grid import GridBinnedClusterRecipe
+from .recipes.binned_parent import BinnedClusterRecipe
+
+__version__ = "1.0.2"

crow/cluster_modules/_clmm_patches.py

@@ -0,0 +1,174 @@
+import numpy as np
+from scipy.integrate import quad, simpson
+from scipy.interpolate import splev, splrep
+from scipy.special import gamma, gammainc, jv
+
+from crow.integrator.numcosmo_integrator import NumCosmoIntegrator
+
+
+def numcosmo_miscentered_mean_surface_density(  # pragma: no cover
+    r_proj, r_mis, integrand, norm, aux_args, extra_integral
+):
+    """
+    NumCosmo replacement for `integrate_azimuthially_miscentered_mean_surface_density`.
+
+    Integrates azimuthally and radially for the mean surface mass density kernel.
+    """
+    integrator = NumCosmoIntegrator(
+        relative_tolerance=1e-6,
+        absolute_tolerance=1e-3,
+    )
+    integrand = np.vectorize(integrand)
+    r_proj = np.atleast_1d(r_proj)
+    r_lower = np.full_like(r_proj, 1e-6)
+    r_lower[1:] = r_proj[:-1]
+
+    results = []
+    args = (r_mis, *aux_args)
+    integrator.extra_args = np.array(args)
+    for r_low, r_high in zip(r_lower, r_proj):
+        if extra_integral:
+            integrator.integral_bounds = [
+                (r_low, r_high),
+                (1.0e-6, np.pi),
+                (0.0, np.inf),
+            ]
+
+            def integrand_numcosmo(int_args, extra_args):
+                r_local = int_args[:, 0]
+                theta = int_args[:, 1]
+                extra = int_args[:, 2]
+                return integrand(theta, r_local, extra, *extra_args)
+
+        else:
+            integrator.integral_bounds = [(r_low, r_high), (1.0e-6, np.pi)]
+
+            def integrand_numcosmo(int_args, extra_args):
+                r_local = int_args[:, 0]
+                theta = int_args[:, 1]
+                return integrand(theta, r_local, *extra_args)
+
+        res = integrator.integrate(integrand_numcosmo)
+        results.append(res)
+
+    results = np.array(results)
+    mean_surface_density = np.cumsum(results) * norm * 2 / np.pi / r_proj**2
+    if not np.iterable(r_proj):
+        return res[0] * norm * 2 / np.pi / r_proj**2
+    return mean_surface_density
+
+
+def _eval_2halo_term_generic_orig(  # pragma: no cover
+    self,
+    sph_harm_ord,
+    r_proj,
+    z_cl,
+    halobias=1.0,
+    logkbounds=(-5, 5),
+    ksteps=1000,
+    loglbounds=(0, 6),
+    lsteps=500,
+):
+    """eval excess surface density from the 2-halo term (original)"""
+    # pylint: disable=protected-access
+    da = self.cosmo.eval_da(z_cl)
+    rho_m = self.cosmo._get_rho_m(z_cl)
+
+    k_values = np.logspace(logkbounds[0], logkbounds[1], ksteps)
+    pk_values = self.cosmo._eval_linear_matter_powerspectrum(k_values, z_cl)
+    interp_pk = splrep(k_values, pk_values)
+    theta = r_proj / da
+
+    # calculate integral, units [Mpc]**-3
+    def __integrand__(l_value, theta):
+        k_value = l_value / ((1 + z_cl) * da)
+        return l_value * jv(sph_harm_ord, l_value * theta) * splev(k_value, interp_pk)
+
+    l_values = np.logspace(loglbounds[0], loglbounds[1], lsteps)
+    kernel = np.array([simpson(__integrand__(l_values, t), x=l_values) for t in theta])
+    return halobias * kernel * rho_m / (2 * np.pi * (1 + z_cl) ** 3 * da**2)
+
+
+def _eval_2halo_term_generic_new(  # pragma: no cover
+    ####################################################################################
+    # NOTE: This function is just a small optimization of the one implemented on CLMM  #
+    # here just to benchmark the difference due the restructuration of the integration #
+    ####################################################################################
+    self,
+    sph_harm_ord,
+    r_proj,
+    z_cl,
+    halobias=1.0,
+    logkbounds=(-5, 5),
+    ksteps=1000,
+    loglbounds=(0, 6),
+    lsteps=500,
+):
+    """eval excess surface density from the 2-halo term (updated integration)"""
+    # pylint: disable=protected-access
+    da = self.cosmo.eval_da(z_cl)
+    rho_m = self.cosmo._get_rho_m(z_cl)
+    theta = r_proj / da
+
+    # interp pk
+    _k_values = np.logspace(logkbounds[0], logkbounds[1], ksteps)
+    interp_pk = splrep(
+        _k_values, self.cosmo._eval_linear_matter_powerspectrum(_k_values, z_cl)
+    )
+
+    # integrate
+    l_values = np.logspace(loglbounds[0], loglbounds[1], lsteps)
+    kernel = simpson(
+        (
+            l_values
+            * jv(sph_harm_ord, l_values * theta)
+            * splev(l_values / ((1 + z_cl) * da), interp_pk)
+        ),
+        x=l_values,
+    )
+    return [halobias * kernel * rho_m / (2 * np.pi * (1 + z_cl) ** 3 * da**2)]
+
+
+def _eval_2halo_term_generic_vec(  # pragma: no cover
+    self,
+    sph_harm_ord,
+    r_proj,
+    z_cl,
+    halobias=1.0,
+    logkbounds=(-5, 5),
+    ksteps=1000,
+    loglbounds=(0, 6),
+    lsteps=500,
+):
+    """eval excess surface density from the 2-halo term (vectorized)"""
+    z_cl = np.atleast_1d(z_cl)
+    # pylint: disable=protected-access
+    da = self.cosmo.eval_da(z_cl)
+    rho_m = self.cosmo._get_rho_m(z_cl)
+
+    # (n_z, n_r)
+    theta = (r_proj / da[None, :]).T
+
+    # calculate integral, units [Mpc]**-3
+    l_values = np.logspace(loglbounds[0], loglbounds[1], lsteps)
+
+    # (n_l, n_z)
+    k_values = l_values[:, np.newaxis] / ((1 + z_cl) * da)
+    pk_values = np.zeros(k_values.shape)
+    for i in range(z_cl.size):
+        pk_values[:, i] = self.cosmo._eval_linear_matter_powerspectrum(
+            k_values[:, i], z_cl[i]
+        )
+
+    # (n_l, n_z, n_r)
+    jv_values = jv(sph_harm_ord, l_values[:, None, None] * theta[None, :, :])
+    kernel = l_values[:, None, None] * pk_values[:, :, None] * jv_values
+
+    # (n_z, n_r)
+    integ = simpson(kernel, x=l_values, axis=0)
+
+    # (n_z, n_r)
+    out = halobias * integ * (rho_m / (2 * np.pi * (1 + z_cl) ** 3 * da**2))[:, None]
+
+    # (n_r, n_z)
+    return out.T

crow/cluster_modules/abundance.py

@@ -0,0 +1,87 @@
+"""The module responsible for building the cluster abundance calculation.
+
+The galaxy cluster abundance integral is a combination of both theoretical
+and phenomenological predictions.  This module contains the classes and
+functions that produce those predictions.
+"""
+
+import numpy as np
+import numpy.typing as npt
+import pyccl
+import pyccl.background as bkg
+from pyccl.cosmology import Cosmology
+
+from .parameters import Parameters
+
+
+class ClusterAbundance:
+    """The class that calculates the predicted number counts of galaxy clusters.
+
+    The abundance is a function of a specific cosmology, a mass and redshift range,
+    an area on the sky, a halo mass function, as well as multiple kernels, where
+    each kernel represents a different distribution involved in the final cluster
+    abundance integrand.
+    """
+
+    @property
+    def cosmo(self) -> Cosmology | None:
+        """The cosmology used to predict the cluster number count."""
+        return self._cosmo
+
+    @cosmo.setter
+    def cosmo(self, cosmo: Cosmology) -> None:
+        """Update the cluster abundance calculation with a new cosmology."""
+        self._cosmo = cosmo
+        self._hmf_cache: dict[tuple[float, float], float] = {}
+
+    def __init__(
+        self,
+        cosmo: Cosmology,
+        halo_mass_function: pyccl.halos.MassFunc,
+    ) -> None:
+        super().__init__()
+        self.cosmo = cosmo
+        self.halo_mass_function = halo_mass_function
+        self.parameters = Parameters({})
+
+    def comoving_volume(
+        self, z: npt.NDArray[np.float64], sky_area: float = 0
+    ) -> npt.NDArray[np.float64]:
+        """The differential comoving volume given area sky_area at redshift z.
+
+        :param sky_area: The area of the survey on the sky in square degrees.
+        """
+        assert self.cosmo is not None
+        scale_factor = 1.0 / (1.0 + z)
+        angular_diam_dist = bkg.angular_diameter_distance(self.cosmo, scale_factor)
+        h_over_h0 = bkg.h_over_h0(self.cosmo, scale_factor)
+
+        dV = (
+            pyccl.physical_constants.CLIGHT_HMPC
+            * (angular_diam_dist**2)
+            * ((1.0 + z) ** 2)
+            / (self.cosmo["h"] * h_over_h0)
+        )
+        assert isinstance(dV, np.ndarray)
+
+        sky_area_rad = sky_area * (np.pi / 180.0) ** 2
+
+        return np.array(dV * sky_area_rad, dtype=np.float64)
+
+    def mass_function(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """The mass function at z and mass."""
+        scale_factor = 1.0 / (1.0 + z)
+        return_vals = []
+
+        for logm, a in zip(log_mass.astype(float), scale_factor.astype(float)):
+            val = self._hmf_cache.get((logm, a))
+            if val is None:
+                val = self.halo_mass_function(self.cosmo, 10**logm, a)
+                self._hmf_cache[(logm, a)] = val
+            return_vals.append(val)
+
+        return np.asarray(return_vals, dtype=np.float64)

crow/cluster_modules/completeness_models.py

@@ -0,0 +1,75 @@
+"""The cluster completeness module.
+
+This module holds the classes that define the kernels that can be included
+in the cluster abundance integrand.
+"""
+
+import numpy as np
+import numpy.typing as npt
+
+from .parameters import Parameters
+
+
+class Completeness:
+    """The completeness kernel for the numcosmo simulated survey.
+
+    This kernel will affect the integrand by accounting for the incompleteness
+    of a cluster selection.
+    """
+
+    def __init__(self):
+        pass
+
+    def distribution(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the completeness contribution to the integrand."""
+        raise NotImplementedError
+
+
+REDMAPPER_DEFAULT_PARAMETERS = {
+    "a_n": 0.38,
+    "b_n": 1.2634,
+    "a_logm_piv": 13.31,
+    "b_logm_piv": 0.2025,
+}
+
+
+class CompletenessAguena16(Completeness):
+    """The completeness kernel for the numcosmo simulated survey.
+
+    This kernel will affect the integrand by accounting for the incompleteness
+    of a cluster selection.
+    """
+
+    def __init__(
+        self,
+    ):
+        self.parameters = Parameters({**REDMAPPER_DEFAULT_PARAMETERS})
+
+    def _mpiv(self, z: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        log_mpiv = self.parameters["a_logm_piv"] + self.parameters["b_logm_piv"] * (
+            1.0 + z
+        )
+        mpiv = 10.0**log_mpiv
+        return mpiv.astype(np.float64)
+
+    def _nc(self, z: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        nc = self.parameters["a_n"] + self.parameters["b_n"] * (1.0 + z)
+        assert isinstance(nc, np.ndarray)
+        return nc
+
+    def distribution(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the completeness contribution to the integrand."""
+
+        mass_norm_pow = (10.0**log_mass / self._mpiv(z)) ** self._nc(z)
+
+        completeness = mass_norm_pow / (mass_norm_pow + 1.0)
+        assert isinstance(completeness, np.ndarray)
+        return completeness

crow/cluster_modules/kernel.py

@@ -0,0 +1,37 @@
+"""The cluster kernel module.
+
+This module holds the classes that define the kernels that can be included
+in the cluster abundance integrand.
+"""
+
+import numpy as np
+import numpy.typing as npt
+
+
+class TrueMass:
+    """The true mass kernel.
+
+    Assuming we measure the true mass, this will always be 1.
+    """
+
+    def distribution(self) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the mass distribution contribution to the integrand.
+
+        We have set this to 1.0 (i.e. it does not affect the mass distribution)
+        """
+        return np.atleast_1d(1.0)
+
+
+class SpectroscopicRedshift:
+    """The spec-z kernel.
+
+    Assuming the spectroscopic redshift has no uncertainties, this is akin to
+    multiplying by 1.
+    """
+
+    def distribution(self) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the z distribution contribution to the integrand.
+
+        We have set this to 1.0 (i.e. it does not affect the redshift distribution)
+        """
+        return np.atleast_1d(1.0)

crow/cluster_modules/mass_proxy/__init__.py

@@ -0,0 +1,8 @@
+"""The mass richness kernel module.
+
+This module holds the classes that define the mass richness relations
+that can be included in the cluster abundance integrand.  These are
+implementations of Kernels.
+"""
+
+from .murata import MurataBinned, MurataUnbinned

crow/cluster_modules/mass_proxy/gaussian_protocol.py

@@ -0,0 +1,79 @@
+"""Gaussian class for mass richness distributiosn."""
+
+from abc import abstractmethod
+
+import numpy as np
+import numpy.typing as npt
+from scipy import special
+
+from crow.integrator.numcosmo_integrator import NumCosmoIntegrator
+
+
+class MassRichnessGaussian:
+    """The representation of mass richness relations that are of a gaussian form."""
+
+    @abstractmethod
+    def get_ln_mass_proxy_mean(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Return observed quantity corrected by redshift and mass."""
+
+    @abstractmethod
+    def get_ln_mass_proxy_sigma(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Return observed scatter corrected by redshift and mass."""
+
+    def integrated_gaussian(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+        log_mass_proxy_limits: tuple[float, float],
+    ) -> npt.NDArray[np.float64]:
+        ln_mass_proxy_mean = self.get_ln_mass_proxy_mean(log_mass, z)
+        ln_mass_proxy_sigma = self.get_ln_mass_proxy_sigma(log_mass, z)
+
+        x_min = (ln_mass_proxy_mean - log_mass_proxy_limits[0] * np.log(10.0)) / (
+            np.sqrt(2.0) * ln_mass_proxy_sigma
+        )
+        x_max = (ln_mass_proxy_mean - log_mass_proxy_limits[1] * np.log(10.0)) / (
+            np.sqrt(2.0) * ln_mass_proxy_sigma
+        )
+
+        return_vals = np.empty_like(x_min)
+        mask1 = (x_max > 3.0) | (x_min < -3.0)
+        mask2 = ~mask1
+
+        # pylint: disable=no-member
+        return_vals[mask1] = (
+            -(special.erfc(x_min[mask1]) - special.erfc(x_max[mask1])) / 2.0
+        )
+        # pylint: disable=no-member
+        return_vals[mask2] = (
+            special.erf(x_min[mask2]) - special.erf(x_max[mask2])
+        ) / 2.0
+        assert isinstance(return_vals, np.ndarray)
+        return return_vals
+
+    def gaussian_kernel(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+        log_mass_proxy: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        ln_mass_proxy_mean = self.get_ln_mass_proxy_mean(log_mass, z)
+        ln_mass_proxy_sigma = self.get_ln_mass_proxy_sigma(log_mass, z)
+
+        normalization = 1 / np.sqrt(2 * np.pi * ln_mass_proxy_sigma**2)
+        result = normalization * np.exp(
+            -0.5
+            * ((log_mass_proxy * np.log(10) - ln_mass_proxy_mean) / ln_mass_proxy_sigma)
+            ** 2
+        )
+
+        assert isinstance(result, np.ndarray)
+        return result

crow/cluster_modules/mass_proxy/murata.py

@@ -0,0 +1,109 @@
+"""The Murata et al. 19 mass richness kernel models."""
+
+import numpy as np
+import numpy.typing as npt
+
+from ..parameters import Parameters
+from .gaussian_protocol import MassRichnessGaussian
+
+MURATA_DEFAULT_PARAMETERS = {
+    "mu0": 3.0,
+    "mu1": 0.8,
+    "mu2": -0.3,
+    "sigma0": 0.3,
+    "sigma1": 0.0,
+    "sigma2": 0.0,
+}
+
+
+class MurataModel:
+    """The mass richness modeling defined in Murata 19."""
+
+    def __init__(
+        self,
+        pivot_log_mass: float,
+        pivot_redshift: float,
+    ):
+        super().__init__()
+        self.pivot_redshift = pivot_redshift
+        self.pivot_ln_mass = pivot_log_mass * np.log(10.0)  # ln(M)
+        self.log1p_pivot_redshift = np.log1p(self.pivot_redshift)
+
+        self.parameters = Parameters({**MURATA_DEFAULT_PARAMETERS})
+
+        # Verify this gets called last or first
+
+    @staticmethod
+    def observed_value(
+        p: tuple[float, float, float],
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+        pivot_ln_mass: float,
+        log1p_pivot_redshift: float,
+    ) -> npt.NDArray[np.float64]:
+        """Return observed quantity corrected by redshift and mass."""
+        ln_mass = log_mass * np.log(10)
+        delta_ln_mass = ln_mass - pivot_ln_mass
+        delta_z = np.log1p(z) - log1p_pivot_redshift
+
+        result = p[0] + p[1] * delta_ln_mass + p[2] * delta_z
+        assert isinstance(result, np.ndarray)
+        return result
+
+    def get_ln_mass_proxy_mean(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Return observed quantity corrected by redshift and mass."""
+        return MurataModel.observed_value(
+            (self.parameters["mu0"], self.parameters["mu1"], self.parameters["mu2"]),
+            log_mass,
+            z,
+            self.pivot_ln_mass,
+            self.log1p_pivot_redshift,
+        )
+
+    def get_ln_mass_proxy_sigma(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Return observed scatter corrected by redshift and mass."""
+        return MurataModel.observed_value(
+            (
+                self.parameters["sigma0"],
+                self.parameters["sigma1"],
+                self.parameters["sigma2"],
+            ),
+            log_mass,
+            z,
+            self.pivot_ln_mass,
+            self.log1p_pivot_redshift,
+        )
+
+
+class MurataBinned(MurataModel, MassRichnessGaussian):
+    """The mass richness relation defined in Murata 19 for a binned data vector."""
+
+    def distribution(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+        log_mass_proxy_limits: tuple[float, float],
+    ) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the mass-richness contribution to the integrand."""
+        return self.integrated_gaussian(log_mass, z, log_mass_proxy_limits)
+
+
+class MurataUnbinned(MurataModel, MassRichnessGaussian):
+    """The mass richness relation defined in Murata 19 for a unbinned data vector."""
+
+    def distribution(
+        self,
+        log_mass: npt.NDArray[np.float64],
+        z: npt.NDArray[np.float64],
+        log_mass_proxy: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """Evaluates and returns the mass-richness contribution to the integrand."""
+        return self.gaussian_kernel(log_mass, z, log_mass_proxy)

crow/cluster_modules/parameters.py

@@ -0,0 +1,56 @@
+"""The parameters module.
+
+This module holds the class that stores and manages parameter to be used in
+each cluster_module object.
+"""
+
+
+class Parameters:
+    """The parameter class that stores and manages parameter to be used in
+    each cluster_module object.
+    """
+
+    def __init__(self, default_parameters_dict):
+        """
+        Parameters
+        ----------
+        default_parameters_dict: dict
+            Dictionary with the default parameters names and values.
+            Only parameters defined in this dictionary will be accepted
+            in this class
+        """
+        self.__pars = {**default_parameters_dict}
+
+    def __getitem__(self, item):
+        return self.__pars[item]
+
+    def __setitem__(self, item, value):
+        if item not in self.__pars:
+            raise KeyError(
+                f"key={item} not accepted, " f"must be in {list(self.__pars.keys())}"
+            )
+        self.__pars[item] = value
+
+    def keys(self):
+        return self.__pars.keys()
+
+    def values(self):
+        return self.__pars.values()
+
+    def items(self):
+        return self.__pars.items()
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def update(self, update_dict):
+        if not isinstance(update_dict, (dict, Parameters)):
+            raise ValueError(
+                "argument of update must be dict or Parameters, "
+                f"{type(update_dict)} given!"
+            )
+        bad_keys = list(filter(lambda key: key not in self.__pars.keys(), update_dict))
+        if len(bad_keys) > 0:
+            raise KeyError(f"bad keys provided for update: {bad_keys}")
+        self.__pars.update(update_dict)