MassVariance

class hmf.core.mass_variance.MassVariance(*, power: PowerSource, filter: object = NOTHING, mass_accuracy: MassAccuracy = NOTHING, k_accuracy: KAccuracy = NOTHING, truncation_rtol=0.001)

The mass variance sigma(m) of the unnormalised linear power at z = 0, and its slope.

See the module documentation for the mass lattice behind it. The results do not depend on sigma8 (the power is unnormalised) or on redshift: those enter later.

Examples

>>> import numpy as np
>>> from hmf.core.power_source import TabulatedPower
>>> from hmf.core.units import Msun_h, h_Mpc, power_unit, rho_unit
>>> k = np.logspace(-5, 3, 400)
>>> source = TabulatedPower(
...     k=k * h_Mpc, pk=1e4 * k / (1 + (k / 0.02) ** 2.5) ** 1.6 * power_unit,
...     mean_density=8.5e10 * rho_unit,
... )
>>> mv = MassVariance(power=source, filter="TopHat")
>>> s = mv.sigma([1e10, 1e12, 1e14] * Msun_h)
>>> bool(np.all(np.diff(s) < 0))
True

Parameters:

• power (hmf.core.power_source.PowerSource) – The source of the unnormalised linear power at z = 0 (a PowerSource).

• filter (hmf.core.filters.Filter, default computed) – The smoothing filter: a Filter instance, or the alias of one (e.g. ‘SharpK’).

• mass_accuracy (hmf.core.accuracy.MassAccuracy, default computed) – The settings of the mass lattice.

• k_accuracy (hmf.core.accuracy.KAccuracy, default computed) – The settings of the k grid. Its upper end is set from mass_accuracy.log10_m_min.

• truncation_rtol (float, default 0.001) – The largest bound on the relative error in sigma or dln(sigma)/dln(m), from truncating the k integrals at the ends of the grid, accepted for a mass. Masses beyond it raise a DomainError.

Attributes

power: PowerSource

filter: Filter

mass_accuracy: MassAccuracy

k_accuracy: KAccuracy

truncation_rtol: float

valid_domain

Methods

dlnsigma_dlnm(m: Any) → ndarray[tuple[Any, ...], dtype[float64]]

The logarithmic slope dln(sigma)/dln(m) (independent of the normalisation of the power).

Parameters:

m (Quantity) – Masses, in Msun/h (or Msun, if the power source has an H0).

Returns:

dln(sigma)/dln(m), dimensionless, of the shape of m (a scalar for a scalar m).

Return type:

numpy.float64 or ndarray

Raises:

DomainError – As for sigma().

evolve(**changes: Any) → Self

Return a copy of this stage with some fields changed.

The copy is built (and so validated) by the constructor. If that fails, the error propagates and this stage, which is immutable, is unchanged. Cached results are not copied: the new stage computes its own.

Parameters:

**changes – New values of fields, by name.

Returns:

A new stage of the same class.

Return type:

Stage

Raises:

TypeError – If a name is not a field of this stage (with suggestions).

classmethod fields_info() → tuple[FieldInfo, ...]

Describe this class’s fields, without creating an instance.

Returns:

The name, type, default and documentation of each field.

Return type:

tuple of FieldInfo

ln_sigma_and_slope_kernel(m: ArrayLike) → tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]

ln(sigma) and dln(sigma)/dln(m) at masses in Msun/h, at kernel level.

The values of sigma() (as its ln) and dlnsigma_dlnm(), from one lookup of the lattice, on plain arrays in canonical units, for library code (see hmf.core._kernels). Results do not depend on the batch size, or on the order of requests. The results for the latest few arrays of masses are remembered (not as part of the stage’s value), and returned again, read-only, for the same masses.

Parameters:

m – Masses in Msun/h: a plain array, of any shape.

Returns:

ln_sigma, dlnsigma_dlnm – Dimensionless, with the shape of m; read-only.

Return type:

numpy.ndarray

Raises:

DomainError – As for sigma() (a mass outside valid_domain is found from the extent of m).

ln_sigma_at_radius_kernel(r: ArrayLike) → ndarray[tuple[Any, ...], dtype[float64]]

ln(sigma) at filter radii in Mpc/h, evaluated directly, at kernel level.

The integral for sigma at each radius, with this stage’s filter, power and k grid, without the mass lattice: so it is not limited to the lattice’s range (mass_accuracy.extension does not apply), and does not interpolate. It agrees with ln_sigma_and_slope_kernel() at the radius’s mass to INTERPOLATION_RTOL at the default settings. For sigma_8, use a TopHat stage at R = 8 Mpc/h. Nothing is memoised.

Parameters:

r – Filter radii in Mpc/h: a plain array, of any shape.

Returns:

ln(sigma), dimensionless, with the shape of r.

Return type:

numpy.ndarray

Raises:

DomainError – If a radius is not finite and > 0, the k grid can’t resolve the integrals there, or sigma is not finite there (see the module documentation).

m_from_radius(r: Any) → ndarray[tuple[Any, ...], dtype[float64]]

The mass of a filter radius: m = (4π/3) rho_cb (cR)³, with the filter’s c.

rho_cb is the mean density of CDM + baryons today (the power source’s rho_mean0).

Parameters:

r (Quantity) – Radii, in Mpc/h (or Mpc, if the power source has an H0).

Returns:

Masses, in Msun/h.

Return type:

Quantity

Raises:

DomainError – If a radius is not finite and > 0.

m_from_radius_kernel(r: ArrayLike) → ndarray[tuple[Any, ...], dtype[float64]]

The mass of a filter radius, at kernel level: see m_from_radius().

Parameters:

r – Filter radii in Mpc/h: a plain array, of any shape.

Returns:

Masses in Msun/h, with the shape of r.

Return type:

numpy.ndarray

Raises:

DomainError – If a radius is not finite and > 0.

m_from_sigma(sigma: Any) → ndarray[tuple[Any, ...], dtype[float64]]

The mass at which sigma(m) takes the given values: the inverse of sigma().

sigma(m) is inverted on the lattice nodes of the default range [mass_accuracy.log10_m_min, mass_accuracy.log10_m_max], then within the bracketing interval by bisection on the sigma interpolant, so m_from_sigma(sigma(m)) returns m to about 1e-12.

Parameters:

sigma (float or array_like) – Values of sigma (dimensionless, unnormalised as in sigma()).

Returns:

Masses, in Msun/h.

Return type:

Quantity

Raises:

DomainError – If a value is outside valid_domain (not finite and > 0), is outside the range of sigma on the default lattice range, or sigma(m) is not monotonically decreasing where the value is crossed.

m_from_sigma_kernel(sigma: ArrayLike) → ndarray[tuple[Any, ...], dtype[float64]]

The mass at which sigma(m) takes the given values, at kernel level.

The inverse of ln_sigma_and_slope_kernel()’s sigma: see m_from_sigma().

Parameters:

sigma – Values of sigma (dimensionless, unnormalised as in sigma()): a plain array, of any shape.

Returns:

Masses in Msun/h, with the shape of sigma.

Return type:

numpy.ndarray

Raises:

DomainError – As for m_from_sigma() (a value that is not finite and > 0 is found from the extent of sigma).

radius_from_m(m: Any) → ndarray[tuple[Any, ...], dtype[float64]]

The filter radius of a mass: the inverse of m_from_radius().

Parameters:

m (Quantity) – Masses, in Msun/h (or Msun, if the power source has an H0).

Returns:

Radii, in Mpc/h.

Return type:

Quantity

Raises:

DomainError – If a mass is not finite and > 0.

radius_from_m_kernel(m: ArrayLike) → ndarray[tuple[Any, ...], dtype[float64]]

The filter radius of a mass, at kernel level: see radius_from_m().

Any mass > 0 has a radius: the lattice’s range does not apply.

Parameters:

m – Masses in Msun/h: a plain array, of any shape.

Returns:

Radii in Mpc/h, with the shape of m.

Return type:

numpy.ndarray

Raises:

DomainError – If a mass is not finite and > 0.

sigma(m: Any) → ndarray[tuple[Any, ...], dtype[float64]]

The mass variance sigma(m) of the unnormalised linear power at z = 0.

Parameters:

m (Quantity) – Masses, in Msun/h (or Msun, if the power source has an H0).

Returns:

sigma, dimensionless, of the shape of m (a scalar for a scalar m).

Return type:

numpy.float64 or ndarray

Raises:

DomainError – If a mass is outside valid_domain (not finite and > 0, or outside the lattice with extension='raise'), can’t be resolved by the k grid, or sigma is not finite there.