earthsciencekit 0.2.0__py3-none-any.whl

earthsciencekit/atmosphere/tests/test_physics.py

@@ -0,0 +1,81 @@
+"""Physical identities, limits and dynamic checks for earthsciencekit.atmosphere."""
+
+import numpy as np
+import pytest
+
+from earthsciencekit.atmosphere.systems.dynamics import rossby_wave_speed, simulate_barotropic_vorticity
+from earthsciencekit.atmosphere.systems.hydrostatics import barometer_column_height, surface_pressure_tendency, two_layer_temperature
+from earthsciencekit.atmosphere.systems.thermodynamics import potential_temperature, richardson_number, simulate_dry_ascent
+
+
+def test_dry_ascent_conserves_potential_temperature():
+    time = np.linspace(0, 1000, 51)
+    result = simulate_dry_ascent(300, 1e5, 1, time)
+    theta = potential_temperature(result.values[:, 0], result.values[:, 1], 1e5)
+    np.testing.assert_allclose(theta, 300, rtol=1e-8)
+    assert np.all(np.diff(result.values[:, 1]) < 0)
+    with pytest.raises(ValueError):
+        simulate_dry_ascent([300, 310], 1e5, 1, time)
+    with pytest.raises(ValueError):
+        simulate_dry_ascent(300, 1e5, 100, time)
+
+
+def _barotropic_grid(n=16, spacing=6e5):
+    x = np.arange(n) * spacing
+    return np.meshgrid(x, x), n * spacing
+
+
+def test_barotropic_single_mode_is_rossby_wave():
+    beta, spacing = 1.6e-11, 6e5
+    (X, Y), length = _barotropic_grid(spacing=spacing)
+    k, l = 2 * np.pi * 2 / length, 2 * np.pi / length
+    time = np.linspace(3600, 2 * 86400, 7)
+    result = simulate_barotropic_vorticity(1e-5 * np.cos(k * X + l * Y), time, beta, spacing)
+    c = rossby_wave_speed(0, beta, np.hypot(k, l))
+    expected = 1e-5 * np.cos(k * (X[None] - c * (time - time[0])[:, None, None]) + l * Y[None])
+    np.testing.assert_allclose(result.values, expected.reshape(time.size, -1), atol=1e-10)
+    assert result.names[17] == "cell_1_1" and result.units[0] == "1/s"
+
+
+def test_barotropic_conserves_mean_energy_and_enstrophy():
+    spacing = 6e5
+    (X, Y), length = _barotropic_grid(spacing=spacing)
+    rng = np.random.default_rng(1)
+    modes = [(i, j) for i in range(1, 4) for j in range(-3, 4)]
+    zeta = 2e-6 + sum(1e-5 * rng.normal() * np.cos(2 * np.pi * (i * X + j * Y) / length + rng.uniform(0, 2 * np.pi)) for i, j in modes)
+    result = simulate_barotropic_vorticity(zeta, np.linspace(0, 86400, 5), 1.6e-11, spacing)
+    fields = result.values.reshape(-1, *X.shape)
+    np.testing.assert_allclose(fields.mean(axis=(1, 2)), 0, atol=1e-20)
+    spectra = np.abs(np.fft.fft2(fields)) ** 2
+    k2 = (2 * np.pi * np.fft.fftfreq(X.shape[0], spacing)[:, None]) ** 2 + (2 * np.pi * np.fft.fftfreq(X.shape[1], spacing)[None, :]) ** 2
+    energy = np.sum(np.divide(spectra, k2, out=np.zeros_like(spectra), where=k2 > 0), axis=(1, 2))
+    np.testing.assert_allclose(spectra.sum(axis=(1, 2)), spectra[0].sum(), rtol=1e-5)
+    np.testing.assert_allclose(energy, energy[0], rtol=1e-5)
+    assert not np.allclose(fields[-1], fields[0])
+
+
+@pytest.mark.parametrize(
+    "zeta,beta,spacing",
+    [(np.zeros((3, 8)), 1e-11, 1e5), (np.zeros(16), 1e-11, 1e5), (np.zeros((4, 4)), [1e-11, 1e-11], 1e5), (np.zeros((4, 4)), 1e-11, 0)],
+)
+def test_barotropic_rejects_bad_setup(zeta, beta, spacing):
+    with pytest.raises(ValueError):
+        simulate_barotropic_vorticity(zeta, [0, 1], beta, spacing)
+
+
+def test_two_layer_profile_hydrostatic_pressure_matches_standard_atmosphere():
+    height = np.linspace(0, 11000, 2001)
+    temperature = two_layer_temperature(height, 288.15, 0.0065, 11000)
+    integrand = 9.80665 / (287.05 * temperature)
+    log_ratio = np.sum((integrand[1:] + integrand[:-1]) / 2 * np.diff(height))
+    assert np.isclose(101325 * np.exp(-log_ratio), 101325 * (216.65 / 288.15) ** (9.80665 / (287.05 * 0.0065)), rtol=1e-7)
+    assert two_layer_temperature(20000, 288.15, 0.0065, 11000) == two_layer_temperature(11000, 288.15, 0.0065, 11000)
+
+
+def test_richardson_and_rossby_limits():
+    assert richardson_number(-1e-4, 0.01) < 0 < richardson_number(1e-4, -0.01)
+    beta, wind = 1.6e-11, 15.0
+    assert np.isclose(rossby_wave_speed(wind, beta, np.sqrt(beta / wind)), 0, atol=1e-12)
+    assert rossby_wave_speed(wind, 0, 1e-6) == wind
+    assert np.isclose(surface_pressure_tendency(-1e-6, 1e5) * 21600, 2160)
+    assert np.isclose(barometer_column_height(101325, 13595.1, 9.80665), 0.76, rtol=1e-4)

earthsciencekit/atmosphere/visualizers/__init__.py

@@ -0,0 +1,9 @@
+"""Plots for earthsciencekit.atmosphere.
+
+The dynamic models return a TimeSeries, whose ``plot`` and ``animate`` methods
+call these package-wide helpers.
+"""
+
+from earthsciencekit.visualizers import animate_series, plot_series
+
+__all__ = ["plot_series", "animate_series"]

earthsciencekit/climate/__init__.py

@@ -0,0 +1,63 @@
+"""Inspectable climate models; SI units unless stated otherwise."""
+
+from earthsciencekit.climate.systems.carbon import (
+    carbon_airborne_fraction,
+    carbon_decay,
+)
+from earthsciencekit.climate.systems.forcing import (
+    co2_forcing,
+    methane_forcing,
+    nitrous_oxide_forcing,
+)
+from earthsciencekit.climate.systems.radiation import (
+    absorbed_solar,
+    daily_insolation,
+    effective_temperature,
+    greenhouse_surface_temperature,
+    outgoing_longwave,
+    radiative_convective_temperature,
+)
+from earthsciencekit.climate.systems.response import (
+    equilibrium_solar_constant,
+    equilibrium_warming,
+    gregory_regression,
+    heat_capacity_column,
+    heat_uptake,
+    ice_albedo,
+    planck_feedback,
+    red_noise_spectrum,
+    response_timescale,
+    simulate_one_box,
+    step_temperature,
+)
+from earthsciencekit.climate.systems.sea_level import (
+    thermal_expansion_sea_level,
+    water_equivalent_sea_level,
+)
+
+__all__ = [
+    "absorbed_solar",
+    "effective_temperature",
+    "outgoing_longwave",
+    "planck_feedback",
+    "co2_forcing",
+    "equilibrium_warming",
+    "heat_capacity_column",
+    "response_timescale",
+    "step_temperature",
+    "heat_uptake",
+    "ice_albedo",
+    "carbon_airborne_fraction",
+    "carbon_decay",
+    "thermal_expansion_sea_level",
+    "water_equivalent_sea_level",
+    "greenhouse_surface_temperature",
+    "daily_insolation",
+    "radiative_convective_temperature",
+    "equilibrium_solar_constant",
+    "red_noise_spectrum",
+    "methane_forcing",
+    "nitrous_oxide_forcing",
+    "gregory_regression",
+    "simulate_one_box",
+]

earthsciencekit/climate/core/__init__.py

@@ -0,0 +1,5 @@
+"""Result containers for earthsciencekit.climate."""
+
+from earthsciencekit.climate.core.base import TimeSeries
+
+__all__ = ["TimeSeries"]

earthsciencekit/climate/core/base.py

@@ -0,0 +1,10 @@
+"""Result containers for earthsciencekit.climate.
+
+Algebraic models return NumPy scalars or arrays. The sampled dynamic models
+return the package-wide immutable :class:`~earthsciencekit.results.TimeSeries`,
+which is re-exported here as this domain's result type.
+"""
+
+from earthsciencekit.results import TimeSeries
+
+__all__ = ["TimeSeries"]

earthsciencekit/climate/systems/__init__.py

@@ -0,0 +1 @@
+"""Models of earthsciencekit.climate, grouped by topic."""

earthsciencekit/climate/systems/carbon.py

@@ -0,0 +1,76 @@
+"""Carbon budget: airborne fraction and single-reservoir decay.
+
+SI units unless stated otherwise.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity
+
+__all__ = [
+    "carbon_airborne_fraction",
+    "carbon_decay",
+]
+
+
+@model
+def carbon_airborne_fraction(atmospheric_increase, emissions):
+    """Carbon budget fraction.
+
+    A carbon mass budget partitions emissions and atmospheric accumulation.
+
+    Parameters
+    ----------
+    atmospheric_increase : float or array_like
+        kg C; constraint: nonnegative.
+    emissions : float or array_like
+        kg C; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Same time interval and carbon mass units; feedback-driven values above one are not clipped.
+    Equation: ``atmospheric_increase / emissions``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    atmospheric_increase = quantity("atmospheric_increase", atmospheric_increase, lower=0)
+    emissions = quantity("emissions", emissions, lower=0, strict_lower=True)
+    return atmospheric_increase / emissions
+
+
+@model
+def carbon_decay(initial_excess, timescale, time):
+    """Single-reservoir carbon relaxation.
+
+    A reservoir model illustrates first-order removal and residence time.
+
+    Parameters
+    ----------
+    initial_excess : float or array_like
+        kg C; constraint: nonnegative.
+    timescale : float or array_like
+        s; constraint: positive.
+    time : float or array_like
+        s; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Not a realistic complete atmospheric CO2 impulse response, which has multiple timescales.
+    Equation: ``initial_excess * np.exp(-time / timescale)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    initial_excess = quantity("initial_excess", initial_excess, lower=0)
+    timescale = quantity("timescale", timescale, lower=0, strict_lower=True)
+    time = quantity("time", time, lower=0)
+    return initial_excess * np.exp(-time / timescale)

earthsciencekit/climate/systems/forcing.py

@@ -0,0 +1,124 @@
+"""Radiative forcing of the well-mixed greenhouse gases.
+
+SI units unless stated otherwise.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity
+
+__all__ = [
+    "co2_forcing",
+    "methane_forcing",
+    "nitrous_oxide_forcing",
+]
+
+
+@model
+def co2_forcing(concentration, reference_concentration, coefficient):
+    """Logarithmic CO2 forcing approximation.
+
+    A logarithmic approximation connects concentration changes to a forcing perturbation.
+
+    Parameters
+    ----------
+    concentration : float or array_like
+        ppm; constraint: positive.
+    reference_concentration : float or array_like
+        ppm; constraint: positive.
+    coefficient : float or array_like
+        W/m^2; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    User-supplied coefficient; an educational parameterization, not a current assessed forcing product.
+    Equation: ``coefficient * np.log(concentration / reference_concentration)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    concentration = quantity("concentration", concentration, lower=0, strict_lower=True)
+    reference_concentration = quantity("reference_concentration", reference_concentration, lower=0, strict_lower=True)
+    coefficient = quantity("coefficient", coefficient, lower=0, strict_lower=True)
+    return coefficient * np.log(concentration / reference_concentration)
+
+
+def _methane_nitrous_overlap(methane, nitrous_oxide):
+    """Myhre et al. (1998) CH4-N2O band overlap in W/m^2; concentrations in ppb."""
+    product = methane * nitrous_oxide
+    return 0.47 * np.log(1 + 2.01e-5 * product**0.75 + 5.31e-15 * methane * product**1.52)
+
+
+@model
+def methane_forcing(concentration, reference_concentration, nitrous_oxide):
+    """Methane radiative forcing (Myhre et al. 1998).
+
+    Methane forcing grows as a square root of concentration, less the band it shares with nitrous oxide.
+
+    Parameters
+    ----------
+    concentration : float or array_like
+        ppb; constraint: positive.
+    reference_concentration : float or array_like
+        ppb; constraint: positive.
+    nitrous_oxide : float or array_like
+        ppb, reference N2O concentration; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Simplified fit to line-by-line calculations, valid near present-day concentrations; with
+    ``f(M, N) = 0.47 * log(1 + 2.01e-5 * (M * N)**0.75 + 5.31e-15 * M * (M * N)**1.52)``.
+    Equation: ``0.036 * (sqrt(M) - sqrt(M0)) - (f(M, N0) - f(M0, N0))``, with ``M = concentration``,
+    ``M0 = reference_concentration`` and ``N0 = nitrous_oxide``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    concentration = quantity("concentration", concentration, lower=0, strict_lower=True)
+    reference_concentration = quantity("reference_concentration", reference_concentration, lower=0, strict_lower=True)
+    nitrous_oxide = quantity("nitrous_oxide", nitrous_oxide, lower=0, strict_lower=True)
+    overlap = _methane_nitrous_overlap(concentration, nitrous_oxide) - _methane_nitrous_overlap(reference_concentration, nitrous_oxide)
+    return 0.036 * (np.sqrt(concentration) - np.sqrt(reference_concentration)) - overlap
+
+
+@model
+def nitrous_oxide_forcing(concentration, reference_concentration, methane):
+    """Nitrous oxide radiative forcing (Myhre et al. 1998).
+
+    Nitrous oxide forcing grows as a square root of concentration, less the band it shares with methane.
+
+    Parameters
+    ----------
+    concentration : float or array_like
+        ppb; constraint: positive.
+    reference_concentration : float or array_like
+        ppb; constraint: positive.
+    methane : float or array_like
+        ppb, reference CH4 concentration; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Simplified fit to line-by-line calculations, valid near present-day concentrations; f is the overlap term of methane_forcing.
+    Equation: ``0.12 * (sqrt(N) - sqrt(N0)) - (f(M0, N) - f(M0, N0))``, with ``N = concentration``,
+    ``N0 = reference_concentration`` and ``M0 = methane``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    concentration = quantity("concentration", concentration, lower=0, strict_lower=True)
+    reference_concentration = quantity("reference_concentration", reference_concentration, lower=0, strict_lower=True)
+    methane = quantity("methane", methane, lower=0, strict_lower=True)
+    overlap = _methane_nitrous_overlap(methane, concentration) - _methane_nitrous_overlap(methane, reference_concentration)
+    return 0.12 * (np.sqrt(concentration) - np.sqrt(reference_concentration)) - overlap

earthsciencekit/climate/systems/radiation.py

@@ -0,0 +1,214 @@
+"""Radiation: absorbed sunlight, emission, greenhouse layers, insolation and radiative-convective profiles.
+
+SI units unless stated otherwise.
+"""
+
+import numpy as np
+
+from earthsciencekit._validation import model, quantity
+from earthsciencekit.constants import SIGMA_SB
+
+__all__ = [
+    "absorbed_solar",
+    "effective_temperature",
+    "outgoing_longwave",
+    "greenhouse_surface_temperature",
+    "daily_insolation",
+    "radiative_convective_temperature",
+]
+
+
+@model
+def absorbed_solar(solar_constant, albedo):
+    """Planetary mean absorbed sunlight.
+
+    Sphere geometry and reflection set the global mean solar input.
+
+    Parameters
+    ----------
+    solar_constant : float or array_like
+        W/m^2; constraint: nonnegative.
+    albedo : float or array_like
+        1; constraint: fraction.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Global mean rather than local insolation; fixed bolometric albedo.
+    Equation: ``solar_constant * (1 - albedo) / 4``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    solar_constant = quantity("solar_constant", solar_constant, lower=0)
+    albedo = quantity("albedo", albedo, lower=0, upper=1)
+    return solar_constant * (1 - albedo) / 4
+
+
+@model
+def effective_temperature(absorbed_flux, emissivity):
+    """Radiative equilibrium temperature.
+
+    Stefan-Boltzmann emission links an energy balance to temperature.
+
+    Parameters
+    ----------
+    absorbed_flux : float or array_like
+        W/m^2; constraint: nonnegative.
+    emissivity : float or array_like
+        1; constraint: open fraction.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Single emitting level in equilibrium; not the surface temperature of a greenhouse atmosphere.
+    Equation: ``(absorbed_flux / (emissivity * SIGMA_SB))**0.25``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    absorbed_flux = quantity("absorbed_flux", absorbed_flux, lower=0)
+    emissivity = quantity("emissivity", emissivity, lower=0, upper=1, strict_lower=True)
+    return (absorbed_flux / (emissivity * SIGMA_SB)) ** 0.25
+
+
+@model
+def outgoing_longwave(temperature, emissivity):
+    """Greybody infrared emission.
+
+    A greybody approximation maps temperature to outgoing radiant flux.
+
+    Parameters
+    ----------
+    temperature : float or array_like
+        K; constraint: positive.
+    emissivity : float or array_like
+        1; constraint: fraction.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Constant emissivity; not a spectral atmospheric radiative-transfer solver.
+    Equation: ``emissivity * SIGMA_SB * temperature**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)
+    emissivity = quantity("emissivity", emissivity, lower=0, upper=1)
+    return emissivity * SIGMA_SB * temperature**4
+
+
+@model
+def greenhouse_surface_temperature(absorbed_flux, layer_emissivity):
+    """Surface temperature under one absorbing atmospheric layer.
+
+    A layer that absorbs and re-emits infrared returns part of the surface emission and warms the ground.
+
+    Parameters
+    ----------
+    absorbed_flux : float or array_like
+        W/m^2; constraint: nonnegative.
+    layer_emissivity : float or array_like
+        1; constraint: fraction.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [K]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Blackbody surface, a grey isothermal layer transparent to sunlight; the layer temperature is the surface temperature over 2**0.25.
+    Equation: ``(2 * absorbed_flux / ((2 - layer_emissivity) * SIGMA_SB))**0.25``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    absorbed_flux = quantity("absorbed_flux", absorbed_flux, lower=0)
+    layer_emissivity = quantity("layer_emissivity", layer_emissivity, lower=0, upper=1)
+    return (2 * absorbed_flux / ((2 - layer_emissivity) * SIGMA_SB)) ** 0.25
+
+
+@model
+def daily_insolation(solar_constant, latitude, declination, distance_ratio):
+    """Daily-mean top-of-atmosphere insolation.
+
+    Latitude, solar declination and Earth-Sun distance set the sunlight a latitude receives over a day.
+
+    Parameters
+    ----------
+    solar_constant : float or array_like
+        W/m^2 at the mean Earth-Sun distance; constraint: nonnegative.
+    latitude : float or array_like
+        rad; constraint: closed interval [-pi/2, pi/2].
+    declination : float or array_like
+        rad; constraint: closed interval [-pi/2, pi/2].
+    distance_ratio : float or array_like
+        1, mean over actual Earth-Sun distance; constraint: positive.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [W/m^2]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Declination fixed over the day, no atmosphere; the sunset hour angle h0 is clipped for polar day and night.
+    Equation: ``solar_constant * distance_ratio**2 / pi * (h0 * sin(phi) * sin(delta) + cos(phi) * cos(delta) * sin(h0))``
+    with ``phi = latitude``, ``delta = declination`` and ``h0 = arccos(clip(-tan(phi) * tan(delta), -1, 1))``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    solar_constant = quantity("solar_constant", solar_constant, lower=0)
+    latitude = quantity("latitude", latitude, lower=-np.pi / 2, upper=np.pi / 2)
+    declination = quantity("declination", declination, lower=-np.pi / 2, upper=np.pi / 2)
+    distance_ratio = quantity("distance_ratio", distance_ratio, lower=0, strict_lower=True)
+    hour_angle = np.arccos(np.clip(-np.tan(latitude) * np.tan(declination), -1, 1))
+    geometry = hour_angle * np.sin(latitude) * np.sin(declination) + np.cos(latitude) * np.cos(declination) * np.sin(hour_angle)
+    return solar_constant * distance_ratio**2 / np.pi * geometry
+
+
+@model
+def radiative_convective_temperature(height, effective_temperature, lapse_rate, emission_height):
+    """Radiative-convective equilibrium temperature profile.
+
+    Convection holds the troposphere at a fixed lapse rate below a radiatively balanced stratosphere.
+
+    Parameters
+    ----------
+    height : float or array_like
+        m above the surface; constraint: nonnegative.
+    effective_temperature : float or array_like
+        K; constraint: positive.
+    lapse_rate : float or array_like
+        K/m; constraint: positive.
+    emission_height : float or array_like
+        m; constraint: nonnegative.
+
+    Returns
+    -------
+    numpy scalar or ndarray
+        Model value [K]. Scalar input returns a NumPy scalar; arrays broadcast.
+
+    Notes
+    -----
+    Grey optically thin stratosphere at the skin temperature effective_temperature / 2**0.25; the troposphere
+    passes through effective_temperature at emission_height, so the surface is effective_temperature + lapse_rate * emission_height.
+    Equation: ``np.maximum(effective_temperature + lapse_rate * (emission_height - height), effective_temperature / 2**0.25)``.
+    Invalid, empty, nonreal or nonfinite inputs raise ValueError.
+    NumPy broadcasting applies; singular and overflowing outputs raise ValueError.
+    """
+    height = quantity("height", height, lower=0)
+    effective_temperature = quantity("effective_temperature", effective_temperature, lower=0, strict_lower=True)
+    lapse_rate = quantity("lapse_rate", lapse_rate, lower=0, strict_lower=True)
+    emission_height = quantity("emission_height", emission_height, lower=0)
+    return np.maximum(effective_temperature + lapse_rate * (emission_height - height), effective_temperature / 2**0.25)