pyccl 3.3.0__py3-none-any.whl

pyccl/.gitignore

@@ -0,0 +1 @@
+_version.py

pyccl/CMakeLists.txt

@@ -0,0 +1,42 @@
+#
+# Builds the python module
+#
+include(BuildSWIG)
+include(UseSWIG)
+#set (UseSWIG_TARGET_NAME_PREFERENCE STANDARD)
+
+find_package(PythonLibsNew ${PYTHON_VERSION})
+find_package(NumPy)
+include_directories(BEFORE ${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIRS})
+
+# We also build a static library only for linking the python module
+add_library(ccl_static STATIC $<TARGET_OBJECTS:objlib>)
+target_link_libraries(ccl_static ${GSL_LIBRARIES} ${CLASS_LIBRARIES} ${FFTW_LIBRARIES} m)
+add_dependencies(ccl_static ccl)
+
+# Adds these extra depencies before building SWIG interface, to ensure that SWIG
+# will be built first if need, same goes for GSL (through ccl_static)
+set(SWIG_MODULE_ccllib_EXTRA_DEPS ccl_static)
+if(NOT SWIG_FOUND)
+  set(SWIG_MODULE_ccllib_EXTRA_DEPS ${SWIG_MODULE_ccllib_EXTRA_DEPS} SWIG)
+endif()
+
+# Builds swig python module in place
+if(${CMAKE_VERSION} VERSION_LESS "3.8.0")
+  swig_add_module(ccllib python ccl.i)
+else()
+  swig_add_library(ccllib TYPE SHARED LANGUAGE python SOURCES ccl.i)
+endif()
+swig_link_libraries(ccllib ccl_static)
+
+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
+    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/__init__.py

@@ -0,0 +1,47 @@
+# flake8: noqa E402
+from importlib.metadata import version, PackageNotFoundError
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    pass  # not installed
+del version, PackageNotFoundError
+
+# Set the environment variable for default config path
+from os import environ, path
+if environ.get("CLASS_PARAM_DIR") is None:
+    environ["CLASS_PARAM_DIR"] = path.dirname(path.abspath(__file__))
+del environ, path
+
+# Patch for deprecated alias in Numpy >= 1.20.0 (used in ISiTGR & FAST-PT).
+# Deprecation cycle starts in Numpy 1.20 and ends in Numpy 1.24.
+from packaging.version import parse
+import numpy
+numpy.int = int if parse(numpy.__version__) >= parse("1.20.0") else numpy.int
+del parse, numpy
+
+from . import ccllib as lib
+from .errors import *
+from ._core import *
+from .pyutils import *
+
+from .background import *
+from .power import *
+
+from .tracers import *
+from .cells import *
+from .correlations import *
+from .covariances import *
+
+from .pk2d import *
+from .tk3d import *
+
+from .boltzmann import *
+from .baryons import *
+from .neutrinos import *
+from .emulators import *
+from .nonlimber import *
+
+from . import halos
+from . import nl_pt
+
+from .cosmology import *

pyccl/_core/__init__.py

@@ -0,0 +1,4 @@
+from .parameters import *
+from .caching import *
+from .schema import *
+from .deprecations import *

pyccl/_core/caching.py

@@ -0,0 +1,303 @@
+__all__ = ("hash_", "Caching", "cache", "CacheInfo", "CachedObject",)
+
+import sys
+import functools
+from collections import OrderedDict
+from inspect import signature
+from _thread import RLock
+
+import numpy as np
+
+
+def _to_hashable(obj):
+    """Make unhashable objects hashable in a consistent manner."""
+
+    if isinstance(obj, (int, float, str)):
+        # Strings and Numbers are hashed directly.
+        return obj
+
+    elif hasattr(obj, "__iter__"):
+        # Encapsulate all the iterables to quickly discard as needed.
+
+        if isinstance(obj, np.ndarray):
+            # Numpy arrays: Convert the data buffer to a byte string.
+            return obj.tobytes()
+
+        elif isinstance(obj, dict):
+            # Dictionaries: Build a tuple from key-value pairs,
+            # where all values are converted to hashables.
+            out = {key: _to_hashable(value) for key, value in obj.items()}
+            # Sort unordered dictionaries for hash consistency.
+            if isinstance(obj, OrderedDict):
+                return tuple(out.items())
+            return tuple(sorted(out.items()))
+
+        else:
+            # Iterables: Build a tuple from values converted to hashables.
+            out = [_to_hashable(item) for item in obj]
+            return tuple(out)
+
+    elif hasattr(obj, "__hash__"):
+        # Hashables: Just return the object.
+        return obj
+
+    # NotImplemented: Can't hash safely, so raise TypeError.
+    # Note: This will never be triggered since `type` has a repr slot wrapper.
+    raise TypeError(f"Hashing for {type(obj)} not implemented.")
+
+
+def hash_(obj):
+    """Generic hash method, which changes between processes."""
+    digest = hash(repr(_to_hashable(obj))) + sys.maxsize + 1
+    return digest
+
+
+class _CachingMeta(type):
+    """Implement ``property`` to a ``classmethod`` for ``Caching``."""
+    # NOTE: Only in 3.8 < py < 3.11 can `classmethod` wrap `property`.
+    # https://docs.python.org/3.11/library/functions.html#classmethod
+    @property
+    def maxsize(cls):
+        return cls._maxsize
+
+    @maxsize.setter
+    def maxsize(cls, value):
+        if value < 0:
+            raise ValueError(
+                "`maxsize` should be larger than zero. "
+                "To disable caching, use `Caching.disable()`.")
+        cls._maxsize = value
+        for func in cls._cached_functions:
+            func.cache_info.maxsize = value
+
+    @property
+    def policy(cls):
+        return cls._policy
+
+    @policy.setter
+    def policy(cls, value):
+        if value not in cls._policies:
+            raise ValueError("Cache retention policy not recognized.")
+        if value == "lfu" != cls._policy:
+            # Reset counter if we change policy to lfu
+            # otherwise new objects are prone to being discarded immediately.
+            # Now, the counter is not just used for stats,
+            # it is part of the retention policy.
+            for func in cls._cached_functions:
+                for item in func.cache_info._caches.values():
+                    item.reset()
+        cls._policy = value
+        for func in cls._cached_functions:
+            func.cache_info.policy = value
+
+
+class Caching(metaclass=_CachingMeta):
+    """Infrastructure to hold cached objects.
+
+    Caching is used for pre-computed objects that are expensive to compute.
+
+    Attributes:
+        maxsize (``int``):
+            Maximum number of caches to store. If the dictionary is full, new
+            caches are assigned according to the set cache retention policy.
+        policy (``'fifo'``, ``'lru'``, ``'lfu'``):
+            Cache retention policy.
+    """
+    _enabled: bool = False
+    _policies: list = ['fifo', 'lru', 'lfu']
+    _default_maxsize: int = 128   # class default maxsize
+    _default_policy: str = 'lru'  # class default policy
+    _maxsize = _default_maxsize   # user-defined maxsize
+    _policy = _default_policy     # user-defined policy
+    _cached_functions: list = []
+
+    @classmethod
+    def _get_key(cls, func, *args, **kwargs):
+        """Calculate the hex hash from arguments and keyword arguments."""
+        # get a dictionary of default parameters
+        params = func.cache_info._signature.parameters
+        # get a dictionary of the passed parameters
+        passed = {**dict(zip(params, args)), **kwargs}
+        # discard the values equal to the default
+        defaults = {param: value.default for param, value in params.items()}
+        return hex(hash_({**defaults, **passed}))
+
+    @classmethod
+    def _get(cls, dic, key, policy):
+        """Get the cached object container
+        under the implemented caching policy.
+        """
+        obj = dic[key]
+        if policy == "lru":
+            dic.move_to_end(key)
+        # update stats
+        obj.increment()
+        return obj
+
+    @classmethod
+    def _pop(cls, dic, policy):
+        """Remove one cached item as per the implemented caching policy."""
+        if policy == "lfu":
+            keys = list(dic)
+            idx = np.argmin([item.counter for item in dic.values()])
+            dic.move_to_end(keys[idx], last=False)
+        dic.popitem(last=False)
+
+    @classmethod
+    def _decorator(cls, func, maxsize, policy):
+        # assign caching attributes to decorated function
+        func.cache_info = CacheInfo(func, maxsize=maxsize, policy=policy)
+        func.clear_cache = func.cache_info._clear_cache
+        cls._cached_functions.append(func)
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if not cls._enabled:
+                return func(*args, **kwargs)
+
+            key = cls._get_key(func, *args, **kwargs)
+            # shorthand access
+            caches = func.cache_info._caches
+            maxsize = func.cache_info.maxsize
+            policy = func.cache_info.policy
+
+            with RLock():
+                if key in caches:
+                    # output has been cached; update stats and return it
+                    out = cls._get(caches, key, policy)
+                    func.cache_info.hits += 1
+                    return out.item
+
+            with RLock():
+                while len(caches) >= maxsize:
+                    # output not cached and no space available, so remove
+                    # items as per the caching policy until there is space
+                    cls._pop(caches, policy)
+
+            # cache new entry and update stats
+            out = CachedObject(func(*args, **kwargs))
+            caches[key] = out
+            func.cache_info.misses += 1
+            return out.item
+
+        return wrapper
+
+    @classmethod
+    def cache(cls, func=None, *, maxsize=_maxsize, policy=_policy):
+        """Cache the output of the decorated function, using the input
+        arguments as a proxy to build a hash key.
+
+        Arguments:
+            func (``function``):
+                Function to be decorated.
+            maxsize (``int``):
+                Maximum cache size for the decorated function.
+            policy (``'fifo'``, ``'lru'``, ``'lfu'``):
+                Cache retention policy. When the storage reaches maxsize
+                decide which cached object will be deleted. Default is 'lru'.\n
+                'fifo': first-in-first-out,\n
+                'lru': least-recently-used,\n
+                'lfu': least-frequently-used.
+        """
+        if maxsize < 0:
+            raise ValueError(
+                "`maxsize` should be larger than zero. "
+                "To disable caching, use `Caching.disable()`.")
+        if policy not in cls._policies:
+            raise ValueError("Cache retention policy not recognized.")
+
+        if func is None:
+            # `@cache` with parentheses
+            return functools.partial(
+                cls._decorator, maxsize=maxsize, policy=policy)
+        # `@cache()` without parentheses
+        return cls._decorator(func, maxsize=maxsize, policy=policy)
+
+    @classmethod
+    def enable(cls):
+        cls._enabled = True
+
+    @classmethod
+    def disable(cls):
+        cls._enabled = False
+
+    @classmethod
+    def reset(cls):
+        cls.maxsize = cls._default_maxsize
+        cls.policy = cls._default_policy
+
+    @classmethod
+    def clear_cache(cls):
+        [func.clear_cache() for func in cls._cached_functions]
+
+
+cache = Caching.cache
+
+
+class CacheInfo:
+    """Cache info container.
+    Assigned to cached function as ``function.cache_info``.
+
+    Parameters:
+        func (``function``):
+            Function in which an instance of this class will be assigned.
+        maxsize (``Caching.maxsize``):
+            Maximum number of caches to store.
+        policy (``Caching.policy``):
+            Cache retention policy.
+
+    .. note:: To assist in deciding an optimal ``maxsize`` and ``policy``,
+              instances of this class contain the following attributes:
+              - ``hits``: number of times the function has been bypassed.
+              - ``misses``: number of times the function has computed
+              something.
+              - ``current_size``: current size of the cache dictionary.
+    """
+
+    def __init__(self, func, maxsize=Caching.maxsize, policy=Caching.policy):
+        # we store the signature of the function on import
+        # as it is the most expensive operation (~30x slower)
+        self._signature = signature(func)
+        self._caches = OrderedDict()
+        self.maxsize = maxsize
+        self.policy = policy
+        self.hits = self.misses = 0
+
+    @property
+    def current_size(self):
+        return len(self._caches)
+
+    def __repr__(self):
+        s = f"<{self.__class__.__name__}>"
+        for par, val in self.__dict__.items():
+            if not par.startswith("_"):
+                s += f"\n\t {par} = {val!r}"
+        s += f"\n\t current_size = {self.current_size!r}"
+        return s
+
+    def _clear_cache(self):
+        self._caches = OrderedDict()
+        self.hits = self.misses = 0
+
+
+class CachedObject:
+    """A cached object container.
+
+    Attributes:
+        counter (``int``):
+            Number of times the cached item has been retrieved.
+    """
+    counter: int = 0
+
+    def __init__(self, obj):
+        self.item = obj
+
+    def __repr__(self):
+        s = f"CachedObject(counter={self.counter})"
+        return s
+
+    def increment(self):
+        self.counter += 1
+
+    def reset(self):
+        self.counter = 0

pyccl/_core/deprecations.py

@@ -0,0 +1,73 @@
+__all__ = ("deprecated", "deprecate_attr",)
+
+import functools
+import warnings
+
+from .. import CCLDeprecationWarning
+
+
+def deprecated(new_function=None):
+    """This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used. If there is a replacement function,
+    pass it as `new_function`.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            s = f"The function {func.__qualname__} is deprecated."
+            if new_function:
+                s += f" Use {new_function.__qualname__} instead."
+            warnings.warn(s, CCLDeprecationWarning)
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def deprecate_attr(getter=None, *, pairs=[]):
+    """This decorator can be used to deprecate attributes,
+    warning users about it and pointing them to the new attribute.
+
+    Parameters
+    ----------
+    getter : slot wrapper ``__getattribute__``
+        This is the getter method to be decorated.
+    pairs : list of pairs
+        List of renaming pairs ``('old', 'new')``.
+
+    Example
+    -------
+    We have the legacy attribute ``old_name`` which we want to rename
+    to ``new_name``. To achieve this we decorate the ``__getattribute__``
+    method of the parent class in the main class body to retrieve the
+    ``__getattr__`` method for the main class, like so:
+
+    >>>  __getattr__ = deprecate_attr([('old_name', 'new_name')])(
+             super.__getattribute__)
+
+    Now, every time the attribute is called via its old name, the user will
+    be warned about the renaming, and the attribute value will be returned.
+
+    .. note:: Make sure that you bind ``__getattr__`` to the decorator,
+              rather than ``__getattribute__``, because ``__getattr__``
+              provides the fallback mechanism we want to use. Otherwise,
+              an infinite recursion will initiate.
+
+    """
+    if getter is None:
+        return functools.partial(deprecate_attr, pairs=pairs)
+
+    rename = dict(pairs)
+
+    @functools.wraps(getter)
+    def wrapper(cls, name):
+        if name in rename:
+            new_name = rename[name]
+            class_name = cls.__class__.__name__
+            warnings.warn(
+                f"Attribute {name} is deprecated in {class_name}. "
+                f"Pass the new name {new_name}.", CCLDeprecationWarning)
+            name = new_name
+
+        return cls.__getattribute__(name)
+    return wrapper

pyccl/_core/parameters/__init__.py

@@ -0,0 +1,3 @@
+from .parameters_base import *
+from .cosmology_params import *
+from .fftlog_params import *

pyccl/_core/parameters/cosmology_params.py

@@ -0,0 +1,21 @@
+__all__ = ("CosmologyParams",)
+
+from ... import lib
+from . import CCLParameters
+
+
+class CosmologyParams(CCLParameters, factory=lib.parameters):
+    """Instances of this class hold cosmological parameters."""
+
+    def __getattribute__(self, key):
+        if key == "m_nu":
+            N_nu_mass = self._instance.N_nu_mass
+            nu_masses = lib.parameters_get_nu_masses(self._instance, N_nu_mass)
+            return nu_masses.tolist()
+        return super().__getattribute__(key)
+
+    def __setattr__(self, key, value):
+        if key == "m_nu":
+            self._instance.N_nu_mass = len(value)
+            return lib.parameters_m_nu_set_custom(self._instance, value)
+        super().__setattr__(key, value)

pyccl/_core/parameters/fftlog_params.py

@@ -0,0 +1,100 @@
+__all__ = ("FFTLogParams",)
+
+
+class FFTLogParams:
+    """Objects of this class store the FFTLog accuracy parameters.
+    See documentation in :meth:`update_parameters` for a full
+    description of all allowed parameters.
+    """
+    #: Anti-aliasing. Factor mulitplying the lower boundary.
+    padding_lo_fftlog = 0.1
+    #: Anti-aliasing. Factor mulitplying the upper boundary.
+    padding_hi_fftlog = 10.
+
+    #: Samples per decade for the Hankel transforms.
+    n_per_decade = 100
+    #: Extrapolation type (`linx_liny`, `linx_logy` etc.).
+    extrapol = "linx_liny"
+
+    #: Padding for intermediate transforms (lower bound).
+    padding_lo_extra = 0.1
+    #: Padding for intermediate transforms (upper bound).
+    padding_hi_extra = 10.
+    #: If True, high precision intermediate transforms.
+    large_padding_2D = False
+
+    #: Power law index used to prewhiten data before transform.
+    plaw_fourier = -1.5
+    #: Pre-whitening power law index for 2D and cumulative profiles.
+    plaw_projected = -1.0
+
+    @property
+    def params(self):
+        return ["padding_lo_fftlog", "padding_hi_fftlog", "n_per_decade",
+                "extrapol", "padding_lo_extra", "padding_hi_extra",
+                "large_padding_2D", "plaw_fourier", "plaw_projected"]
+
+    def to_dict(self):
+        """ Returns a dictionary containing this object's parameters.
+        """
+        return {param: getattr(self, param) for param in self.params}
+
+    def __getitem__(self, name):
+        return getattr(self, name)
+
+    def __setattr__(self, name, value):
+        raise AttributeError("FFTLogParams can only be updated via "
+                             "`updated_parameters`.")
+
+    def __repr__(self):
+        return repr(self.to_dict())
+
+    def __eq__(self, other):
+        if self is other:
+            True
+        if type(self) is not type(other):
+            return False
+        return self.to_dict() == other.to_dict()
+
+    def update_parameters(self, **kwargs):
+        """Update the precision of FFTLog for the Hankel transforms.
+
+        Arguments
+        ---------
+        padding_lo_fftlog: :obj:`float`
+            Factor by which the minimum scale is multiplied to avoid
+            aliasing. Default: 0.1.
+        padding_hi_fftlog: :obj:`float`
+            Factor by which the maximum scale is multiplied to avoid
+            aliasing. Default: 10.
+        n_per_decade : :obj:`float`
+            Samples per decade for the Hankel transforms. Default: 100.
+        extrapol : {'linx_liny', 'linx_logy'}
+            Extrapolation type when FFTLog has narrower output support.
+            Default ``'linx_liny'``.
+        padding_lo_extra: :obj:`float`
+            Additional minimum scale padding for double Hankel transforms,
+            used when computing 2D projected and cumulative profiles. In
+            these, the first transform goes from 3D real space to
+            Fourier, and the second transform goes from Fourier to 2D
+            real space.
+            Default: 0.1.
+        padding_hi_extra: :obj:`float`
+            As ``padding_lo_extra`` for the maximum scale.
+            Default: 10.
+        large_padding_2D : :obj:`bool`
+            Override ``padding_xx_extra`` in the intermediate transform,
+            and use ``padding_xx_fftlog``. The default is False.
+        plaw_fourier: :obj:`float`
+            FFTLog pre-whitens its arguments (makes them flatter) to avoid
+            aliasing. The ``plaw_fourier`` parameter describes the tilt of
+            the profile, :math:`P(r) \\propto r^{\\mathrm{tilt}}`, for
+            standard 3D transforms. Default: -1.5
+        plaw_fourier_projected: :obj:`float`
+            As ``plaw_fourier`` for 2D transforms (when computing 2D
+            projected or cumulative profiles. Default: -1.0.
+        """
+        for name, value in kwargs.items():
+            if name not in self.params:
+                raise AttributeError(f"Parameter {name} does not exist.")
+            object.__setattr__(self, name, value)