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