RRTMGP.jl

The RRTMGP.jl package is a Julia implementation of the radiative transfer solver RTE (Radiative Transfer for Energetics) and the RRTMGP (RRTM for General circulation model applications—Parallel) correlated-k gas optics (Pincus et al., 2019), based on the reference Fortran implementation rte-rrtmgp. It computes longwave and shortwave radiative fluxes and heating rates for clear, cloudy, and aerosol-laden atmospheres, and is the radiation scheme of the CliMA Earth System Model.

Quick Start

Installation

using Pkg
Pkg.add("RRTMGP")

Basic Usage

The standalone entry points provide a quick start. A gray (single-band) atmosphere uses analytic formulas:

using RRTMGP

out = RRTMGP.solve_gray(Float64; nlay = 60, ncol = 1)
out.net_flux     # net flux at each level [W/m²]
out.heating_rate # radiative heating rate at each layer [K/s]

For the full correlated-k gas optics, build an idealized clear-sky profile and solve it (the lookup tables are downloaded automatically; loading NCDatasets activates them):

using RRTMGP, NCDatasets

profile = RRTMGP.standard_atmosphere(Float64; kind = :tropical)
out = RRTMGP.solve(profile)
out.lw_flux_up[end, 1] # outgoing longwave radiation at the top [W/m²]
out.heating_rate       # radiative heating rate at each layer [K/s]

Host-Model Usage

Climate models construct an RRTMGPSolver once, write their state through the getter contract, and call update_fluxes!(solver) every radiation step:

solver = RRTMGP.RRTMGPSolver(grid_params, method, params, bcs_lw, bcs_sw, as)
RRTMGP.update_fluxes!(solver)          # allocation-free, in place
F = RRTMGP.net_flux(solver)            # (nlev, ncol) view into solver memory

This snippet is schematic; How to drive RRTMGP from a host model shows the full construction, step by step.

Key Features

• Full RRTMGP gas optics: longwave and shortwave correlated-k lookup tables, clouds (with McICA sampling of partial cloudiness), and MERRA aerosols, validated against the Fortran rte-rrtmgp reference fluxes.
• Gray radiation: analytic single-band optics for idealized-climate and teaching use.
• Two-stream and no-scattering solvers for the longwave and shortwave, with optional per-band (spectrally resolved) flux output.
• CPU and GPU: the same code runs single-threaded, multi-threaded, and on CUDA GPUs via ClimaComms.
• Zero-allocation driver: update_fluxes! is allocation-free and type-stable, asserted in CI with @allocated and JET.
• Dual precision: Float32 and Float64 throughout; measured Float32↔Float64 flux differences are a few 10⁻⁴ W/m² in the longwave and a few 10⁻² W/m² in the shortwave, enforced by ratcheting CI thresholds.

Design

RRTMGP.jl is organized in three layers:

1. Functional core: solve_lw! / solve_sw! kernels acting on explicit state (AtmosphericState, optics, sources, boundary conditions, flux workspaces). See the Functional core page.
2. Solver aggregate: RRTMGPSolver bundles the configuration, state, and workspaces; hosts exchange data through documented getters and drive it with update_fluxes!.
3. Standalone entry points: solve_gray(FT), standard_atmosphere(FT), and solve(profile) for classroom use, single-column experiments, and quick starts.

Readers coming from the Fortran implementation can use the Fortran and paper concordance to map names between the two code bases and the underlying papers.

Documentation

• Documentation home: overview and page index.
• Tutorials: a first radiation calculation, and Manabe's radiative-convective equilibrium experiment as a single-column climate model.
• Functional core: the solver kernels, with runnable gray and clear-sky examples.
• Getter contract: the host data-exchange interface.
• API reference: types and functions.

Integration with Climate Models

RRTMGP.jl provides radiative fluxes and heating rates for the CliMA ecosystem, including:

• ClimaAtmos
• ClimaCoupler

Getting Help

For questions, check the documentation or open an issue on GitHub.

Contributing

Contributors should follow the shared CliMA engineering standards in docs/dev-guides/, which cover architecture, performance, code quality, documentation, and workflows. These are vendored from CliMA/DeveloperGuides. The repo's AGENTS.md is a starting point for AI agents with repo-specific guidance.

Acknowledgments

• Robert Pincus, Eli Mlawer, and Jennifer Delamere, the developers of RTE+RRTMGP and its reference Fortran implementation, on which this code is based.
• Robert Pincus for his help and advice during development.