earthsciencekit 0.2.0__py3-none-any.whl

earthsciencekit/volcanology/systems/eruptions.py

@@ -0,0 +1,161 @@
+"""Eruptions: buoyant plume rise, eruption-column height, the Volcanic Explosivity Index and a rising column parcel.
+
+SI units unless stated otherwise.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity, require, safe_arithmetic
+from earthsciencekit.results import TimeSeries
+
+__all__ = [
+    "plume_rise_height",
+    "column_height",
+    "volcanic_explosivity_index",
+    "simulate_eruption_column",
+]
+
+
+@model
+def plume_rise_height(buoyancy_flux, buoyancy_frequency):
+    """Maximum height of a buoyant plume in a stratified fluid.
+
+    Turbulent entrainment dilutes a plume until the stratification removes its buoyancy, which caps its height at a value
+    set by only the source buoyancy flux and the stratification.
+
+    Parameters
+    ----------
+    buoyancy_flux : float or array_like
+        m^4/s^3, source ``reduced_gravity * velocity * radius**2`` (the factor pi omitted); constraint: positive.
+    buoyancy_frequency : float or array_like
+        1/s; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [m]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Morton, Taylor and Turner (1956) for a steady point source of buoyancy in uniform stratification, with Briggs's
+    constant 5.0 (entrainment about 0.1); source momentum, wind and moisture are neglected.
+    Equation: ``5.0 * buoyancy_flux**0.25 * buoyancy_frequency**-0.75``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    buoyancy_flux = quantity("buoyancy_flux", buoyancy_flux, lower=0, strict_lower=True)
+    buoyancy_frequency = quantity("buoyancy_frequency", buoyancy_frequency, lower=0, strict_lower=True)
+    return 5.0 * buoyancy_flux**0.25 * buoyancy_frequency**-0.75
+
+
+@model
+def column_height(heat_flux):
+    """Height of a Plinian eruption column from its heat flux.
+
+    The thermal energy released at the vent, not the eruption velocity, controls how high a volcanic column rises.
+
+    Parameters
+    ----------
+    heat_flux : float or array_like
+        W, rate of heat release ``mass_eruption_rate * specific_heat * temperature_excess``; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [m]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Wilson, Sparks, Huang and Watkins (1978), JGR 83: 1829-1836, for a standard atmosphere and a strong steady column;
+    wind bends weak plumes lower.
+    Equation: ``8.2 * heat_flux**0.25``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    heat_flux = quantity("heat_flux", heat_flux, lower=0, strict_lower=True)
+    return 8.2 * heat_flux**0.25
+
+
+@model
+def volcanic_explosivity_index(erupted_volume):
+    """Volcanic Explosivity Index from the erupted tephra volume.
+
+    A single logarithmic number lets eruptions of very different style and size be compared and catalogued.
+
+    Parameters
+    ----------
+    erupted_volume : float or array_like
+        m^3, bulk tephra volume; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1], an integer from 0 to 8. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Newhall and Self (1982), volume criterion only: VEI 0 below 1e4 m^3, 1 below 1e6 m^3, then one step per factor of
+    ten up to VEI 8 at 1e12 m^3 and above. Column height and other criteria are not used.
+    Equation: ``np.where(erupted_volume < 1e4, 0, np.where(erupted_volume < 1e6, 1,
+    np.clip(np.floor(np.log10(erupted_volume)) - 4, 2, 8)))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    erupted_volume = quantity("erupted_volume", erupted_volume, lower=0)
+    steps = np.clip(np.floor(np.log10(np.maximum(erupted_volume, 1e6))) - 4, 2, 8)
+    return np.where(erupted_volume < 1e4, 0.0, np.where(erupted_volume < 1e6, 1.0, steps))[()]
+
+
+@safe_arithmetic
+def simulate_eruption_column(vent_radius, vent_velocity, reduced_gravity, buoyancy_frequency, time, *, entrainment=0.12):
+    """Follow a parcel up the axis of a steady buoyant eruption column.
+
+    Parameters
+    ----------
+    vent_radius : float
+        Positive scalar source radius [m].
+    vent_velocity : float
+        Positive scalar source velocity [m/s].
+    reduced_gravity : float
+        Positive scalar source buoyancy ``g (rho_air - rho_plume) / rho_air`` [m/s^2].
+    buoyancy_frequency : float
+        Nonnegative scalar Brunt-Vaisala frequency of the atmosphere [1/s].
+    time : array_like
+        Nonnegative strictly increasing travel times since the parcel left the vent [s].
+    entrainment : float
+        Positive scalar top-hat entrainment coefficient [1]; 0.12 reproduces the constant 5.0 of plume_rise_height.
+
+    Returns
+    -------
+    TimeSeries
+        Parcel height [m], vertical velocity [m/s] and reduced gravity [m/s^2].
+
+    Notes
+    -----
+    The Morton, Taylor and Turner (1956) top-hat plume equations for the fluxes Q = b**2 w, M = b**2 w**2 and
+    F = b**2 w g' (pi omitted), carried by a parcel moving at w = M / Q: dz/dt = M / Q, dQ/dt = 2 alpha abs(M)**1.5 / Q,
+    dM/dt = F and dF/dt = -N**2 M. In a uniform atmosphere the parcel stops near plume_rise_height. Past that height the
+    steady theory ends; the parcel is continued as a fountain that falls back with the same entrainment law and oscillates
+    about the level of neutral buoyancy, near three quarters of the maximum height, where the umbrella cloud spreads.
+    This illustrative closure omits wind, the dense gas-thrust region, particle fallout and moisture.
+    """
+    from earthsciencekit._validation import time_grid
+    from earthsciencekit.integrators import integrate_ode
+
+    radius = quantity("vent_radius", vent_radius, lower=0, strict_lower=True)
+    velocity = quantity("vent_velocity", vent_velocity, lower=0, strict_lower=True)
+    buoyancy = quantity("reduced_gravity", reduced_gravity, lower=0, strict_lower=True)
+    frequency = quantity("buoyancy_frequency", buoyancy_frequency, lower=0)
+    alpha = quantity("entrainment", entrainment, lower=0, strict_lower=True)
+    require(all(v.ndim == 0 for v in (radius, velocity, buoyancy, frequency, alpha)), "eruption column parameters must be scalars")
+    time = time_grid(time)
+
+    def rhs(t, state):
+        _, volume, momentum, flux = state
+        return [momentum / volume, 2 * alpha * np.abs(momentum) ** 1.5 / volume, flux, -(frequency**2) * momentum]
+
+    initial = [0.0, radius**2 * velocity, radius**2 * velocity**2, radius**2 * velocity * buoyancy]
+    fluxes = integrate_ode(rhs, initial, time - time[0], names=("height", "Q", "M", "F"), units=("m", "m^3/s", "m^4/s^2", "m^4/s^3"))
+    _, volume, momentum, flux = fluxes.values.T
+    values = np.column_stack([fluxes.values[:, 0], momentum / volume, flux / volume])
+    return TimeSeries(time, values, ("height", "vertical_velocity", "reduced_gravity"), ("m", "m/s", "m/s^2"))

earthsciencekit/volcanology/systems/geochemistry.py

@@ -0,0 +1,226 @@
+"""Geochemistry: Rayleigh fractionation, delta notation, melt crystallization, lattice strain and the oxygen-isotope thermometer.
+
+SI units unless stated otherwise; isotope delta values are per mil.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity
+from earthsciencekit.constants import AVOGADRO, R_GAS
+
+__all__ = [
+    "rayleigh_fractionation",
+    "delta_value",
+    "fractional_crystallization_melt",
+    "equilibrium_crystallization_melt",
+    "lattice_strain_partition",
+    "isotope_temperature",
+]
+
+
+@model
+def rayleigh_fractionation(initial_ratio, remaining_fraction, fractionation_factor):
+    """Isotope ratio of a reservoir depleted by Rayleigh distillation.
+
+    Removing a product that is always slightly enriched in one isotope drives the remaining reservoir further and further
+    from its starting composition.
+
+    Parameters
+    ----------
+    initial_ratio : float or array_like
+        1, heavy-to-light isotope ratio of the reservoir at the start; constraint: positive.
+    remaining_fraction : float or array_like
+        1, fraction of the reservoir left; constraint: fraction above zero.
+    fractionation_factor : float or array_like
+        1, product ratio over reservoir ratio at each instant; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Rayleigh (1896): the product leaves as soon as it forms, the reservoir stays well mixed and the factor is constant.
+    Equation: ``initial_ratio * remaining_fraction**(fractionation_factor - 1)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    initial_ratio = quantity("initial_ratio", initial_ratio, lower=0, strict_lower=True)
+    remaining_fraction = quantity("remaining_fraction", remaining_fraction, lower=0, upper=1, strict_lower=True)
+    fractionation_factor = quantity("fractionation_factor", fractionation_factor, lower=0, strict_lower=True)
+    return initial_ratio * remaining_fraction ** (fractionation_factor - 1)
+
+
+@model
+def delta_value(ratio, standard_ratio):
+    """Isotope delta value relative to a standard.
+
+    Isotope ratios vary in the fourth decimal place, so geochemists report deviations from a standard in per mil.
+
+    Parameters
+    ----------
+    ratio : float or array_like
+        1, heavy-to-light isotope ratio of the sample; constraint: positive.
+    standard_ratio : float or array_like
+        1, the same ratio in the standard (e.g. VSMOW, VPDB); constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [per mil]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Linear in the ratio; delta values of different standards must be converted before they are compared.
+    Equation: ``(ratio / standard_ratio - 1) * 1000``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    ratio = quantity("ratio", ratio, lower=0, strict_lower=True)
+    standard_ratio = quantity("standard_ratio", standard_ratio, lower=0, strict_lower=True)
+    return (ratio / standard_ratio - 1) * 1000
+
+
+@model
+def fractional_crystallization_melt(initial_concentration, melt_fraction, partition_coefficient):
+    """Trace-element concentration in a melt during fractional crystallization.
+
+    Crystals removed as soon as they form leave the residual melt enriched in the elements they reject.
+
+    Parameters
+    ----------
+    initial_concentration : float or array_like
+        Concentration in the parent melt (any unit, e.g. ppm); constraint: nonnegative.
+    melt_fraction : float or array_like
+        1, fraction of melt remaining; constraint: fraction above zero.
+    partition_coefficient : float or array_like
+        1, bulk solid/melt concentration ratio; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [unit of initial_concentration]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Rayleigh fractional crystallization (Bowen 1928; Gast 1968): crystals do not re-equilibrate and the bulk partition
+    coefficient is constant.
+    Equation: ``initial_concentration * melt_fraction**(partition_coefficient - 1)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    initial_concentration = quantity("initial_concentration", initial_concentration, lower=0)
+    melt_fraction = quantity("melt_fraction", melt_fraction, lower=0, upper=1, strict_lower=True)
+    partition_coefficient = quantity("partition_coefficient", partition_coefficient, lower=0)
+    return initial_concentration * melt_fraction ** (partition_coefficient - 1)
+
+
+@model
+def equilibrium_crystallization_melt(initial_concentration, melt_fraction, partition_coefficient):
+    """Trace-element concentration in a melt during equilibrium crystallization.
+
+    Crystals that keep reacting with the melt, as in Bowen's continuous series, limit how far the melt can evolve.
+
+    Parameters
+    ----------
+    initial_concentration : float or array_like
+        Concentration in the parent melt (any unit, e.g. ppm); constraint: nonnegative.
+    melt_fraction : float or array_like
+        1, fraction of melt remaining; constraint: fraction.
+    partition_coefficient : float or array_like
+        1, bulk solid/melt concentration ratio; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [unit of initial_concentration]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Batch mass balance (Shaw 1970): solid and melt stay in equilibrium, so an incompatible element is enriched at most by
+    1 / partition_coefficient.
+    Equation: ``initial_concentration / (partition_coefficient + melt_fraction * (1 - partition_coefficient))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    initial_concentration = quantity("initial_concentration", initial_concentration, lower=0)
+    melt_fraction = quantity("melt_fraction", melt_fraction, lower=0, upper=1)
+    partition_coefficient = quantity("partition_coefficient", partition_coefficient, lower=0, strict_lower=True)
+    return initial_concentration / (partition_coefficient + melt_fraction * (1 - partition_coefficient))
+
+
+@model
+def lattice_strain_partition(ionic_radius, optimal_radius, peak_partition, youngs_modulus, temperature):
+    """Mineral-melt partition coefficient from the strain of the crystal lattice.
+
+    Ions close in size to the site they replace enter a crystal easily, which is Goldschmidt's first rule of substitution.
+
+    Parameters
+    ----------
+    ionic_radius : float or array_like
+        m; constraint: positive.
+    optimal_radius : float or array_like
+        m, radius that fits the site without strain; constraint: positive.
+    peak_partition : float or array_like
+        1, partition coefficient of an ion of the optimal radius; constraint: positive.
+    youngs_modulus : float or array_like
+        Pa, apparent Young's modulus of the site; constraint: positive.
+    temperature : float or array_like
+        K; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Blundy and Wood (1994) quantification of Goldschmidt (1937) for isovalent ions on one site; charge differences
+    need a separate parabola.
+    Equation: ``peak_partition * np.exp(-4 * np.pi * youngs_modulus * AVOGADRO * (optimal_radius / 2 * (ionic_radius - optimal_radius)**2
+    + (ionic_radius - optimal_radius)**3 / 3) / (R_GAS * temperature))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    ionic_radius = quantity("ionic_radius", ionic_radius, lower=0, strict_lower=True)
+    optimal_radius = quantity("optimal_radius", optimal_radius, lower=0, strict_lower=True)
+    peak_partition = quantity("peak_partition", peak_partition, lower=0, strict_lower=True)
+    youngs_modulus = quantity("youngs_modulus", youngs_modulus, lower=0, strict_lower=True)
+    temperature = quantity("temperature", temperature, lower=0, strict_lower=True)
+    misfit = ionic_radius - optimal_radius
+    strain = 4 * np.pi * youngs_modulus * AVOGADRO * (optimal_radius / 2 * misfit**2 + misfit**3 / 3)
+    return peak_partition * np.exp(-strain / (R_GAS * temperature))
+
+
+@model
+def isotope_temperature(delta_calcite, delta_water):
+    """Calcite-water oxygen-isotope paleotemperature.
+
+    The oxygen-isotope fractionation between a shell and the water it grew in falls with temperature, so fossil shells
+    record ancient ocean temperatures.
+
+    Parameters
+    ----------
+    delta_calcite : float or array_like
+        per mil, delta18O of the carbonate (CO2 from the calcite, PDB scale); constraint: real.
+    delta_water : float or array_like
+        per mil, delta18O of the water on the same scale; constraint: real.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [K]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Urey (1947) predicted the effect; this is the empirical calibration of Epstein, Buchsbaum, Lowenstam and Urey (1953),
+    valid for about 7-30 degC and equilibrium calcite.
+    Equation: ``273.15 + 16.5 - 4.3 * d + 0.14 * d**2`` with ``d = delta_calcite - delta_water``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    delta_calcite = quantity("delta_calcite", delta_calcite)
+    delta_water = quantity("delta_water", delta_water)
+    difference = delta_calcite - delta_water
+    return 273.15 + 16.5 - 4.3 * difference + 0.14 * difference**2

earthsciencekit/volcanology/systems/geochronology.py

@@ -0,0 +1,304 @@
+"""Geochronology: radioactive decay, the age equation, radiocarbon, lead-lead ages, the concordia and the isochron.
+
+SI units unless stated otherwise; ages and half-lives are seconds and decay constants 1/s.
+"""
+
+import numpy as np
+from scipy.optimize import brentq
+
+from earthsciencekit._validation import model, quantity, require
+from earthsciencekit.constants import LAMBDA_U235, LAMBDA_U238, LIBBY_MEAN_LIFE, SECONDS_PER_YEAR, U238_U235
+
+__all__ = [
+    "decay_constant",
+    "parent_fraction",
+    "radiometric_age",
+    "radiogenic_daughter",
+    "radiocarbon_age",
+    "radiogenic_lead_ratio",
+    "lead_lead_age",
+    "concordia_ratios",
+    "isochron_fit",
+]
+
+_YOUNGEST, _OLDEST = SECONDS_PER_YEAR, 1e10 * SECONDS_PER_YEAR  # s, the bracket of lead_lead_age
+
+
+@model
+def decay_constant(half_life):
+    """Decay constant from a half-life.
+
+    Every radioactive nuclide has a fixed probability per unit time of decaying, set by its half-life.
+
+    Parameters
+    ----------
+    half_life : float or array_like
+        s; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1/s]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Rutherford and Soddy (1902): first-order decay, independent of temperature, pressure and chemistry.
+    Equation: ``np.log(2) / half_life``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    half_life = quantity("half_life", half_life, lower=0, strict_lower=True)
+    return np.log(2) / half_life
+
+
+@model
+def parent_fraction(decay_constant, time):
+    """Fraction of radioactive parent atoms remaining.
+
+    Exponential decay is the clock behind every radiometric age.
+
+    Parameters
+    ----------
+    decay_constant : float or array_like
+        1/s; constraint: positive.
+    time : float or array_like
+        s; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Rutherford and Soddy (1902): a closed system with no parent added after time zero.
+    Equation: ``np.exp(-decay_constant * time)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    decay_constant = quantity("decay_constant", decay_constant, lower=0, strict_lower=True)
+    time = quantity("time", time, lower=0)
+    return np.exp(-decay_constant * time)
+
+
+@model
+def radiometric_age(daughter_parent_ratio, decay_constant):
+    """Age from a radiogenic daughter-to-parent ratio.
+
+    The ratio of accumulated daughter atoms to surviving parent atoms grows with time, so measuring it dates the rock.
+
+    Parameters
+    ----------
+    daughter_parent_ratio : float or array_like
+        1, radiogenic daughter atoms per parent atom; constraint: nonnegative.
+    decay_constant : float or array_like
+        1/s; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [s]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Closed system with no initial daughter; Boltwood (1907) applied it to lead in uranium minerals.
+    Equation: ``np.log1p(daughter_parent_ratio) / decay_constant``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    daughter_parent_ratio = quantity("daughter_parent_ratio", daughter_parent_ratio, lower=0)
+    decay_constant = quantity("decay_constant", decay_constant, lower=0, strict_lower=True)
+    return np.log1p(daughter_parent_ratio) / decay_constant
+
+
+@model
+def radiogenic_daughter(parent, decay_constant, time):
+    """Radiogenic daughter accumulated beside the surviving parent.
+
+    Forward accumulation shows how the daughter-to-parent ratio of a rock records its age.
+
+    Parameters
+    ----------
+    parent : float or array_like
+        Surviving parent amount today (atoms, moles or any consistent unit); constraint: nonnegative.
+    decay_constant : float or array_like
+        1/s; constraint: positive.
+    time : float or array_like
+        s; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [unit of parent]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Closed system with no initial daughter; the inverse of radiometric_age. Holmes (1913) used it to build the first
+    radiometric time scale.
+    Equation: ``parent * np.expm1(decay_constant * time)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    parent = quantity("parent", parent, lower=0)
+    decay_constant = quantity("decay_constant", decay_constant, lower=0, strict_lower=True)
+    time = quantity("time", time, lower=0)
+    return parent * np.expm1(decay_constant * time)
+
+
+@model
+def radiocarbon_age(fraction_modern):
+    """Conventional radiocarbon age.
+
+    Living matter exchanges carbon-14 with the atmosphere; after death the carbon-14 decays, dating organic remains.
+
+    Parameters
+    ----------
+    fraction_modern : float or array_like
+        1, sample 14C/12C relative to the modern standard; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [s]; negative for bomb carbon above the standard. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Libby et al. (1949) with the conventional 5568-year (Libby) half-life, mean life LIBBY_MEAN_LIFE; it is a radiocarbon
+    age, not a calendar age, until calibrated.
+    Equation: ``-LIBBY_MEAN_LIFE * np.log(fraction_modern)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    fraction_modern = quantity("fraction_modern", fraction_modern, lower=0, strict_lower=True)
+    return -LIBBY_MEAN_LIFE * np.log(fraction_modern)
+
+
+@model
+def radiogenic_lead_ratio(time):
+    """Radiogenic 207Pb/206Pb ratio produced over a given age.
+
+    Two uranium isotopes decaying at different rates make the ratio of their lead daughters a clock that needs no uranium
+    measurement.
+
+    Parameters
+    ----------
+    time : float or array_like
+        s; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [1]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Patterson (1956): closed system with today's 238U/235U = U238_U235 and the Jaffey et al. (1971) decay constants. The
+    ratio tends to LAMBDA_U235 / (U238_U235 * LAMBDA_U238) at zero age.
+    Equation: ``np.expm1(LAMBDA_U235 * time) / (U238_U235 * np.expm1(LAMBDA_U238 * time))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    time = quantity("time", time, lower=0, strict_lower=True)
+    return np.expm1(LAMBDA_U235 * time) / (U238_U235 * np.expm1(LAMBDA_U238 * time))
+
+
+@model
+def lead_lead_age(lead_ratio):
+    """Age from a radiogenic 207Pb/206Pb ratio.
+
+    Patterson dated the Earth from the slope of a meteorite lead isochron, which equals this ratio.
+
+    Parameters
+    ----------
+    lead_ratio : float or array_like
+        1, radiogenic 207Pb*/206Pb* or the slope of a Pb-Pb isochron; constraint: between the ratios at one year
+        (about 0.0461) and at 10 Ga.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [s]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Inverts radiogenic_lead_ratio by Brent's method between one year and 10 Ga; same closed-system assumptions.
+    Equation: ``radiogenic_lead_ratio(age) = lead_ratio``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    """
+    lead_ratio = quantity("lead_ratio", lead_ratio)
+    require(lead_ratio >= radiogenic_lead_ratio(_YOUNGEST), "lead_ratio is below the ratio at one year")
+    require(lead_ratio <= radiogenic_lead_ratio(_OLDEST), "lead_ratio exceeds the ratio at 10 Ga")
+
+    def solve(ratio):
+        return brentq(lambda age: radiogenic_lead_ratio(age) - ratio, _YOUNGEST, _OLDEST, xtol=1e-6 * SECONDS_PER_YEAR, rtol=1e-14)
+
+    return np.vectorize(solve, otypes=[float])(lead_ratio)[()]
+
+
+@model
+def concordia_ratios(time):
+    """Point on the Wetherill U-Pb concordia.
+
+    Both uranium-lead clocks agree only on this curve, so a zircon off it has lost lead and its chord dates the loss.
+
+    Parameters
+    ----------
+    time : float or array_like
+        s; constraint: nonnegative.
+
+    Returns
+    -------
+    ndarray, shape (..., 2)
+        Model value [1]: ``[207Pb*/235U, 206Pb*/238U]``, the horizontal and vertical concordia coordinates.
+
+    Notes
+    -----
+    Wetherill (1956): closed system with the Jaffey et al. (1971) decay constants. Episodic lead loss puts samples on a
+    straight chord (discordia) between the concordia points of formation and loss.
+    Equation: ``[np.expm1(LAMBDA_U235 * time), np.expm1(LAMBDA_U238 * time)]``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    time = quantity("time", time, lower=0)
+    return np.stack([np.expm1(LAMBDA_U235 * time), np.expm1(LAMBDA_U238 * time)], axis=-1)
+
+
+@model
+def isochron_fit(parent_ratio, daughter_ratio, decay_constant):
+    """Age and initial ratio from a whole-rock or mineral isochron.
+
+    Cogenetic minerals with different parent contents line up on a straight line whose slope gives the age without knowing
+    the initial daughter.
+
+    Parameters
+    ----------
+    parent_ratio : array_like, shape (n,), n >= 2
+        1, parent over a stable reference isotope (e.g. 87Rb/86Sr); constraint: nonnegative, not all equal.
+    daughter_ratio : array_like, shape (n,)
+        1, daughter over the same reference isotope (e.g. 87Sr/86Sr); constraint: nonnegative.
+    decay_constant : float
+        1/s; constraint: positive scalar.
+
+    Returns
+    -------
+    numpy.ndarray, shape (2,)
+        ``[age, initial_ratio]``: the age [s] from the least-squares slope and the intercept [1].
+
+    Notes
+    -----
+    Nicolaysen (1961): every sample formed at the same time with the same initial ratio and stayed closed; ordinary least
+    squares without measurement-error weighting (a York fit would weight them). The slope must be positive.
+    Equation: ``daughter_ratio = initial_ratio + parent_ratio * np.expm1(decay_constant * age)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    """
+    parent_ratio = quantity("parent_ratio", parent_ratio, lower=0)
+    daughter_ratio = quantity("daughter_ratio", daughter_ratio, lower=0)
+    decay_constant = quantity("decay_constant", decay_constant, lower=0, strict_lower=True)
+    require(parent_ratio.ndim == 1 and parent_ratio.size >= 2, "parent_ratio must be a vector of at least two samples")
+    require(daughter_ratio.shape == parent_ratio.shape, "daughter_ratio must match parent_ratio")
+    require(decay_constant.ndim == 0, "decay_constant must be a scalar")
+    anomaly = parent_ratio - parent_ratio.mean()
+    require(np.any(anomaly != 0), "parent_ratio must vary")
+    slope = np.dot(anomaly, daughter_ratio - daughter_ratio.mean()) / np.dot(anomaly, anomaly)
+    require(slope > 0, "isochron slope must be positive")
+    return np.array([np.log1p(slope) / decay_constant, daughter_ratio.mean() - slope * parent_ratio.mean()])