ST

class hmf.core.fits.ST(*, a=0.707, p=0.3, A=None)[source]

The Sheth-Tormen mass function: the same model as SMT, under its other name.

Parameters:
  • a (float, default 0.707) – The parameter a (rescales nu^2).

  • p (float, default 0.3) – The low-mass slope parameter p (< 0.5).

  • A (float | None, default None) – The amplitude; None for the value that normalises the fit to unit mass.

Model metadata

alias: ClassVar[str | None] = 'ST'

The short name the model is registered under, if any. Set by the alias class keyword; never inherited.

calibration

Where this model was calibrated, with its source (None if it was not).

The class’s calibration_domain, unless it depends on the instance’s parameters.

calibration_domain: ClassVar[Domain | None] = Domain(bounds=(('z', Interval(lower=0.0, upper=4.0, unit=None, lower_open=False, upper_open=False)),), source='Sheth & Tormen 1999, Fig. 2 caption: GIF simulations at z = 0, 0.5, 1, 2, 4. sigma / mass range: not stated (the Fig. 2 data span roughly -1.1 < ln(1/sigma) < 0.85). Cosmologies: SCDM, OCDM and LCDM GIF runs (Sec. 3).')

Where the fit was calibrated against simulations, with its source; None for a fit that was not calibrated (e.g. an analytic one). Ask an instance for calibration.

measured_mass_definition: ClassVar[MassDefinition] = SOVirial()

The halo mass definition the fit was measured in (see “Mass definitions” in the module documentation).

measured_mass_definition_note: ClassVar[str] = 'Sheth & Tormen 1999, Sec. 3: a spherical-overdensity group finder (Tormen 1998). Sheth, Mo & Tormen 2001, Sec. 4.1, instead associate a = 0.707 with FoF(b=0.2).'

Where measured_mass_definition comes from in the paper, and anything else worth knowing about it (halo finder, unbinding, …).

modifies_dndm: ClassVar[bool] = False

Whether modify_dndm_kernel() changes the mass function (see “Post-processing the mass function” in the module documentation); if False, it is the identity.

normalized

Whether the amplitude is the normalising one (A is None).

parameter_source: ClassVar[str] = 'Sheth & Tormen 1999, eq. 10 (a = 0.707, p = 0.3); A from the normalisation (Sheth, Mo & Tormen 2001, eq. 5: A = 0.3222).'

The exact source (paper, version, table or equation) of the parameter defaults, e.g. “Tinker et al. 2008, ApJ 688, 709 (published), Table 2”.

references: ClassVar[tuple[str, ...]] = ('Sheth, R. K., Mo, H. J., Tormen, G., 2001. MNRAS 323, 1. https://doi.org/10.1046/j.1365-8711.2001.04006.x', 'Sheth, R. K., Tormen, G., 1999. MNRAS 308, 119. https://doi.org/10.1046/j.1365-8711.1999.02692.x')

References to cite when the model is used, each a formatted citation.

requires: ClassVar[frozenset[str]] = frozenset({'delta_c'})

The inputs (from INPUTS) that fsigma() needs, besides sigma.

simulations: ClassVar[SimulationDetails | None] = SimulationDetails(box_size=<Quantity [ 84.5, 141.3, 141.3] Mpc / littleh>, n_particles=(16777216, 16777216, 16777216), omega_m=(1.0, 0.3, 0.3), omega_b=None, sigma_8=None, h=(0.5, 0.7, 0.7), n_s=None, softening=None, transfer=None, z_start=None, initial_conditions=None, halo_finder='SO (Tormen 1998)', n_min=None, z_range=(0.0, 4.0), names=('SCDM', 'OCDM', 'LCDM'), notes='The GIF simulations; OCDM has Omega_Lambda = 0, LCDM 0.7. sigma_8, softening, transfer function and starting redshift: not stated (hmf 3.x took them from Jenkins et al. 2001, Table 1).', source='Sheth & Tormen 1999, Sec. 3 and Fig. 2.')

The simulations the fit was calibrated on (None for a fit to no simulations).

valid_domain: ClassVar[Domain] = Domain(bounds=(('delta_c', Interval(lower=0.0, upper=inf, unit=None, lower_open=True, upper_open=True)), ('sigma', Interval(lower=0.0, upper=inf, unit=None, lower_open=True, upper_open=True))), source='sigma > 0 and delta_c > 0.')

fsigma() raises outside it.

Type:

Where the formula is defined or sensible

Methods

check_required(x: FitInputs) → None

Raise if an input needed to evaluate the fit is missing from x.

Parameters:

x – The inputs.

Raises:

ValueError – If an input in requires (or needed to check valid_domain) is missing.

check_valid(x: FitInputs) → None

Raise if any input is outside valid_domain.

Parameters:

x – The inputs.

Raises:

DomainError – Always, if any value is outside the valid domain: this does not depend on any policy.

classmethod coerce(value: object) → Self

Convert a value to a model of this kind: the converter of a model field.

Parameters:

value – An instance of cls, which is returned as it is; or a name, import path or class that get() accepts, which is looked up and instantiated with its default parameters.

Returns:

An instance of cls.

Return type:

Model

Raises:
  • ModelNotFoundError – If value is a name that no model of this kind is known by.

  • TypeError – If value is of any other type, or names a class that is not a concrete subclass of cls.

Examples

>>> from hmf.core.filters import Filter, TopHat
>>> Filter.coerce("TopHat") == TopHat()
True
classmethod domain_inputs() → frozenset[str]

The inputs (besides sigma) needed to evaluate the fit and check both domains.

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

fsigma(sigma: ArrayLike, *, z: ArrayLike | None = None, omega_m_z: ArrayLike | None = None, delta_halo: ArrayLike | None = None, delta_c: ArrayLike | None = None, n_eff: ArrayLike | None = None, m: ArrayLike | None = None) → ndarray[tuple[Any, ...], dtype[float64]]

The multiplicity function, \(f(\sigma) = \nu f(\nu)\).

m must be a Quantity (see hmf.core.units); every other input is dimensionless. Code that already has plain arrays in canonical units calls fsigma_kernel() or evaluate_fsigma() instead (see “Evaluating a fit” in the module documentation). It applies no calibration policy (see evaluate_fsigma() for that), but always checks valid_domain.

Parameters:
  • sigma – \(\sigma(m, z)\).

  • z – Redshift.

  • omega_m_z – \(\Omega_m(z)\).

  • delta_halo – The halo overdensity relative to the mean density.

  • delta_c – The critical overdensity for collapse.

  • n_eff – The effective spectral index.

  • m – The halo mass, a Quantity (e.g. in Msun_h).

Returns:

\(f(\sigma)\) (dimensionless), broadcast over the inputs.

Return type:

numpy.ndarray

Raises:
  • ValueError – If an input the fit requires is not given.

  • UnitBoundaryError – If m is not a Quantity.

  • DomainError – If any input is outside valid_domain, or makes the fit’s parameters unphysical.

fsigma_kernel(x: FitInputs) → ndarray[tuple[Any, ...], dtype[float64]]

fsigma() at kernel level, from inputs that are plain arrays.

The inputs are in canonical units (the mass in Msun/h); see hmf.core._kernels. It checks the valid domain, as fsigma() does, and applies no calibration policy (see evaluate_fsigma()).

Parameters:

x – The inputs.

Return type:

numpy.ndarray

Raises:
  • ValueError – If an input the fit requires is not in x.

  • DomainError – As for fsigma().

classmethod get(name: str | type[Model]) → type[Self]

Look up a model of this kind.

Parameters:

name – An alias ("Tinker08"), a qualified name ("hmf.core.fits:Tinker08"), an import path to a class not yet imported ("pkg.mod:Cls" or "pkg.mod.Cls"), or a class.

Returns:

The model class (not an instance). It is always a subclass of cls.

Return type:

type

Raises:
  • ModelNotFoundError – If no model of this kind is known by name, even after loading the hmf.models entry points and trying name as an import path.

  • TypeError – If name resolves to something that is not a concrete subclass of cls.

classmethod get_aliases() → Mapping[str, str]

Return a read-only mapping from alias to qualified name, for this kind.

classmethod get_models() → Mapping[str, type[Self]]

Return the registered models of this kind, by qualified name.

Plugins advertised in the hmf.models entry-point group are loaded first.

Returns:

A read-only mapping from qualified name to class. Called on a kind, it is a live view of the registry. Called on a non-kind subclass, it holds only the models that subclass it.

Return type:

Mapping

in_calibration_domain_kernel(x: FitInputs) → bool | ndarray[tuple[Any, ...], dtype[bool]]

Whether each input is inside calibration, at kernel level.

It checks x against valid_domain, as fsigma_kernel() does.

Parameters:

x – The inputs, from inputs().

Returns:

A bool if every input is a scalar, else the broadcast array. True if the fit has no calibration domain (it is None).

Return type:

bool or numpy.ndarray of bool

Raises:
  • ValueError – If an input needed to check the domain was not given.

  • DomainError – If any input is outside valid_domain.

inputs(sigma: ArrayLike, *, z: ArrayLike | None = None, omega_m_z: ArrayLike | None = None, delta_halo: ArrayLike | None = None, delta_c: ArrayLike | None = None, n_eff: ArrayLike | None = None, m: ArrayLike | None = None) → FitInputs

Collect the inputs, checking that the required ones are given.

Parameters are as for fsigma() (m is a Quantity). Code that already has plain arrays in canonical units calls inputs_from_arrays() instead (see “Evaluating a fit” in the module documentation).

Parameters:
  • sigma – \(\sigma(m, z)\).

  • z – As for fsigma().

  • omega_m_z – As for fsigma().

  • delta_halo – As for fsigma().

  • delta_c – As for fsigma().

  • n_eff – As for fsigma().

  • m – The halo mass, a Quantity (e.g. in Msun_h).

Returns:

The inputs as plain arrays, in canonical units.

Return type:

FitInputs

Raises:
inputs_from_arrays(sigma: ArrayLike, *, z: ArrayLike | None = None, omega_m_z: ArrayLike | None = None, delta_halo: ArrayLike | None = None, delta_c: ArrayLike | None = None, n_eff: ArrayLike | None = None, m: ArrayLike | None = None) → FitInputs

Collect inputs that are plain arrays, checking that the required ones are given.

The one place where a FitInputs is filled in: inputs(), fsigma() and library code (e.g. a mass-function Stage) all build theirs here. It does not check the values against valid_domain: fsigma_kernel() and evaluate_fsigma() do.

Parameters:
  • sigma – \(\sigma(m, z)\) (dimensionless).

  • z – As for fsigma() (dimensionless); None if not given.

  • omega_m_z – As for fsigma() (dimensionless); None if not given.

  • delta_halo – As for fsigma() (dimensionless); None if not given.

  • delta_c – As for fsigma() (dimensionless); None if not given.

  • n_eff – As for fsigma() (dimensionless); None if not given.

  • m – The halo mass in Msun/h, a plain array; None if not given.

Returns:

The inputs as float arrays.

Return type:

FitInputs

Raises:

ValueError – If an input in requires (or needed to check valid_domain) is missing.

modify_dndm(m: Any, dndm: Any, *, z: ArrayLike, ngtm: Any, H0: Any, omega_m0: ArrayLike) → Any

Map the mass function computed from fsigma() to the fit’s.

The identity unless modifies_dndm (see “Post-processing the mass function” in the module documentation). Every fit takes the same arguments, whether it uses them or not. This method converts them and calls modify_dndm_kernel(), which a mass-function Stage calls directly.

Parameters:
  • m – Halo masses, a Quantity: in h-units, or physical units (converted with H0).

  • dndm – The mass function from fsigma(), a Quantity (number density per mass).

  • z – Redshift.

  • ngtm – The cumulative mass function n(>m) from fsigma(), a Quantity.

  • H0 – The Hubble constant, a scalar Quantity (e.g. 70 * H0_unit). It converts physical units, and gives h to fits whose formula is in physical units.

  • omega_m0 – The density parameter of CDM + baryons today.

Returns:

The fit’s mass function, in dndm_unit.

Return type:

Quantity

modify_dndm_kernel(m: ArrayLike, dndm: ArrayLike, *, z: ArrayLike, ngtm: ArrayLike, h: ArrayLike, omega_m0: ArrayLike) → ndarray[tuple[Any, ...], dtype[float64]]

modify_dndm() at kernel level, on plain arrays.

A pure kernel in canonical units (see hmf.core._kernels): the identity, unless the fit sets modifies_dndm (its class documentation describes the correction). All arguments broadcast. It checks the arguments that say where the mass function is evaluated (m, z, h, omega_m0), from their extent; dndm and ngtm are values it maps, and may be NaN (e.g. masked by a domain policy).

Parameters:
  • m – Halo masses, in Msun/h.

  • dndm – The mass function from fsigma(), in h^4 / (Msun Mpc^3).

  • z – Redshift.

  • ngtm – The cumulative mass function n(>m) from fsigma(), in h^3 / Mpc^3.

  • h – The dimensionless Hubble parameter, H0 / (100 km/s/Mpc).

  • omega_m0 – The density parameter of CDM + baryons today.

Returns:

The fit’s mass function, in h^4 / (Msun Mpc^3).

Return type:

numpy.ndarray

Raises:

DomainError – If an m, h or omega_m0 is not finite and > 0, or a z is not finite and >= 0.

classmethod qualified_name() → str

Return this class’s qualified name, package.module:Class.