pyccl 3.3.2__tar.gz → 3.3.4__tar.gz

{pyccl-3.3.2 → pyccl-3.3.4}/.github/environment.yml

@@ -25,11 +25,12 @@ dependencies:
   - wheel # for classy
   - cython < 3  # for classy
   - pip:
+      - scipy<1.14
       - classy  # Note the benchmarks were generated with 2.9.4
       - isitgr  # Note the benchmarks were generated with 1.0.2
       - velocileptors @ git+https://github.com/sfschen/velocileptors
       - baccoemu @ git+https://bitbucket.org/rangulo/baccoemu.git@master
       - MiraTitanHMFemulator
-      - dark_emulator  # Note the benchmarks were generated with 1.1.2
+      - dark_emulator @ git+https://github.com/DarkQuestCosmology/dark_emulator_public.git@main # Note the benchmarks were generated with 1.1.2
       - colossus
       

{pyccl-3.3.2 → pyccl-3.3.4}/.github/workflows/ci.yml

@@ -59,12 +59,13 @@ jobs:
     steps:
 
       - name: Checkout CCL repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up conda
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
         with:
           channels: conda-forge
+          conda-remove-defaults: true
           show-channel-urls: true
           miniforge-version: latest
           miniforge-variant: Miniforge3
@@ -85,7 +86,7 @@ jobs:
         run: echo "TODAY=$(date +'%Y.%m.%d')" >> $GITHUB_ENV
 
       - name: Get cached environment
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache
         with:
           path: ${{ matrix.prefix }}
@@ -108,7 +109,7 @@ jobs:
         run: echo "dir=$(pip cache dir)" >> $GITHUB_OUTPUT
 
       - name: Cache pip packages
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ${{ steps.pip-cache.outputs.dir }}
           key: pip-py${{ matrix.python-version }}-${{ runner.os }}-${{ hashFiles('**/environment.yml') }}-${{ hashFiles('setup.py') }}
@@ -146,7 +147,7 @@ jobs:
       contents: read
     steps:
       - name: Checkout CCL repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Lint
         uses: py-actions/flake8@v2

pyccl-3.3.4/.github/workflows/publish.yml

@@ -0,0 +1,111 @@
+name: Build and publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            cibw_archs: x86_64
+          - os: macos-latest
+            cibw_archs: arm64
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.3.1
+        env:
+          CIBW_ARCHS: ${{ matrix.cibw_archs }}
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v7
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ matrix.cibw_archs }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.10"
+
+      - name: Install build dependencies
+        run: python -m pip install --upgrade pip build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v7
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  publish_testpypi:
+    name: Publish to TestPyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch'
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/pyccl
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v8
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  publish:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pyccl
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v8
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

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

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

{pyccl-3.3.2 → pyccl-3.3.4}/cmake/Modules/BuildFFTW.cmake

@@ -11,7 +11,7 @@ if(NOT FFTW_FOUND )
     ExternalProject_Add(FFTW
         PREFIX FFTW
         URL http://www.fftw.org/fftw-${FFTWVersion}.tar.gz
-        URL_MD5 ${GSLMD5}
+        URL_MD5 ${FFTWMD5}
         DOWNLOAD_NO_PROGRESS 1
         CONFIGURE_COMMAND ./configure --prefix=${CMAKE_BINARY_DIR}/extern --enable-shared=no --with-pic=yes
         BUILD_COMMAND           make -j8

{pyccl-3.3.2 → pyccl-3.3.4}/cmake/Modules/FindPythonLibsNew.cmake

@@ -74,12 +74,12 @@ endif()
 # The library suffix is from the config var LDVERSION sometimes, otherwise
 # VERSION. VERSION will typically be like "2.7" on unix, and "27" on windows.
 execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
-    "from distutils import sysconfig as s;import sys;import struct;
+    "import sysconfig as s;import sys;import struct;
 print('.'.join(str(v) for v in sys.version_info));
 print(sys.prefix);
-print(s.get_python_inc(plat_specific=True));
-print(s.get_python_lib(plat_specific=True));
-print(s.get_config_var('SO'));
+print(s.get_path('platinclude'));
+print(s.get_path('platlib'));
+print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO') or '');
 print(hasattr(sys, 'gettotalrefcount')+0);
 print(struct.calcsize('@P'));
 print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));

{pyccl-3.3.2 → pyccl-3.3.4}/pyccl/CMakeLists.txt

@@ -29,14 +29,12 @@ else()
 endif()
 swig_link_libraries(ccllib ccl_static)
 
+# SWIG>=4.4 triggers int-conversion warning/error while calling numpy's import_array()
+# GCC 14+ and Clang both treat this as an error.
+target_compile_options(${SWIG_MODULE_ccllib_REAL_NAME} PRIVATE "-Wno-error=int-conversion")
+
 if(APPLE)
-    # SWIG>=4.4 triggers int-conversion warning/error while calling numpy's import_array()
-    # GCC seems to be raising warnings but clang raises an error, instead.
-    # We make clang to treat them as warnings with next line.
-    target_compile_options(${SWIG_MODULE_ccllib_REAL_NAME} PRIVATE "-Wno-error=int-conversion")
-    # Unpleasant subtelty for linking on osx
+    # On macOS, allow undefined symbols to be resolved at runtime by the Python interpreter.
     set_target_properties(${SWIG_MODULE_ccllib_REAL_NAME} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
-else(APPLE)
-    swig_link_libraries(ccllib ${PYTHON_LIBRARIES})
 endif()
 set_target_properties(${SWIG_MODULE_ccllib_REAL_NAME} PROPERTIES SUFFIX .so)

{pyccl-3.3.2 → pyccl-3.3.4}/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,
@@ -243,6 +269,10 @@ def _auto_limber_transition_ell(clt1, clt2, cosmo, psp_lin, psp_nonlin,
                 + cls_nonlimber_lin_temp
             )
             thresh = cl_temp / cl_limber_nonlin_temp[-1] - 1.0
+
+            lib.cl_tracer_collection_t_free(t1_temp)
+            lib.cl_tracer_collection_t_free(t2_temp)
+
             if np.abs(thresh) >= limber_max_error:
                 return status, False
     return status, True
@@ -273,7 +303,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 +345,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 +439,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 +456,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 +505,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
@@ -469,4 +518,6 @@ def _nonlimber_FKEM(
         l_limber = ls[-1]
     if False in np.isfinite(cells):
         status = 1
+    lib.cl_tracer_collection_t_free(t1)
+    lib.cl_tracer_collection_t_free(t2)
     return l_limber, np.array(cells), status

{pyccl-3.3.2 → pyccl-3.3.4}/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.4/pyccl.egg-info}/PKG-INFO

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

{pyccl-3.3.2 → pyccl-3.3.4}/pyproject.toml

@@ -37,10 +37,7 @@ documentation = "https://ccl.readthedocs.io/en/latest/"
 repository = "https://github.com/LSSTDESC/CCL"
 
 [project.optional-dependencies]
-dev = [
-    "pytest",
-    "pytest-cov",
-]
+dev = ["pytest", "pytest-cov"]
 
 [tool.setuptools.packages.find]
 include = ["pyccl*"]
@@ -49,3 +46,16 @@ include = ["pyccl*"]
 pyccl = ["_ccllib.so", "emulators/data/*.npz"]
 
 [tool.setuptools_scm]
+
+[tool.cibuildwheel]
+build = "cp310-* cp311-* cp312-* cp313-* cp314-*"
+skip = "pp* *-musllinux_* *-win* *-manylinux_i686 *-manylinux_s390x *-manylinux_ppc64le"
+test-command = "python -c \"import pyccl; print(pyccl.__version__)\""
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+before-all = "dnf install -y pcre-devel automake autoconf libtool bison"
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "11.0" }

{pyccl-3.3.2 → pyccl-3.3.4}/setup.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 import sys
 from subprocess import call
 
@@ -9,10 +10,15 @@ from setuptools.command.develop import develop as _develop
 
 
 def _compile_ccl(debug=False):
-    call(["mkdir", "-p", "build"])
+    # Clean stale CMake cache to avoid cross-version contamination
+    # (e.g. when cibuildwheel builds multiple Python versions sequentially).
+    if os.path.exists("build/CMakeCache.txt"):
+        shutil.rmtree("build")
+    os.makedirs("build", exist_ok=True)
     v = sys.version_info
     cmd = ["cmake", "-H.", "-Bbuild",
-           "-DPYTHON_VERSION=%d.%d.%d" % (v.major, v.minor, v.micro)]
+           "-DPYTHON_VERSION=%d.%d.%d" % (v.major, v.minor, v.micro),
+           "-DPYTHON_EXECUTABLE=%s" % sys.executable]
     if debug:
         cmd += ["-DCMAKE_BUILD_TYPE=Debug"]
     if call(cmd) != 0:
@@ -45,6 +51,9 @@ class Distribution(_distribution):
         self.debug = False
         super().__init__(attr)
 
+    def has_ext_modules(self):
+        return True
+
 
 class Build(_build):
     """Specialized Python source builder."""

{pyccl-3.3.2 → pyccl-3.3.4}/src/ccl_fftlog.c

@@ -208,7 +208,7 @@ static void fht(int npk, int N,
     double dim, double mu, double q, double kcrc,
     int noring, double complex* u, int *status)
 {
-  fftw_plan forward_plan, reverse_plan;
+  fftw_plan forward_plan = NULL, reverse_plan = NULL;
   double L = log(k[N-1]/k[0]) * N/(N-1.);
   double complex* ulocal = NULL;
   if(u == NULL) {
@@ -225,8 +225,8 @@ static void fht(int npk, int N,
     }
   }
 
-  fftw_complex* a_tmp;
-  fftw_complex* b_tmp;
+  fftw_complex* a_tmp = NULL;
+  fftw_complex* b_tmp = NULL;
   if(*status == 0) {
     a_tmp = fftw_alloc_complex(N);
     if(a_tmp==NULL)
@@ -336,10 +336,8 @@ static void fht(int npk, int N,
     } //end omp parallel
   }
 
-  if(*status == 0) {
-    fftw_destroy_plan(forward_plan);
-    fftw_destroy_plan(reverse_plan);
-  }
+  if(forward_plan != NULL) fftw_destroy_plan(forward_plan);
+  if(reverse_plan != NULL) fftw_destroy_plan(reverse_plan);
 
   free(ulocal);
   //TODO: free this up
@@ -347,7 +345,7 @@ static void fht(int npk, int N,
   fftw_free(b_tmp);
 }
 
-/* Compute the discrete Hankel transform of the function a(r) 
+/* Compute the discrete Hankel transform of the function a(r)
 * weighted by a power law and the nth derivative of the 
 * (spherical) bessel function. Explicitly, this function computes 
 * \tilde{a}(k)= \int \frac{dr}{(xk)^plaw} a(r) (J/j)^(n)_\mu(xk)
@@ -369,11 +367,11 @@ static void general_fht(int npk, int N,
   kcrc = mu+1.0;
   mu = mu+0.5*spherical_bessel;
 
-  fftw_plan forward_plan, reverse_plan;
+  fftw_plan forward_plan = NULL, reverse_plan = NULL;
   double L = log(k[N-1]/k[0]) * N/(N-1.);
   double complex* ulocal = NULL;
   if(u == NULL) {
-    
+
       kcrc = goodkr_new_deriv(N, mu, q, L, spherical_bessel, bessel_deriv,plaw, kcrc);
 
     ulocal = malloc (sizeof(complex double)*N);
@@ -386,8 +384,8 @@ static void general_fht(int npk, int N,
     }
   }
 
-  fftw_complex* a_tmp;
-  fftw_complex* b_tmp;
+  fftw_complex* a_tmp = NULL;
+  fftw_complex* b_tmp = NULL;
   if(*status == 0) {
     a_tmp = fftw_alloc_complex(N);
     if(a_tmp==NULL)
@@ -500,10 +498,8 @@ static void general_fht(int npk, int N,
     } //end omp parallel
   }
 
-  if(*status == 0) {
-    fftw_destroy_plan(forward_plan);
-    fftw_destroy_plan(reverse_plan);
-  }
+  if(forward_plan != NULL) fftw_destroy_plan(forward_plan);
+  if(reverse_plan != NULL) fftw_destroy_plan(reverse_plan);
 
   free(ulocal);
   //TODO: free this up

{pyccl-3.3.2 → pyccl-3.3.4}/src/ccl_power.c

@@ -129,10 +129,12 @@ static ccl_f2d_t *ccl_compute_linpower_analytic(ccl_cosmology* cosmo, void* par,
       y2d[j] += log_sigma8;
   }
 
+  // Free the first spline unconditionally; re-allocate with normalisation only on success.
+  // Without this, ccl_sigma8 failure above would leak the first psp_out.
+  ccl_f2d_t_free(psp_out);
+  psp_out = NULL;
+
   if(*status==0) {
-    // Free the previous P(k,a) spline, and allocate a new one to store the
-    // properly-normalized P(k,a)
-    ccl_f2d_t_free(psp_out);
     psp_out = ccl_f2d_t_new(na,z,nk,x,y2d,NULL,NULL,0,
                             1,2,ccl_f2d_cclgrowth,1,0,2,
                             ccl_f2d_3,status);