def _from_path_LC(path, mission, flux_type="PDCSAP_FLUX"):
origins = {"Kepler": "KLC", "K2": "KLC", "TESS": "TLC"}
if ((mission == "Kepler") | (mission == "K2")):
lcf = KeplerLightCurveFile(path)
elif mission == "TESS":
lcf = TessLightCurveFile(path)
else:
raise KeyError("Invalid mission. Pass 'Kepler', 'K2', or 'TESS'.")
lc = lcf.get_lightcurve(flux_type)
flc = _convert_LC_to_FLC(lc, origin=origins[mission])
return flc
def from_KeplerLightCurve_source(target, lctype='SAP_FLUX', **kwargs):
"""
Accepts paths and EPIC IDs as targets. Either fetches a ``KeplerLightCurveFile``
from MAST via ID or directly from a path, then creates a ``FlareLightCurve``
preserving all data from ``KeplerLightCurve``.
Parameters
------------
target : str or int
EPIC ID (e.g., 211119999) or path to zipped ``KeplerLightCurveFile``
lctype: 'SAP_FLUX' or 'PDCSAP_FLUX'
takes in either raw or PDC flux, default is 'SAP_FLUX' because it seems
to work best with the K2SC detrending pipeline
kwargs : dict
Keyword arguments to pass to `KeplerLightCurveFile.from_archive
<https://lightkurve.keplerscience.org/api/lightkurve.lightcurvefile.KeplerLightCurveFile.html#lightkurve.lightcurvefile.KeplerLightCurveFile.from_archive>`_
Returns
--------
FlareLightCurve
"""
lcf = KeplerLightCurveFile.from_archive(target, **kwargs)
lc = lcf.get_lightcurve(lctype)
return from_KeplerLightCurve(lc)
def get_lightcurve(target):
lcs = KeplerLightCurveFile.from_archive(target,
quarter='all',
cadence='long')
lc = lcs[0].PDCSAP_FLUX.remove_nans()
lc.flux = -2.5 * np.log10(lc.flux)
lc.flux = lc.flux - np.average(lc.flux)
for i in lcs[1:]:
i = i.PDCSAP_FLUX.remove_nans()
i.flux = -2.5 * np.log10(i.flux)
i.flux = i.flux - np.average(i.flux)
lc = lc.append(i)
return lc.time, lc.flux
# if (x == self.peakFlare):
# break
# i += 1
# print(time[i])
def reduceandplot(self):
p = [self.peakTime, 0.05, self.peakFlare]
print('First values of peakTime, peakFlare, and fwhm' +
str(self.peakTime) + " " + str(self.peakFlare) + " " + str(0.05))
result = minimize(ng_ln_like, p, args=[self.time, self.flux])
print(result)
self.peakTime, fwhm, flarePeak = result.x
print(self.peakTime, fwhm, flarePeak)
pl.plot(
self.time,
ap.aflare1(self.time,
tpeak=self.peakTime,
fwhm=fwhm,
ampl=flarePeak,
upsample=True,
uptime=10))
pl.plot(self.time, self.flux)
pl.show()
w359 = KeplerLightCurveFile.from_archive(201885041)
flare1 = strPlot(w359, 250, 280, 2)
#flare1.peaks()
flare1.reduceandplot()
i, j, k = [5, 4, 3]
print(k)
def neg_ln_like(p):
gp.set_parameter_vector(p)
return -gp.log_likelihood(y)
def grad_neg_ln_like(p):
gp.set_parameter_vector(p)
return -gp.grad_log_likelihood(y)
strLC = KeplerLightCurveFile.from_archive(206208968)
strPDC = strLC.PDCSAP_FLUX.remove_outliers()
y = strPDC.flux[:300]
x = strPDC.time[:300]
y = (y / np.median(y)) - 1 # sets the function to begin at 0
x = x[np.isfinite(y)]
y = y[np.isfinite(y)] # removes NaN values
pl.plot(x, y)
#pl.show()
print(median_absolute_deviation(y))
print(np.var(y))
kernel = np.var(y) * kernels.ExpSquaredKernel(0.5) * kernels.ExpSine2Kernel(
log_period=0.5, gamma=1)
def from_KeplerLightCurve_source(target):
lcf = KeplerLightCurveFile.from_archive(target)
lc = lcf.get_lightcurve('SAP_FLUX')
return from_KeplerLightCurve(lc)
def retreive_data(num_periods=4,
KIC=4570949,
drop_outliers=False,
downloaded=True,
base_dir="../mastDownload/Kepler/",
params=None,
which_quarters=None):
"""
Retreives and conditions data for the given KIC object
Args:
num_periods (int, optional) - window size for median filter
KIC (optional, int) - KIC number
drop_outliers (optional, boolean) - drop outliers?
downloaded (optional, boolean) - whether data are DLed
base_dir (optional, str) - directory under which to find data files
params (optional, dict) - if not None, the routine masks
points in transit (as indicated by the params values)
while conditioning the data
which_quarters (optional, list) - which quarters to return
Returns:
time (float array) - observational times
flux (float array) - unconditioned light curve data
filtered_time (float array) - observational times, conditioned
filtered_flux (float array) - observational data, conditioned
"""
if (not downloaded):
for q in range(0, 18):
try:
lc = KeplerLightCurveFile.from_archive(
str(KIC), quarter=q, verbose=False).PDCSAP_FLUX
tpf = KeplerTargetPixelFile.from_archive(str(KIC), quarter=q)
except:
pass
time = np.array([])
flux = np.array([])
filtered_time = np.array([])
filtered_flux = np.array([])
# Return the filter
returned_filter = np.array([])
# Collect all data files
ls = glob(base_dir + "kplr*" + str(KIC) + "_lc_Q*/*.fits")
tpfs = glob(base_dir + "kplr*" + str(KIC) + "_lc_Q*/*targ.fits.gz")
if (which_quarters is None):
which_quarters = range(len(ls))
for i in which_quarters:
# PDCSAP_FLUX supposedly takes care of the flux fraction -
# _Data Processing Handbook_, p. 129
# https://archive.stsci.edu/kepler/manuals/KSCI-19081-002-KDPH.pdf
lc = KeplerLightCurveFile(ls[i]).PDCSAP_FLUX
lc.remove_nans()
cur_time = lc.time
cur_flux = lc.flux
# Remove nans since remove_nans above doesn't seem to work.
ind = ~np.isnan(cur_flux)
cur_time = cur_time[ind]
cur_flux = cur_flux[ind]
time = np.append(time, cur_time)
flux = np.append(flux, cur_flux)
cur_filtered_time, cur_filtered_flux, cur_filter =\
filter_data(cur_time, cur_flux, num_periods=num_periods,
drop_outliers=drop_outliers, params=params)
filtered_time = np.append(filtered_time, cur_filtered_time)
filtered_flux = np.append(filtered_flux, cur_filtered_flux)
returned_filter = np.append(returned_filter, cur_filter)
# Finally remove any NaNs that snuck through
ind = ~np.isnan(filtered_flux)
filtered_time = filtered_time[ind]
filtered_flux = filtered_flux[ind]
return time, flux, filtered_time, filtered_flux, returned_filter
int(quarter), '\nHost Star Mass in Solar Masses: ', starmass,
'\nRadius of Host Star in Solar Radii: ', starradius,
'\nTemperature of Host Star in Kelvin: ', startemp)
# Importing our data (target pixel file)
tpf = KeplerTargetPixelFile.from_archive(int(stellarsystem),
quarter=int(quarter))
tpf.plot(aperture_mask=tpf.pipeline_mask)
# Convert the target pixel file into a light curve using the pipeline-defined aperture mask
lc = tpf.to_lightcurve(aperture_mask=tpf.pipeline_mask)
lc.plot()
plt.title("Light Curve from TPF")
# Use Kepler Light Curve File now (rather than being generated by us using a Target Pixel File, these files have been pregenerated using NASA’s Kepler Data Processing Pipeline - contains SAP and PDCSAP flux)
lcf = KeplerLightCurveFile.from_archive(
int(stellarsystem), quarter=int(quarter)).PDCSAP_FLUX.remove_nans()
lcf.plot()
plt.title('PDCSAP Flux Light Curve From Archive of Kepler ' +
str(stellarsystem))
# lcf.scatter()
print('----------------------------------------')
# Convert light curve file to a periodogram and find orbital period
pg = lcf.to_periodogram()
pg.plot()
pg.plot(format='period', scale='log')
pg = lcf.to_periodogram(
oversample_factor=30