PyCosmo 2.3.2__tar.gz → 2.3.3__tar.gz

{pycosmo-2.3.2/src/PyCosmo.egg-info → pycosmo-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyCosmo
-Version: 2.3.2
+Version: 2.3.3
 Summary: A multi-purpose cosmology calculation tool
 Author-email: Uwe Schmitt et al <uwe.schmitt@id.ethz.ch>
 License-Expression: GPL-3.0

{pycosmo-2.3.2 → pycosmo-2.3.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyCosmo"
-version = "2.3.2"
+version = "2.3.3"
 license = "GPL-3.0"
 description = "A multi-purpose cosmology calculation tool"
 authors = [{name = "Uwe Schmitt et al", email = "uwe.schmitt@id.ethz.ch"}]

{pycosmo-2.3.2 → pycosmo-2.3.3}/src/PyCosmo/Background.py

@@ -14,6 +14,28 @@
 # You should have received a copy of the GNU General Public License along with this
 # program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""
+Background cosmology: expansion history, distances and thermodynamics.
+
+Unit conventions
+----------------
+Two conventions coexist in this module, so pay attention to the units stated
+in each docstring:
+
+* Geometry / distances are in *physical* Mpc: ``dist_rad_a``, ``dist_trans_a``,
+  ``dist_ang_a`` and ``dist_lum_a`` all return physical Mpc.
+* The sound horizon ``r_s`` is returned in Mpc/h, i.e. its numerical value
+  equals the physical value multiplied by ``h``.
+* The curvature scale is ``c/H0`` in physical Mpc. Be careful with
+  ``params.rh``: it is ``(c/H0) * h``, i.e. the value of ``c/H0`` expressed in
+  units of Mpc/h (numerically ~2997.9, independent of ``h``). It must be
+  divided by ``h`` before it can be combined with the physical-Mpc distances
+  above. Equivalently, the physical curvature scale is ``params.c / params.H0``.
+* Quantities tied to the perturbation/thermodynamics core follow the Mpc/h
+  convention: ``taudot`` is in h/Mpc and the conformal time ``eta`` is in
+  Mpc/h. ``g_a`` converts ``taudot`` back to 1/Mpc by multiplying by ``h``.
+"""
+
 import numpy as np
 from scipy import integrate
 from scipy.interpolate import interp1d
@@ -137,7 +159,10 @@ class Background(object):
 
     def _chi(self, a):
         r"""
-        Calculates the comoving horizon, by calling the CosmologyCore_model.py
+        Calculates the raw comoving horizon integral, by calling the
+        CosmologyCore_model.py. This is the distance divided by the speed of
+        light: multiply the result by ``params.c`` to obtain physical Mpc
+        (see :meth:`dist_rad_a`).
 
         :param a: scale factor [1]
         :return: Radial comoving horizon, :math:`\chi(a)`, in :math:`[Mpc s/km]`.
@@ -160,18 +185,23 @@ class Background(object):
         """
 
         Dc = self.dist_rad_a(a)
+        # Dc is in physical Mpc, so the curvature scale must be c/H0 in physical
+        # Mpc as well. Note that params.rh = c/H0 * h is in Mpc/h, i.e. it is the
+        # h-independent value of c/H0; using it here would introduce a spurious
+        # 1/h factor in the sinh/sin argument.
+        c_over_H0 = self._params.c / self._params.H0
         if self._params.omega_k == 0.0:
             Dm = Dc
         elif self._params.omega_k > 0.0:
             Dm = (
-                self._params.rh
-                * np.sinh(self._params.sqrtk * Dc / self._params.rh)
+                c_over_H0
+                * np.sinh(self._params.sqrtk * Dc / c_over_H0)
                 / self._params.sqrtk
             )
         elif self._params.omega_k < 0.0:
             Dm = (
-                self._params.rh
-                * np.sin(self._params.sqrtk * Dc / self._params.rh)
+                c_over_H0
+                * np.sin(self._params.sqrtk * Dc / c_over_H0)
                 / self._params.sqrtk
             )
         return Dm
@@ -219,6 +249,14 @@ class Background(object):
         return self._eta_to_a(eta)
 
     def eta(self, a):
+        r"""
+        Calculates the conformal time :math:`\eta(a)`. Note that this follows
+        the Mpc/h convention of the perturbation/thermodynamics core (it is the
+        physical conformal time multiplied by ``h``).
+
+        :param a: scale factor [1]
+        :return: Conformal time, :math:`\eta(a)`, in :math:`[Mpc/h]`.
+        """
         a = np.atleast_1d(a)
         af = a[a > 1e-100]
         af = np.concatenate(([1e-100], af))
@@ -356,6 +394,10 @@ class Background(object):
         r"""
         Calculates the sound horizon at drag epoch.
 
+        Note the unit: the returned value is in Mpc/h, i.e. it equals the
+        physical sound horizon (in Mpc) multiplied by ``h``. This differs from
+        the physical-Mpc distances returned by e.g. :meth:`dist_rad_a`.
+
         :return: sound horizon [:math:`\mathrm{Mpc} / h`]
         """
         a_log = np.logspace(np.log10(2e-4), np.log10(2e-3), 200)

{pycosmo-2.3.2 → pycosmo-2.3.3}/src/PyCosmo/Cosmo.py

@@ -509,9 +509,11 @@ class Cosmo(object):
         derived_parameters.H0 = (
             100.0 * params.h * nudge[0]
         )  # Hubble constant [km/s/Mpc]
-        derived_parameters.rh = (
-            params.c / derived_parameters.H0 * params.h
-        )  # Hubble radius (=c/H0) at z=0 [h^-1 Mpc]
+        # Hubble radius rh = c/H0 at z=0, expressed in units of h^-1 Mpc. The
+        # factor h makes the numerical value h-independent (~2997.9); the
+        # physical scale is c/H0 = rh / h in Mpc. Do not combine rh directly
+        # with quantities in physical Mpc (see the units note in Background.py).
+        derived_parameters.rh = params.c / derived_parameters.H0 * params.h
         # critical density at z=0 [h^2 M_sun Mpc^-3]
         derived_parameters.rho_crit = (
             3.0
@@ -769,12 +771,12 @@ class Cosmo(object):
 
         DERIVED_INFO = dict(
             _sigma_27="Dimensionless CMB temperature [1]",
-            _z_equality="Redshift of matter-radiation equlity [1]",
+            _z_equality="Redshift of matter-radiation equality [1]",
             _z_drag="Redshift of drag epoch [1]",
-            _k_eq="Particle horizon at equality epoch [Mpc-1]",
-            _sound_horiz="Sound horizon [Mpc-1]",
+            _k_eq="Wavenumber at matter-radiation equality [Mpc^-1]",
+            _sound_horiz="Sound horizon [Mpc]",
             H0="Hubble constant (H0) [km/s/Mpc]",
-            rh="Hubble radius (rh) [Mpc/h]",
+            rh="Hubble radius (c/H0, value in h^-1 Mpc) [Mpc/h]",
             rho_crit="Critical Density (rho_crit) [h^2 M_sun/Mpc^3]",
             omega_dm="Dark Matter density (omega_dm) [1]",
             omega_gamma="Photon density (omega_gamma) [1]",

{pycosmo-2.3.2 → pycosmo-2.3.3}/src/PyCosmo/LinearPerturbationApprox.py

@@ -61,6 +61,15 @@ class LinearPerturbationApprox(LinearPerturbationBase):
     def max_redshift(self, k):
         """computes max redshift for which this model is applicable.
 
+        The matter-era start used for the growth integration and for the
+        tabulation grids is the scale factor at which the matter density
+        fraction is maximal.  For a closed universe (``omega_k < 0``) the
+        negative-curvature term lowers :math:`E^2(a)` at late times and thereby
+        inflates :math:`\\Omega_m(a)`, moving the maximum to a spurious, late
+        scale factor.  The curvature term is therefore dropped when locating
+        the maximum, so that the onset of matter domination is found
+        independently of curvature.
+
         :param k: wavenumber k, introduced in the abstract base class since this
                   might be needed for some models.
                   [:math:`h Mpc^{-1}`]
@@ -68,7 +77,13 @@ class LinearPerturbationApprox(LinearPerturbationBase):
         """
         k = np.atleast_1d(k)
         avec = np.linspace(1e-4, 1, 10000)
-        ai = avec[np.argmax(self._background._omega_m_a(avec))]
+        if self._params.omega_k < 0.0:
+            e2 = self._background._H2_H02_a(a=avec)
+            e2 -= self._background._H2_H02_Omegak_a(a=avec)
+            omega_m_a = self._background._H2_H02_Omegam_a(a=avec) / e2
+            ai = avec[np.argmax(omega_m_a)]
+        else:
+            ai = avec[np.argmax(self._background._omega_m_a(avec))]
         return (1 / ai - 1).repeat(len(k))
 
     def _D1(self, a=1.0, norm=0):
@@ -91,8 +106,19 @@ class LinearPerturbationApprox(LinearPerturbationBase):
         a_start = min(
             np.concatenate((a, np.array([ai])))
         )  # initial condition for integration
-        if a_start < ai:
-            raise ValueError(f"initial a_start={a_start} too high (at max {ai})")
+        # The matter-era initial conditions used below are valid throughout the
+        # matter era, i.e. also for a below ``ai = 1/(1+max_redshift)``, which is
+        # only the location of the maximum of Omega_m(a).  Refuse to start only
+        # once radiation dominates, where those initial conditions break down.
+        # (For closed or low-Omega_Lambda cosmologies ``ai`` is pushed to late
+        # times, so growth_a(a < ai) used to fail even though ``a`` is still
+        # well inside the matter era.)
+        a_eq = getattr(self._params, "a_eq", np.nan)
+        if np.isfinite(a_eq) and a_start < a_eq:
+            raise ValueError(
+                f"initial a_start={a_start} is below matter-radiation equality "
+                f"a_eq={a_eq}"
+            )
 
         a = np.atleast_1d(a)
         a_out = np.concatenate((np.array([a_start]), a, np.array([1.0])))
@@ -208,7 +234,11 @@ class LinearPerturbationApprox(LinearPerturbationBase):
         OL = 1.0 - Om  # flat complement, NOT omega_l (which includes radiation)
         x = -OL * a**3 / Om
         x1 = -OL / Om
-        return a * special.hyp2f1(1.0 / 3, 1.0, 11.0 / 6, x) / special.hyp2f1(1.0 / 3, 1.0, 11.0 / 6, x1)
+        return (
+            a
+            * special.hyp2f1(1.0 / 3, 1.0, 11.0 / 6, x)
+            / special.hyp2f1(1.0 / 3, 1.0, 11.0 / 6, x1)
+        )
 
     def transfer_k(self, k):
         r"""

{pycosmo-2.3.2 → pycosmo-2.3.3}/src/PyCosmo/Obs.py

@@ -447,6 +447,9 @@ class Obs(object):
         chi = cosmo.background.dist_rad_a(a=a_temp)
         chi_a = cosmo.background.dist_rad_a(a=a_vec)
         rchi_a = cosmo.background.dist_trans_a(a=a_vec)
+        # chi is in physical Mpc, so the curvature scale is c/H0 in physical Mpc.
+        # params.rh = c/H0 * h is in Mpc/h and must not be used with physical Mpc.
+        c_over_H0 = cosmo.params.c / cosmo.params.H0
 
         for i in range(len(a_vec)):
             if cosmo.params.omega_k == 0.0:
@@ -457,21 +460,20 @@ class Obs(object):
                 integrand = (
                     pz[: anum + i]
                     * np.sin(
-                        cosmo.params.sqrtk
-                        * (chi[: anum + i] - chi_a[i])
-                        / cosmo.params.rh
+                        cosmo.params.sqrtk * (chi[: anum + i] - chi_a[i]) / c_over_H0
                     )
-                    / np.sin(cosmo.params.sqrtk * chi[: anum + i] / cosmo.params.rh)
+                    / np.sin(cosmo.params.sqrtk * chi[: anum + i] / c_over_H0)
                 )
             else:
+                # Open universe (omega_k > 0, negative curvature): the transverse
+                # comoving distance is R*sinh(chi/R), so both the numerator (the
+                # lens-to-source distance) and the denominator must use sinh.
                 integrand = (
                     pz[: anum + i]
-                    * np.sin(
-                        cosmo.params.sqrtk
-                        * (chi[: anum + i] - chi_a[i])
-                        / cosmo.params.rh
+                    * np.sinh(
+                        cosmo.params.sqrtk * (chi[: anum + i] - chi_a[i]) / c_over_H0
                     )
-                    / np.sinh(cosmo.params.sqrtk * chi[: anum + i] / cosmo.params.rh)
+                    / np.sinh(cosmo.params.sqrtk * chi[: anum + i] / c_over_H0)
                 )
 
             wind = np.trapezoid(integrand, a_temp[: anum + i])