We have discussed in previous tutorials how Simple Aperture Photometry works. We choose a set of pixels in the image and sum those to produce a single flux value. We sum the same pre-selected pixels for every image at each time slice to produce a light curve.
The Kepler Data Pipeline produces an aperture, which is used by default by lightkurve. However, there are some cases where you might want to produce your own aperture. The field may be crowded, or you may wish to change the aperture size to change the relative contribution of the background. K2 data generally needs larger apertures than the default pipeline mask. Lightkurve offers tools to select pixels programmatically.
First, let's load a target pixel file. Let's choose Kepler planet canidate KIC 6679295. We'll use the
search_targetpixelfile function to download every target pixel file available for each quarter of this data set.
%matplotlib inline from lightkurve import search_targetpixelfile import matplotlib.pyplot as plt tpfs = search_targetpixelfile('KIC 6679295').download_all()
We've now created a list of
KeplerTargetPixelFile objects, where each item is a different quarter. We're going to be able to combine these just like in the stitching tutorial.
Let's take a look at just one of those target pixel files.
# Build the light curve pipeline_lc = tpfs.to_lightcurve().flatten() for tpf in tpfs: pipeline_lc = pipeline_lc.append(tpf.to_lightcurve().flatten()) # Clean the light curve pipeline_lc = pipeline_lc.remove_nans().remove_outliers()
Above we have created the light curve from the target pixel files, stitched them all together in the same way as in the [stitching tutorial] using lightkurves
append function. To recap the steps we:
The period for this planet candidate is 24.57537 days. Let's plot it up and take a look.
pipeline_lc.fold(period=24.57537, t0=21.3).bin().errorbar() plt.xlim(-0.015, 0.015) plt.ylim(0.998, 1.0015);
Looks like a great candidate. However, we might just want to check on the pixels. Let's plot one of the target pixel files.
tpf.plot(frame=100, aperture_mask=tpf.pipeline_mask, mask_color='red');
The Kepler Pipeline aperture is in red. It looks like there is a nearby contaminate star! We might want to check that the signal is not really coming from the bright, nearby contaminant, rather than our target star. Let's use the top right corner four pixels as our new mask.
import numpy as np aper = np.zeros(tpf.shape[1:], dtype=np.int) aper[-2:, 0:2] = 1 tpf.plot(aperture_mask=aper, mask_color='red');
The new mask covers the bright star. Now we can iterate through the target pixel files and build the light curve in the same way as before, but this time
# Build the NEW aperture, and the light curve aper = np.zeros(tpfs.shape[1:]) aper[-2:, 0:2] = 1 user_lc = tpfs.to_lightcurve(aperture_mask=aper.astype(bool)).flatten() for tpf in tpfs: aper = np.zeros(tpf.shape[1:]) aper[-2:, 0:2]=1 user_lc = user_lc.append(tpf.to_lightcurve(aperture_mask=aper.astype(bool)).flatten()) # Clean the light curve user_lc = user_lc.remove_nans().remove_outliers()
Now we have our new light curve we can plot it up again and find out if there is still a planet signal.
user_lc.fold(period=24.57537, t0=-0.133).bin().errorbar(); plt.xlim(-0.015,0.015) plt.ylim(0.998,1.0015)
Looks like the planet signal is only in the target star and doesn't belong to the contaminant. This is just one of many checks you might want to perform to validate your planet candidates!