pyccl 3.3.2__tar.gz → 3.3.3__tar.gz

{pyccl-3.3.2/pyccl.egg-info → pyccl-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyccl
-Version: 3.3.2
+Version: 3.3.3
 Summary: Library of validated cosmological functions.
 Author: LSST DESC
 License: BSD

{pyccl-3.3.2 → pyccl-3.3.3}/pyccl/nonlimber/_nonlimber_FKEM.py

@@ -41,6 +41,30 @@ def _get_general_params(b):
     return nu, deriv, plaw
 
 
+def _get_k_common(ks_1, ks_2):
+    """Get the common k array for the two tracers to perform the final
+    chi-integral integration over.
+    Args:
+        ks_1 (array): List of wavenumbers at which to evaluate
+            the chi integrands for tracer 1.
+        ks_2 (array): List of wavenumbers at which to evaluate
+            the chi integrands for tracer 2.
+    Returns:
+        k_common (array): Common wavenumbers at which to evaluate the
+            chi-integral integration for all tracers.
+    """
+    all_ks = [np.asarray(k, dtype=float) for k in (*ks_1, *ks_2)]
+
+    k_mins = [k[np.isfinite(k) & (k > 0.0)].min() for k in all_ks]
+    k_maxs = [k[np.isfinite(k) & (k > 0.0)].max() for k in all_ks]
+
+    k_min = max(k_mins)   # overlap lower bound
+    k_max = min(k_maxs)   # overlap upper bound
+
+    n_k = max(len(k) for k in all_ks)
+    return np.logspace(np.log10(k_min), np.log10(k_max), n_k)
+
+
 def _chi_integrands(cosmo, clt,
                     Nchi, chi_min, chi_max,
                     ell, k_low,
@@ -77,6 +101,7 @@ def _chi_integrands(cosmo, clt,
 
     fks = np.zeros((len(kernels), Nchi))
     transfers = np.zeros((len(kernels), Nchi))
+    ks = []
     for i in range(len(kernels)):
         k, fk = clt._get_fkem_fft(
             clt._trc[i], Nchi, chi_min, chi_max, ell, cosmo,
@@ -124,10 +149,11 @@ def _chi_integrands(cosmo, clt,
         clt._set_fkem_fft(
             clt._trc[i], cosmo, Nchi, chi_min, chi_max, ell, k, fk,
         )
+        ks.append(k)
         fks[i] = fk
         transfers[i] = np.array(clt.get_transfer(np.log(k), avg_as[i]))[i]
 
-    return k, fks, transfers
+    return ks, fks, transfers
 
 
 def _auto_limber_transition_ell(clt1, clt2, cosmo, psp_lin, psp_nonlin,
@@ -273,7 +299,8 @@ def _nonlimber_FKEM(
             - chi_min: Minimum comoving distance used by FKEM to sample
               the tracer radial kernels. Must be greater than zero.
             - Nchi: Number of values of the comoving distance over which
-              FKEM will interpolate the radial kernels.
+              FKEM will interpolate the radial kernels. Default is
+              two times the maximum number of chi samples across the tracers.
             - pk_linear: Linear power spectrum to use for growth factor
               scaling. If a string, it must correspond to one of the
               linear power spectra stored in `cosmo`
@@ -314,12 +341,16 @@ def _nonlimber_FKEM(
     if Nchi is None or not isinstance(Nchi, int) or Nchi <= 0:
         warnings.warn("Nchi must be a positive integer. "
                       "Setting to match tracer with"
-                      " fewest chi samples.",
+                      " large chi samples x 2.",
                       category=CCLWarning,
                       importance='high'
                       )
-        Nchi = min(min(len(i) for i in chis_t1),
-                   min(len(i) for i in chis_t2))
+        # We put factor of 2 to help reduce spikes when comparing
+        # the decomposed and direct integration approaches to order 1e-6
+        # for at least a simple Gaussian density kernel.
+        # May need to go higher for different cases.
+        Nchi = 2 * max(max(len(i) for i in chis_t1),
+                       max(len(i) for i in chis_t2))
     if chi_min is None or not isinstance(chi_min, (float)) or chi_min <= 0.0:
         warnings.warn("chi_min must be greater than zero."
                       "Setting to default 1e-6 Mpc.",
@@ -404,14 +435,15 @@ def _nonlimber_FKEM(
         check(status, cosmo=cosmo)
 
         # chi-integral integrand splines
-        k, fks_1, transfers_t1 = _chi_integrands(
+        ks, fks_1, transfers_t1 = _chi_integrands(
             cosmo, clt1,
             Nchi, chi_min, chi_max,
             ell, k_low,
             chi_logspace_arr, status
         )
+
         if clt1 != clt2:
-            k, fks_2, transfers_t2 = _chi_integrands(
+            ks_2, fks_2, transfers_t2 = _chi_integrands(
                 cosmo, clt2,
                 Nchi, chi_min, chi_max,
                 ell, k_low,
@@ -420,12 +452,25 @@ def _nonlimber_FKEM(
         else:
             fks_2 = fks_1
             transfers_t2 = transfers_t1
+            ks_2 = ks
+        k = _get_k_common(ks, ks_2)
+        # need to interpolate the fks and transfers to the common k array
+        fks_1_interp = np.zeros((len(clt1._trc), len(k)))
+        fks_2_interp = np.zeros((len(clt2._trc), len(k)))
+        transfers_t1_interp = np.zeros((len(clt1._trc), len(k)))
+        transfers_t2_interp = np.zeros((len(clt2._trc), len(k)))
+        for i in range(len(clt1._trc)):
+            fks_1_interp[i] = np.interp(k, ks[i], fks_1[i])
+            transfers_t1_interp[i] = np.interp(k, ks[i], transfers_t1[i])
+        for i in range(len(clt2._trc)):
+            fks_2_interp[i] = np.interp(k, ks_2[i], fks_2[i])
+            transfers_t2_interp[i] = np.interp(k, ks_2[i], transfers_t2[i])
 
         cls_nonlimber_lin = np.sum(
-            fks_1[:, None, :]
-            * transfers_t1[:, None, :]
-            * fks_2[None, :, :]
-            * transfers_t2[None, :, :]
+            fks_1_interp[:, None, :]
+            * transfers_t1_interp[:, None, :]
+            * fks_2_interp[None, :, :]
+            * transfers_t2_interp[None, :, :]
             * (k**kpow
                 * pk(k, 1.0, cosmo))[None, None, :]
             * dlnr
@@ -456,8 +501,8 @@ def _nonlimber_FKEM(
             # the limber threshold
             status, is_limber = _auto_limber_transition_ell(
                 clt1, clt2, cosmo, psp_lin,
-                psp_nonlin, fks_1, fks_2,
-                transfers_t1, transfers_t2,
+                psp_nonlin, fks_1_interp, fks_2_interp,
+                transfers_t1_interp, transfers_t2_interp,
                 fll_t1, fll_t2, k, kpow,
                 pk, dlnr, el, ell,
                 limber_max_error, status

{pyccl-3.3.2 → pyccl-3.3.3}/pyccl/tests/test_cells.py

@@ -279,6 +279,104 @@ def test_fkem_multicomponent_tracer():
     assert np.all(np.isfinite(cl_gk))
 
 
+def test_fkem_decomposed_matches_direct_number_counts_mag():
+    z = np.linspace(0.01, 2.0, 200)
+    nz = np.exp(-((z - 1.0) ** 2) / 0.1)
+    ells = np.arange(2, 200)
+    cosmo = ccl.CosmologyVanillaLCDM()
+
+    ccl_kwargs = dict(
+        l_limber=210,
+        non_limber_integration_method="FKEM",
+        fkem_Nchi=200,
+        fkem_chi_min=1e-6,
+    )
+
+    tracer_den = ccl.NumberCountsTracer(
+        cosmo,
+        dndz=(z, nz),
+        bias=(z, 1.5 * np.ones_like(z)),
+        has_rsd=False,
+        mag_bias=None,
+    )
+    tracer_mag = ccl.NumberCountsTracer(
+        cosmo,
+        dndz=(z, nz),
+        bias=None,
+        has_rsd=False,
+        mag_bias=(z, 1.0 * np.ones_like(z)),
+    )
+    tracer_full = ccl.NumberCountsTracer(
+        cosmo,
+        dndz=(z, nz),
+        bias=(z, 1.5 * np.ones_like(z)),
+        has_rsd=False,
+        mag_bias=(z, 1.0 * np.ones_like(z)),
+    )
+
+    cl_dd = ccl.angular_cl(cosmo, tracer_den, tracer_den, ells, **ccl_kwargs)
+    cl_dM = ccl.angular_cl(cosmo, tracer_den, tracer_mag, ells, **ccl_kwargs)
+    cl_MM = ccl.angular_cl(cosmo, tracer_mag, tracer_mag, ells, **ccl_kwargs)
+    cl_decomposed = cl_dd + 2.0 * cl_dM + cl_MM
+
+    cl_direct = ccl.angular_cl(cosmo, tracer_full, tracer_full, ells,
+                               **ccl_kwargs)
+
+    rel = np.abs(cl_direct / cl_decomposed - 1.0)
+    assert np.all(np.isfinite(rel))
+    assert np.max(rel) < 5e-3
+
+
+def test_fkem_decomposed_matches_direct_weak_lensing_ia():
+    z = np.linspace(0.01, 2.0, 200)
+    nz = np.exp(-((z - 1.0) ** 2) / 0.1)
+    ia_amp = 0.5 * np.ones_like(z)
+    ells = np.arange(2, 200)
+    cosmo = ccl.CosmologyVanillaLCDM()
+
+    ccl_kwargs = dict(
+        l_limber=210,
+        non_limber_integration_method="FKEM",
+        fkem_Nchi=200,
+        fkem_chi_min=1e-6,
+    )
+
+    tracer_lens = ccl.WeakLensingTracer(
+        cosmo,
+        dndz=(z, nz),
+        has_shear=True,
+        ia_bias=None,
+    )
+    tracer_ia = ccl.WeakLensingTracer(
+        cosmo,
+        dndz=(z, nz),
+        has_shear=False,
+        ia_bias=(z, ia_amp),
+        use_A_ia=False,
+    )
+    tracer_full = ccl.WeakLensingTracer(
+        cosmo,
+        dndz=(z, nz),
+        has_shear=True,
+        ia_bias=(z, ia_amp),
+        use_A_ia=False,
+    )
+
+    cl_gg = ccl.angular_cl(cosmo, tracer_lens, tracer_lens, ells,
+                           **ccl_kwargs)
+    cl_gi = ccl.angular_cl(cosmo, tracer_lens, tracer_ia, ells,
+                           **ccl_kwargs)
+    cl_ii = ccl.angular_cl(cosmo, tracer_ia, tracer_ia, ells, **ccl_kwargs)
+    cl_decomposed = cl_gg + 2.0 * cl_gi + cl_ii
+
+    cl_direct = ccl.angular_cl(cosmo, tracer_full, tracer_full, ells,
+                               **ccl_kwargs)
+
+    rel = np.abs(cl_direct / cl_decomposed - 1.0)
+    assert np.all(np.isfinite(rel))
+    assert np.max(rel) < 5e-3
+
+
 def test_cells_mg():
     # Check that if we feed the non-linear matter power spectrum from a MG
     # cosmology into a Calculator and get Cells using MG tracers, we get the

{pyccl-3.3.2 → pyccl-3.3.3/pyccl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyccl
-Version: 3.3.2
+Version: 3.3.3
 Summary: Library of validated cosmological functions.
 Author: LSST DESC
 License: BSD