diff --git a/docs/source/conf.py b/docs/source/conf.py
index 9d26f7c..4d5dfe5 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -19,7 +19,7 @@
     'sphinx.ext.autodoc',
     'sphinx.ext.doctest',
     'sphinx.ext.intersphinx',
-    'sphinx.ext.autosummary',
+    # 'sphinx.ext.autosummary',
     'myst_parser',
     # 'sphinx_autodoc_typehints',
 ]
@@ -48,3 +48,9 @@
 # napoleon_include_init_with_doc = False
 # napoleon_include_special_with_doc = True
 # napoleon_attr_annotations = True
+
+numpydoc_xref_param_type = True
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+default_role = "obj"
diff --git a/docs/source/glossary.rst b/docs/source/glossary.rst
new file mode 100644
index 0000000..b2d50b7
--- /dev/null
+++ b/docs/source/glossary.rst
@@ -0,0 +1,128 @@
+Glossary
+========
+
+This scientific library assumes from its users a large amount of knowledge and a familiarity with
+a variety of terminology related to the topic. Furthermore, some amount of naming conventions have
+been created here to encode all the necessary functionality in code. This page serves to briefly
+explain and define all the terms used throughout the library, both the ones used as a standard in
+the wider scientific literature, and the ones specified by this library. For more details, please
+see the :doc:`theory` pages.
+
+
+Glossary
+--------
+
+Most relevant terms
+^^^^^^^^^^^^^^^^^^^
+
+.. glossary::
+
+    resolution
+        The ability of an :term:`instrument` to show results in detail. The better the resolution,
+        the higher the detail and the less broad the peaks.
+
+    resolution function
+        A mathematical function that models the :term:`resolution` of an :term:`instrument`, as a
+        function of some physical property, such as energy or momentum.
+
+    instrument
+        A collection of physical devices used to perform an INS experiment. Different instruments are
+        set up to specialise in different kinds of experiments, and so they consist of different devices
+        placed at different distances and made of different materials. This results in different
+        :term:`resolution` profiles.
+
+    version
+        A particular combination of parameters for an :term:`instrument`. Over time, instruments are
+        upgraded by switching out and rearranging their components, resulting in a changed
+        :term:`resolution` (hopefully improved!). For past and future compatibility, every time an
+        upgrade significant enough to alter the :term:`resolution` is done, a new "version" is
+        created for that :term:`instrument`.
+
+    setting
+        A set of :term:`options<option>` that can be made for a particular :term:`version` of a
+        particular :term:`instrument`. This can be, for example, the choice of the
+        :term:`Fermi chopper` parameters.
+
+    option
+        One of the options that can be chosen for a given :term:`setting`. This is tied to a
+        particular :term:`version` of a particular :term:`instrument`. For example, if a
+        :term:`Fermi chopper` is a :term:`setting`, the "option" is one of the choices that can be
+        made for that :term:`Fermi chopper`.
+
+    model
+        A method to represent the :term:`resolution function`. There are different ways of
+        approximating the :term:`resolution function`, each taking into account different levels of
+        detail. The same model can often be used to describe multiple similar
+        :term:`instruments<instrument>` or multiple :term:`versions<version>` of an
+        :term:`instrument`, but in the context of this package, a model can only be accessed through
+        a particular :term:`version` of an :term:`instrument`.
+
+
+Neutron terminology
+^^^^^^^^^^^^^^^^^^^
+
+.. glossary::
+
+    source
+        A device that produces neutrons used for neutron experiments. In practice, this is usually
+        either a nuclear reactor or spallation source (a particle accelerator).
+
+    target
+        A material used in spallation :term:`sources<source>`, which is hit by the particle produced
+        from the accelerator. The collision emits neutrons which are used for the experiments.
+
+    moderator
+        A material used to slow down the neutrons produced by the collision with the :term:`target`.
+
+    beam
+        A collection of neutrons. In nuclear reactor :term:`sources<source>`, this is usually a
+        continuous beam (somewhat similar to a laser beam), while in spallation
+        :term:`sources<source>` this is usually a pulse (a short burst).
+
+    chopper
+        A rotating mechanical device designed to block the neutron :term:`beam` for some fraction of
+        each revolution.
+
+    Fermi chopper
+        A :term:`chopper` designed to select a particular narrow slice of energies from the wide
+        range of energies coming from the moderator. This kind of :term:`chopper` often has multiple
+        openings, allowing the user to make a choice of which energies to use or how good a
+        :term:`resolution` to obtain.
+
+    disk chopper
+        A type of :term:`chopper` shaped like a disk. Can be used for various purposes, such as
+        improving :term:`resolution` or removing contamination, etc.
+
+    sample
+        The material being studied by the neutron experiment. Unless specified otherwise, in this
+        library the term "sample" combines two things: the :term:`sample environment` and the sample
+        itself. The latter is the stuff that the user brings to be studied, in :term:`INS` usually
+        a single crystal or a powder.
+
+    sample environment
+        A device used to enclose the :term:`sample`, usually an aluminium "can". May consist of
+        extra parts, such as a cooling system. Further parts may also be present, such as a vacuum
+        pump or extra experimental devices like a Raman spectrometer, but these are generally not
+        exposed to the neutron :term:`beam` and therefore shouldn't affect the :term:`resolution`.
+
+    detector
+        A device used used to detect the presence of a neutron. These are placed in an array such
+        that the the neutrons that hit the :term:`sample`, hit the detectors, registering where and
+        when the neutron hit the detector.
+
+
+.. _abbreviations:
+
+Abbreviations and Acronyms
+--------------------------
+
+.. glossary::
+
+    INS
+        Inelastic Neutron Scattering
+
+    FWHM
+        Full Width Half Maximum
+
+    FWHH
+        Full Width Half Height
\ No newline at end of file
diff --git a/src/resolution_functions/instrument.py b/src/resolution_functions/instrument.py
index 2f68715..956221c 100644
--- a/src/resolution_functions/instrument.py
+++ b/src/resolution_functions/instrument.py
@@ -1,6 +1,6 @@
 """
-The main entry-point to the library - contains the `Instrument` class used for managing all data ond
-computing resolution functions.
+The main entry-point to the library - contains the `Instrument` class used for managing all data and
+computing :term:`resolution functions<resolution function>`.
 """
 from __future__ import annotations
 
@@ -36,13 +36,13 @@
 
 
 class InvalidInstrumentError(Exception):
-    """An Exception representing an invalid user input for the instrument name."""
+    """An Exception representing an invalid user input for the :term:`instrument` name."""
     pass
 
 
 class InvalidModelError(Exception):
     """
-    An Exception representing an invalid user input for the model of an instrument.
+    An Exception representing an invalid user input for the :term:`model` of an :term:`instrument`.
 
     This class does not support an arbitrary message; instead the message is constructed in here
     from the provided information.
@@ -64,7 +64,8 @@ def __init__(self, provided_name: str, instrument: Instrument):
 
 class InvalidSettingError(Exception):
     """
-    An Exception representing an invalid user input for the setting of a model of an instrument.
+    An Exception representing an invalid user input for the :term:`setting` of a :term:`model` of 
+    an :term:`instrument`.
 
     This class does not support an arbitrary message; instead the message is constructed in here
     from the provided information.
@@ -87,20 +88,22 @@ def __init__(self, provided_name: str, model_name: str, instrument: Instrument):
 
 
 class InvalidVersionError(Exception):
-    """An Exception representing an invalid user input for the version of an instrument."""
+    """An Exception representing an invalid user input for the :term:`version`                                                                         of an instrument."""
     pass
 
 
 @dataclasses.dataclass(init=True, repr=True, frozen=True, slots=True)
 class Instrument:
     """
-    Instrument is a representation of a physical INS instrument, containing all its associated data.
+    Instrument is a representation of a physical :term:`INS` :term:`instrument`, containing all its
+    associated data.
 
-    To be precise, it holds all information about one version of an instrument (for more about
-    instrument versions, see ...), which makes it the centrepiece of this library; the data is
-    necessary for computing the resolution functions.
+    To be precise, it holds all information about one :term:`version` of an :term:`instrument` (for
+    more about :term:`instrument` versions, see ...), which makes it the centrepiece of this
+    library; the data is necessary for computing the
+    :term:`resolution functions<resolution function>`.
 
-    However, this information is static and curated by the library, which is why Instrument is a
+    However, this information is static and curated by the library, which is why `Instrument` is a
     frozen data class. It should never be instantiated directly; instead the `from_default`
     constructor should be used. Similarly, it should not be inspected directly; a variety of methods
     and properties are provided for querying relevant information.
@@ -145,7 +148,7 @@ def __str__(self):
     @classmethod
     def available_instruments(cls) -> list[str]:
         """
-        Lists all INS instruments currently available.
+        Lists all :term:`INS` :term:`instruments<instrument>` currently available.
 
         Returns
         -------
@@ -183,7 +186,8 @@ def _available_versions(cls, path: str) -> tuple[list[str], str]:
     @classmethod
     def available_versions(cls, instrument_name: str) -> tuple[list[str], str]:
         """
-        Lists the names of all versions available for an INS instrument, as well as the default version.
+        Lists the names of all :term:`versions<version>` available for an :term:`INS`
+        :term:`instrument`, as well as the default :term:`version`.
 
         Parameters
         ----------
@@ -276,10 +280,12 @@ def from_file(cls, path: str, version: Optional[str] = None) -> Instrument:
     @classmethod
     def from_default(cls, name: str, version: Optional[str] = None) -> Instrument:
         """
-        Instantiates an `Instrument` class with the data of the `name` INS instrument and its `version`.
+        Instantiates an `Instrument` class with the data of the `name` :term:`INS`
+        :term:`instrument` and its `version`.
 
-        This is the primary, recommended way of instantiating the Instrument class. It loads the
-        instrument data as curated in this library for a particular version of an INS instrument.
+        This is the primary, recommended way of instantiating the `Instrument` class. It loads the
+        instrument data as curated in this library for a particular :term:`version` of an
+        :term:`INS` :term:`instrument`.
 
         Parameters
         ----------
@@ -357,8 +363,8 @@ def get_model_data(self, model_name: Optional[str] = None, **kwargs) -> ModelDat
         """
         Retrieves the physical parameters associated with the specified `model_name`.
 
-        This method can be used for inspecting the parameters of a particular model, but cannot be
-        used to modify them. It returns a subclass of the `ModelData` class corresponding to the
+        This method can be used for inspecting the parameters of a particular :term:`model`, but
+        cannot be used to modify them. It returns a subclass of the `ModelData` class corresponding to the
         particular model. Another use for this method is to inspect the default values for the
         model's parameters, as well as any restrictions that they might have, via the
         `ModelData.restrictions` and `ModelData.defaults` attributes.
@@ -368,7 +374,7 @@ def get_model_data(self, model_name: Optional[str] = None, **kwargs) -> ModelDat
         model_name
             The name of the model whose parameters to retrieve. If not provided, the parameters of
             the default_model will be retrieved.
-        kwargs
+        **kwargs
             Keyword arguments can be passed in to choose an option for each of settings specific to
             the `model_name`. If not provided, default values are used.
 
@@ -437,25 +443,28 @@ def _get_model_data(self, model_name: Optional[str] = None, **kwargs) -> tuple[M
 
     def get_resolution_function(self, model_name: Optional[str] = None, **kwargs) -> InstrumentModel:
         """
-        Generates a resolution function, as modelled by the `model_name` model, for a set of parameters.
+        Generates a :term:`resolution function`, as modelled by the `model_name` :term:`model`, for
+        a set of parameters.
 
         This method is the main use case of the `Instrument` class. It generates a callable object
-        that, when called, returns the resolution of the instrument at an energy value(s).
-
-        However, while a simple, common interface is provided, different models (and sometimes the
-        same model for different instruments!) require different settings to be chosen and different
-        parameters to be provided. All of these have to be passed in as keyword arguments (though
-        sensible defaults are provided). These keyword arguments correspond to physical user choices
-        made when running an INS experiment on the corresponding instrument. For example, direct
-        instruments have a tunable incident energy, so their models usually require an ``e_init``
-        parameter. For more information about a model, please see its corresponding documentation,
+        that, when called, returns the :term:`resolution` of the :term:`instrument` at an energy
+        value(s).
+
+        However, while a simple, common interface is provided, different :term:`models<model>` (and
+        sometimes the same :term:`model` for different :term:`instruments!<instrument>`) require
+        different :term:`settings<setting>` to be chosen and different parameters to be provided.
+        All of these have to be passed in as keyword arguments (though sensible defaults are
+        provided). These keyword arguments correspond to physical user choices made when running an
+        INS experiment on the corresponding :term:`instrument`. For example, direct instruments
+        have a tunable incident energy, so their models usually require an ``e_init`` parameter.
+        For more information about a model, please see its corresponding documentation,
         or for programmatic querying, please see "How to programmatically query model".
 
         Parameters
         ----------
         model_name
             The name of the model to instantiate. If not provided, the `default_model` is used.
-        kwargs
+        **kwargs
             Keyword arguments specifying the various settings and parameters of the `model_name` model
 
         Returns
@@ -467,13 +476,16 @@ def get_resolution_function(self, model_name: Optional[str] = None, **kwargs) ->
         ------
         InvalidModelError
             If the provided `model_name` is not available for this version of this instrument.
+        InvalidInputError
+            If the model has restrictions on its inputs and these have been violated. The
+            restrictions can be checked by using the `get_model_data` method and then viewing the
+            ``restrictions`` attribute of the returned object.
+        Exception
+            Other model-specific exceptions may be raised.
 
         Warnings
         --------
-        Other custom, model-specific errors may be raised, e.g. the PyChop model can raise the
-        ``NoTransmissionError``. Default Python errors are likely to be bugs.
-
-        *Importantly*, if there are any mistakes in the model-specific parameters passed in as
+        If there are any mistakes in the model-specific parameters passed in as
         keyword arguments, they will be silently ignored and the default values for the missing
         parameters will be used.
 
@@ -502,13 +514,14 @@ def get_resolution_function(self, model_name: Optional[str] = None, **kwargs) ->
 
     def get_model_signature(self, model_name: Optional[str] = None) -> Signature:
         """
-        Constructs a call signature for the `get_resolution_function` method with a specific model.
+        Constructs a call signature for the `get_resolution_function` method with a specific
+        :term:`model`.
 
         This method provides a programmatic way of inspecting the call signature of the
-        `get_resolution_function` method required when calling it for the `model_name` model. This
-        is useful because its default signature uses the ``**kwargs`` construct to provide a
-        unified interface, but in fact different models require different sets of parameters that
-        have to be passed in through the keyword arguments.
+        `get_resolution_function` method required when calling it for the `model_name`
+        :term:`model`. This is useful because its default signature uses the ``**kwargs`` construct
+        to provide a unified interface, but in fact different :term:`models<model>` require
+        different sets of parameters that have to be passed in through the keyword arguments.
 
         There are other methods and properties that can be used to inspect some of the options, but
         this method retrieves all the information and returns it as an `inspect.Signature` object
@@ -594,7 +607,8 @@ def get_model_signature(self, model_name: Optional[str] = None) -> Signature:
     @property
     def available_models(self) -> list[str]:
         """
-        A list of all models available for this version of this instrument.
+        A list of all :term:`models<model>` available for this :term:`version` of this
+        :term:`instrument`.
 
         Returns
         -------
@@ -606,9 +620,11 @@ def available_models(self) -> list[str]:
     @property
     def available_models_and_settings(self) -> dict[str, list[str]]:
         """
-        A dictionary mapping each available model to the user settings available for that model.
+        A dictionary mapping each available :term:`model` to the user :term:`settings<setting>`
+        available for that :term:`model`.
 
-        All models available for this version of this instrument, and all their settings are listed.
+        All :term:`models<model>` available for this :term:`version` of this :term:`instrument`,
+        and all their :term:`settings<setting>` are listed.
 
         Returns
         -------
@@ -620,10 +636,12 @@ def available_models_and_settings(self) -> dict[str, list[str]]:
     @property
     def all_available_models_options(self) -> dict[str, dict[str, list[str]]]:
         """
-        A dictionary mapping each available model, to the user settings and its options.
+        A dictionary mapping each available :term:`model`, to the user :term:`settings<setting>`
+        and its :term:`options<option>`.
 
-        All models available for this version of this instrument, all the settings of each of the
-        models, and all the options for each of the settings, are listed.
+        All :term:`models<model>` available for this :term:`version` of this :term:`instrument`, all
+        the :term:`settings<setting>` of each of the :term:`models<model>`, and all the
+        :term:`options<option>` for each of the :term:`settings<setting>`, are listed.
 
         Returns
         -------
@@ -635,7 +653,7 @@ def all_available_models_options(self) -> dict[str, dict[str, list[str]]]:
 
     def possible_settings_for_model(self, model_name: str) -> list[str]:
         """
-        Returns all the settings that the `model_name` model supports.
+        Returns all the :term:`settings<setting>` that the `model_name` :term:`model` supports.
 
         Parameters
         ----------
@@ -661,7 +679,8 @@ def possible_settings_for_model(self, model_name: str) -> list[str]:
 
     def possible_options_for_model(self, model_name: str) -> dict[str, list[str]]:
         """
-        Returns a dictionary mapping all the settings of the `model_name` model to their options.
+        Returns a dictionary mapping all the :term:`settings<setting>` of the `model_name`
+        :term:`model` to their :term:`options<option>`.
 
         Parameters
         ----------
@@ -687,7 +706,8 @@ def possible_options_for_model(self, model_name: str) -> dict[str, list[str]]:
 
     def possible_options_for_model_and_setting(self, model_name: str, setting: str) -> list[str]:
         """
-        Lists all the options that can be chosen for a given `setting` of the `model_name` model.
+        Lists each :term:`option` that can be chosen for a given :term:`setting` of the `model_name`
+        :term:`model`.
 
         Parameters
         ----------
@@ -744,7 +764,8 @@ def _get_options(setting: dict[str, Union[str, dict]]) -> list[str]:
 
     def default_option_for_setting(self, model_name: str, setting: str) -> str:
         """
-        Returns the default option for the `setting` setting of the `model_name` model of this instrument.
+        Returns the default :term:`option` for the `setting` :term:`setting` of the `model_name`
+        :term:`model` of this :term:`instrument`.
 
         Parameters
         ----------
diff --git a/src/resolution_functions/models/__init__.py b/src/resolution_functions/models/__init__.py
index ad71c24..baea30c 100644
--- a/src/resolution_functions/models/__init__.py
+++ b/src/resolution_functions/models/__init__.py
@@ -1,9 +1,9 @@
 """
-Package containing the implementation of the various models.
+Package containing the implementation of the various :term:`models<model>`.
 
 All classes within are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 
 Advanced Use
 ------------
diff --git a/src/resolution_functions/models/panther_abins.py b/src/resolution_functions/models/panther_abins.py
index c66ea8b..7d4e997 100644
--- a/src/resolution_functions/models/panther_abins.py
+++ b/src/resolution_functions/models/panther_abins.py
@@ -1,9 +1,9 @@
 """
-The AbINS model of the PANTHER instrument.
+The AbINS :term:`model` of the PANTHER :term:`instrument`.
 
 All classes within are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 """
 from __future__ import annotations
 
@@ -22,7 +22,7 @@
 @dataclass(init=True, repr=True, frozen=True, slots=True, kw_only=True)
 class PantherAbINSModelData(ModelData):
     """
-    Data for the `PantherAbINSModel` model.
+    Data for the `PantherAbINSModel` :term:`model`.
 
     Parameters
     ----------
@@ -65,18 +65,18 @@ class PantherAbINSModelData(ModelData):
 
 class PantherAbINSModel(InstrumentModel):
     """
-    Model for the PANTHER instrument originating from the AbINS software.
+    Model for the PANTHER :term:`instrument` originating from the AbINS software.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being a Gaussian. This is done by fitting three power-series polynomials (see
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output model being a Gaussian. This is done by fitting three power-series polynomials (see
     `numpy.polynomial.polynomial.Polynomial`) to the resolution curve, where the result of the sum
     of the polynomials is the width (sigma) of the Gaussian. Each polynomial can be of any degree
     ane is given via the `PolynomialModelData`.
 
-    The resolution is modelled as::
+    The :term:`resolution` is modelled as::
 
-        resolution = Polynomial(model_data.abs)(frequencies) + \
-                     Polynomial(model_data.ei_dependence)(e_init) + \
+        resolution = Polynomial(model_data.abs)(frequencies) +
+                     Polynomial(model_data.ei_dependence)(e_init) +
                      Polynomial(model_data.ei_energy_product)(e_init * frequencies)
 
     where ``e_init`` is the initial energy, ``frequencies`` is the energy transfer, and
diff --git a/src/resolution_functions/models/polynomial.py b/src/resolution_functions/models/polynomial.py
index d07d03c..9efeea3 100644
--- a/src/resolution_functions/models/polynomial.py
+++ b/src/resolution_functions/models/polynomial.py
@@ -2,8 +2,8 @@
 Collection of models based off polynomials.
 
 All classes within are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 """
 from __future__ import annotations
 
@@ -22,7 +22,7 @@
 @dataclass(init=True, repr=True, frozen=True, slots=True, kw_only=True)
 class PolynomialModelData(ModelData):
     """
-    Data for the `PolynomialModel1D` model.
+    Data for the `PolynomialModel1D` :term:`model`.
 
     Parameters
     ----------
@@ -50,11 +50,11 @@ class PolynomialModelData(ModelData):
 
 class PolynomialModel1D(InstrumentModel):
     """
-    Model using a 1D polynomial to model an instrument.
+    Model using a 1D polynomial to model an :term:`instrument`.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being a Gaussian. This is done by fitting a single power-series polynomial (see
-    `numpy.polynomial.polynomial.Polynomial`) to the resolution curve, where the result of the
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output :term:`model` being a Gaussian. This is done by fitting a single power-series polynomial
+    (see `numpy.polynomial.polynomial.Polynomial`) to the resolution curve, where the result of the
     polynomial is the width (sigma) of the Gaussian. The polynomial can be of any degree and is
     given via the `PolynomialModelData`.
 
@@ -106,7 +106,7 @@ def __call__(self, frequencies: Float[np.ndarray, 'frequencies'], *args, **kwarg
 @dataclass(init=True, repr=True, frozen=True, slots=True, kw_only=True)
 class DiscontinuousPolynomialModelData(ModelData):
     """
-    Data for the `DiscontinuousPolynomialModel1D`.
+    Data for the `DiscontinuousPolynomialModel1D` :term:`model`.
 
     Parameters
     ----------
@@ -162,12 +162,12 @@ class DiscontinuousPolynomialModelData(ModelData):
 
 class DiscontinuousPolynomialModel1D(InstrumentModel):
     """
-    Model using a 1D polynomial to model an instrument, but with values above and below certain
-    energy transfer set to constant values.
+    Model using a 1D polynomial to model an :term:`instrument`, but with values above and below
+    certain energy transfer set to constant values.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being a Gaussian. This is done by fitting a single power-series polynomial (see
-    `numpy.polynomial.polynomial.Polynomial`) to the resolution curve, where the result of the
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output :term:`model` being a Gaussian. This is done by fitting a single power-series polynomial
+    (see `numpy.polynomial.polynomial.Polynomial`) to the resolution curve, where the result of the
     polynomial is the width (sigma) of the Gaussian. The polynomial can be of any degree and is
     given via the `PolynomialModelData`. However, all ``sigma`` values below
     `DiscontinuousPolynomialModelData.low_energy_cutoff` are set to the value of
diff --git a/src/resolution_functions/models/pychop.py b/src/resolution_functions/models/pychop.py
index cf1d13e..4641d87 100644
--- a/src/resolution_functions/models/pychop.py
+++ b/src/resolution_functions/models/pychop.py
@@ -1,16 +1,18 @@
 """
-The [PyChop]_ model, a 1D model for direct-geometry 2D instruments.
+The [PyChop]_ :term:`model`, a 1D :term:`model` for direct-geometry 2D
+:term:`instruments<instrument>`.
 
-[PyChop]_, originating from [Mantid]_ as a single model, is here organised as a collection of
-models. These can be split into two types: the `PyChopModelFermi` model, used for all instruments
-with a Fermi chopper (which is the sole determinant of the chopper contribution to the resolution),
-and models such as `PyChopModelLET` and `PyChopModelCNCS`, which are models of instruments without
-a Fermi chopper, in which the first and last choppers determine the chopper contribution to the
-resolution.
+[PyChop]_, originating from [Mantid]_ as a single :term:`model`, is here organised as a collection
+of models. These can be split into two types: the `PyChopModelFermi` :term:`model`, used for all
+:term:`instruments<instrument>` with a :term:`Fermi chopper` (which is the sole determinant of the
+:term:`chopper` contribution to the :term:`resolution`), and models such as `PyChopModelLET` and
+`PyChopModelCNCS`, which are models of instruments without a :term:`Fermi chopper`, in which the
+first and last :term:`choppers<chopper>` determine the :term:`chopper` contribution to the
+:term:`resolution`.
 
-All classes here are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+All classes within are exposed for reference only and should not be instantiated directly. For
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 
 .. [PyChop] https://github.com/mducle/pychop/tree/main
 .. [Mantid] https://mantidproject.org/
@@ -48,7 +50,7 @@
 @dataclass(init=True, repr=True, frozen=True, slots=True)
 class PyChopModelData(ModelData):
     """
-    Base class for PyChop model data.
+    Base class for PyChop :term:`model` data.
 
     Corresponds to the abstract base class `PyChopModel` and so should not be used directly.
     Concrete implementations of the PyChop model should have their own model data subclasses of this
@@ -139,7 +141,7 @@ class PyChopModelData(ModelData):
 @dataclass(init=True, repr=True, frozen=True, slots=True)
 class PyChopModelDataFermi(PyChopModelData):
     """
-    Data for the `PyChopModelFermi` model.
+    Data for the `PyChopModelFermi` :term:`model`.
 
     Parameters
     ----------
@@ -148,43 +150,43 @@ class PyChopModelDataFermi(PyChopModelData):
     citation
         The citation for a particular model.
     d_chopper_sample
-        Distance from the final chopper to sample in meters (m).
+        Distance from the final :term:`chopper` to :term:`sample` in meters (m).
     d_sample_detector
-        Distance from sample to detector in meters (m).
+        Distance from :term:`sample` to :term:`detector` in meters (m).
     aperture_width
-        Width of aperture at moderator face in meters (m)
+        Width of aperture at :term:`moderator` face in meters (m)
     theta
-        The angle that the beamline makes with the moderator face in degrees.
+        The angle that the beamline makes with the :term:`moderator` face in degrees.
     default_e_init
         The default value for the initial energy (``e_init``) in meV.
     allowed_e_init
         The limits (lower and upper bound) for the allowed initial energies (``e_init``). This
-        should correspond to the physical limitations of the INS instrument.
+        should correspond to the physical limitations of the INS :term:`instrument`.
     frequency_matrix
         A matrix mapping the relationship between the user-provided parameter ``chopper_frequency``
-        to the frequency of each chopper in the instrument.
+        to the frequency of each :term:`chopper` in the :term:`instrument`.
     choppers
-        Data for each chopper in the instrument. See `FermiChopper` and `DiskChopper` for more info.
+        Data for each :term:`chopper` in the :term:`instrument`. See `FermiChopper` and `DiskChopper` for more info.
     moderator
-        Data for the moderator. See `Moderator` for more info.
+        Data for the :term:`moderator`. See `Moderator` for more info.
     detector
-        Data for the detector. See `Detector` for more info.
+        Data for the :term:`detector`. See `Detector` for more info.
     sample
-        Data for the sample. See `Sample` for more info.
+        Data for the :term:`sample`. See `Sample` for more info.
     tjit
         The jitter time in microseconds (us).
     default_chopper_frequency
-        The default value for the Fermi chopper frequency (``chopper_frequency``) in Hz.
+        The default value for the :term:`Fermi chopper` frequency (``chopper_frequency``) in Hz.
     allowed_chopper_frequencies
-        The allowed values for the Fermi chopper frequency (``chopper_frequency``) in Hz.
+        The allowed values for the :term:`Fermi chopper` frequency (``chopper_frequency``) in Hz.
         `allowed_chopper_frequencies` defines the (start, stop, step), which is converted into a
         list at runtime.
     pslit
         Width of the neutron-transparent slit in meters (m).
     radius
-        Radius of the chopper package in meters (m).
+        Radius of the :term:`chopper` package in meters (m).
     rho
-        Curvature of the chopper package in meters (m).
+        Curvature of the :term:`chopper` package in meters (m).
 
     Attributes
     ----------
@@ -193,43 +195,43 @@ class PyChopModelDataFermi(PyChopModelData):
     citation
         The citation for the model. Please use this to look up more details and cite the model.
     d_chopper_sample
-        Distance from the final chopper to sample in meters (m).
+        Distance from the final :term:`chopper` to :term:`sample` in meters (m).
     d_sample_detector
-        Distance from sample to detector in meters (m).
+        Distance from :term:`sample` to :term:`detector` in meters (m).
     aperture_width
-        Width of aperture at moderator face in meters (m)
+        Width of aperture at :term:`moderator` face in meters (m)
     theta
-        The angle that the beamline makes with the moderator face in degrees.
+        The angle that the beamline makes with the :term:`moderator` face in degrees.
     default_e_init
         The default value for the initial energy (``e_init``) in meV.
     allowed_e_init
         The limits (lower and upper bound) for the allowed initial energies (``e_init``). This
-        should correspond to the physical limitations of the INS instrument.
+        should correspond to the physical limitations of the INS :term:`instrument`.
     frequency_matrix
         A matrix mapping the relationship between the user-provided parameter ``chopper_frequency``
-        to the frequency of each chopper in the instrument.
+        to the frequency of each :term:`chopper` in the :term:`instrument`.
     choppers
-        Data for each chopper in the instrument. See `FermiChopper` and `DiskChopper` for more info.
+        Data for each :term:`chopper` in the :term:`instrument`. See `FermiChopper` and `DiskChopper` for more info.
     moderator
-        Data for the moderator. See `Moderator` for more info.
+        Data for the :term:`moderator`. See `Moderator` for more info.
     detector
-        Data for the detector. See `Detector` for more info.
+        Data for the :term:`detector`. See `Detector` for more info.
     sample
-        Data for the sample. See `Sample` for more info.
+        Data for the :term:`sample`. See `Sample` for more info.
     tjit
         The jitter time in microseconds (us).
     default_chopper_frequency
-        The default value for the Fermi chopper frequency (``chopper_frequency``) in Hz.
+        The default value for the :term:`Fermi chopper` frequency (``chopper_frequency``) in Hz.
     allowed_chopper_frequencies
-        The allowed values for the Fermi chopper frequency (``chopper_frequency``) in Hz.
+        The allowed values for the :term:`Fermi chopper` frequency (``chopper_frequency``) in Hz.
         `allowed_chopper_frequencies` defines the (start, stop, step), which is converted into a
         list at runtime.
     pslit
         Width of the neutron-transparent slit in meters (m).
     radius
-        Radius of the chopper package in meters (m).
+        Radius of the :term:`chopper` package in meters (m).
     rho
-        Curvature of the chopper package in meters (m).
+        Curvature of the :term:`chopper` package in meters (m).
     restrictions
     defaults
     """
@@ -251,7 +253,7 @@ def defaults(self) -> dict:
 @dataclass(init=True, repr=True, frozen=True, slots=True)
 class PyChopModelDataNonFermi(PyChopModelData):
     """
-    Data for the PyChop models that do not have a Fermi chopper:
+    Data for the PyChop :term:`models<model>` that do not have a :term:`Fermi chopper` :
 
     - `PyChopModelCNCS`
     - `PyChopModelLET`
@@ -263,41 +265,44 @@ class PyChopModelDataNonFermi(PyChopModelData):
     citation
         The citation for a particular model.
     d_chopper_sample
-        Distance from the final chopper to sample in meters (m).
+        Distance from the final :term:`chopper` to :term:`sample` in meters (m).
     d_sample_detector
-        Distance from sample to detector in meters (m).
+        Distance from :term:`sample` to :term:`detector` in meters (m).
     aperture_width
-        Width of aperture at moderator face in meters (m)
+        Width of aperture at :term:`moderator` face in meters (m)
     theta
-        The angle that the beamline makes with the moderator face in degrees.
+        The angle that the beamline makes with the :term:`moderator` face in degrees.
     default_e_init
         The default value for the initial energy (``e_init``) in meV.
     allowed_e_init
         The limits (lower and upper bound) for the allowed initial energies (``e_init``). This
-        should correspond to the physical limitations of the INS instrument.
+        should correspond to the physical limitations of the INS :term:`instrument`.
     frequency_matrix
-        A matrix mapping the relationship between all user-provided chopper frequency parameters
-        (i.e. the choppers with user control) to the frequency of each chopper in the instrument.
+        A matrix mapping the relationship between all user-provided :term:`chopper` frequency
+        parameters (i.e. the choppers with user control) to the frequency of each :term:`chopper` in
+        the :term:`instrument`.
     choppers
-        Data for each chopper in the instrument. See `DiskChopper` for more info.
+        Data for each :term:`chopper` in the :term:`instrument`. See `DiskChopper` for more info.
     moderator
-        Data for the moderator. See `Moderator` for more info.
+        Data for the :term:`moderator`. See `Moderator` for more info.
     detector
-        Data for the detector. See `Detector` for more info.
+        Data for the :term:`detector`. See `Detector` for more info.
     sample
-        Data for the sample. See `Sample` for more info.
+        Data for the :term:`sample`. See `Sample` for more info.
     tjit
         The jitter time in microseconds (us).
     default_chopper_frequency
-        The default value for the chopper frequency of each user-controlled chopper in Hz.
+        The default value for the :term:`chopper` frequency of each user-controlled :term:`chopper`
+        in Hz.
     allowed_chopper_frequencies
-        The allowed values for the chopper frequency of each user-controlled chopper, in Hz. Each
-        value defines the (start, stop, step), which is converted into a list at runtime.
+        The allowed values for the :term:`chopper` frequency of each user-controlled
+        :term:`chopper`, in Hz. Each value defines the (start, stop, step), which is converted into
+        a list at runtime.
     constant_frequencies
-        The frequency of each chopper in Hz, with those run at a constant frequency having
+        The frequency of each :term:`chopper` in Hz, with those run at a constant frequency having
         non-zero values.
     source_frequency
-        The frequency of the neutron source in Hz.
+        The frequency of the neutron :term:`source` in Hz.
     n_frame
         Number of frames to calculate time-distance diagram for.
 
@@ -308,41 +313,44 @@ class PyChopModelDataNonFermi(PyChopModelData):
     citation
         The citation for the model. Please use this to look up more details and cite the model.
     d_chopper_sample
-        Distance from the final chopper to sample in meters (m).
+        Distance from the final :term:`chopper` to :term:`sample` in meters (m).
     d_sample_detector
-        Distance from sample to detector in meters (m).
+        Distance from :term:`sample` to :term:`detector` in meters (m).
     aperture_width
-        Width of aperture at moderator face in meters (m)
+        Width of aperture at :term:`moderator` face in meters (m)
     theta
-        The angle that the beamline makes with the moderator face in degrees.
+        The angle that the beamline makes with the :term:`moderator` face in degrees.
     default_e_init
         The default value for the initial energy (``e_init``) in meV.
     allowed_e_init
         The limits (lower and upper bound) for the allowed initial energies (``e_init``). This
-        should correspond to the physical limitations of the INS instrument.
+        should correspond to the physical limitations of the INS :term:`instrument`.
     frequency_matrix
-        A matrix mapping the relationship between all user-provided chopper frequency parameters
-        (i.e. the choppers with user control) to the frequency of each chopper in the instrument.
+        A matrix mapping the relationship between all user-provided :term:`chopper` frequency
+        parameters (i.e. the choppers with user control) to the frequency of each :term:`chopper` in
+        the :term:`instrument`.
     choppers
-        Data for each chopper in the instrument. See `DiskChopper` for more info.
+        Data for each :term:`chopper` in the :term:`instrument`. See `DiskChopper` for more info.
     moderator
-        Data for the moderator. See `Moderator` for more info.
+        Data for the :term:`moderator`. See `Moderator` for more info.
     detector
-        Data for the detector. See `Detector` for more info.
+        Data for the :term:`detector`. See `Detector` for more info.
     sample
-        Data for the sample. See `Sample` for more info.
+        Data for the :term:`sample`. See `Sample` for more info.
     tjit
         The jitter time in microseconds (us).
     default_chopper_frequency
-        The default value for the chopper frequency of each user-controlled chopper in Hz.
+        The default value for the :term:`chopper` frequency of each user-controlled :term:`chopper`
+        in Hz.
     allowed_chopper_frequencies
-        The allowed values for the chopper frequency of each user-controlled chopper, in Hz. Each
-        value defines the (start, stop, step), which is converted into a list at runtime.
+        The allowed values for the :term:`chopper` frequency of each user-controlled
+        :term:`chopper`, in Hz. Each value defines the (start, stop, step), which is converted into
+        a list at runtime.
     constant_frequencies
-        The frequency of each chopper in Hz, with those run at a constant frequency having
+        The frequency of each :term:`chopper` in Hz, with those run at a constant frequency having
         non-zero values.
     source_frequency
-        The frequency of the neutron source in Hz.
+        The frequency of the neutron :term:`source` in Hz.
     n_frame
         Number of frames to calculate time-distance diagram for.
     restrictions
@@ -365,14 +373,14 @@ def defaults(self) -> dict:
 
 class FermiChopper(TypedDict):
     """
-    Data for a Fermi chopper.
+    Data for a :term:`Fermi chopper`.
 
     Attributes
     ----------
     distance
-        Distance from moderator to this Fermi chopper in meters (m).
+        Distance from :term:`moderator` to this :term:`Fermi chopper` in meters (m).
     aperture_distance
-        Distance from aperture (moderator face) to this Fermi chopper in meters (m).
+        Distance from aperture (:term:`moderator` face) to this :term:`Fermi chopper` in meters (m).
     """
     distance: float
     aperture_distance: float
@@ -380,31 +388,31 @@ class FermiChopper(TypedDict):
 
 class DiskChopper(TypedDict):
     """
-    Data for a disk chopper.
+    Data for a :term:`disk chopper`.
 
     Attributes
     ----------
     distance
-        Distance from moderator to this disk chopper in meters (m).
+        Distance from :term:`moderator` to this :term:`disk chopper` in meters (m).
     nslot
-        Number of slots in the chopper.
+        Number of slots in the :term:`chopper`.
     slot_width
         Width of all slots (assumed to be equal) in millimeters (mm).
     slot_ang_pos
-        Angular position of each slot in the chopper, in degrees. Must be monotonically increasing.
-        If None, equal spacing is assumed.
+        Angular position of each slot in the :term:`chopper`, in degrees. Must be monotonically
+        increasing. If None, equal spacing is assumed.
     guide_width
-        Width of the guide after the chopper in millimeters (mm).
+        Width of the guide after the :term:`chopper` in millimeters (mm).
     radius
         Disk radius in millimeters (mm)?
     num_disk
-        Number of disks making up this disk chopper.
+        Number of disks making up this :term:`disk chopper`.
     is_phase_independent
         Whether this disk is supposed to be phased independently.
     default_phase
-        Default phase for this disk chopper. If an ``int`` is provided, it is assumed to be time in
-        microseconds (us), and if a ``str`` is provided, it is assumed to be a slot index for the
-        desired rep to go through.
+        Default phase for this :term:`disk chopper`. If an ``int`` is provided, it is assumed to be
+        time in microseconds (us), and if a ``str`` is provided, it is assumed to be a slot index
+        for the desired rep to go through.
     """
     distance: float
     nslot: int
@@ -419,7 +427,7 @@ class DiskChopper(TypedDict):
 
 class Sample(TypedDict):
     """
-    Data for the sample.
+    Data for the :term:`sample`.
 
     Attributes
     ----------
@@ -443,7 +451,7 @@ class Sample(TypedDict):
     
 class Detector(TypedDict):
     """
-    Data for the detector.
+    Data for the :term:`detector`.
 
     Attributes
     ----------
@@ -461,7 +469,7 @@ class Detector(TypedDict):
 
 class Moderator(TypedDict):
     """
-    Data for the moderator.
+    Data for the :term:`moderator`.
 
     Attributes
     ----------
@@ -1058,13 +1066,14 @@ def _get_sample_width_squared(sample_data: Sample) -> float:
 
 class PyChopModelFermi(PyChopModel):
     """
-    PyChop model of 2D direct-geometry INS instruments that use a Fermi chopper.
+    PyChop :term:`model` of 2D direct-geometry INS :term:`instruments<instrument>` that use a
+    :term:`Fermi chopper`.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being a Gaussian. This is done by computing the contribution of each part of the instrument to
-    the resolution function. However, this model calculates the resolution on a coarse grid, and
-    then fits a polynomial to the results - the resolution at the user-provided ``frequencies`` is
-    obtained by evaluating the polynomial.
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output :term:`model` being a Gaussian. This is done by computing the contribution of each part
+    of the :term:`instrument` to the :term:`resolution function`. However, this model calculates the
+    :term:`resolution` on a coarse grid, and then fits a polynomial to the results - the
+    :term:`resolution` at the user-provided ``frequencies`` is obtained by evaluating the polynomial.
 
     Parameters
     ----------
@@ -1413,10 +1422,11 @@ def _get_chopper_width_squared(cls,
 
 class PyChopModelCNCS(PyChopModelNonFermi):
     """
-    A PyChop model for the CNCS instrument.
+    A PyChop :term:`model` for the CNCS :term:`instrument`.
 
-    This model is identical to all other PyChop models for instruments without a Fermi chopper, but
-    the user-choice chopper frequencies have unique names compared to the other models.
+    This :term:`model` is identical to all other PyChop models for instruments without a
+    :term:`Fermi chopper`, but the user-choice :term:`chopper` frequencies have unique names
+    compared to the other models.
 
     Parameters
     ----------
@@ -1480,10 +1490,11 @@ def polynomial(self):
 
 class PyChopModelLET(PyChopModelNonFermi):
     """
-    A PyChop model for the LET instrument.
+    A PyChop :term:`model` for the LET :term:`instrument`.
 
-    This model is identical to all other PyChop models for instruments without a Fermi chopper, but
-    the user-choice chopper frequencies have unique names compared to the other models.
+    This :term:`model` is identical to all other PyChop models for instruments without a
+    :term:`Fermi chopper`, but the user-choice :term:`chopper` frequencies have unique names
+    compared to the other models.
 
     The LET instrument, specifically, has a set-up with multiple choppers of variable frequency, but
     where some of the choppers are set to a pre-determined fraction of the frequency of another
diff --git a/src/resolution_functions/models/tosca_book.py b/src/resolution_functions/models/tosca_book.py
index 915034f..a7f3753 100644
--- a/src/resolution_functions/models/tosca_book.py
+++ b/src/resolution_functions/models/tosca_book.py
@@ -1,11 +1,11 @@
 """
-Model for the TOSCA instrument from the [INS book]_.
+Model for the TOSCA :term:`instrument` from the [INS-book]_.
 
-All classes here are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+All classes within are exposed for reference only and should not be instantiated directly. For
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 
-.. [INS book] PCH Mitchell, SF Parker, AJ Ramirez-Cuesta and J Tomkinson, Vibrational Spectroscopy with Neutrons With Applications in Chemistry, Biology, Materials Science and Catalysis, World Scientific Publishing Co. Pte. Ltd., Singapore, 2005.
+.. [INS-book] PCH Mitchell, SF Parker, AJ Ramirez-Cuesta and J Tomkinson, Vibrational Spectroscopy with Neutrons With Applications in Chemistry, Biology, Materials Science and Catalysis, World Scientific Publishing Co. Pte. Ltd., Singapore, 2005.
 """
 from __future__ import annotations
 
@@ -23,7 +23,7 @@
 @dataclass(init=True, repr=True, frozen=True, slots=True, kw_only=True)
 class ToscaBookModelData(ModelData):
     """
-    Data for the `ToscaBookModel` model.
+    Data for the `ToscaBookModel` :term:`model`.
 
     Parameters
     ----------
@@ -32,7 +32,7 @@ class ToscaBookModelData(ModelData):
     citation
         The citation for a particular model.
     primary_flight_path
-        Distance between the moderator and the sample in meters (m).
+        Distance between the :term:`moderator` and the :term:`sample` in meters (m).
     primary_flight_path_uncertainty
         The uncertainty associated with the `primary_flight_path`, in meters (m).
     water_moderator_constant
@@ -40,23 +40,23 @@ class ToscaBookModelData(ModelData):
     time_channel_uncertainty
         Time channel uncertainty in microseconds (us).
     sample_thickness
-        Thickness of the sample in meters (m).
+        Thickness of the :term:`sample` in meters (m).
     graphite_thickness
         Thickness of the graphite analyser in meters (m).
     detector_thickness
-        Thickness of the detector in meters (m).
+        Thickness of the :term:`detector` in meters (m).
     sample_width
-        Width of the sample in meters (m).
+        Width of the :term:`sample` in meters (m).
     detector_width
-        Width of the detector in meters (m).
+        Width of the :term:`detector` in meters (m).
     crystal_plane_spacing
-        Distance between the layers of atoms making up the detector, in meters (m).
+        Distance between the layers of atoms making up the :term:`detector`, in meters (m).
     angles
-        Angle between the sample and the analyser, in degrees.
+        Angle between the :term:`sample` and the analyser, in degrees.
     average_secondary_flight_path
-        Average length of the path from the sample to the detector in meters (m).
+        Average length of the path from the :term:`sample` to the :term:`detector` in meters (m).
     average_final_energy
-        Average energy of the neutrons hitting the detector in meV.
+        Average energy of the neutrons hitting the :term:`detector` in meV.
     average_bragg_angle_graphite
         Average Bragg angle of the graphite analyser, in degrees.
     change_average_bragg_angle_graphite
@@ -69,7 +69,7 @@ class ToscaBookModelData(ModelData):
     citation
         The citation for the model. Please use this to look up more details and cite the model.
     primary_flight_path
-        Distance between the moderator and the sample in meters (m).
+        Distance between the :term:`moderator` and the :term:`sample` in meters (m).
     primary_flight_path_uncertainty
         The uncertainty associated with the `primary_flight_path`, in meters (m).
     water_moderator_constant
@@ -77,23 +77,23 @@ class ToscaBookModelData(ModelData):
     time_channel_uncertainty
         Time channel uncertainty in microseconds (us).
     sample_thickness
-        Thickness of the sample in meters (m).
+        Thickness of the :term:`sample` in meters (m).
     graphite_thickness
         Thickness of the graphite analyser in meters (m).
     detector_thickness
-        Thickness of the detector in meters (m).
+        Thickness of the :term:`detector` in meters (m).
     sample_width
-        Width of the sample in meters (m).
+        Width of the :term:`sample` in meters (m).
     detector_width
-        Width of the detector in meters (m).
+        Width of the :term:`detector` in meters (m).
     crystal_plane_spacing
-        Distance between the layers of atoms making up the detector, in meters (m).
+        Distance between the layers of atoms making up the :term:`detector`, in meters (m).
     angles
-        Angle between the sample and the analyser, in degrees.
+        Angle between the :term:`sample` and the analyser, in degrees.
     average_secondary_flight_path
-        Average length of the path from the sample to the detector in meters (m).
+        Average length of the path from the :term:`sample` to the :term:`detector` in meters (m).
     average_final_energy
-        Average energy of the neutrons hitting the detector in meV.
+        Average energy of the neutrons hitting the :term:`detector` in meV.
     average_bragg_angle_graphite
         Average Bragg angle of the graphite analyser, in degrees.
     change_average_bragg_angle_graphite
@@ -120,11 +120,11 @@ class ToscaBookModelData(ModelData):
 
 class ToscaBookModel(InstrumentModel):
     """
-    Model for the TOSCA instrument from the [INS book]_.
+    Model for the TOSCA :term:`instrument` from the [INS book]_.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being a Gaussian. This is done by taking into account the contributions from the various parts
-    of the instrument (for more information, please see the reference).
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output model being a Gaussian. This is done by taking into account the contributions from the
+    various parts of the :term:`instrument` (for more information, please see the reference).
 
     Parameters
     ----------
diff --git a/src/resolution_functions/models/vision_paper.py b/src/resolution_functions/models/vision_paper.py
index caf5609..5a9f1b7 100644
--- a/src/resolution_functions/models/vision_paper.py
+++ b/src/resolution_functions/models/vision_paper.py
@@ -1,11 +1,11 @@
 """
-Model for TOSCA-like instruments from the [VISION paper]_.
+Model for TOSCA-like :term:`instruments<instrument>` from the [VISION-paper]_.
 
-All classes here are exposed for reference only and should not be instantiated directly. For
-obtaining the resolution function of an instrument, please use the
-`Instrument.get_resolution_function` method.
+All classes within are exposed for reference only and should not be instantiated directly. For
+obtaining the :term:`resolution function` of an :term:`instrument`, please use the
+`resolution_functions.instrument.Instrument.get_resolution_function` method.
 
-.. [VISION paper] https://doi.org/10.1016/j.nima.2009.03.204
+.. [VISION-paper] https://doi.org/10.1016/j.nima.2009.03.204
 """
 from __future__ import annotations
 
@@ -23,7 +23,7 @@
 @dataclass(init=True, repr=True, frozen=True, slots=True, kw_only=True)
 class VisionPaperModelData(ModelData):
     """
-    Data for the `VisionPaperModel` model.
+    Data for the `VisionPaperModel` :term:`model`.
 
     Parameters
     ----------
@@ -32,23 +32,23 @@ class VisionPaperModelData(ModelData):
     citation
         The citation for a particular model.
     primary_flight_path
-        Distance between the moderator and the sample in meters (m).
+        Distance between the :term:`moderator` and the :term:`sample` in meters (m).
     primary_flight_path_uncertainty
         The uncertainty associated with the `primary_flight_path`, in meters (m).
     sample_thickness
-        Thickness of the sample in meters (m).
+        Thickness of the :term:`sample` in meters (m).
     detector_thickness
-        Thickness of the detector in meters (m).
+        Thickness of the :term:`detector` in meters (m).
     crystal_plane_spacing
-        Distance between the layers of atoms making up the detector, in meters (m).
+        Distance between the layers of atoms making up the :term:`detector`, in meters (m).
     d_r
-        Uncertainty associated with the detector offset, in meters (m).
+        Uncertainty associated with the :term:`detector` offset, in meters (m).
     d_t
-        Uncertainty associated with the source pulse shape, in ? (?).
+        Uncertainty associated with the :term:`source` pulse shape, in ? (?).
     angles
-        Angle between the sample and the analyser, in degrees.
+        Angle between the :term:`sample` and the analyser, in degrees.
     distance_sample_analyzer
-        Distance between the sample and the analyser, in meters (m).
+        Distance between the :term:`sample` and the analyser, in meters (m).
     average_bragg_angle_graphite
         Average Bragg angle of the graphite analyser, in degrees.
 
@@ -59,23 +59,23 @@ class VisionPaperModelData(ModelData):
     citation
         The citation for the model. Please use this to look up more details and cite the model.
     primary_flight_path
-        Distance between the moderator and the sample in meters (m).
+        Distance between the :term:`moderator` and the :term:`sample` in meters (m).
     primary_flight_path_uncertainty
         The uncertainty associated with the `primary_flight_path`, in meters (m).
     sample_thickness
-        Thickness of the sample in meters (m).
+        Thickness of the :term:`sample` in meters (m).
     detector_thickness
-        Thickness of the detector in meters (m).
+        Thickness of the :term:`detector` in meters (m).
     crystal_plane_spacing
-        Distance between the layers of atoms making up the detector, in meters (m).
+        Distance between the layers of atoms making up the :term:`detector`, in meters (m).
     d_r
-        Uncertainty associated with the detector offset, in meters (m).
+        Uncertainty associated with the :term:`detector` offset, in meters (m).
     d_t
-        Uncertainty associated with the source pulse shape, in ? (?).
+        Uncertainty associated with the :term:`source` pulse shape, in ? (?).
     angles
-        Angle between the sample and the analyser, in degrees.
+        Angle between the :term:`sample` and the analyser, in degrees.
     distance_sample_analyzer
-        Distance between the sample and the analyser, in meters (m).
+        Distance between the :term:`sample` and the analyser, in meters (m).
     average_bragg_angle_graphite
         Average Bragg angle of the graphite analyser, in degrees.
     restrictions
@@ -95,11 +95,12 @@ class VisionPaperModelData(ModelData):
 
 class VisionPaperModel(InstrumentModel):
     """
-    Model for TOSCA-like instruments from the [VISION paper]_.
+    Model for TOSCA-like :term:`instruments<instrument>` from the [VISION paper]_.
 
-    Models the resolution as a function of energy transfer (frequencies) only, with the output model
-    being an Ikeda-Carpenter distribution. This is done by taking into account the contributions
-    from the various parts of the instrument (for more information, please see the reference).
+    Models the :term:`resolution` as a function of energy transfer (frequencies) only, with the
+    output model being an Ikeda-Carpenter distribution. This is done by taking into account the
+    contributions from the various parts of the :term:`instrument` (for more information, please see
+    the reference).
 
     Parameters
     ----------