def identifyTces(time, flux, bls_durs_hrs=[1,2,4,8,12], minSnr=3, fracRemain=0.5, \
maxTces=10, minP=None, maxP=None):
"""
Find highest point in the bls.
remove that signal, median detrend again
Find the next signal.
Stop when less than half the original data set remains.
Or, when depth of signal is less than snr*running_std
returns period, t0, depth, duration, snr for each signal found.
"""
keepLooking = True
counter = 0
results = []
stats = []
bls_durs_day=np.array(bls_durs_hrs)/24
t=time.copy()
f=flux.copy()
while keepLooking:
bls_results = findBlsSignal(t, f, bls_durs_day, minP=minP, maxP=maxP)
#print(bls_results)
#simple ssnr because the BLS depth snr is acting strangely
bls_results[4] = simpleSnr(t, f, bls_results)
results.append(bls_results)
bls = BoxLeastSquares(t,f)
bls_stats = bls.compute_stats(bls_results[0], bls_results[3],bls_results[1])
stats.append(bls_stats)
#signal_snr = bls_stats['depth'][0]/bls_stats['depth'
transit_mask = bls.transit_mask(t, bls_results[0],\
bls_results[3]*1.1, bls_results[1])
#plt.figure()
#plt.plot(t,f,'ko',ms=3)
t=t[~transit_mask]
f=f[~transit_mask]
#plt.plot(t,f,'r.')
#Conditions to keep looking
if (len(t)/len(time) > fracRemain) & \
(bls_results[4] >= minSnr) & \
(counter <= maxTces) :
counter=counter + 1
keepLooking = True
else:
keepLooking = False
return np.array(results), np.array(stats)
def find_and_mask_transits(time,
flux,
flux_err,
periods,
durations,
nplanets=1,
plot=False):
"""
Iteratively find and mask transits in the flattened light curve.
Args:
time (array): The time array.
flux (array): The flux array. You'll get the best results
if this is flattened.
flux_err (array): The array of flux uncertainties.
periods (array): The array of periods to search over for BLS.
For example, periods = np.linspace(0.5, 20, 10)
durations (array): The array of durations to search over for BLS.
For example, durations = np.linspace(0.05, 0.2, 10)
nplanets (Optional[int]): The number of planets you'd like to search for.
This function will interatively find and remove nplanets. Default is 1.
Returns:
transit_masks (list): a list of masks that correspond to the in
transit points of each light curve. To mask out transits do
time[~transit_masks[index]], etc.
"""
cum_transit = np.ones(len(time), dtype=bool)
_time, _flux, _flux_err = time * 1, flux * 1, flux_err * 1
t0s, durs, porbs = [np.zeros(nplanets) for i in range(3)]
transit_masks = []
for i in range(nplanets):
bls = BoxLeastSquares(t=_time, y=_flux, dy=_flux_err)
bls.power(periods, durations)
periods = bls.autoperiod(durations,
minimum_n_transit=3,
frequency_factor=5.0)
results = bls.autopower(durations, frequency_factor=5.0)
# Find the period of the peak
period = results.period[np.argmax(results.power)]
# Extract the parameters of the best-fit model
index = np.argmax(results.power)
porbs[i] = results.period[index]
t0s[i] = results.transit_time[index]
durs[i] = results.duration[index]
if plot:
# Plot the periodogram
fig, ax = plt.subplots(1, 1, figsize=(10, 5))
ax.plot(results.period, results.power, "k", lw=0.5)
ax.set_xlim(results.period.min(), results.period.max())
ax.set_xlabel("period [days]")
ax.set_ylabel("log likelihood")
# Highlight the harmonics of the peak period
ax.axvline(period, alpha=0.4, lw=4)
for n in range(2, 10):
ax.axvline(n * period, alpha=0.4, lw=1, linestyle="dashed")
ax.axvline(period / n, alpha=0.4, lw=1, linestyle="dashed")
# plt.show()
# plt.plot(_time, _flux, ".")
# plt.xlim(1355, 1360)
in_transit = bls.transit_mask(_time, porbs[i], durs[i], t0s[i])
transit_masks.append(in_transit)
_time, _flux, _flux_err = _time[~in_transit], _flux[~in_transit], \
_flux_err[~in_transit]
return transit_masks, t0s, durs, porbs