From 7ec6c98658dffb4a655950268adee95547114c50 Mon Sep 17 00:00:00 2001 From: Benjamin Pope Date: Fri, 24 Aug 2018 10:00:26 +1000 Subject: [PATCH] standalone package --- notebooks/lightkurve.ipynb | 277 ++++++++++++++++++++++++++++++++++--- src/standalone.py | 268 +++++++++++++++++++++++++++++++++++ 2 files changed, 523 insertions(+), 22 deletions(-) create mode 100644 src/standalone.py diff --git a/notebooks/lightkurve.ipynb b/notebooks/lightkurve.ipynb index 6d17dcb..30f7684 100644 --- a/notebooks/lightkurve.ipynb +++ b/notebooks/lightkurve.ipynb @@ -30,6 +30,26 @@ "colours = mpl.rcParams['axes.prop_cycle'].by_key()['color']\n" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'1.0b13'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lightkurve.__version__" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -54,7 +74,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -78,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -91,16 +111,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 36, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -119,6 +139,98 @@ "plt.plot(lc.time, lc.flux,'.')\n" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[, ]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lc.to_fits('test.fits')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import fitsio" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "f = fitsio.FITS('test.fits')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "hdr = fitsio.read_header('test.fits')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "SIMPLE = T / conforms to FITS standards\n", + "BITPIX = 8 / array data type\n", + "NAXIS = 0 / number of array dimensions\n", + "EXTEND = T / file contains extensions\n", + "NEXTEND = 2 / number of standard extensions\n", + "EXTNAME = 'PRIMARY ' / name of extension\n", + "EXTVER = 1 / extension version number (not format version)\n", + "ORIGIN = 'Unofficial data product' / institution responsible for file\n", + "DATE = '2018-08-23' / file creation date.\n", + "CREATOR = 'lightkurve' / pipeline job and program used t\n", + "TELESCOP= 'KEPLER ' / telescope\n", + "INSTRUME= 'Kepler Photometer' / detector type\n", + "OBJECT = '212300977' / string version of target id\n", + "KEPLERID= 212300977 / unique Kepler target identifier\n", + "CHANNEL = 36 / CCD channel\n", + "RADESYS = 'ICRS ' / reference frame of celestial coordinates\n", + "RA_OBJ = 203.75811 / [deg] right ascension\n", + "DEC_OBJ = -17.50355 / [deg] declination\n", + "EQUINOX = 2000 / equinox of celestial coordinate system\n", + "PROCVER = '1.0b13 '\n", + "CAMPAIGN= 6\n", + "MISSION = 'K2 '\n", + "DATE-OBS= '2015-07-13T23:07:23.227'\n", + "CHECKSUM= 'PA66QA64PA64PA64' / HDU checksum updated 2018-08-23T10:18:45\n", + "DATASUM = '0 ' / data unit checksum updated 2018-08-23T10:18:45" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdr" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -128,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -138,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -232,20 +344,44 @@ "(' DE iteration %3i -ln(L) %4.1f', 77, -4502.918658856899)\n", "(' DE iteration %3i -ln(L) %4.1f', 78, -4502.918658856899)\n", "(' DE iteration %3i -ln(L) %4.1f', 79, -4502.918658856899)\n", - "(' DE finished in %i seconds', 301.6952328681946)\n", - "(' DE minimum found at: %s', '[-4.486e+00 9.789e-01 8.843e+00 4.567e-03 -2.395e+00 2.903e+00 2.179e+01 -3.104e+00]')\n", - "(' DE -ln(L) %4.1f', -4502.918658856899)\n", + "(' DE iteration %3i -ln(L) %4.1f', 80, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 81, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 82, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 83, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 84, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 85, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 86, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 87, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 88, -4504.47530752586)\n", + "(' DE iteration %3i -ln(L) %4.1f', 89, -4505.200494144365)\n", + "(' DE iteration %3i -ln(L) %4.1f', 90, -4505.200494144365)\n", + "(' DE iteration %3i -ln(L) %4.1f', 91, -4505.200494144365)\n", + "(' DE iteration %3i -ln(L) %4.1f', 92, -4505.200494144365)\n", + "(' DE iteration %3i -ln(L) %4.1f', 93, -4507.917969620311)\n", + "(' DE iteration %3i -ln(L) %4.1f', 94, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 95, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 96, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 97, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 98, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 99, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 100, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 101, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 102, -4508.122441639004)\n", + "(' DE iteration %3i -ln(L) %4.1f', 103, -4508.122441639004)\n", + "(' DE finished in %i seconds', 301.5297107696533)\n", + "(' DE minimum found at: %s', '[-4.389e+00 9.985e-01 4.726e+00 3.476e-03 -2.350e+00 3.046e+00 1.918e+01 -3.098e+00]')\n", + "(' DE -ln(L) %4.1f', -4508.122441639004)\n", "Starting local hyperparameter optimisation\n", - "(' Local minimum found at: %s', '[-4.495e+00 9.991e-01 8.545e+00 4.878e-03 -2.308e+00 2.767e+00\\n 1.848e+01 -3.102e+00]')\n", + "(' Local minimum found at: %s', '[-4.408e+00 9.994e-01 4.701e+00 4.698e-03 -2.293e+00 2.887e+00\\n 2.007e+01 -3.105e+00]')\n", "Starting final outlier detection\n", - "(' %5i too high', 47)\n", - "(' %5i too low', 122)\n", + "(' %5i too high', 43)\n", + "(' %5i too low', 121)\n", "(' %5i not finite', 0)\n", "Computing time and position trends\n", "(' CDPP - raw - %6.3f', 14538.952100223865)\n", - "(' CDPP - position component removed - %6.3f', 370.1521173577549)\n", - "(' CDPP - full reduction - %6.3f', 369.42057715286234)\n", - "('Detrending time %6.3f', 320.3114609718323)\n" + "(' CDPP - position component removed - %6.3f', 367.8693336450076)\n", + "(' CDPP - full reduction - %6.3f', 368.31939197172034)\n", + "('Detrending time %6.3f', 312.2114460468292)\n" ] } ], @@ -255,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -264,13 +400,13 @@ "Text(0.5,1.01,'WASP-55')" ] }, - "execution_count": 41, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -290,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -299,13 +435,13 @@ "(215000, 235000)" ] }, - "execution_count": 42, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -322,6 +458,103 @@ "plt.title('WASP-55',y=1.01)\n", "plt.ylim(215000,235000)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we save this" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[, ]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "extras = {'CORR_FLUX':lc.corr_flux,\n", + " 'TR_TIME':lc.tr_time,\n", + " 'TR_POSITION':lc.tr_position}\n", + "lc.to_fits(extra_data=extras,path='test.fits',overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + " file: test.fits\n", + " extension: 1\n", + " type: BINARY_TBL\n", + " extname: LIGHTCURVE\n", + " rows: 3561\n", + " column info:\n", + " TIME f8 \n", + " FLUX f4 \n", + " FLUX_ERR f4 \n", + " CADENCENO i4 " + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f = fitsio.FITS('test.fits')\n", + "f[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "hdr = fitsio.read_header('test.fits')" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "ename": "IOError", + "evalue": "extension not found: 2 (case insensitive)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIOError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/anaconda2/lib/python2.7/site-packages/fitsio/fitslib.pyc\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 1067\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1068\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mext\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhdu_map\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1069\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mIOError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"extension not found: %s %s\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmess\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1070\u001b[0m \u001b[0mhdu\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhdu_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1071\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIOError\u001b[0m: extension not found: 2 (case insensitive)" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/standalone.py b/src/standalone.py new file mode 100644 index 0000000..86dc0ea --- /dev/null +++ b/src/standalone.py @@ -0,0 +1,268 @@ +from k2sc.core import * +from k2sc.k2io import DataReader +from k2sc.k2data import K2Data +from k2sc.ls import fasper +from numpy import * +import math as mt +from time import time, sleep +from k2sc.cdpp import cdpp +from k2sc.de import DiffEvol +from numpy.random import normal +import warnings +from collections import namedtuple + +from k2sc.detrender import Detrender +from k2sc.kernels import kernels, BasicKernel, BasicKernelEP, QuasiPeriodicKernel, QuasiPeriodicKernelEP +from k2sc.utils import medsig, sigma_clip + +import lightkurve + +def psearch(time, flux, min_p, max_p): + freq,power,nout,jmax,prob = fasper(time, flux, 6, 0.5) + period = 1/freq + m = (period > min_p) & (period < max_p) + period, power = period[m], power[m] + j = argmax(power) + + expy = mt.exp(-power[j]) + effm = 2*nout/6 + fap = expy*effm + + if fap > 0.01: + fap = 1.0-(1.0-expy)**effm + + return period[j], fap + +def detrend(dataset,splits=None,quiet=False,save_dir='.',seed=0,flux_type='pdc',default_position_kernel='SqrExp', + kernel=None, kernel_period=None,p_mask_center=None,p_mask_period=None,p_mask_duration=None, + tr_nrandom=400,tr_nblocks=6,tr_bspan=50,de_npop=100,de_niter=150,de_max_time=300, + ls_max_fap=-50,ls_min_period=0.05,ls_max_period=25,outlier_sigma=5,outlier_mwidth=25): + '''This is a function to detrend a single k2sc dataset, outside of the framework of + logging that is in bin/k2sc, but duplicating the functionality of the + local function there 'detrend'. This is here to permit access to k2sc from lightkurve, or other + similar light curve wrapping packages that might like to use k2sc.''' + + ## Setup the logger + ## ---------------- + ds = dataset + Result = namedtuple('SCResult', 'detrender pv tr_time tr_position cdpp_r cdpp_t cdpp_c warn') + results = [] # a list of Result tuples, one per aperture + masks = [] # a list of light curve masks, one per aperture + + + ## Define the splits + ## ----------------- + + default_splits = {3:[2154,2190], 4:[2240,2273], 5:[2344], 6:[2390,2428], 7:[2468.5,2515],13:[2998,3033]} + + if splits is None and ds.campaign not in default_splits.keys(): + print('The campaign not known and no splits given.') + return 0 + elif splits is not None: + splits = splits + print('Using split values {:s} given from the command line'.format(str(splits))) + else: + splits = default_splits[ds.campaign] + print('Using default splits {:s} for campaign {:d}'.format(str(splits), ds.campaign)) + + ## Periodic signal masking + ## ----------------------- + if p_mask_center and p_mask_period and p_mask_duration: + ds.mask_periodic_signal(p_mask_center, p_mask_period, p_mask_duration) + + ## Initial outlier and period detection + ## ------------------------------------ + ## We carry out an initial outlier and period detection using + ## a default GP hyperparameter vector based on campaign 4 fits + ## done using (almost) nonprintrmative priors. + + for iset in range(ds.nsets): + flux = ds.fluxes[iset] + mask = isfinite(flux) + mask &= ~(ds.mflags[iset] & M_PERIODIC).astype(bool) # Apply the transit mask, if any + mask &= ~(ds.quality & 2**20).astype(bool) # Mask out the thruster firings + inputs = transpose([ds.time, ds.x, ds.y]) + masks.append(mask) + + detrender = Detrender(flux, inputs, mask = mask, splits = splits, + kernel = BasicKernelEP(), + tr_nrandom = tr_nrandom, + tr_nblocks = tr_nblocks, + tr_bspan = tr_bspan) + + ttrend,ptrend = detrender.predict(detrender.kernel.pv0+1e-5, components=True) + cflux = flux-ptrend+median(ptrend)-ttrend+median(ttrend) + cflux /= nanmedian(cflux) + + ## Iterative sigma-clipping + ## ------------------------ + print('Starting initial outlier detection') + omask = mask & sigma_clip(cflux, max_iter=10, max_sigma=5, mexc=mask) + ofrac = (~omask).sum() / omask.size + if ofrac < 0.25: + mask &= omask + print(' Flagged %i (%4.1f%%) outliers.' % ((~omask).sum(), 100*ofrac)) + else: + print(' Found %i (%4.1f%%) outliers. Not flagging.' % ((~omask).sum(), 100*ofrac)) + + ## Lomb-Scargle period search + ## -------------------------- + if ofrac < 0.9: + print('Starting Lomb-Scargle period search') + nflux = flux - ptrend + nanmedian(ptrend) + ntime = ds.time - ds.time.mean() + pflux = poly1d(polyfit(ntime[mask], nflux[mask], 9))(ntime) + + period, fap = psearch(ds.time[mask], (nflux-pflux)[mask], ls_min_period, ls_max_period) + + if fap < 1e-50: + ds.is_periodic = True + ds.ls_fap = fap + ds.ls_period = period + else: + print('Too many outliers, skipping the Lomb-Scargle period search') + + ## Kernel selection + ## ---------------- + if kernel: + print('Overriding automatic kernel selection, using %s kernel as given in the command line' % kernel) + if 'periodic' in kernel and not kernel_period: + print('Need to give period (--kernel-period) if overriding automatic kernel detection with a periodic kernel. Quitting.') + return 0 + kernel = kernels[kernel](period=kernel_period) + else: + print(' Using %s position kernel' % default_position_kernel) + if ds.is_periodic: + print(' Found periodicity p = {:7.2f} (fap {:7.4e} < 1e-50), will use a quasiperiodic kernel'.format(ds.ls_period, ds.ls_fap)) + else: + print(' No strong periodicity found, using a basic kernel') + + if default_position_kernel.lower() == 'sqrexp': + kernel = QuasiPeriodicKernel(period=ds.ls_period) if ds.is_periodic else BasicKernel() + else: + kernel = QuasiPeriodicKernelEP(period=ds.ls_period) if ds.is_periodic else BasicKernelEP() + + + ## Detrending + ## ---------- + for iset in range(ds.nsets): + if ds.nsets > 1: + name = 'Worker {:d} <{:d}-{:d}>'.format(mpi_rank, dataset.epic, iset+1) + random.seed(seed) + tstart = time() + + inputs = transpose([ds.time,ds.x,ds.y]) + detrender = Detrender(ds.fluxes[iset], inputs, mask=masks[iset], + splits=splits, kernel=kernel, tr_nrandom=tr_nrandom, + tr_nblocks=tr_nblocks, tr_bspan=tr_bspan) + de = DiffEvol(detrender.neglnposterior, kernel.bounds, de_npop) + + ## Period population generation + ## ---------------------------- + if isinstance(kernel, QuasiPeriodicKernel): + de._population[:,2] = clip(normal(kernel.period, 0.1*kernel.period, size=de.n_pop), + ls_min_period, ls_max_period) + ## Hyperparameter optimisation + ## --------------------------- + if isfinite(ds.fluxes[iset]).sum() >= 100: + ## Global hyperparameter optimisation + ## ---------------------------------- + print('Starting global hyperparameter optimisation using DE') + tstart_de = time() + for i,r in enumerate(de(de_niter)): + print(' DE iteration %3i -ln(L) %4.1f', i, de.minimum_value) + tcur_de = time() + if ((de._fitness.ptp() < 3) or (tcur_de - tstart_de > de_max_time)) and (i>2): + break + print(' DE finished in %i seconds', tcur_de-tstart_de) + print(' DE minimum found at: %s', array_str(de.minimum_location, precision=3, max_line_width=250)) + print(' DE -ln(L) %4.1f', de.minimum_value) + + ## Local hyperparameter optimisation + ## --------------------------------- + print('Starting local hyperparameter optimisation') + try: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning, append=True) + pv, warn = detrender.train(de.minimum_location) + except ValueError as e: + print('Local optimiser failed, %s' % e) + print('Skipping the file') + return + print(' Local minimum found at: %s', array_str(pv, precision=3)) + + ## Trend computation + ## ----------------- + (mt,tt),(mp,tp) = map(lambda a: (nanmedian(a), a-nanmedian(a)), detrender.predict(pv, components=True)) + + ## Iterative sigma-clipping + ## ------------------------ + print('Starting final outlier detection') + flux = detrender.data.unmasked_flux + cflux = flux-tp-tt + cflux /= nanmedian(cflux) + + mper = ~(ds.mflags[iset] & M_PERIODIC).astype(bool) # Apply the transit mask, if any + mthf = ~(ds.quality & 2**20).astype(bool) # Mask out the thruster firings + minf = isfinite(cflux) + + mlow, mhigh = sigma_clip(cflux, max_iter = 10, max_sigma = 5, separate_masks = True, mexc = mper&mthf) + ds.mflags[iset][~minf] |= M_NOTFINITE + ds.mflags[iset][~mhigh] |= M_OUTLIER_U + ds.mflags[iset][~mlow] |= M_OUTLIER_D + + print(' %5i too high', (~mhigh).sum()) + print(' %5i too low', (~mlow).sum()) + print(' %5i not finite', (~minf).sum()) + + ## Detrending and CDPP computation + ## ------------------------------- + print('Computing time and position trends') + dd = detrender.data + cdpp_r = cdpp(dd.masked_time, dd.masked_flux) + cdpp_t = cdpp(dd.unmasked_time, dd.unmasked_flux-tp, exclude=~dd.mask) + cdpp_c = cdpp(dd.unmasked_time, dd.unmasked_flux-tp-tt, exclude=~dd.mask) + else: + print('Skipping dataset %i, not enough finite datapoints') + cdpp_r, cdpp_t, cdpp_c, warn = -1, -1, -1, -1 + mt, mp = nan, nan + tt = full_like(detrender.data.unmasked_flux, nan) + tp = full_like(detrender.data.unmasked_flux, nan) + pv = full(kernel.npar, nan) + detrender.tr_pv = pv.copy() + + result = Result(detrender, pv, tt+mt, tp+mp, cdpp_r, cdpp_t, cdpp_c, warn) + print(' CDPP - raw - %6.3f', cdpp_r) + print(' CDPP - position component removed - %6.3f', cdpp_t) + print(' CDPP - full reduction - %6.3f', cdpp_c) + print('Detrending time %6.3f', time()-tstart) + + return result + +class k2sc_lc(lightkurve.KeplerLightCurve): + + def get_k2data(self): + try: + x, y = self.pos_corr1, self.pos_corr2 + except: + x, y = self.centroid_col, self.centroid_row + dataset = K2Data(self.keplerid, + time = self.time, + cadence = self.cadenceno, + quality = self.quality, + fluxes = self.flux, + errors = self.flux_err, + x = x, + y = y, + primary_header = self.primary_header, + data_header = self.data_header, + campaign=5) + return dataset + + def k2sc(self): + dataset = self.get_k2data() + results = detrend(dataset) + self.tr_position = results.tr_position + self.tr_time = results.tr_time + self.pv = results.pv # hyperparameters + self.corr_flux = self.flux - self.tr_position + nanmedian(self.tr_position)