Example #1
0
 def run_acf(self):
     """
     Compute the autocorrelation function.
     """
     self.lags, self.acf = interpacf.interpolated_acf(
         self.l_curve.times,
         self.l_curve.fluxes,
         cadences=self.l_curve.cadences)
 def detect(ts_data, ts_timestamp):
     ts_data = is_array(ts_data)
     ts_timestamp = is_array(ts_timestamp)
     ts_data_ = ts_data - np.mean(ts_data)
     lag, acf = interpolated_acf(ts_timestamp, ts_data_)
     # TODO: 当使用csv_test.csv时,出现detected_period为non的情况
     detected_period = dominant_period(lag, acf, plot=False)
     interval = int(get_interval(ts_timestamp))
     return int(detected_period // interval)
Example #3
0
def fig_acf(lc):
    """
    display the acf results of light curve. However, this package is not robust as 
    Mcquillian method. So we just take it as a reference. The acf accurate results are
    adopted from Mcq+ catalog
    
    Return:
    -------
    figure:
        matplotlib.figure.Figure
    """
    x = lc.lcf.time
    y = lc.lcf.flux
    min_period = np.max(sigmaclip(np.diff(x))[0])
    max_period = 0.5 * (x.max() - x.min())
    lag, acf = interpolated_acf(x, y)
    period, fig = dominant_period(lag,
                                  acf,
                                  min=min_period,
                                  max=max_period,
                                  plot=True)

    return period, fig
Example #4
0
def k2_test(style=None):
    """
    Demonstrate the technique for a K2 EB.

    Parameters
    ----------
    style : str, optional
        The name of a matplotlib style sheet.

    """
    nova = pd.read_csv("villanova-db.csv")

    # Load Aigrain et al. (2015) pipeline light curve.
    hdu = fits.open("hlsp_k2sc_k2_llc_212012387-c05_kepler_v1_lc.fits")
    time = hdu[1].data["time"]
    cadence = hdu[1].data["cadence"]
    # Add back stellar variability correction.
    flux = hdu[1].data["flux"] + hdu[1].data["trend_t"] - \
        np.nanmedian(hdu[1].data["trend_t"])
    flux /= np.nanmedian(flux)

    # Mask out bad fluxes
    finite = np.isfinite(flux)
    time = time[finite]
    flux = flux[finite]
    cadence = cadence[finite]

    # Load parameters from Villanova catalog
    epic = 212012387
    eb = nova[nova["KIC"] == epic]
    p_orb = eb.period.values[0]
    t_0 = eb.bjd0.values[0]
    p_width = eb.pwidth.values[0]
    s_width = eb.swidth.values[0]
    sep = eb.sep.values[0]

    phase = ((time - t_0) % p_orb) / p_orb
    window = 1.0
    mask = ((phase > p_width * window) & (phase < 1 - p_width * window)) & \
        ((phase > sep + s_width * window) | (phase < sep - s_width * window))
    timecut = time[mask]
    fluxcut = flux[mask]
    cadencecut = cadence[mask]

    model = LombScargleFast().fit(time, flux)
    period, power = model.periodogram_auto(oversampling=5)
    model = LombScargleFast().fit(timecut, fluxcut)
    period_c, power_c = model.periodogram_auto(oversampling=5)

    lag, acf = interpacf.interpolated_acf(time,
                                          flux - np.median(flux), cadence)
    lag_c, acf_c = interpacf.interpolated_acf(timecut,
                                              fluxcut - np.median(fluxcut),
                                              cadencecut)

    if style is not None:
        plt.style.use(style)

    plt.rcParams["font.size"] = 22
    fig = plt.figure(figsize=(15, 12))
    ax1 = plt.subplot2grid((2, 2), (0, 0), colspan=2)
    ax2 = plt.subplot2grid((2, 2), (1, 0))
    ax3 = plt.subplot2grid((2, 2), (1, 1))

    # Plot lightcurve
    offset = 2304.
    ax1.plot(time - offset, flux, lw=1, color="k", alpha=0.4)
    ax1.plot(timecut - offset, fluxcut, lw=1, color="k")

    ax1.set_ylim(0.95, 1.01)
    ax1.set_xlabel("BJD - {0:.0f}".format(2454833 + offset))
    ax1.set_ylabel("Normalized Flux")
    ax1.minorticks_on()

    # Plot periodograms
    ax2.plot(period, 2 * power, color="r", lw=1.25, alpha=1.0)
    ax2.plot(period_c, power_c, color="k", lw=1.25)

    ax2.axvline(p_orb, color="k", lw=1.5, linestyle=":")
    ax2.axvline(p_orb / 2., color="k", lw=1.5, linestyle=":")
    ax2.text(p_orb, ax2.get_ylim()[1] + 0.01, "$P_{orb}$", ha="center")
    ax2.text(p_orb / 2., ax2.get_ylim()[1] + 0.01, "$P_{orb}/2$",
             ha="center")

    ax2.set_xlabel("Period (days)")
    ax2.set_ylabel("Normalized Power")
    ax2.minorticks_on()

    ax2.set_xlim(0.01, 10)
    ax2.set_ylim(0, 0.6)

    ax3.plot(lag, acf / acf.max(), color="r", lw=1.5, alpha=1.0)
    ax3.plot(lag_c, acf_c / acf_c.max(), color="k", lw=1.5)

    ax3.axvline(p_orb, color="k", lw=1.5, linestyle=":")
    ax3.axvline(p_orb / 2., color="k", lw=1.5, linestyle=":")
    ax3.text(p_orb, 1.05, "$P_{orb}$", ha="center")
    ax3.text(p_orb / 2., 1.05, "$P_{orb}/2$",
             ha="center")

    ax3.minorticks_on()
    ax3.set_xlim(0.01, 10)
    ax3.set_ylim(-0.55, 1)
    ax3.set_xlabel("Lag (days)")
    ax3.set_ylabel("ACF")

    fig.suptitle("EPIC {0}".format(epic), fontsize=26, y=0.94)
    fig.subplots_adjust(wspace=0.3, hspace=0.35)

    plt.savefig("k2_removal_demo.pdf")
Example #5
0
def eclipse_removal(kic, p_xlim=(0, 40), timerange=None, style=None,):
    """
    Demonstrate the removal of eclipse signal.

    Parameters
    ----------
    kic : int
        The system KIC number.
    p_xlim : 2-tuple, optional
        The x-limit of the periodogram plot. (Default: (0, 40))
    timerange : 2-tuple, optional
        The time range of the light curve plot in Kepler mission days.
        Default plots first 50 days of light curve.
    style : str, optional
        The name of a matplotlib style sheet.

    """
    binary = binaries.RealBinary(kic)

    timecut, fluxcut, errcut, cadencecut = binary.curve_cut(window=0.75)[:4]

    period, power = binary.periodogram(binary.time, binary.flux, binary.err,
                                       oversampling=1)
    period_c, power_c = binary.periodogram(timecut, fluxcut, errcut,
                                           oversampling=1)

    lag, acf = interpacf.interpolated_acf(binary.time,
                                          binary.flux - np.median(binary.flux),
                                          binary.cadence)
    lag_c, acf_c = interpacf.interpolated_acf(timecut,
                                              fluxcut - np.median(fluxcut),
                                              cadencecut)

    if style is not None:
        plt.style.use(style)

    if timerange is None:
        timerange = (binary.time[0], binary.time[0] + 50)

    plt.rcParams["font.size"] = 22
    fig = plt.figure(figsize=(15, 12))
    ax1 = plt.subplot2grid((2, 2), (0, 0), colspan=2)
    ax2 = plt.subplot2grid((2, 2), (1, 0))
    ax3 = plt.subplot2grid((2, 2), (1, 1))

    # Plot lightcurve
    offset = timerange[0]
    ax1.plot(binary.time - offset, binary.flux, lw=1, color="k", alpha=0.4)
    ax1.plot(timecut - offset, fluxcut, lw=1, color="k")

    ax1.set_xlim(0, timerange[-1] - timerange[0])
    ax1.set_ylim(0.95, 1.03)
    ax1.set_xlabel("BJD - {0:.0f}".format(2454833 + offset))
    ax1.set_ylabel("Normalized Flux")
    ax1.minorticks_on()

    # Plot periodograms
    ax2.plot(period_c, power_c, color="k", lw=1.25)
    ax2.plot(period, 2 * power, color="r", lw=1.25, alpha=1, zorder=2)

    ax2.axvline(binary.p_orb, color="k", lw=1.5, linestyle=":")
    ax2.axvline(binary.p_orb / 2., color="k", lw=1.5, linestyle=":")
    ax2.text(binary.p_orb, ax2.get_ylim()[1] + 0.01, "$P_{orb}$", ha="center")
    ax2.text(binary.p_orb / 2., ax2.get_ylim()[1] + 0.01, "$P_{orb}/2$",
             ha="center")

    ax2.set_xlabel("Period (days)")
    ax2.set_ylabel("Normalized Power")
    ax2.minorticks_on()
    ax2.set_xlim(p_xlim)

    ax3.plot(lag, acf / acf.max(), color="r", lw=1.5, alpha=1.0)
    ax3.plot(lag_c, acf_c / acf_c.max(), color="k", lw=1.5)

    ax3.axvline(binary.p_orb, color="k", lw=1.5, linestyle=":")
    ax3.axvline(binary.p_orb / 2., color="k", lw=1.5, linestyle=":")
    ax3.text(binary.p_orb, 1.05, "$P_{orb}$", ha="center")
    ax3.text(binary.p_orb / 2., 1.05, "$P_{orb}/2$",
             ha="center")

    ax3.minorticks_on()
    ax3.set_xlim(p_xlim)
    ax3.set_ylim(-0.5, 1)
    ax3.set_xlabel("Lag (days)")
    ax3.set_ylabel("ACF")

    fig.suptitle("KIC {0}".format(kic), fontsize=26, y=0.94)
    fig.subplots_adjust(wspace=0.3, hspace=0.35)

    plt.savefig("removal_demo.pdf")
Example #6
0
        # ax[1, 0].plot(obs_time, model_residual, 'r', lw=2, zorder=10, label='microvar + spots')

        ax[1, 0].plot(obs_time,
                      transitless_gp_mean,
                      color='DodgerBlue',
                      label='GP-transit',
                      zorder=15)
        ax[1, 0].legend()
        ax[1, 0].set(xlabel='Time [d]', ylabel='Residuals')
        nparams = 5
        # samples_t0 = obs_planet.samples_t0.reshape((len(obs_planet.samples_t0)//nparams, nparams))
        samples_t0 = obs_planet.samples_t0.reshape(
            (nparams, len(obs_planet.samples_t0) // nparams))

        for chain in samples_t0:
            lag, acf = interpolated_acf(np.arange(len(chain)),
                                        chain - np.median(chain))
            ax[1, 1].plot(lag, acf / acf.max())
        ax[1, 1].set_title('$t_0$ chains ACF')
        ax[1, 1].set(xlabel='Lag [d]', ylabel='ACF')

        lag, acf = interpolated_acf(
            obs_time, transitless_obs_flux - np.median(transitless_obs_flux))
        ax[1, 3].plot(lag,
                      acf / np.percentile(acf, 98),
                      label='(Obs - transit) ACF')
        #ax[1, 3].set_title('(Obs. - transit) ACF')

        lag, acf = interpolated_acf(
            obs_time, transitless_gp_mean - np.median(transitless_gp_mean))
        ax[1, 3].plot(lag,
                      acf / acf.max(),