Skip to main content
`Ctrl`+`K`

# FLRW

class astropy.cosmology.FLRW(H0, Om0, Ode0, Tcmb0=Parameter(default=<Quantity 0. K>, derived=False, unit=Unit("K"), equivalencies=[], fvalidate='scalar', doc='Temperature of the CMB at z=0.'), Neff=Parameter(default=3.04, derived=False, unit=None, equivalencies=[], fvalidate='non-negative', doc='Number of effective neutrino species.'), m_nu=Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), equivalencies=[(Unit("kg"), Unit("J"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / m2"), Unit("J / m2"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / m3"), Unit("J / m3"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / s"), Unit("J / s"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>)], fvalidate=<function FLRW.m_nu>, doc='Mass of neutrino species.'), Ob0=Parameter(default=0.0, derived=False, unit=None, equivalencies=[], fvalidate=<function FLRW.Ob0>, doc='Omega baryon; baryonic matter density/critical density at z=0.'), *, name=None, meta=None)

  Bases: `Cosmology`, `BaryonComponent`, `TotalComponent`, `CriticalDensity`, `MatterComponent`, `CurvatureComponent`, `DarkEnergyComponent`, `HubbleParameter`, `PhotonComponent`, `NeutrinoComponent`, `ScaleFactor`, `DarkMatterComponent`, `TemperatureCMB`

  An isotropic and homogeneous (Friedmann-Lemaitre-Robertson-Walker) cosmology.

  This is an abstract base class – you cannot instantiate examples of this class, but must work with one of its subclasses, such as `LambdaCDM` or `wCDM`.

  Parameters:
    H0 `python:float` or scalar astropy:quantity-like [:ref: ‘frequency’]

      Hubble constant at z = 0. If a float, must be in [km/sec/Mpc].

    Om0 `python:float`

      Omega matter: density of non-relativistic matter in units of the critical density at z=0. Note that this does not include massive neutrinos.

    Ode0 `python:float`

      Omega dark energy: density of dark energy in units of the critical density at z=0.

    Tcmb0 `python:float` or scalar astropy:quantity-like [:ref: ‘temperature’], optional

      Temperature of the CMB z=0. If a float, must be in [K]. Default: 0 [K]. Setting this to zero will turn off both photons and neutrinos (even massive ones).

    Neff `python:float`, optional

      Effective number of Neutrino species. Default 3.04.

    m_nu astropy:quantity-like [:ref: ‘energy’, :ref: ‘mass’] or numpy:array_like, optional

      Mass of each neutrino species in [eV] (mass-energy equivalency enabled). If this is a scalar Quantity, then all neutrino species are assumed to have that mass. Otherwise, the mass of each species. The actual number of neutrino species (and hence the number of elements of m_nu if it is not scalar) must be the floor of Neff. Typically this means you should provide three neutrino masses unless you are considering something like a sterile neutrino.

    Ob0 `python:float`, optional

      Omega baryons: density of baryonic matter in units of the critical density at z=0.

    name `python:str` or `python:None` (optional, keyword-only)

      Name for this cosmological object.

    meta python:mapping or `python:None` (optional, keyword-only)

      Metadata for the cosmology, e.g., a reference.

  Notes

  Class instances are immutable – you cannot change the parameters’ values. That is, all of the above attributes (except meta) are read only.

  For details on how to create performant custom subclasses, see the documentation on Speeding up Integrals in Custom Cosmologies.

  Attributes Summary

  `H0` | Hubble Parameter at redshift 0.
  `Neff` | Number of effective neutrino species.
  `Ob0` | Omega baryons: density of baryonic matter in units of the critical density at z=0.
  `Ode0` | Omega dark energy; dark energy density/critical density at z=0.
  `Odm0` | Omega dark matter; dark matter density/critical density at z=0.
  `Ogamma0` | Omega gamma; the density/critical density of photons at z=0.
  `Ok0` | Omega curvature; the effective curvature density/critical density at z=0.
  `Om0` | Omega matter; matter density/critical density at z=0.
  `Onu0` | Omega nu; the density/critical density of neutrinos at z=0.
  `Otot0` | Omega total; the total density/critical density at z=0.
  `Tcmb0` | Temperature of the CMB at z=0.
  `Tnu0` | Temperature of the neutrino background as |Quantity| at z=0.
  `critical_density0` | Critical mass density at z=0.
  `from_format` | Transform object to a `Cosmology`.
  `h` | Dimensionless Hubble constant: h = H_0 / 100 [km/sec/Mpc].
  `has_massive_nu` | Does this cosmology have at least one massive neutrino species?
  `hubble_distance` | Hubble distance.
  `hubble_time` | Hubble time.
  `is_flat` | Return `bool`; `True` if the cosmology is globally flat.
  `m_nu` | Mass of neutrino species.
  `meta` |
  `name` | The name of the cosmology realization, e.g. 'Planck2018' or `None`.
  `parameters` | Immutable mapping of the Parameters.
  `read` | Read and parse data to a `Cosmology`.
  `scale_factor0` | Scale factor at redshift 0.
  `to_format` | Transform this Cosmology to another format.
  `write` | Write this Cosmology object out in the specified format.

  Methods Summary

  `H`(z, /) | Hubble parameter at redshift `z`.
  `Ob`(z, /) | Return the density parameter for baryonic matter at redshift `z`.
  `Ode`(z, /) | Return the density parameter for dark energy at redshift `z`.
  `Odm`(z, /) | Return the density parameter for dark matter at redshift `z`.
  `Ogamma`(z, /) | Return the density parameter for photons at redshift `z`.
  `Ok`(z, /) | Return the equivalent density parameter for curvature at redshift `z`.
  `Om`(z, /) | Return the density parameter for non-relativistic matter at redshift `z`.
  `Onu`(z) | Return the density parameter for neutrinos at redshift `z`.
  `Otot`(z, /) | The total density parameter at redshift `z`.
  `Tcmb`(z, /) | Compute the CMB temperature at redshift `z`.
  `Tnu`(z) | Return the neutrino temperature at redshift `z`.
  `abs_distance_integrand`(z, /) | Integrand of the absorption distance (eq.
  `absorption_distance`(z, /) | Absorption distance at redshift `z` (eq.
  `age`(z, /) | Age of the universe in Gyr at redshift `z`.
  `angular_diameter_distance`(z[, z2]) | Angular diameter distance between objects at 2 redshifts.
  `angular_diameter_distance_z1z2`(z1, z2) |
  `arcsec_per_kpc_comoving`(z, /) | Angular separation in arcsec equal to a comoving kpc at redshift `z`.
  `arcsec_per_kpc_proper`(z, /) | Angular separation in arcsec corresponding to a proper kpc at redshift `z`.
  `clone`(*[, meta]) | Returns a copy of this object with updated parameters, as specified.
  `comoving_distance`(z[, z2]) | Comoving line-of-sight distance \(d_c(z1, z2)\) in Mpc.
  `comoving_transverse_distance`(z, /) | Comoving transverse distance in Mpc at a given redshift.
  `comoving_volume`(z, /) | Comoving volume in cubic Mpc at redshift `z`.
  `critical_density`(z, /) | Critical density in grams per cubic cm at redshift `z`.
  `de_density_scale`(z, /) | Evaluates the redshift dependence of the dark energy density.
  `differential_comoving_volume`(z, /) | Differential comoving volume at redshift z.
  `distmod`(z, /) | Distance modulus at redshift `z`.
  `efunc`(z, /) | Function used to calculate H(z), the Hubble parameter.
  `inv_efunc`(z, /) | Inverse of `efunc`.
  `is_equivalent`(other, /, *[, format]) | Check equivalence between Cosmologies.
  `kpc_comoving_per_arcmin`(z, /) | Separation in transverse comoving kpc equal to an arcmin at redshift `z`.
  `kpc_proper_per_arcmin`(z, /) | Separation in transverse proper kpc equal to an arcminute at redshift `z`.
  `lookback_distance`(z, /) | The lookback distance is the light travel time distance to a given redshift.
  `lookback_time`(z, /) | Lookback time in Gyr to redshift `z`.
  `lookback_time_integrand`(z, /) | Integrand of the lookback time (equation 30 of [1]).
  `luminosity_distance`(z, /) | Luminosity distance in Mpc at redshift `z`.
  `nu_relative_density`(z) | Neutrino density function relative to the energy density in photons.
  `scale_factor`(z, /) | Compute the scale factor at redshift `z`.
  `w`(z, /) | The dark energy equation of state.

  Attributes Documentation

  H0

    Hubble Parameter at redshift 0.

  Neff

    Number of effective neutrino species.

  Ob0

    Omega baryons: density of baryonic matter in units of the critical density at z=0.

  Ode0

    Omega dark energy; dark energy density/critical density at z=0.

  Odm0

    Omega dark matter: dark matter density/critical density at z=0.

  Ogamma0

    Omega gamma; the density/critical density of photons at z=0.

  Ok0

    Omega curvature; the effective curvature density/critical density at z=0.

  Om0

    Omega matter; matter density/critical density at z=0.

  Onu0

    Omega nu; the density/critical density of neutrinos at z=0.

  Otot0

    Omega total; the total density/critical density at z=0.

  Tcmb0

    Temperature of the CMB at z=0.

  Tnu0

    Temperature of the neutrino background as |Quantity| at z=0.

    Returns:
      Tnu0 `Quantity` [:ref: ‘temperature’]

        The neutrino temperature at z=0 in Kelvin.

    Notes

    The neutrino temperature is related to the CMB temperature by:

    \[T_{\nu 0} = \left(\frac{4}{11}\right)^{1/3} T_{CMB}\]

    This comes from the decoupling of neutrinos before electron-positron annihilation. See Weinberg ‘Cosmology’ p 154 eq (3.1.21).

  critical_density0

    Critical density at redshift 0.

  from_format

    Transform object to a `Cosmology`.

    This function provides the Cosmology interface to the Astropy unified I/O layer. This allows easily parsing supported data formats using syntax such as:

        >>> from astropy.cosmology import Cosmology
        >>> cosmo1 = Cosmology.from_format(cosmo_mapping, format='mapping')

    When the `from_format` method is called from a subclass the subclass will provide a keyword argument `cosmology=<class>` to the registered parser. The method uses this cosmology class, regardless of the class indicated in the data, and sets parameters’ default values from the class’ signature.

    Get help on the available readers using the `help()` method:

        >>> Cosmology.from_format.help()  # Get help and list supported formats
        >>> Cosmology.from_format.help('<format>')  # Get detailed help on a format
        >>> Cosmology.from_format.list_formats()  # Print list of available formats

    See also: https://docs.astropy.org/en/stable/io/unified.html

    Parameters:
      obj `object`

        The object to parse according to ‘format’

      *args

        Positional arguments passed through to data parser.

      format `python:str` or `python:None`, optional keyword-only

        Object format specifier. For `None` (default) CosmologyFromFormat tries to identify the correct format.

      **kwargs

        Keyword arguments passed through to data parser. Parsers should accept the following keyword arguments:

        - cosmologythe class (or string name thereof) to use / check when

            constructing the cosmology instance.

    Returns:
      out `Cosmology` subclass instance

        `Cosmology` corresponding to `obj` contents.

  h

    Dimensionless Hubble constant: h = H_0 / 100 [km/sec/Mpc].

  has_massive_nu

    Does this cosmology have at least one massive neutrino species?

  hubble_distance

    Hubble distance.

  hubble_time

    Hubble time.

  is_flat

    Return `bool`; `True` if the cosmology is globally flat.

  m_nu

    Mass of neutrino species.

  meta = None
  name = None

    The name of the cosmology realization, e.g. ‘Planck2018’ or `None`.

  parameters = mappingproxy({'H0': Parameter(derived=False, unit=Unit("km / (Mpc s)"), equivalencies=[], fvalidate='scalar', doc='Hubble constant at z=0.'), 'Om0': Parameter(derived=False, unit=None, equivalencies=[], fvalidate='non-negative', doc='Omega matter; matter density/critical density at z=0.'), 'Ode0': Parameter(derived=False, unit=None, equivalencies=[], fvalidate='float', doc='Omega dark energy; dark energy density/critical density at z=0.'), 'Tcmb0': Parameter(default=<Quantity 0. K>, derived=False, unit=Unit("K"), equivalencies=[], fvalidate='scalar', doc='Temperature of the CMB at z=0.'), 'Neff': Parameter(default=3.04, derived=False, unit=None, equivalencies=[], fvalidate='non-negative', doc='Number of effective neutrino species.'), 'm_nu': Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), equivalencies=[(Unit("kg"), Unit("J"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / m2"), Unit("J / m2"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / m3"), Unit("J / m3"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>), (Unit("kg / s"), Unit("J / s"), <function mass_energy.<locals>.<lambda>>, <function mass_energy.<locals>.<lambda>>)], fvalidate=<function FLRW.m_nu>, doc='Mass of neutrino species.'), 'Ob0': Parameter(default=0.0, derived=False, unit=None, equivalencies=[], fvalidate=<function FLRW.Ob0>, doc='Omega baryon; baryonic matter density/critical density at z=0.')})

    Immutable mapping of the Parameters.

    If accessed from the class, this returns a mapping of the Parameter objects themselves. If accessed from an instance, this returns a mapping of the values of the Parameters.

  read

    Read and parse data to a `Cosmology`.

    This function provides the Cosmology interface to the Astropy unified I/O layer. This allows easily reading a file in supported data formats using syntax such as:

        >>> from astropy.cosmology import Cosmology
        >>> cosmo1 = Cosmology.read('<file name>')

    When the `read` method is called from a subclass the subclass will provide a keyword argument `cosmology=<class>` to the registered read method. The method uses this cosmology class, regardless of the class indicated in the file, and sets parameters’ default values from the class’ signature.

    Get help on the available readers using the `help()` method:

        >>> Cosmology.read.help()  # Get help reading and list supported formats
        >>> Cosmology.read.help(format='<format>')  # Get detailed help on a format
        >>> Cosmology.read.list_formats()  # Print list of available formats

    See also: https://docs.astropy.org/en/stable/io/unified.html

    Parameters:
      *args

        Positional arguments passed through to data reader. If supplied the first argument is typically the input filename.

      format `python:str` (optional, keyword-only)

        File format specifier.

      **kwargs

        Keyword arguments passed through to data reader.

    Returns:
      out `Cosmology` subclass instance

        `Cosmology` corresponding to file contents.

  scale_factor0

    Scale factor at redshift 0.

    The scale factor is defined as \(a = a_0 / (1 + z)\). The common convention is to set \(a_0 = 1\). However, in some cases, like in some old CMB papers, \(a_0\) is used to normalize `a` to be a convenient number at the redshift of interest for that paper. Explicitly using \(a_0\) in both calculation and code avoids ambiguity.

  to_format

    Transform this Cosmology to another format.

    This function provides the Cosmology interface to the astropy unified I/O layer. This allows easily transforming to supported data formats using syntax such as:

        >>> from astropy.cosmology import Planck18
        >>> Planck18.to_format("mapping")
        {'cosmology': astropy.cosmology.core.FlatLambdaCDM,
         'name': 'Planck18',
         'H0': <Quantity 67.66 km / (Mpc s)>,
         'Om0': 0.30966,
         ...

    Get help on the available representations for `Cosmology` using the `help()` method:

        >>> Cosmology.to_format.help()  # Get help and list supported formats
        >>> Cosmology.to_format.help('<format>')  # Get detailed help on format
        >>> Cosmology.to_format.list_formats()  # Print list of available formats

    Parameters:
      format `python:str`

        Format specifier.

      *args

        Positional arguments passed through to data writer. If supplied the first argument is the output filename.

      **kwargs

        Keyword arguments passed through to data writer.

  write

    Write this Cosmology object out in the specified format.

    This function provides the Cosmology interface to the astropy unified I/O layer. This allows easily writing a file in supported data formats using syntax such as:

        >>> from astropy.cosmology import Planck18
        >>> Planck18.write('<file name>')

    Get help on the available writers for `Cosmology` using the `help()` method:

        >>> Cosmology.write.help()  # Get help writing and list supported formats
        >>> Cosmology.write.help(format='<format>')  # Get detailed help on format
        >>> Cosmology.write.list_formats()  # Print list of available formats

    Parameters:
      *args

        Positional arguments passed through to data writer. If supplied the first argument is the output filename.

      format `python:str` (optional, keyword-only)

        File format specifier.

      **kwargs

        Keyword arguments passed through to data writer.

  Methods Documentation

  H(z, /)

    Hubble parameter at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

    Returns:
      H `Quantity` [:ref: ‘frequency’]

        Hubble parameter at each input redshift.

  Ob(z, /)

    Return the density parameter for baryonic matter at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Ob `ndarray`

        The density of baryonic matter relative to the critical density at each redshift.

  Ode(z, /)

    Return the density parameter for dark energy at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Ode `ndarray`

        The density of dark energy relative to the critical density at each redshift.

  Odm(z, /)

    Return the density parameter for dark matter at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Odm `ndarray`

        The density of dark matter relative to the critical density at each redshift.

  Ogamma(z, /)

    Return the density parameter for photons at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Ogamma `array`

        The energy density of photons relative to the critical density at each redshift.

  Ok(z, /)

    Return the equivalent density parameter for curvature at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Ok `ndarray`

        The equivalent density parameter for curvature at each redshift.

        Changed in version 7.2: Always returns a numpy object, never a `float`.

    Examples

        >>> import numpy as np
        >>> from astropy.cosmology import Planck18, units as cu

        >>> Planck18.Ok(2)
        array(0.)

        >>> Planck18.Ok([1, 2])
        array([0., 0.])

        >>> Planck18.Ok(np.array([2]))
        array([0.])

        >>> Planck18.Ok(2 * cu.redshift)
        array(0.)

        >>> cosmo = Planck18.clone(Ode0=0.71, to_nonflat=True)

        >>> cosmo.Ok0
        np.float64(-0.021153694455455927)

        >>> cosmo.Ok(100)
        np.float64(-0.0006557825253017665)

  Om(z, /)

    Return the density parameter for non-relativistic matter at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Om `ndarray`

        The density of non-relativistic matter relative to the critical density at each redshift.

    Notes

    This does not include neutrinos, even if non-relativistic at the redshift of interest.

  Onu(z)

    Return the density parameter for neutrinos at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

    Returns:
      Onu `ndarray`

        The energy density of neutrinos relative to the critical density at each redshift. Note that this includes their kinetic energy (if they have mass), so it is not equal to the commonly used \(\sum \frac{m_{\nu}}{94 eV}\), which does not include kinetic energy.

    Notes

    The neutrino density parameter evolves with redshift according to:

    \[\begin{split}\\Omega_{\\nu}(z) = \\Omega_{\\gamma}(z) \\times f(z)\end{split}\]

    where f(z) is the neutrino-to-photon density ratio computed by nu_relative_density(z). For massless neutrinos, f(z) is constant. For massive neutrinos, f(z) evolves as neutrinos transition from relativistic to non-relativistic.

  Otot(z, /)

    The total density parameter at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshifts.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Otot `array`

        The total density relative to the critical density at each redshift.

  Tcmb(z, /)

    Compute the CMB temperature at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      Tcmb `Quantity` [:ref: ‘temperature’]

        The temperature of the CMB.

    Examples

        >>> import astropy.units as u
        >>> from astropy.cosmology import Planck18, units as cu

        >>> Planck18.Tcmb(u.Quantity([0.5, 1.0], cu.redshift))
        <Quantity [4.08825, 5.451  ] K>

        >>> Planck18.Tcmb(u.Quantity(0.5, ''))
        <Quantity 4.08825 K>

        >>> Planck18.Tcmb(0.5)
        <Quantity 4.08825 K>

        >>> Planck18.Tcmb([0.5, 1.0])
        <Quantity [4.08825, 5.451  ] K>

  Tnu(z)

    Return the neutrino temperature at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

    Returns:
      Tnu `Quantity` [:ref: ‘temperature’]

        The temperature of the cosmic neutrino background in K.

    Notes

    The neutrino temperature scales with redshift as:

    \[T_{\nu}(z) = T_{\nu 0} (1 + z)\]

    This simple scaling applies to both massless and massive neutrinos, as the temperature depends only on the expansion of the universe.

  abs_distance_integrand(z, /)

    Integrand of the absorption distance (eq. 4, [1]).

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      dX `array`

        The integrand for the absorption distance (dimensionless).

    References

    [1]

    Bahcall, John N. and Peebles, P.J.E. 1969, ApJ, 156L, 7B

  absorption_distance(z, /)

    Absorption distance at redshift `z` (eq. 4, [1]).

    This is used to calculate the number of objects with some cross section of absorption and number density intersecting a sightline per unit redshift path [1].

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

    Returns:
      X `array`

        Absorption distance (dimensionless) at each input redshift.

    References

    [1] (1,2)

    Bahcall, John N. and Peebles, P.J.E. 1969, ApJ, 156L, 7B

  age(z, /)

    Age of the universe in Gyr at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      t `Quantity` [:ref: ‘time’]

        The age of the universe in Gyr at each input redshift.

    See also

    `z_at_value`

      Find the redshift corresponding to an age.

  angular_diameter_distance(z, z2=None, /)

    Angular diameter distance between objects at 2 redshifts.

    This gives the proper (sometimes called ‘physical’) transverse distance corresponding to an angle of 1 radian for an object at redshift `z2` as seen by an observer at redshift `z1` ([1], [2], [3]). When one redshift is given the observer is at `z1=0` and `z2=z`.

    The two redshift form is useful for e.g. gravitational lensing for computing the angular diameter distance between a lensed galaxy and the foreground lens.

    Parameters:
      z1, z2 Quantity-like [‘redshift’], numpy:array_like

        Input redshifts. If one argument `z` is given, the distance \(d_A(0, z)\) is returned. If two arguments `z1, z2` are given, the distance \(d_A(z_1, z_2)\) is returned.

        For most practical applications such as gravitational lensing, `z2` should be larger than `z1`. The method will work for `z2 < z1`; however, this will return negative distances.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      d `Quantity` [:ref: ‘length’]

        Angular diameter distance in Mpc at each input redshift.

    References

    [1]

    Weinberg, 1972, pp 420-424; Weedman, 1986, pp 421-424.

    [2]

    Weedman, D. (1986). Quasar astronomy, pp 65-67.

    [3]

    Peebles, P. (1993). Principles of Physical Cosmology, pp 325-327.

  angular_diameter_distance_z1z2(z1, z2)

    Deprecated since version 8.0: Use `angular_diameter_distance(z1, z2)` instead.

    See `angular_diameter_distance(z1, z2)`.

  arcsec_per_kpc_comoving(z, /)

    Angular separation in arcsec equal to a comoving kpc at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      theta `Quantity` [:ref: ‘angle’]

        The angular separation in arcsec corresponding to a comoving kpc at each input redshift.

  arcsec_per_kpc_proper(z, /)

    Angular separation in arcsec corresponding to a proper kpc at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      theta `Quantity` [:ref: ‘angle’]

        The angular separation in arcsec corresponding to a proper kpc at each input redshift.

  clone(*, meta=None, **kwargs)

    Returns a copy of this object with updated parameters, as specified.

    In general this returns an instance of the same class. For some classes (e.g. flat classes like `FlatLambdaCDM`) there are more options, which are documented in the relevant subclass.

    Parameters:
      meta python:mapping or `python:None` (optional, keyword-only)

        Metadata that will update the current metadata.

      **kwargs

        Cosmology parameter (and name) modifications. If any parameter is changed and a new name is not given, the name will be set to “[old name] (modified)”.

    Returns:
      newcosmo `Cosmology` subclass instance

        A new instance of this (or non-flat equivalent) class with updated parameters as specified. If no arguments are given, then a reference to this object is returned instead of a copy.

    Examples

    To make a copy of the `Planck13` cosmology with a different matter density (`Om0`), and a new name:

        >>> from astropy.cosmology import Planck13
        >>> Planck13.clone(name="Modified Planck 2013", Om0=0.35)
        FlatLambdaCDM(name='Modified Planck 2013', H0=<Quantity 67.77 km / (Mpc s)>,
                      Om0=0.35, ...

    If no name is specified, the new name will note the modification.

        >>> Planck13.clone(Om0=0.35).name
        'Planck13 (modified)'

  comoving_distance(z, z2=None, /)

    Comoving line-of-sight distance \(d_c(z1, z2)\) in Mpc.

    The comoving distance along the line-of-sight between two objects remains constant with time for objects in the Hubble flow.

    Parameters:
      z, z2 `Quantity` [‘redshift’]

        Input redshifts. If one argument `z` is given, the distance \(d_c(0, z)\) is returned. If two arguments `z1, z2` are given, the distance \(d_c(z_1, z_2)\) is returned.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z(1), z2 must be positional arguments.

    Returns:
      `Quantity` [:ref: ‘length’]

        Comoving distance in Mpc between each input redshift.

  comoving_transverse_distance(z, /)

    Comoving transverse distance in Mpc at a given redshift.

    This value is the transverse comoving distance at redshift `z` corresponding to an angular separation of 1 radian. This is the same as the comoving distance if \(\Omega_k\) is zero (as in the current concordance Lambda-CDM model).

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

    Returns:
      d `Quantity` [:ref: ‘length’]

        Comoving transverse distance in Mpc at each input redshift.

    Notes

    This quantity is also called the ‘proper motion distance’ in some texts.

  comoving_volume(z, /)

    Comoving volume in cubic Mpc at redshift `z`.

    This is the volume of the universe encompassed by redshifts less than `z`. For the case of \(\Omega_k = 0\) it is a sphere of radius `comoving_distance` but it is less intuitive if \(\Omega_k\) is not.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      V `Quantity` [:ref: ‘volume’]

        Comoving volume in \(Mpc^3\) at each input redshift.

  critical_density(z, /)

    Critical density in grams per cubic cm at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      rho `Quantity` [:ref: ‘mass density’]

        Critical density at each input redshift.

  de_density_scale(z, /)

    Evaluates the redshift dependence of the dark energy density.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      I `ndarray` or `python:float`

        The scaling of the energy density of dark energy with redshift. Returns `float` if the input is scalar.

    Notes

    The scaling factor, I, is defined by \(\rho(z) = \rho_0 I\), and is given by

    \[I = \exp \left( 3 \int_{a}^1 \frac{ da^{\prime} }{ a^{\prime} } \left[ 1 + w\left( a^{\prime} \right) \right] \right)\]

    The actual integral used is rewritten from [1] to be in terms of z.

    It will generally helpful for subclasses to overload this method if the integral can be done analytically for the particular dark energy equation of state that they implement.

    References

    [1]

    Linder, E. (2003). Exploring the Expansion History of the Universe. Phys. Rev. Lett., 90, 091301.

  differential_comoving_volume(z, /)

    Differential comoving volume at redshift z.

    Useful for calculating the effective comoving volume. For example, allows for integration over a comoving volume that has a sensitivity function that changes with redshift. The total comoving volume is given by integrating `differential_comoving_volume` to redshift `z` and multiplying by a solid angle.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      dV `Quantity`

        Differential comoving volume per redshift per steradian at each input redshift.

  distmod(z, /)

    Distance modulus at redshift `z`.

    The distance modulus is defined as the (apparent magnitude - absolute magnitude) for an object at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      distmod `Quantity` [:ref: ‘length’]

        Distance modulus at each input redshift, in magnitudes.

    See also

    `z_at_value`

      Find the redshift corresponding to a distance modulus.

  efunc(z, /)

    Function used to calculate H(z), the Hubble parameter.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      E `array`

        The redshift scaling of the Hubble constant. Defined such that \(H(z) = H_0 E(z)\).

    Notes

    It is not necessary to override this method, but if de_density_scale takes a particularly simple form, it may be advantageous to.

  inv_efunc(z, /)

    Inverse of `efunc`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      E `array`

        The redshift scaling of the inverse Hubble constant.

  is_equivalent(other, /, *, format=False)

    Check equivalence between Cosmologies.

    Two cosmologies may be equivalent even if not the same class. For example, an instance of `LambdaCDM` might have \(\Omega_0=1\) and \(\Omega_k=0\) and therefore be flat, like `FlatLambdaCDM`.

    Parameters:
      other `Cosmology` subclass instance, positional-only

        The object to which to compare.

      format bool or `python:None` or `python:str`, optional keyword-only

        Whether to allow, before equivalence is checked, the object to be converted to a |Cosmology|. This allows, e.g. a |Table| to be equivalent to a Cosmology. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. `format` is broadcast to match the shape of `other`. Note that the cosmology arguments are not broadcast against `format`, so it cannot determine the output shape.

    Returns:
      bool

        True if cosmologies are equivalent, False otherwise.

    Examples

    Two cosmologies may be equivalent even if not of the same class. In this examples the `LambdaCDM` has `Ode0` set to the same value calculated in `FlatLambdaCDM`.

        >>> import astropy.units as u
        >>> from astropy.cosmology import LambdaCDM, FlatLambdaCDM
        >>> cosmo1 = LambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3, 0.7)
        >>> cosmo2 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3)
        >>> cosmo1.is_equivalent(cosmo2)
        True

    While in this example, the cosmologies are not equivalent.

        >>> cosmo3 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3, Tcmb0=3 * u.K)
        >>> cosmo3.is_equivalent(cosmo2)
        False

    Also, using the keyword argument, the notion of equivalence is extended to any Python object that can be converted to a |Cosmology|.

        >>> from astropy.cosmology import Planck18
        >>> tbl = Planck18.to_format("astropy.table")
        >>> Planck18.is_equivalent(tbl, format=True)
        True

    The list of valid formats, e.g. the |Table| in this example, may be checked with `Cosmology.from_format.list_formats()`.

    As can be seen in the list of formats, not all formats can be auto-identified by `Cosmology.from_format.registry`. Objects of these kinds can still be checked for equivalence, but the correct format string must be used.

        >>> tbl = Planck18.to_format("yaml")
        >>> Planck18.is_equivalent(tbl, format="yaml")
        True

  kpc_comoving_per_arcmin(z, /)

    Separation in transverse comoving kpc equal to an arcmin at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      d `Quantity` [:ref: ‘length’]

        The distance in comoving kpc corresponding to an arcmin at each input redshift.

  kpc_proper_per_arcmin(z, /)

    Separation in transverse proper kpc equal to an arcminute at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      d `Quantity` [:ref: ‘length’]

        The distance in proper kpc corresponding to an arcmin at each input redshift.

  lookback_distance(z, /)

    The lookback distance is the light travel time distance to a given redshift.

    It is simply c * lookback_time. It may be used to calculate the proper distance between two redshifts, e.g. for the mean free path to ionizing radiation.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      d `Quantity` [:ref: ‘length’]

        Lookback distance in Mpc

  lookback_time(z, /)

    Lookback time in Gyr to redshift `z`.

    The lookback time is the difference between the age of the Universe now and the age at redshift `z`.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      t `Quantity` [:ref: ‘time’]

        Lookback time in Gyr to each input redshift.

    See also

    `z_at_value`

      Find the redshift corresponding to a lookback time.

  lookback_time_integrand(z, /)

    Integrand of the lookback time (equation 30 of [1]).

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      I `array`

        The integrand for the lookback time.

    References

    [1] (1,2)

    Hogg, D. (1999). Distance measures in cosmology, section 11. arXiv e-prints, astro-ph/9905116.

  luminosity_distance(z, /)

    Luminosity distance in Mpc at redshift `z`.

    This is the distance to use when converting between the bolometric flux from an object at redshift `z` and its bolometric luminosity [1].

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      d `Quantity` [:ref: ‘length’]

        Luminosity distance in Mpc at each input redshift.

    See also

    `z_at_value`

      Find the redshift corresponding to a luminosity distance.

    References

    [1]

    Weinberg, 1972, pp 420-424; Weedman, 1986, pp 60-62.

  nu_relative_density(z)

    Neutrino density function relative to the energy density in photons.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      f `array`

        The neutrino density scaling factor relative to the density in photons at each redshift.

    Notes

    The density in neutrinos is given by

    \[\rho_{\nu} \left(a\right) = 0.2271 \, N_{eff} \, f\left(m_{\nu} a / T_{\nu 0} \right) \, \rho_{\gamma} \left( a \right)\]

    where

    \[f \left(y\right) = \frac{120}{7 \pi^4} \int_0^{\infty} \, dx \frac{x^2 \sqrt{x^2 + y^2}} {e^x + 1}\]

    assuming that all neutrino species have the same mass. If they have different masses, a similar term is calculated for each one. Note that `f` has the asymptotic behavior \(f(0) = 1\). This method returns \(0.2271 f\) using an analytical fitting formula given in Komatsu et al. 2011, ApJS 192, 18.

  scale_factor(z, /)

    Compute the scale factor at redshift `z`.

    The scale factor is defined as \(a = a_0 / (1 + z)\).

    Parameters:
      z Quantity-like [‘redshift’] | numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      |Quantity|

        Scale factor at each input redshift.

  abstractmethod w(z, /)

    The dark energy equation of state.

    Parameters:
      z Quantity-like [‘redshift’], numpy:array_like

        Input redshift.

        Changed in version 7.0: Passing z as a keyword argument is deprecated.

        Changed in version 8.0: z must be a positional argument.

    Returns:
      w `ndarray` or `python:float`

        The dark energy equation of state. `float` if scalar input.

    Notes

    The dark energy equation of state is defined as \(w(z) = P(z)/\rho(z)\), where \(P(z)\) is the pressure at redshift z and \(\rho(z)\) is the density at redshift z, both in units where c=1.

    This must be overridden by subclasses.