As AtmosphericPrisonEscape mentioned in a comment, this could in principle be done, but there are some difficulties involved.
Let's consider a very idealistic case in which we are able to measure the light curve of a star for a long period of time, at regular intervals, and we see many transits.
In this toy model each transiting planet is described by four parameters:
- The orbital period $P$
- the contrast ratio $k = {R_p^2 \over R_s^2}$, where $R_p$ and $R_s$ are the effective radius of the planet and the star, respectively.
- the transit duration $\tau$.
- the time of first transit $t_0$, which is chosen arbitrary of as the middle time of one of the transits.
The ligth curve $lc(t) $ can be then modelled as follows:
- when there is no planet transiting, $lc(t) = 1$
- when there are one or more planets transiting, $lc(t) = 1- \sum k_i$, where $k_i$ is the contrast ratio of the i-th planet that is transiting at time $t$.
This model can be easily implemented in python:
import numpy as np
class Planet_Transit:
def __init__(self, period, contrast_ratio, transit_duration, first_transit_time):
"""
This class contains the bare minimum parameters necessary to describe a planet
transiting in front of a star
"""
self.P = period # the orbital period
self.k = contrast_ratio # the square of the ratio of the effective
# radii of the planet and of the star
self.tau = transit_duration # the time it takes to transit
self.t0 = first_transit_time # the time at which the planet is at
# the middle point of a transit.
# It is needed to fix a reference time
def is_in_transit(self, t):
"""
return whether the planet is transiting the star at time t
"""
return np.mod(t - (self.t0-self.tau/2), self.P) < self.tau
def light_curve(t_start, t_end, dt, planet_transits):
Dt = t_end-t_start
t = np.linspace(t_start, t_end, int(Dt/dt))
lc = np.ones(t.shape) # the light curve
for p in planet_transits:
lc = lc - p.k * p.is_in_transit(t)
return t, lc
So, for example, we could have two planets with the following characteristics
$$P_1 = 8, P_2 = 13$$
$$k_1 = 0.01, k_2 = 0.005$$
$$k_1 = 0.01, k_2 = 0.005$$
$$\tau_1 = 0.1, \tau_2 = 0.06$$
$$t_{0,1} = 0.3, t_{0,2} = 0.5$$
Plotting the light curve gives
import matplotlib.pyplot as plt
P1 = 8
P2 = 13
planet_transits =[
Planet_Transit(P1, 0.01, 0.1, 0.3),
Planet_Transit(P2, 0.005, 0.06, 0.5)
]
t_start = 0
t_end = 1
dt = 0.001
t, lc = light_curve(t_start, t_end, dt, planet_transits)
plt.plot(t, lc)
plt.xlabel("time")
plt.ylabel("light curve")
plt.show()
the two transits are neat and clearly visible. If we look at the star for a longer time, we see a clear pattern.
In this simple example it is easy to see that there are two planets, just by looking at the light curve. Will taking the Fourier transform make things even simpler?
Let's plot the Fourier transform of the latest plot:
from scipy.fft import fft
# The array of frequencies
freq = np.linspace(0, 1/dt, len(t))
# The fourier transform. Notice that I subtract 1 from lc, in order to
# suppress the zero frequency mode.
transform = np.abs(fft(lc-1))
plt.plot(freq, transform)
... a forest of peaks... probably not what you expected. But if you zoom on the region where we know there are the planet's orbital frequencies (marked with a red line) we see that at least there are two peaks corresponding to the planet's frequencies.
# The array of frequencies
freq = np.linspace(0, 1/dt, len(t))
# The fourier transform. Notice that I subtract 1 from lc, in order to
# suppress the zero frequency mode.
transform = np.abs(fft(lc-1))
plt.plot(freq, transform)
plt.xlim(0,1)
plt.axvline(1/P1, color="red")
plt.axvline(1/P2, color="red")
plt.show()
All the other peaks appear because the function we are transforming is not just the sum of two $\sin$ functions. It contains many other frequencies that are shown in the Fourier transforms as peaks. Furthermore, we are not guaranteed that the peak with the lowest frequency will be a planet, because it could be an alias of a higher frequency.
Analyzing the Fourier transform looking for planets is thus not straightforward. Moreover, this is a very idealized case. In reality things can only become much worse. A real light curve will be much more complicated: there will be a phase modulation, limb darkening effects, starspots and flares, and noise, lots of it, at all the frequencies. If there are many planets in the system, there could also be transit time variations, so that the time between one transit and the next one is not fixed.
If this wasn't enough, we must also consider that it is not common to be able to observe a star for a very long time, taking data points at regular intervals without any interruption. But if the points are not regularly spaced in time, one cannot use a Fourier transform. And this is why other methods such as the Lomb-Scargle peridogram are sometimes preferred.
