earthsciencekit 0.2.0__py3-none-any.whl

earthsciencekit/volcanology/systems/magma.py

@@ -0,0 +1,190 @@
+"""Magma: viscosity, water solubility, ascent in dikes and ground deformation above a magma chamber.
+
+SI units unless stated otherwise.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity
+from earthsciencekit.constants import R_GAS
+
+__all__ = [
+    "arrhenius_viscosity",
+    "shaw_viscosity",
+    "water_solubility",
+    "dike_ascent_velocity",
+    "mogi_displacement",
+]
+
+
+@model
+def arrhenius_viscosity(temperature, reference_viscosity, activation_energy, reference_temperature):
+    """Arrhenius temperature dependence of melt viscosity.
+
+    Silicate melts stiffen by orders of magnitude as they cool, which controls how lava flows and how magma erupts.
+
+    Parameters
+    ----------
+    temperature : float or array_like
+        K; constraint: positive.
+    reference_viscosity : float or array_like
+        Pa s, viscosity at the reference temperature; constraint: positive.
+    activation_energy : float or array_like
+        J/mol; constraint: nonnegative.
+    reference_temperature : float or array_like
+        K; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [Pa s]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Constant activation energy over the range of interest; crystal- and bubble-free Newtonian melt.
+    Equation: ``reference_viscosity * np.exp(activation_energy / R_GAS * (1 / temperature - 1 / reference_temperature))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    temperature = quantity("temperature", temperature, lower=0, strict_lower=True)
+    reference_viscosity = quantity("reference_viscosity", reference_viscosity, lower=0, strict_lower=True)
+    activation_energy = quantity("activation_energy", activation_energy, lower=0)
+    reference_temperature = quantity("reference_temperature", reference_temperature, lower=0, strict_lower=True)
+    return reference_viscosity * np.exp(activation_energy / R_GAS * (1 / temperature - 1 / reference_temperature))
+
+
+@model
+def shaw_viscosity(temperature, slope):
+    """Shaw's empirical viscosity of an anhydrous or hydrous silicate melt.
+
+    One composition-dependent slope predicts the viscosity of melts from basalt to rhyolite.
+
+    Parameters
+    ----------
+    temperature : float or array_like
+        K; constraint: positive.
+    slope : float or array_like
+        1, Shaw's s from the molar composition (about 2-3 for basalt, 3.5-4 for rhyolite); constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [Pa s]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Shaw (1972), Am. J. Sci. 272: 870-893; all lines pass near ln(eta [poise]) = -6.4 at 1e4/T = 1.5. Crystal- and
+    bubble-free Newtonian melt; about 0.2 log units of accuracy.
+    Equation: ``0.1 * np.exp(slope * (1e4 / temperature) - 1.5 * slope - 6.4)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    temperature = quantity("temperature", temperature, lower=0, strict_lower=True)
+    slope = quantity("slope", slope, lower=0, strict_lower=True)
+    return 0.1 * np.exp(slope * (1e4 / temperature) - 1.5 * slope - 6.4)
+
+
+@model
+def water_solubility(pressure, solubility_constant):
+    """Dissolved water in a melt saturated at a given pressure.
+
+    Water dissolves as hydroxyl, so its solubility grows as the square root of pressure and ascending magma exsolves
+    bubbles.
+
+    Parameters
+    ----------
+    pressure : float or array_like
+        Pa; constraint: nonnegative.
+    solubility_constant : float or array_like
+        1/sqrt(Pa), mass fraction per root pascal (about 4.1e-6 for rhyolite); constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1], mass fraction. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Square-root (Henry-type) law for pure water vapour, valid up to a few hundred MPa; ignores CO2 and temperature.
+    Equation: ``solubility_constant * np.sqrt(pressure)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    pressure = quantity("pressure", pressure, lower=0)
+    solubility_constant = quantity("solubility_constant", solubility_constant, lower=0, strict_lower=True)
+    return solubility_constant * np.sqrt(pressure)
+
+
+@model
+def dike_ascent_velocity(width, density_contrast, viscosity, gravity):
+    """Mean laminar velocity of buoyant magma in a dike.
+
+    Buoyancy drives magma up a planar crack, and the viscous drag on its walls sets how fast it rises.
+
+    Parameters
+    ----------
+    width : float or array_like
+        m, full dike width; constraint: positive.
+    density_contrast : float or array_like
+        kg/m^3, host rock minus magma; constraint: real.
+    viscosity : float or array_like
+        Pa s; constraint: positive.
+    gravity : float or array_like
+        m/s^2; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [m/s], positive upward. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Wilson and Head (1981): plane Poiseuille flow between parallel walls driven by buoyancy alone; check that the Reynolds
+    number ``magma_density * velocity * width / viscosity`` stays below about 2000.
+    Equation: ``width**2 * density_contrast * gravity / (12 * viscosity)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    width = quantity("width", width, lower=0, strict_lower=True)
+    density_contrast = quantity("density_contrast", density_contrast)
+    viscosity = quantity("viscosity", viscosity, lower=0, strict_lower=True)
+    gravity = quantity("gravity", gravity, lower=0, strict_lower=True)
+    return width**2 * density_contrast * gravity / (12 * viscosity)
+
+
+@model
+def mogi_displacement(radial_distance, depth, volume_change, poisson_ratio):
+    """Surface displacement above an inflating point source.
+
+    Magma entering a chamber lifts the ground in a bell-shaped dome whose width reveals the chamber depth.
+
+    Parameters
+    ----------
+    radial_distance : float or array_like
+        m, horizontal distance from the point above the source; constraint: nonnegative.
+    depth : float or array_like
+        m; constraint: positive.
+    volume_change : float or array_like
+        m^3, signed change of the source volume; constraint: real.
+    poisson_ratio : float or array_like
+        1; constraint: between 0 and 0.5.
+
+    Returns
+    -------
+    ndarray, shape (..., 2)
+        Model value [m]: ``[radial, vertical]`` displacement, outward and upward positive.
+
+    Notes
+    -----
+    Mogi (1958) point source in an elastic half-space; the chamber radius must be small compared with its depth. The
+    uplift halves at ``radial_distance = 0.766 * depth``.
+    Equation: ``(1 - poisson_ratio) * volume_change / np.pi * [radial_distance, depth] / (radial_distance**2 + depth**2)**1.5``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    radial_distance = quantity("radial_distance", radial_distance, lower=0)
+    depth = quantity("depth", depth, lower=0, strict_lower=True)
+    volume_change = quantity("volume_change", volume_change)
+    poisson_ratio = quantity("poisson_ratio", poisson_ratio, lower=0, upper=0.5)
+    scale = (1 - poisson_ratio) * volume_change / np.pi / (radial_distance**2 + depth**2) ** 1.5
+    return np.stack(np.broadcast_arrays(scale * radial_distance, scale * depth), axis=-1)

earthsciencekit/volcanology/tests/test_models.py

@@ -0,0 +1,485 @@
+"""Golden checks and invalid-input contracts for every public model."""
+
+import numpy as np
+import pytest
+
+from earthsciencekit import volcanology as domain
+from earthsciencekit.constants import AVOGADRO, LAMBDA_U238, R_GAS
+
+HALF_LIFE_U238 = np.log(2) / LAMBDA_U238
+BAD = [np.nan, np.inf, -np.inf, [], "bad", True, 1j]
+
+
+def test_decay_constant_reference():
+    result = domain.decay_constant(*[2])
+    np.testing.assert_allclose(result, np.log(2) / 2, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_decay_constant_rejects_invalid(bad):
+    args = [2]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.decay_constant(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0)])
+def test_decay_constant_physical_bound(index, value):
+    args = [2]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.decay_constant(*args)
+
+
+def test_parent_fraction_reference():
+    result = domain.parent_fraction(*[np.log(2), 1])
+    np.testing.assert_allclose(result, 0.5, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_parent_fraction_rejects_invalid(bad):
+    args = [np.log(2), 1]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.parent_fraction(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, -1)])
+def test_parent_fraction_physical_bound(index, value):
+    args = [np.log(2), 1]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.parent_fraction(*args)
+
+
+def test_radiometric_age_reference():
+    result = domain.radiometric_age(*[np.e - 1, 2])
+    np.testing.assert_allclose(result, 0.5, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_radiometric_age_rejects_invalid(bad):
+    args = [np.e - 1, 2]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.radiometric_age(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, 0)])
+def test_radiometric_age_physical_bound(index, value):
+    args = [np.e - 1, 2]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.radiometric_age(*args)
+
+
+def test_radiogenic_daughter_reference():
+    result = domain.radiogenic_daughter(*[3, np.log(2), 1])
+    np.testing.assert_allclose(result, 3, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_radiogenic_daughter_rejects_invalid(bad):
+    args = [3, np.log(2), 1]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.radiogenic_daughter(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, 0), (2, -1)])
+def test_radiogenic_daughter_physical_bound(index, value):
+    args = [3, np.log(2), 1]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.radiogenic_daughter(*args)
+
+
+def test_radiocarbon_age_reference():
+    result = domain.radiocarbon_age(*[np.exp(-1)])
+    np.testing.assert_allclose(result, 8033 * 365.25 * 86400, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_radiocarbon_age_rejects_invalid(bad):
+    args = [np.exp(-1)]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.radiocarbon_age(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0)])
+def test_radiocarbon_age_physical_bound(index, value):
+    args = [np.exp(-1)]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.radiocarbon_age(*args)
+
+
+def test_radiogenic_lead_ratio_reference():
+    result = domain.radiogenic_lead_ratio(*[HALF_LIFE_U238])
+    np.testing.assert_allclose(result, (2 ** (9.8485 / 1.55125) - 1) / 137.88, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_radiogenic_lead_ratio_rejects_invalid(bad):
+    args = [HALF_LIFE_U238]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.radiogenic_lead_ratio(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0)])
+def test_radiogenic_lead_ratio_physical_bound(index, value):
+    args = [HALF_LIFE_U238]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.radiogenic_lead_ratio(*args)
+
+
+def test_lead_lead_age_reference():
+    result = domain.lead_lead_age(*[(2 ** (9.8485 / 1.55125) - 1) / 137.88])
+    np.testing.assert_allclose(result, HALF_LIFE_U238, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_lead_lead_age_rejects_invalid(bad):
+    args = [(2 ** (9.8485 / 1.55125) - 1) / 137.88]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.lead_lead_age(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0.04), (0, 50.0)])
+def test_lead_lead_age_physical_bound(index, value):
+    args = [(2 ** (9.8485 / 1.55125) - 1) / 137.88]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.lead_lead_age(*args)
+
+
+def test_concordia_ratios_reference():
+    result = domain.concordia_ratios(*[HALF_LIFE_U238])
+    np.testing.assert_allclose(result, [2 ** (9.8485 / 1.55125) - 1, 1], rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_concordia_ratios_rejects_invalid(bad):
+    args = [HALF_LIFE_U238]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.concordia_ratios(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1)])
+def test_concordia_ratios_physical_bound(index, value):
+    args = [HALF_LIFE_U238]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.concordia_ratios(*args)
+
+
+def test_isochron_fit_reference():
+    result = domain.isochron_fit(*[[0, 1, 2], [0.7, 0.7 + np.e - 1, 0.7 + 2 * (np.e - 1)], 1])
+    np.testing.assert_allclose(result, [1, 0.7], rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_isochron_fit_rejects_invalid(bad):
+    args = [[0, 1, 2], [0.7, 0.7 + np.e - 1, 0.7 + 2 * (np.e - 1)], 1]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.isochron_fit(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, [-1, 1, 2]), (1, [-1, 1, 2]), (2, 0)])
+def test_isochron_fit_physical_bound(index, value):
+    args = [[0, 1, 2], [0.7, 0.7 + np.e - 1, 0.7 + 2 * (np.e - 1)], 1]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.isochron_fit(*args)
+
+
+def test_rayleigh_fractionation_reference():
+    result = domain.rayleigh_fractionation(*[2, 0.25, 0.5])
+    np.testing.assert_allclose(result, 4, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_rayleigh_fractionation_rejects_invalid(bad):
+    args = [2, 0.25, 0.5]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.rayleigh_fractionation(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0), (1, 1.5), (2, 0)])
+def test_rayleigh_fractionation_physical_bound(index, value):
+    args = [2, 0.25, 0.5]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.rayleigh_fractionation(*args)
+
+
+def test_delta_value_reference():
+    result = domain.delta_value(*[1.01, 1])
+    np.testing.assert_allclose(result, 10, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_delta_value_rejects_invalid(bad):
+    args = [1.01, 1]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.delta_value(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0)])
+def test_delta_value_physical_bound(index, value):
+    args = [1.01, 1]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.delta_value(*args)
+
+
+def test_fractional_crystallization_melt_reference():
+    result = domain.fractional_crystallization_melt(*[10, 0.25, 0.5])
+    np.testing.assert_allclose(result, 20, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_fractional_crystallization_melt_rejects_invalid(bad):
+    args = [10, 0.25, 0.5]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.fractional_crystallization_melt(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, 0), (1, 1.5), (2, -1)])
+def test_fractional_crystallization_melt_physical_bound(index, value):
+    args = [10, 0.25, 0.5]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.fractional_crystallization_melt(*args)
+
+
+def test_equilibrium_crystallization_melt_reference():
+    result = domain.equilibrium_crystallization_melt(*[10, 0.5, 0.5])
+    np.testing.assert_allclose(result, 40 / 3, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_equilibrium_crystallization_melt_rejects_invalid(bad):
+    args = [10, 0.5, 0.5]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.equilibrium_crystallization_melt(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, -0.5), (1, 1.5), (2, 0)])
+def test_equilibrium_crystallization_melt_physical_bound(index, value):
+    args = [10, 0.5, 0.5]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.equilibrium_crystallization_melt(*args)
+
+
+def test_lattice_strain_partition_reference():
+    result = domain.lattice_strain_partition(*[2e-10, 1e-10, 3, 1.2 * R_GAS * 1000 / (4 * np.pi * AVOGADRO * 1e-30), 1000])
+    np.testing.assert_allclose(result, 3 * np.exp(-1), rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_lattice_strain_partition_rejects_invalid(bad):
+    args = [2e-10, 1e-10, 3, 1.2 * R_GAS * 1000 / (4 * np.pi * AVOGADRO * 1e-30), 1000]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.lattice_strain_partition(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)])
+def test_lattice_strain_partition_physical_bound(index, value):
+    args = [2e-10, 1e-10, 3, 1.2 * R_GAS * 1000 / (4 * np.pi * AVOGADRO * 1e-30), 1000]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.lattice_strain_partition(*args)
+
+
+def test_isotope_temperature_reference():
+    result = domain.isotope_temperature(*[1, 0])
+    np.testing.assert_allclose(result, 273.15 + 16.5 - 4.3 + 0.14, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_isotope_temperature_rejects_invalid(bad):
+    args = [1, 0]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.isotope_temperature(*args)
+
+
+def test_arrhenius_viscosity_reference():
+    result = domain.arrhenius_viscosity(*[1000, 10, R_GAS * 1000, 500])
+    np.testing.assert_allclose(result, 10 * np.exp(-1), rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_arrhenius_viscosity_rejects_invalid(bad):
+    args = [1000, 10, R_GAS * 1000, 500]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.arrhenius_viscosity(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0), (2, -1), (3, 0)])
+def test_arrhenius_viscosity_physical_bound(index, value):
+    args = [1000, 10, R_GAS * 1000, 500]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.arrhenius_viscosity(*args)
+
+
+def test_shaw_viscosity_reference():
+    result = domain.shaw_viscosity(*[1e4 / 1.5, 2])
+    np.testing.assert_allclose(result, 0.1 * np.exp(-6.4), rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_shaw_viscosity_rejects_invalid(bad):
+    args = [1e4 / 1.5, 2]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.shaw_viscosity(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0)])
+def test_shaw_viscosity_physical_bound(index, value):
+    args = [1e4 / 1.5, 2]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.shaw_viscosity(*args)
+
+
+def test_water_solubility_reference():
+    result = domain.water_solubility(*[4e8, 4e-6])
+    np.testing.assert_allclose(result, 0.08, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_water_solubility_rejects_invalid(bad):
+    args = [4e8, 4e-6]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.water_solubility(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, 0)])
+def test_water_solubility_physical_bound(index, value):
+    args = [4e8, 4e-6]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.water_solubility(*args)
+
+
+def test_dike_ascent_velocity_reference():
+    result = domain.dike_ascent_velocity(*[2, 300, 100, 10])
+    np.testing.assert_allclose(result, 10, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_dike_ascent_velocity_rejects_invalid(bad):
+    args = [2, 300, 100, 10]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.dike_ascent_velocity(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (2, 0), (3, 0)])
+def test_dike_ascent_velocity_physical_bound(index, value):
+    args = [2, 300, 100, 10]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.dike_ascent_velocity(*args)
+
+
+def test_mogi_displacement_reference():
+    result = domain.mogi_displacement(*[0, 1000, np.pi, 0.5])
+    np.testing.assert_allclose(result, [0, 5e-7], rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_mogi_displacement_rejects_invalid(bad):
+    args = [0, 1000, np.pi, 0.5]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.mogi_displacement(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1), (1, 0), (3, -0.1), (3, 0.6)])
+def test_mogi_displacement_physical_bound(index, value):
+    args = [0, 1000, np.pi, 0.5]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.mogi_displacement(*args)
+
+
+def test_plume_rise_height_reference():
+    result = domain.plume_rise_height(*[16, 1 / 16])
+    np.testing.assert_allclose(result, 80, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_plume_rise_height_rejects_invalid(bad):
+    args = [16, 1 / 16]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.plume_rise_height(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0), (1, 0)])
+def test_plume_rise_height_physical_bound(index, value):
+    args = [16, 1 / 16]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.plume_rise_height(*args)
+
+
+def test_column_height_reference():
+    result = domain.column_height(*[1e12])
+    np.testing.assert_allclose(result, 8200, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_column_height_rejects_invalid(bad):
+    args = [1e12]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.column_height(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, 0)])
+def test_column_height_physical_bound(index, value):
+    args = [1e12]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.column_height(*args)
+
+
+def test_volcanic_explosivity_index_reference():
+    result = domain.volcanic_explosivity_index(*[5e7])
+    np.testing.assert_allclose(result, 3, rtol=1e-11, atol=1e-12)
+
+
+@pytest.mark.parametrize("bad", BAD)
+def test_volcanic_explosivity_index_rejects_invalid(bad):
+    args = [5e7]
+    args[0] = bad
+    with pytest.raises(ValueError):
+        domain.volcanic_explosivity_index(*args)
+
+
+@pytest.mark.parametrize("index,value", [(0, -1)])
+def test_volcanic_explosivity_index_physical_bound(index, value):
+    args = [5e7]
+    args[index] = value
+    with pytest.raises(ValueError):
+        domain.volcanic_explosivity_index(*args)