Box Least Squares

Basic Usage

import numpy as np
import astropy.units as u
from astropy.timeseries import BoxLeastSquares

# Prepare data
# time, flux, and flux_err should be numpy arrays or Quantities
t = time * u.day  # Add units if not already present
y = flux
dy = flux_err  # Optional but recommended

# Create BLS object
model = BoxLeastSquares(t, y, dy=dy)

# Automatic period search with specified duration
duration = 0.2 * u.day  # Expected transit duration
periodogram = model.autopower(duration)

# Extract results
best_period = periodogram.period[np.argmax(periodogram.power)]
print(f"Best period: {best_period:.5f}")

Using autopower vs power

autopower: Automatic Period Grid

Recommended for initial searches. Automatically determines appropriate period grid:

# Specify duration (or multiple durations)
duration = 0.2 * u.day
periodogram = model.autopower(duration)

# Or search multiple durations
durations = [0.1, 0.15, 0.2, 0.25] * u.day
periodogram = model.autopower(durations)

power: Custom Period Grid

For more control over the search:

# Define custom period grid
periods = np.linspace(2.0, 10.0, 1000) * u.day
duration = 0.2 * u.day

periodogram = model.power(periods, duration)

Warning: Period grid quality matters! Too coarse and you'll miss the true period.

Objective Functions

BLS supports two objective functions:

1. Log Likelihood (default)

Maximizes the statistical likelihood of the model fit:

periodogram = model.autopower(0.2 * u.day, objective='likelihood')

2. Signal-to-Noise Ratio (SNR)

Uses the SNR with which the transit depth is measured:

periodogram = model.autopower(0.2 * u.day, objective='snr')

The SNR objective can improve reliability in the presence of correlated noise.

Complete Example

import numpy as np
import matplotlib.pyplot as plt
import astropy.units as u
from astropy.timeseries import BoxLeastSquares

# Load and prepare data
data = np.loadtxt('light_curve.txt')
time = data[:, 0] * u.day
flux = data[:, 1]
flux_err = data[:, 3]

# Create BLS model
model = BoxLeastSquares(time, flux, dy=flux_err)

# Run BLS with automatic period grid
# Try multiple durations to find best fit
durations = np.linspace(0.05, 0.3, 10) * u.day
periodogram = model.autopower(durations, objective='likelihood')

# Find peak
max_power_idx = np.argmax(periodogram.power)
best_period = periodogram.period[max_power_idx]
best_duration = periodogram.duration[max_power_idx]
best_t0 = periodogram.transit_time[max_power_idx]
max_power = periodogram.power[max_power_idx]

print(f"Period: {best_period:.5f}")
print(f"Duration: {best_duration:.5f}")
print(f"T0: {best_t0:.5f}")
print(f"Power: {max_power:.2f}")

# Plot periodogram
import matplotlib.pyplot as plt
plt.plot(periodogram.period, periodogram.power)
plt.xlabel('Period [days]')
plt.ylabel('BLS Power')
plt.show()

Peak Statistics for Validation

Use compute_stats() to calculate detailed statistics about a candidate transit:

# Get statistics for the best period
stats = model.compute_stats(
    periodogram.period[max_power_idx],
    periodogram.duration[max_power_idx],
    periodogram.transit_time[max_power_idx]
)

# Key statistics for validation
print(f"Depth: {stats['depth']:.6f}")
print(f"Depth uncertainty: {stats['depth_err']:.6f}")
print(f"SNR: {stats['depth_snr']:.2f}")
print(f"Odd/Even mismatch: {stats['depth_odd'] - stats['depth_even']:.6f}")
print(f"Number of transits: {stats['transit_count']}")

# Check for false positives
if abs(stats['depth_odd'] - stats['depth_even']) > 3 * stats['depth_err']:
    print("Warning: Significant odd-even mismatch - may not be planetary")

Validation criteria:

• High depth SNR (>7): Strong signal
• Low odd-even mismatch: Consistent transit depth
• Multiple transits observed: More reliable
• Reasonable duration: Not too long or too short for orbit

Period Grid Sensitivity

The BLS periodogram is sensitive to period grid spacing. The autoperiod() method provides a conservative grid:

# Get automatic period grid
periods = model.autoperiod(durations, minimum_period=1*u.day, maximum_period=10*u.day)
print(f"Period grid has {len(periods)} points")

# Use this grid with power()
periodogram = model.power(periods, durations)

Tips:

• Use autopower() for initial searches
• Use finer grids around promising candidates
• Period grid quality matters more for BLS than for Lomb-Scargle

Comparing BLS Results

To compare multiple peaks:

# Find top 5 peaks
sorted_idx = np.argsort(periodogram.power)[::-1]
top_5 = sorted_idx[:5]

print("Top 5 candidates:")
for i, idx in enumerate(top_5):
    period = periodogram.period[idx]
    power = periodogram.power[idx]
    duration = periodogram.duration[idx]

    stats = model.compute_stats(period, duration, periodogram.transit_time[idx])

    print(f"\n{i+1}. Period: {period:.5f}")
    print(f"   Power: {power:.2f}")
    print(f"   Duration: {duration:.5f}")
    print(f"   SNR: {stats['depth_snr']:.2f}")
    print(f"   Transits: {stats['transit_count']}")

Phase-Folded Light Curve

After finding a candidate, phase-fold to visualize the transit:

# Fold the light curve at the best period
phase = ((time.value - best_t0.value) % best_period.value) / best_period.value

# Plot to verify transit shape
import matplotlib.pyplot as plt
plt.plot(phase, flux, '.')
plt.xlabel('Phase')
plt.ylabel('Flux')
plt.show()

BLS vs Transit Least Squares (TLS)

Both methods search for transits, but differ in implementation:

Box Least Squares (BLS)

Pros:

• Built into Astropy (no extra install)
• Fast for targeted searches
• Good statistical framework
• compute_stats() provides detailed validation

Cons:

• Simpler transit model (box shape)
• Requires careful period grid setup
• May be less sensitive to grazing transits

Transit Least Squares (TLS)

Pros:

• More sophisticated transit models
• Generally more sensitive
• Better handles grazing transits
• Automatic period grid is more robust

Cons:

• Requires separate package
• Slower for very long time series
• Less control over transit shape

Recommendation: Try both! TLS is often more sensitive, but BLS is faster and built-in.

Integration with Preprocessing

BLS works best with preprocessed data. Consider this pipeline:

1. Quality filtering: Remove flagged data points
2. Outlier removal: Clean obvious artifacts
3. Detrending: Remove stellar variability (rotation, trends)
4. BLS search: Run period search on cleaned data
5. Validation: Use compute_stats() to check candidate quality

Key Considerations

• Preprocessing should preserve transit shapes (use gentle methods like flatten())
• Don't over-process - too aggressive cleaning removes real signals
• BLS needs reasonable period and duration ranges
• Always validate with multiple metrics (power, SNR, odd-even)

Common Issues

Issue: No clear peak

Causes:

• Transits too shallow
• Wrong duration range
• Period outside search range
• Over-aggressive preprocessing

Solutions:

• Try wider duration range
• Extend period search range
• Use less aggressive flatten() window
• Check raw data for transits

Issue: Period is 2× or 0.5× expected

Causes:

• Missing alternating transits
• Data gaps
• Period aliasing

Solutions:

• Check both periods manually
• Examine odd-even statistics
• Look at phase-folded plots for both periods

Issue: High odd-even mismatch

Cause:

• Not a planetary transit
• Eclipsing binary
• Instrumental artifact

Solution:

• Check stats['depth_odd'] vs stats['depth_even']
• May not be a transiting planet

Dependencies

pip install astropy numpy matplotlib
# Optional: lightkurve for preprocessing
pip install lightkurve

References

Official Documentation

• Astropy BLS Documentation
• Astropy Time Series Guide

Key Papers

• Kovács, Zucker, & Mazeh (2002): Original BLS paper - A&A 391, 369
• Hartman & Bakos (2016): VARTOOLS implementation - A&C 17, 1

Related Resources

• Lightkurve Tutorials
• TLS GitHub - Alternative transit detection method

When to Use BLS

Use BLS when:

• You want a fast, built-in solution
• You need detailed validation statistics (compute_stats)
• Working within the Astropy ecosystem
• You want fine control over period grid

Use TLS when:

• Maximum sensitivity is critical
• Dealing with grazing or partial transits
• Want automatic robust period grid
• Prefer more sophisticated transit models

Use Lomb-Scargle when:

• Searching for general periodic signals (not specifically transits)
• Detecting stellar rotation, pulsation
• Initial exploration of periodicity

For exoplanet detection, both BLS and TLS are valid choices. Try both and compare results!