FromArray

class hmf.core.transfer_models.FromArray(*, tail_decay_ln_k=1.0, k: Any, t: Any, t_tot: Any | None = None)[source]

A transfer function given as arrays.

t is the transfer function of the CDM + baryon field; t_tot, if given, that of total matter (else the same as t). Neither needs to be normalised. The table has at least 4 nodes, at finite, positive, strictly increasing k, and finite, positive T; it is checked when the model is built (a ValueError otherwise), and used as given, every node included. Beyond the table, T(k) is extrapolated as for every table (see TabulatedTransfer), and the Transfer stage emits an HMFExtrapolationWarning (once per stage instance).

Parameters:
  • tail_decay_ln_k (float, default 1.0) – Above the table’s largest wavenumber, T(k) follows the EH98 no-wiggle shape, rescaled to match the table’s value and logarithmic slope at the join. The tilt correction decays over this many e-folds in k.

  • k (Quantity) – Wavenumbers (at least 4), positive and strictly increasing: a Quantity in h-units (e.g. k * hmf.core.units.h_Mpc), stored in h/Mpc.

  • t (tuple[float, ...]) – The CDM + baryon transfer function at k.

  • t_tot (tuple[float, ...] | None, default None) – The total-matter transfer function at k; None means the same as t.

Attributes

k: Quantity
t: tuple[float, ...]
t_tot: tuple[float, ...] | None
alias: ClassVar[str | None] = 'FromArray'

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

backend: ClassVar[str | None] = None

The Boltzmann code that computes the model ("camb" or "class"), if any.

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] = None

The calibration domain of the class, with its source (None if it was not calibrated): that of its default parameters. Ask an instance for calibration.

parameter_source: ClassVar[str] = ''

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, ...]] = ()

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

tail_decay_ln_k: float
valid_domain: ClassVar[Domain] = Domain(bounds=(('k', Interval(lower=0.0, upper=inf, unit=Unit("littleh / Mpc"), lower_open=True, upper_open=True)),), source='T(k) is defined for k > 0.')

any k > 0. The Transfer stage checks k against the model’s class’s domain, so a model can narrow it.

Type:

Where the model can be evaluated

Methods

check_cosmology(cosmology: FLRW) → None

Raise if the model does not apply to cosmology (by default it does).

Raises:

ValueError – If it does not apply: a model that does not apply to a cosmology is a configuration error.

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 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

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

classmethod qualified_name() → str

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

solve(cosmology: FLRW, k_accuracy: KAccuracy, *, disk_cache: DiskCache | None = None) → TransferSolution

Compute the transfer function (see TransferModel.solve()).