GTLS: GPU Transit Least Squares

GTLS is a CUDA implementation of the Transit Least Squares (TLS) algorithm for detecting periodic exoplanet transits in light curves. It keeps the TLS interface and transit model, and evaluates all trial periods, durations and epochs in parallel on an NVIDIA GPU, which makes it several times faster than CPU TLS.

Features

• Drop-in replacement for the transitleastsquares search API
• Limb-darkened transit templates (default, grazing and box-shaped)
• Batches trial periods automatically to fit the free GPU memory
• Refines the strongest peaks and their period aliases (P/2, 2P, 2P/3, 3P/2) with a full search at every cadence
• Supports multi-GPU machines: pick a device with GPUDeviceID or split one search across several with GPUDeviceIDs

Requirements

• An NVIDIA GPU with CUDA
• Python >= 3.8
• CuPy matching your CUDA version

Installation

CuPy wheels depend on the local CUDA version, so CuPy is not a hard dependency. Install CuPy following the official guide, then install GTLS:

pip install gputls

Or let pip pick a CuPy build for you:

pip install "gputls[cuda12]"   # CUDA 12.x
pip install "gputls[cuda11]"   # CUDA 11.x

To install from source:

git clone https://github.com/Farthing-0/GTLS.git
cd GTLS
pip install .

Quick start

from gputls import gtls

# time in days, flux normalized to 1, optional flux uncertainties dy
model = gtls(time, flux, dy)
result = model.power()

print(result.period, result.T0, result.duration, result.depth, result.SDE)

power() accepts the same keyword arguments as TLS. Commonly used ones:

Results

power() returns a gtlsResult object with the following attributes:

Examples

The examples/ folder contains Jupyter notebooks comparing GTLS with TLS:

• tess_tutorial.ipynb: a TESS target
• kepler_tutorial.ipynb: a Kepler target downloaded with lightkurve

The notebooks also need matplotlib, astropy, transitleastsquares, lightkurve and wotan.

Testing

The test suite runs end-to-end searches on the GPU: injection-recovery on a synthetic light curve, the fast mode, a real Kepler light curve stored in tests/data/, release of GPU memory after a search, and (on machines with at least two GPUs) bitwise agreement between single- and multi-GPU searches. It needs astropy in addition to the runtime dependencies.

One-click build, install and test (inside an environment where CuPy is installed):

./run_tests.sh            # GPU 0
./run_tests.sh 1          # GPU 1
PYTHON=/path/to/python ./run_tests.sh

The script reinstalls only gputls itself (--no-deps) and then runs tests/test_gtls.py. The tests can also be run with pytest tests; select the GPU with the GTLS_GPU_DEVICE environment variable.

Project structure

GTLS/
├── src/gputls/          # Python package
│   ├── main.py          # gtls class (public API)
│   ├── core.py          # GPU search driver
│   ├── kernels.cu       # CUDA kernels, compiled at runtime by CuPy
│   ├── grid.py          # period and duration grids
│   ├── transit.py       # transit templates (batman)
│   ├── stats.py         # periodogram and SNR statistics
│   ├── validate.py      # input and argument validation
│   ├── constants.py     # default parameters
│   └── ...
├── tests/               # GPU test suite and test data
├── examples/            # Jupyter notebooks
├── docs/images/         # Figures used in the documentation
├── run_tests.sh         # One-click build and test
└── pyproject.toml

Acknowledgements and license

GTLS is adapted from TLS by Michael Hippke and René Heller. If you use GTLS, please also cite the TLS paper: Hippke, M. & Heller, R. (2019), Optimized transit detection algorithm to search for periodic transits of small planets, A&A 623, A39.

Both TLS and GTLS are released under the MIT License.