def kepft(infile,
outfile,
fcol,
pmin,
pmax,
nfreq,
plot,
clobber,
verbose,
logfile,
status,
cmdLine=False):
## startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 18
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
## log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPFT -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'fcol=' + fcol + ' '
call += 'pmin=' + str(pmin) + ' '
call += 'pmax=' + str(pmax) + ' '
call += 'nfreq=' + str(nfreq) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
## start time
kepmsg.clock('Start time is', logfile, verbose)
## test log file
logfile = kepmsg.test(logfile)
## clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
## open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
## fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
## read table columns
if status == 0:
try:
barytime = instr[1].data.field('barytime')
except:
barytime, status = kepio.readfitscol(infile, instr[1].data, 'time',
logfile, verbose)
signal, status = kepio.readfitscol(infile, instr[1].data, fcol,
logfile, verbose)
if status == 0:
barytime = barytime + bjdref
## remove infinite data from time series
if status == 0:
incols = [barytime, signal]
outcols = kepstat.removeinfinlc(signal, incols)
barytime = outcols[0]
signal = outcols[1] - median(outcols[1])
## period to frequency conversion
fmin = 1.0 / pmax
fmax = 1.0 / pmin
deltaf = (fmax - fmin) / nfreq
## loop through frequency steps; determine FT power
if status == 0:
fr, power = kepfourier.ft(barytime, signal, fmin, fmax, deltaf, True)
## write output file
if status == 0:
col1 = Column(name='FREQUENCY', format='E', unit='1/day', array=fr)
col2 = Column(name='POWER', format='E', array=power)
cols = ColDefs([col1, col2])
instr.append(new_table(cols))
instr[-1].header.update('EXTNAME', 'POWER SPECTRUM', 'extension name')
instr.writeto(outfile)
## history keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
## close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
## data limits
if status == 0:
nrm = int(log10(power.max()))
power = power / 10**nrm
ylab = 'Power (x10$^{%d}$)' % nrm
xmin = fr.min()
xmax = fr.max()
ymin = power.min()
ymax = power.max()
xr = xmax - xmin
yr = ymax - ymin
fr = insert(fr, [0], fr[0])
fr = append(fr, fr[-1])
power = insert(power, [0], 0.0)
power = append(power, 0.0)
## plot power spectrum
if status == 0 and plot:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
print 'ERROR -- KEPFT: install latex for scientific plotting'
status = 1
if status == 0 and plot:
pylab.figure(1, figsize=[xsize, ysize])
pylab.clf()
pylab.axes([0.06, 0.113, 0.93, 0.86])
pylab.plot(fr, power, color=lcolor, linestyle='-', linewidth=lwidth)
fill(fr, power, color=fcolor, linewidth=0.0, alpha=falpha)
xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin - yr * 0.01 <= 0.0:
ylim(1.0e-10, ymax + yr * 0.01)
else:
ylim(ymin - yr * 0.01, ymax + yr * 0.01)
xlabel(r'Frequency (d$^{-1}$)', {'color': 'k'})
ylabel(ylab, {'color': 'k'})
grid()
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
## end time
if (status == 0):
message = 'KEPFT completed at'
else:
message = '\nKEPFT aborted at'
kepmsg.clock(message, logfile, verbose)
def kepprf(infile,plotfile,rownum,columns,rows,fluxes,border,background,focus,prfdir,xtol,ftol,
imscale,colmap,labcol,apercol,plt,verbose,logfile,status,cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPPRF -- '
call += 'infile='+infile+' '
call += 'plotfile='+plotfile+' '
call += 'rownum='+str(rownum)+' '
call += 'columns='+columns+' '
call += 'rows='+rows+' '
call += 'fluxes='+fluxes+' '
call += 'border='+str(border)+' '
bground = 'n'
if (background): bground = 'y'
call += 'background='+bground+' '
focs = 'n'
if (focus): focs = 'y'
call += 'focus='+focs+' '
call += 'prfdir='+prfdir+' '
call += 'xtol='+str(xtol)+' '
call += 'ftol='+str(xtol)+' '
call += 'imscale='+imscale+' '
call += 'colmap='+colmap+' '
call += 'labcol='+labcol+' '
call += 'apercol='+apercol+' '
plotit = 'n'
if (plt): plotit = 'y'
call += 'plot='+plotit+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# test log file
logfile = kepmsg.test(logfile)
# start time
kepmsg.clock('KEPPRF started at',logfile,verbose)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# construct inital guess vector for fit
if status == 0:
guess = []
try:
f = fluxes.strip().split(',')
x = columns.strip().split(',')
y = rows.strip().split(',')
for i in xrange(len(f)):
f[i] = float(f[i])
except:
f = fluxes
x = columns
y = rows
nsrc = len(f)
for i in xrange(nsrc):
try:
guess.append(float(f[i]))
except:
message = 'ERROR -- KEPPRF: Fluxes must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if len(x) != nsrc or len(y) != nsrc:
message = 'ERROR -- KEPFIT:FITMULTIPRF: Guesses for rows, columns and '
message += 'fluxes must have the same number of sources'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(x[i]))
except:
message = 'ERROR -- KEPPRF: Columns must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(y[i]))
except:
message = 'ERROR -- KEPPRF: Rows must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0 and background:
if border == 0:
guess.append(0.0)
else:
for i in range((border+1)*2):
guess.append(0.0)
if status == 0 and focus:
guess.append(1.0); guess.append(1.0); guess.append(0.0)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPPRF: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile,message,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(infile,logfile,verbose)
npix = numpy.size(numpy.nonzero(maskimg)[0])
# print target data
if status == 0 and verbose:
print ''
print ' KepID: %s' % kepid
print ' BJD: %.2f' % (barytime[rownum-1] + 2454833.0)
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# is this a good row with finite timestamp and pixels?
if status == 0:
if not numpy.isfinite(barytime[rownum-1]) or numpy.nansum(fluxpixels[rownum-1,:]) == numpy.nan:
message = 'ERROR -- KEPFIELD: Row ' + str(rownum) + ' is a bad quality timestamp'
status = kepmsg.err(logfile,message,verbose)
# construct input pixel image
if status == 0:
flux = fluxpixels[rownum-1,:]
ferr = errpixels[rownum-1,:]
DATx = arange(column,column+xdim)
DATy = arange(row,row+ydim)
# if numpy.nanmin > 420000.0: flux -= 420000.0
# image scale and intensity limits of pixel data
if status == 0:
n = 0
DATimg = empty((ydim,xdim))
ERRimg = empty((ydim,xdim))
for i in range(ydim):
for j in range(xdim):
DATimg[i,j] = flux[n]
ERRimg[i,j] = ferr[n]
n += 1
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPPRF: No PRF file found in ' + prfdir
status = kepmsg.err(logfile,message,verbose)
# read PRF images
if status == 0:
prfn = [0,0,0,0,0]
crpix1p = numpy.zeros((5),dtype='float32')
crpix2p = numpy.zeros((5),dtype='float32')
crval1p = numpy.zeros((5),dtype='float32')
crval2p = numpy.zeros((5),dtype='float32')
cdelt1p = numpy.zeros((5),dtype='float32')
cdelt2p = numpy.zeros((5),dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
prfn = array(prfn)
PRFx = arange(0.5,shape(prfn[0])[1]+0.5)
PRFy = arange(0.5,shape(prfn[0])[0]+0.5)
PRFx = (PRFx - size(PRFx) / 2) * cdelt1p[0]
PRFy = (PRFy - size(PRFy) / 2) * cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
if status == 0:
prf = zeros(shape(prfn[0]),dtype='float32')
prfWeight = zeros((5),dtype='float32')
for i in xrange(5):
prfWeight[i] = sqrt((column - crval1p[i])**2 + (row - crval2p[i])**2)
if prfWeight[i] == 0.0:
prfWeight[i] = 1.0e-6
prf = prf + prfn[i] / prfWeight[i]
prf = prf / nansum(prf) / cdelt1p[0] / cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
# if status == 0:
# prf = zeros(shape(prfn[0,:,:]),dtype='float32')
# px = crval1p + len(PRFx) / 2 * cdelt1p[0]
# py = crval2p + len(PRFy) / 2 * cdelt2p[0]
# pp = [[px[0],py[0]],
# [px[1],py[1]],
# [px[2],py[2]],
# [px[3],py[3]],
# [px[4],py[4]]]
# for index,value in ndenumerate(prf):
# pz = prfn[:,index[0],index[1]]
# prf[index] = griddata(pp, pz, ([column], [row]), method='linear')
# print shape(prf)
# location of the data image centered on the PRF image (in PRF pixel units)
if status == 0:
prfDimY = int(ydim / cdelt1p[0])
prfDimX = int(xdim / cdelt2p[0])
PRFy0 = (shape(prf)[0] - prfDimY) / 2
PRFx0 = (shape(prf)[1] - prfDimX) / 2
# interpolation function over the PRF
if status == 0:
splineInterpolation = scipy.interpolate.RectBivariateSpline(PRFx,PRFy,prf)
# construct mesh for background model
if status == 0 and background:
bx = numpy.arange(1.,float(xdim+1))
by = numpy.arange(1.,float(ydim+1))
xx, yy = numpy.meshgrid(numpy.linspace(bx.min(), bx.max(), xdim),
numpy.linspace(by.min(), by.max(), ydim))
# fit PRF model to pixel data
if status == 0:
start = time.time()
if focus and background:
args = (DATx,DATy,DATimg,ERRimg,nsrc,border,xx,yy,splineInterpolation,float(x[0]),float(y[0]))
ans = fmin_powell(kepfunc.PRFwithFocusAndBackground,guess,args=args,xtol=xtol,
ftol=ftol,disp=False)
elif focus and not background:
args = (DATx,DATy,DATimg,ERRimg,nsrc,splineInterpolation,float(x[0]),float(y[0]))
ans = fmin_powell(kepfunc.PRFwithFocus,guess,args=args,xtol=xtol,
ftol=ftol,disp=False)
elif background and not focus:
args = (DATx,DATy,DATimg,ERRimg,nsrc,border,xx,yy,splineInterpolation,float(x[0]),float(y[0]))
ans = fmin_powell(kepfunc.PRFwithBackground,guess,args=args,xtol=xtol,
ftol=ftol,disp=False)
else:
args = (DATx,DATy,DATimg,ERRimg,nsrc,splineInterpolation,float(x[0]),float(y[0]))
ans = fmin_powell(kepfunc.PRF,guess,args=args,xtol=xtol,
ftol=ftol,disp=False)
print 'Convergence time = %.2fs\n' % (time.time() - start)
# pad the PRF data if the PRF array is smaller than the data array
if status == 0:
flux = []; OBJx = []; OBJy = []
PRFmod = numpy.zeros((prfDimY,prfDimX))
if PRFy0 < 0 or PRFx0 < 0.0:
PRFmod = numpy.zeros((prfDimY,prfDimX))
superPRF = zeros((prfDimY+1,prfDimX+1))
superPRF[abs(PRFy0):abs(PRFy0)+shape(prf)[0],abs(PRFx0):abs(PRFx0)+shape(prf)[1]] = prf
prf = superPRF * 1.0
PRFy0 = 0
PRFx0 = 0
# rotate the PRF model around its center
if focus:
angle = ans[-1]
prf = rotate(prf,-angle,reshape=False,mode='nearest')
# iterate through the sources in the best fit PSF model
for i in range(nsrc):
flux.append(ans[i])
OBJx.append(ans[nsrc+i])
OBJy.append(ans[nsrc*2+i])
# calculate best-fit model
y = (OBJy[i]-mean(DATy)) / cdelt1p[0]
x = (OBJx[i]-mean(DATx)) / cdelt2p[0]
prfTmp = shift(prf,[y,x],order=3,mode='constant')
prfTmp = prfTmp[PRFy0:PRFy0+prfDimY,PRFx0:PRFx0+prfDimX]
PRFmod = PRFmod + prfTmp * flux[i]
wx = 1.0
wy = 1.0
angle = 0
b = 0.0
# write out best fit parameters
if verbose:
txt = 'Flux = %10.2f e-/s ' % flux[i]
txt += 'X = %9.4f pix ' % OBJx[i]
txt += 'Y = %9.4f pix ' % OBJy[i]
kepmsg.log(logfile,txt,True)
#
# params = {'backend': 'png',
# 'axes.linewidth': 2.5,
# 'axes.labelsize': 24,
# 'axes.font': 'sans-serif',
# 'axes.fontweight' : 'bold',
# 'text.fontsize': 12,
# 'legend.fontsize': 12,
# 'xtick.labelsize': 24,
# 'ytick.labelsize': 24}
# pylab.rcParams.update(params)
#
# pylab.figure(figsize=[20,10])
# ax = pylab.axes([0.05,0.08,0.46,0.9])
# xxx = numpy.arange(397.5,402.5,0.02)
# yyy = numpy.sum(PRFmod,axis=0) / numpy.max(numpy.sum(PRFmod,axis=0))
# pylab.plot(xxx,yyy,color='b',linewidth=3.0)
# xxx = numpy.append(numpy.insert(xxx,[0],[xxx[0]]),xxx[-1])
# yyy = numpy.append(numpy.insert(yyy,[0],[0.0]),yyy[-1])
# pylab.fill(xxx,yyy,fc='y',linewidth=0.0,alpha=0.3)
# pylab.xlabel('Pixel Column Number')
# pylab.xlim(397.5,402.5)
# pylab.ylim(1.0e-30,1.02)
# for xmaj in numpy.arange(397.5,402.5,1.0):
# pylab.plot([xmaj,xmaj],[0.0,1.1],color='k',linewidth=0.5,linestyle=':')
# for xmaj in numpy.arange(0.2,1.2,0.2):
# pylab.plot([0.0,2000.0],[xmaj,xmaj],color='k',linewidth=0.5,linestyle=':')
#
#
# ax = pylab.axes([0.51,0.08,0.46,0.9])
# xxx = numpy.arange(32.5,37.5,0.02)
# yyy = numpy.sum(PRFmod,axis=1) / numpy.max(numpy.sum(PRFmod,axis=1))
# pylab.plot(xxx,yyy,color='b',linewidth=3.0)
# xxx = numpy.append(numpy.insert(xxx,[0],[xxx[0]]),xxx[-1])
# yyy = numpy.append(numpy.insert(yyy,[0],[0.0]),yyy[-1])
# pylab.fill(xxx,yyy,fc='y',linewidth=0.0,alpha=0.3)
# pylab.setp(pylab.gca(),yticklabels=[])
# pylab.xlabel('Pixel Row Number')
# pylab.xlim(32.5,37.5)
# pylab.ylim(1.0e-30,1.02)
# for xmaj in numpy.arange(32.5,37.5,1.0):
# pylab.plot([xmaj,xmaj],[0.0,1.1],color='k',linewidth=0.5,linestyle=':')
# for xmaj in numpy.arange(0.2,1.2,0.2):
# pylab.plot([0.0,2000.0],[xmaj,xmaj],color='k',linewidth=0.5,linestyle=':')
# pylab.ion()
# pylab.plot([])
# pylab.ioff()
if verbose and background:
bterms = border + 1
if bterms == 1:
b = ans[nsrc*3]
else:
bcoeff = array([ans[nsrc*3:nsrc*3+bterms],ans[nsrc*3+bterms:nsrc*3+bterms*2]])
bkg = kepfunc.polyval2d(xx,yy,bcoeff)
b = nanmean(bkg.reshape(bkg.size))
txt = '\n Mean background = %.2f e-/s' % b
kepmsg.log(logfile,txt,True)
if focus:
wx = ans[-3]
wy = ans[-2]
angle = ans[-1]
if verbose and focus:
if not background: kepmsg.log(logfile,'',True)
kepmsg.log(logfile,' X/Y focus factors = %.3f/%.3f' % (wx,wy),True)
kepmsg.log(logfile,'PRF rotation angle = %.2f deg' % angle,True)
# measure flux fraction and contamination
if status == 0:
PRFall = kepfunc.PRF2DET(flux,OBJx,OBJy,DATx,DATy,wx,wy,angle,splineInterpolation)
PRFone = kepfunc.PRF2DET([flux[0]],[OBJx[0]],[OBJy[0]],DATx,DATy,wx,wy,angle,splineInterpolation)
FluxInMaskAll = numpy.nansum(PRFall)
FluxInMaskOne = numpy.nansum(PRFone)
FluxInAperAll = 0.0
FluxInAperOne = 0.0
for i in range(1,ydim):
for j in range(1,xdim):
if kepstat.bitInBitmap(maskimg[i,j],2):
FluxInAperAll += PRFall[i,j]
FluxInAperOne += PRFone[i,j]
FluxFraction = FluxInAperOne / flux[0]
try:
Contamination = (FluxInAperAll - FluxInAperOne) / FluxInAperAll
except:
Contamination = 0.0
kepmsg.log(logfile,'\n Total flux in mask = %.2f e-/s' % FluxInMaskAll,True)
kepmsg.log(logfile,' Target flux in mask = %.2f e-/s' % FluxInMaskOne,True)
kepmsg.log(logfile,' Total flux in aperture = %.2f e-/s' % FluxInAperAll,True)
kepmsg.log(logfile,' Target flux in aperture = %.2f e-/s' % FluxInAperOne,True)
kepmsg.log(logfile,' Target flux fraction in aperture = %.2f%%' % (FluxFraction * 100.0),True)
kepmsg.log(logfile,'Contamination fraction in aperture = %.2f%%' % (Contamination * 100.0),True)
# constuct model PRF in detector coordinates
if status == 0:
PRFfit = PRFall + 0.0
if background and bterms == 1:
PRFfit = PRFall + b
if background and bterms > 1:
PRFfit = PRFall + bkg
# calculate residual of DATA - FIT
if status == 0:
PRFres = DATimg - PRFfit
FLUXres = numpy.nansum(PRFres) / npix
# calculate the sum squared difference between data and model
if status == 0:
Pearson = abs(numpy.nansum(numpy.square(DATimg - PRFfit) / PRFfit))
Chi2 = numpy.nansum(numpy.square(DATimg - PRFfit) / numpy.square(ERRimg))
DegOfFreedom = npix - len(guess) - 1
try:
kepmsg.log(logfile,'\n Residual flux = %.2f e-/s' % FLUXres,True)
kepmsg.log(logfile,'Pearson\'s chi^2 test = %d for %d dof' % (Pearson,DegOfFreedom),True)
except:
pass
kepmsg.log(logfile,' Chi^2 test = %d for %d dof' % (Chi2,DegOfFreedom),True)
# image scale and intensity limits for plotting images
if status == 0:
imgdat_pl, zminfl, zmaxfl = kepplot.intScale2D(DATimg,imscale)
imgprf_pl, zminpr, zmaxpr = kepplot.intScale2D(PRFmod,imscale)
imgfit_pl, zminfi, zmaxfi = kepplot.intScale2D(PRFfit,imscale)
imgres_pl, zminre, zmaxre = kepplot.intScale2D(PRFres,'linear')
if imscale == 'linear':
zmaxpr *= 0.9
elif imscale == 'logarithmic':
zmaxpr = numpy.max(zmaxpr)
zminpr = zmaxpr / 2
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 28,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 20,
'ytick.labelsize': 20,
'xtick.major.pad': 6,
'ytick.major.pad': 6}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[12,10])
pylab.clf()
plotimage(imgdat_pl,zminfl,zmaxfl,1,row,column,xdim,ydim,0.07,0.53,'observation',colmap,labcol)
# pylab.text(830.0,242.1,'A',horizontalalignment='center',verticalalignment='center',
# fontsize=28,fontweight=500,color='white')
# pylab.text(831.1,240.62,'B',horizontalalignment='center',verticalalignment='center',
# fontsize=28,fontweight=500,color='white')
# plotimage(imgprf_pl,0.0,zmaxpr/0.5,2,row,column,xdim,ydim,0.52,0.52,'model',colmap)
plotimage(imgprf_pl,zminpr,zmaxpr,2,row,column,xdim,ydim,0.44,0.53,'model',colmap,labcol)
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,1,apercol,'--',0.5)
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,2,apercol,'-',3.0)
plotimage(imgfit_pl,zminfl,zmaxfl,3,row,column,xdim,ydim,0.07,0.08,'fit',colmap,labcol)
# plotimage(imgres_pl,-zmaxre,zmaxre,4,row,column,xdim,ydim,0.44,0.08,'residual',colmap,'k')
plotimage(imgres_pl,zminfl,zmaxfl,4,row,column,xdim,ydim,0.44,0.08,'residual',colmap,labcol)
# plot data color bar
# barwin = pylab.axes([0.84,0.53,0.06,0.45])
barwin = pylab.axes([0.84,0.08,0.06,0.9])
if imscale == 'linear':
brange = numpy.arange(zminfl,zmaxfl,(zmaxfl-zminfl)/1000)
elif imscale == 'logarithmic':
brange = numpy.arange(10.0**zminfl,10.0**zmaxfl,(10.0**zmaxfl-10.0**zminfl)/1000)
elif imscale == 'squareroot':
brange = numpy.arange(zminfl**2,zmaxfl**2,(zmaxfl**2-zminfl**2)/1000)
if imscale == 'linear':
barimg = numpy.resize(brange,(1000,1))
elif imscale == 'logarithmic':
barimg = numpy.log10(numpy.resize(brange,(1000,1)))
elif imscale == 'squareroot':
barimg = numpy.sqrt(numpy.resize(brange,(1000,1)))
try:
nrm = len(str(int(numpy.nanmax(brange))))-1
except:
nrm = 0
brange = brange / 10**nrm
pylab.imshow(barimg,aspect='auto',interpolation='nearest',origin='lower',
vmin=numpy.nanmin(barimg),vmax=numpy.nanmax(barimg),
extent=(0.0,1.0,brange[0],brange[-1]),cmap=colmap)
barwin.yaxis.tick_right()
barwin.yaxis.set_label_position('right')
barwin.yaxis.set_major_locator(MaxNLocator(7))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().set_autoscale_on(False)
pylab.setp(pylab.gca(),xticklabels=[],xticks=[])
pylab.ylabel('Flux (10$^%d$ e$^-$ s$^{-1}$)' % nrm)
setp(barwin.get_yticklabels(), 'rotation', 90)
barwin.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
# plot residual color bar
# barwin = pylab.axes([0.84,0.08,0.06,0.45])
# Brange = numpy.arange(-zmaxre,zmaxre,(zmaxre+zmaxre)/1000)
# try:
# nrm = len(str(int(numpy.nanmax(brange))))-1
# except:
# nrm = 0
# brange = brange / 10**nrm
# barimg = numpy.resize(brange,(1000,1))
# pylab.imshow(barimg,aspect='auto',interpolation='nearest',origin='lower',
# vmin=brange[0],vmax=brange[-1],extent=(0.0,1.0,brange[0],brange[-1]),cmap=colmap)
# barwin.yaxis.tick_right()
# barwin.yaxis.set_label_position('right')
# barwin.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
# barwin.yaxis.set_major_locator(MaxNLocator(7))
# pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# pylab.gca().set_autoscale_on(False)
# pylab.setp(pylab.gca(),xticklabels=[],xticks=[])
# pylab.ylabel('Residual (10$^%d$ e$^-$ s$^{-1}$)' % nrm)
# setp(barwin.get_yticklabels(), 'rotation', 90)
# render plot
if status == 0 and len(plotfile) > 0 and plotfile.lower() != 'none':
pylab.savefig(plotfile)
if status == 0 and plt:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\nKEPPRF ended at',logfile,verbose)
return
def keppca(infile,
maskfile,
outfile,
components,
plotpca,
nreps,
clobber,
verbose,
logfile,
status,
cmdLine=False):
try:
import mdp
except:
msg = 'ERROR -- KEPPCA: this task has an external python dependency to MDP, a Modular toolkit for Data Processing (http://mdp-toolkit.sourceforge.net). In order to take advantage of this PCA task, the user must first install MDP with their current python distribution. Note carefully that you may have more than python installation on your machine, and ensure that MDP is installed with the same version of python that the PyKE tools employ. Installation instructions for MDP can be found at the URL provided above.'
status = kepmsg.err(None, msg, True)
# startup parameters
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 10
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
seterr(all="ignore")
# log the call
if status == 0:
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPPCA -- '
call += 'infile=' + infile + ' '
call += 'maskfile=' + maskfile + ' '
call += 'outfile=' + outfile + ' '
call += 'components=' + components + ' '
ppca = 'n'
if (plotpca): ppca = 'y'
call += 'plotpca=' + ppca + ' '
call += 'nmaps=' + str(nreps) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
if status == 0:
kepmsg.clock('KEPPCA started at', logfile, verbose)
# test log file
if status == 0:
logfile = kepmsg.test(logfile)
# clobber output file
if status == 0:
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPCA: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile, message, verbose)
# Set output file names - text file with data and plot
if status == 0:
dataout = copy(outfile)
repname = re.sub('.fits', '.png', outfile)
# open input file
if status == 0:
instr = pyfits.open(infile, mode='readonly', memmap=True)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg, status = \
kepio.readTPF(infile,'FLUX_BKG',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err, status = \
kepio.readTPF(infile,'FLUX_BKG_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr1, status = \
kepio.readTPF(infile,'POS_CORR1',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr2, status = \
kepio.readTPF(infile,'POS_CORR2',logfile,verbose)
# Save original data dimensions, in case of using maskfile
if status == 0:
xdimorig = xdim
ydimorig = ydim
# read mask definition file if it has been supplied
if status == 0 and 'aper' not in maskfile.lower(
) and maskfile.lower() != 'all':
maskx = array([], 'int')
masky = array([], 'int')
lines, status = kepio.openascii(maskfile, 'r', logfile, verbose)
for line in lines:
line = line.strip().split('|')
if len(line) == 6:
y0 = int(line[3])
x0 = int(line[4])
line = line[5].split(';')
for items in line:
try:
masky = numpy.append(masky,
y0 + int(items.split(',')[0]))
maskx = numpy.append(maskx,
x0 + int(items.split(',')[1]))
except:
continue
status = kepio.closeascii(lines, logfile, verbose)
if len(maskx) == 0 or len(masky) == 0:
message = 'ERROR -- KEPPCA: ' + maskfile + ' contains no pixels.'
status = kepmsg.err(logfile, message, verbose)
xdim = max(maskx) - min(maskx) + 1 # Find largest x dimension of mask
ydim = max(masky) - min(masky) + 1 # Find largest y dimension of mask
# pad mask to ensure it is rectangular
workx = array([], 'int')
worky = array([], 'int')
for ip in arange(min(maskx), max(maskx) + 1):
for jp in arange(min(masky), max(masky) + 1):
workx = append(workx, ip)
worky = append(worky, jp)
maskx = workx
masky = worky
# define new subimage bitmap...
if status == 0 and maskfile.lower() != 'all':
aperx = numpy.array([], 'int')
apery = numpy.array([], 'int')
aperb = maskx - x0 + xdimorig * (
masky - y0
) # aperb is an array that contains the pixel numbers in the mask
npix = len(aperb)
# ...or use all pixels
if status == 0 and maskfile.lower() == 'all':
npix = xdimorig * ydimorig
aperb = array([], 'int')
aperb = numpy.r_[0:npix]
# legal mask defined?
if status == 0:
if len(aperb) == 0:
message = 'ERROR -- KEPPCA: no legal pixels within the subimage are defined.'
status = kepmsg.err(logfile, message, verbose)
# Identify principal components desired
if status == 0:
pcaout = []
txt = components.strip().split(',')
for work1 in txt:
try:
pcaout.append(int(work1.strip()))
except:
work2 = work1.strip().split('-')
try:
for work3 in range(int(work2[0]), int(work2[1]) + 1):
pcaout.append(work3)
except:
message = 'ERROR -- KEPPCA: cannot understand principal component list requested'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
pcaout = set(sort(pcaout))
pcarem = array(
list(pcaout)) - 1 # The list of pca component numbers to be removed
# Initialize arrays and variables, and apply pixel mask to the data
if status == 0:
ntim = 0
time = numpy.array([], dtype='float64')
timecorr = numpy.array([], dtype='float32')
cadenceno = numpy.array([], dtype='int')
pixseries = numpy.array([], dtype='float32')
errseries = numpy.array([], dtype='float32')
bkgseries = numpy.array([], dtype='float32')
berseries = numpy.array([], dtype='float32')
quality = numpy.array([], dtype='float32')
pos_corr1 = numpy.array([], dtype='float32')
pos_corr2 = numpy.array([], dtype='float32')
nrows = numpy.size(fluxpixels, 0)
# Apply the pixel mask so we are left with only the desired pixels
if status == 0:
pixseriesb = fluxpixels[:, aperb]
errseriesb = errpixels[:, aperb]
bkgseriesb = flux_bkg[:, aperb]
berseriesb = flux_bkg_err[:, aperb]
# Read in the data to various arrays
if status == 0:
for i in range(nrows):
if qual[i] < 10000 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,int(ydim*xdim/2+0.5)]) and \
numpy.isfinite(fluxpixels[i,1+int(ydim*xdim/2+0.5)]):
ntim += 1
time = numpy.append(time, barytime[i])
timecorr = numpy.append(timecorr, tcorr[i])
cadenceno = numpy.append(cadenceno, cadno[i])
pixseries = numpy.append(pixseries, pixseriesb[i])
errseries = numpy.append(errseries, errseriesb[i])
bkgseries = numpy.append(bkgseries, bkgseriesb[i])
berseries = numpy.append(berseries, berseriesb[i])
quality = numpy.append(quality, qual[i])
pos_corr1 = numpy.append(pos_corr1, pcorr1[i])
pos_corr2 = numpy.append(pos_corr2, pcorr2[i])
pixseries = numpy.reshape(pixseries, (ntim, npix))
errseries = numpy.reshape(errseries, (ntim, npix))
bkgseries = numpy.reshape(bkgseries, (ntim, npix))
berseries = numpy.reshape(berseries, (ntim, npix))
tmp = numpy.median(pixseries, axis=1)
for i in range(len(tmp)):
pixseries[i] = pixseries[i] - tmp[i]
# Figure out which pixels are undefined/nan and remove them. Keep track for adding back in later
if status == 0:
nanpixels = numpy.array([], dtype='int')
i = 0
while (i < npix):
if numpy.isnan(pixseries[0, i]):
nanpixels = numpy.append(nanpixels, i)
npix = npix - 1
i = i + 1
pixseries = numpy.delete(pixseries, nanpixels, 1)
errseries = numpy.delete(errseries, nanpixels, 1)
pixseries[numpy.isnan(pixseries)] = random.gauss(100, 10)
errseries[numpy.isnan(errseries)] = 10
# Compute statistical weights, means, standard deviations
if status == 0:
weightseries = (pixseries / errseries)**2
pixMean = numpy.average(pixseries, axis=0, weights=weightseries)
pixStd = numpy.std(pixseries, axis=0)
# Normalize the input by subtracting the mean and divising by the standard deviation.
# This makes it a correlation-based PCA, which is what we want.
if status == 0:
pixseriesnorm = (pixseries - pixMean) / pixStd
# Number of principal components to compute. Setting it equal to the number of pixels
if status == 0:
nvecin = npix
# Run PCA using the MDP Whitening PCA, which produces normalized PCA components (zero mean and unit variance)
if status == 0:
pcan = mdp.nodes.WhiteningNode(svd=True)
pcar = pcan.execute(pixseriesnorm)
eigvec = pcan.get_recmatrix()
model = pcar
# Re-insert nan columns as zeros
if status == 0:
for i in range(0, len(nanpixels)):
nanpixels[i] = nanpixels[i] - i
eigvec = numpy.insert(eigvec, nanpixels, 0, 1)
pixMean = numpy.insert(pixMean, nanpixels, 0, 0)
# Make output eigenvectors (correlation images) into xpix by ypix images
if status == 0:
eigvec = eigvec.reshape(nvecin, ydim, xdim)
# Calculate sum of all pixels to display as raw lightcurve and other quantities
if status == 0:
pixseriessum = sum(pixseries, axis=1)
nrem = len(pcarem) # Number of components to remove
nplot = npix # Number of pcas to plot - currently set to plot all components, but could set
# nplot = nrem to just plot as many components as is being removed
# Subtract components by fitting them to the summed light curve
if status == 0:
x0 = numpy.tile(-1.0, 1)
for k in range(0, nrem):
def f(x):
fluxcor = pixseriessum
for k in range(0, len(x)):
fluxcor = fluxcor - x[k] * model[:, pcarem[k]]
return mad(fluxcor)
if k == 0:
x0 = array([-1.0])
else:
x0 = numpy.append(x0, 1.0)
myfit = scipy.optimize.fmin(f,
x0,
maxiter=50000,
maxfun=50000,
disp=False)
x0 = myfit
# Now that coefficients for all components have been found, subtract them to produce a calibrated time-series,
# and then divide by the robust mean to produce a normalized time series as well
if status == 0:
c = myfit
fluxcor = pixseriessum
for k in range(0, nrem):
fluxcor = fluxcor - c[k] * model[:, pcarem[k]]
normfluxcor = fluxcor / mean(reject_outliers(fluxcor, 2))
# input file data
if status == 0:
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
table = instr[1].data[:]
maskmap = copy(instr[2].data)
# subimage physical WCS data
if status == 0:
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
# dummy columns for output file
if status == 0:
sap_flux_err = numpy.empty(len(time))
sap_flux_err[:] = numpy.nan
sap_bkg = numpy.empty(len(time))
sap_bkg[:] = numpy.nan
sap_bkg_err = numpy.empty(len(time))
sap_bkg_err[:] = numpy.nan
pdc_flux = numpy.empty(len(time))
pdc_flux[:] = numpy.nan
pdc_flux_err = numpy.empty(len(time))
pdc_flux_err[:] = numpy.nan
psf_centr1 = numpy.empty(len(time))
psf_centr1[:] = numpy.nan
psf_centr1_err = numpy.empty(len(time))
psf_centr1_err[:] = numpy.nan
psf_centr2 = numpy.empty(len(time))
psf_centr2[:] = numpy.nan
psf_centr2_err = numpy.empty(len(time))
psf_centr2_err[:] = numpy.nan
mom_centr1 = numpy.empty(len(time))
mom_centr1[:] = numpy.nan
mom_centr1_err = numpy.empty(len(time))
mom_centr1_err[:] = numpy.nan
mom_centr2 = numpy.empty(len(time))
mom_centr2[:] = numpy.nan
mom_centr2_err = numpy.empty(len(time))
mom_centr2_err[:] = numpy.nan
# mask bitmap
if status == 0 and 'aper' not in maskfile.lower(
) and maskfile.lower() != 'all':
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx, crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery, crval2p + (i + 1 - crpix2p) * cdelt2p)
if maskmap[i, j] == 0:
pass
else:
maskmap[i, j] = 1
for k in range(len(maskx)):
if aperx[-1] == maskx[k] and apery[-1] == masky[k]:
maskmap[i, j] = 3
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].keyword not in list(hdu0.header.keys()):
hdu0.header[cards0[i].keyword] = (cards0[i].value,
cards0[i].comment)
else:
hdu0.header.cards[
cards0[i].keyword].comment = cards0[i].comment
status = kepkey.history(call, hdu0, outfile, logfile, verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
col1 = Column(name='TIME',
format='D',
unit='BJD - 2454833',
array=time)
col2 = Column(name='TIMECORR', format='E', unit='d', array=timecorr)
col3 = Column(name='CADENCENO', format='J', array=cadenceno)
col4 = Column(name='SAP_FLUX',
format='E',
unit='e-/s',
array=pixseriessum)
col5 = Column(name='SAP_FLUX_ERR',
format='E',
unit='e-/s',
array=sap_flux_err)
col6 = Column(name='SAP_BKG', format='E', unit='e-/s', array=sap_bkg)
col7 = Column(name='SAP_BKG_ERR',
format='E',
unit='e-/s',
array=sap_bkg_err)
col8 = Column(name='PDCSAP_FLUX',
format='E',
unit='e-/s',
array=pdc_flux)
col9 = Column(name='PDCSAP_FLUX_ERR',
format='E',
unit='e-/s',
array=pdc_flux_err)
col10 = Column(name='SAP_QUALITY', format='J', array=quality)
col11 = Column(name='PSF_CENTR1',
format='E',
unit='pixel',
array=psf_centr1)
col12 = Column(name='PSF_CENTR1_ERR',
format='E',
unit='pixel',
array=psf_centr1_err)
col13 = Column(name='PSF_CENTR2',
format='E',
unit='pixel',
array=psf_centr2)
col14 = Column(name='PSF_CENTR2_ERR',
format='E',
unit='pixel',
array=psf_centr2_err)
col15 = Column(name='MOM_CENTR1',
format='E',
unit='pixel',
array=mom_centr1)
col16 = Column(name='MOM_CENTR1_ERR',
format='E',
unit='pixel',
array=mom_centr1_err)
col17 = Column(name='MOM_CENTR2',
format='E',
unit='pixel',
array=mom_centr2)
col18 = Column(name='MOM_CENTR2_ERR',
format='E',
unit='pixel',
array=mom_centr2_err)
col19 = Column(name='POS_CORR1',
format='E',
unit='pixel',
array=pos_corr1)
col20 = Column(name='POS_CORR2',
format='E',
unit='pixel',
array=pos_corr2)
col21 = Column(name='PCA_FLUX', format='E', unit='e-/s', array=fluxcor)
col22 = Column(name='PCA_FLUX_NRM', format='E', array=normfluxcor)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11, \
col12,col13,col14,col15,col16,col17,col18,col19,col20,col21,col22])
hdu1 = new_table(cols)
hdu1.header['TTYPE1'] = ('TIME', 'column title: data time stamps')
hdu1.header['TFORM1'] = ('D', 'data type: float64')
hdu1.header['TUNIT1'] = ('BJD - 2454833',
'column units: barycenter corrected JD')
hdu1.header['TDISP1'] = ('D12.7', 'column display format')
hdu1.header['TTYPE2'] = (
'TIMECORR', 'column title: barycentric-timeslice correction')
hdu1.header['TFORM2'] = ('E', 'data type: float32')
hdu1.header['TUNIT2'] = ('d', 'column units: days')
hdu1.header['TTYPE3'] = ('CADENCENO',
'column title: unique cadence number')
hdu1.header['TFORM3'] = ('J', 'column format: signed integer32')
hdu1.header['TTYPE4'] = ('SAP_FLUX',
'column title: aperture photometry flux')
hdu1.header['TFORM4'] = ('E', 'column format: float32')
hdu1.header['TUNIT4'] = ('e-/s', 'column units: electrons per second')
hdu1.header['TTYPE5'] = ('SAP_FLUX_ERR',
'column title: aperture phot. flux error')
hdu1.header['TFORM5'] = ('E', 'column format: float32')
hdu1.header['TUNIT5'] = (
'e-/s', 'column units: electrons per second (1-sigma)')
hdu1.header['TTYPE6'] = (
'SAP_BKG', 'column title: aperture phot. background flux')
hdu1.header['TFORM6'] = ('E', 'column format: float32')
hdu1.header['TUNIT6'] = ('e-/s', 'column units: electrons per second')
hdu1.header['TTYPE7'] = (
'SAP_BKG_ERR', 'column title: ap. phot. background flux error')
hdu1.header['TFORM7'] = ('E', 'column format: float32')
hdu1.header['TUNIT7'] = (
'e-/s', 'column units: electrons per second (1-sigma)')
hdu1.header['TTYPE8'] = ('PDCSAP_FLUX',
'column title: PDC photometry flux')
hdu1.header['TFORM8'] = ('E', 'column format: float32')
hdu1.header['TUNIT8'] = ('e-/s', 'column units: electrons per second')
hdu1.header['TTYPE9'] = ('PDCSAP_FLUX_ERR',
'column title: PDC flux error')
hdu1.header['TFORM9'] = ('E', 'column format: float32')
hdu1.header['TUNIT9'] = (
'e-/s', 'column units: electrons per second (1-sigma)')
hdu1.header['TTYPE10'] = (
'SAP_QUALITY', 'column title: aperture photometry quality flag')
hdu1.header['TFORM10'] = ('J', 'column format: signed integer32')
hdu1.header['TTYPE11'] = ('PSF_CENTR1',
'column title: PSF fitted column centroid')
hdu1.header['TFORM11'] = ('E', 'column format: float32')
hdu1.header['TUNIT11'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE12'] = ('PSF_CENTR1_ERR',
'column title: PSF fitted column error')
hdu1.header['TFORM12'] = ('E', 'column format: float32')
hdu1.header['TUNIT12'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE13'] = ('PSF_CENTR2',
'column title: PSF fitted row centroid')
hdu1.header['TFORM13'] = ('E', 'column format: float32')
hdu1.header['TUNIT13'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE14'] = ('PSF_CENTR2_ERR',
'column title: PSF fitted row error')
hdu1.header['TFORM14'] = ('E', 'column format: float32')
hdu1.header['TUNIT14'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE15'] = (
'MOM_CENTR1', 'column title: moment-derived column centroid')
hdu1.header['TFORM15'] = ('E', 'column format: float32')
hdu1.header['TUNIT15'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE16'] = ('MOM_CENTR1_ERR',
'column title: moment-derived column error')
hdu1.header['TFORM16'] = ('E', 'column format: float32')
hdu1.header['TUNIT16'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE17'] = ('MOM_CENTR2',
'column title: moment-derived row centroid')
hdu1.header['TFORM17'] = ('E', 'column format: float32')
hdu1.header['TUNIT17'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE18'] = ('MOM_CENTR2_ERR',
'column title: moment-derived row error')
hdu1.header['TFORM18'] = ('E', 'column format: float32')
hdu1.header['TUNIT18'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE19'] = (
'POS_CORR1', 'column title: col correction for vel. abbern')
hdu1.header['TFORM19'] = ('E', 'column format: float32')
hdu1.header['TUNIT19'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE20'] = (
'POS_CORR2', 'column title: row correction for vel. abbern')
hdu1.header['TFORM20'] = ('E', 'column format: float32')
hdu1.header['TUNIT20'] = ('pixel', 'column units: pixel')
hdu1.header['TTYPE21'] = ('PCA_FLUX',
'column title: PCA-corrected flux')
hdu1.header['TFORM21'] = ('E', 'column format: float32')
hdu1.header['TUNIT21'] = ('pixel', 'column units: e-/s')
hdu1.header['TTYPE22'] = (
'PCA_FLUX_NRM', 'column title: normalized PCA-corrected flux')
hdu1.header['TFORM22'] = ('E', 'column format: float32')
hdu1.header['EXTNAME'] = ('LIGHTCURVE', 'name of extension')
for i in range(len(cards1)):
if (cards1[i].keyword not in list(hdu1.header.keys())
and cards1[i].keyword[:4] not in [
'TTYP', 'TFOR', 'TUNI', 'TDIS', 'TDIM', 'WCAX', '1CTY',
'2CTY', '1CRP', '2CRP', '1CRV', '2CRV', '1CUN', '2CUN',
'1CDE', '2CDE', '1CTY', '2CTY', '1CDL', '2CDL', '11PC',
'12PC', '21PC', '22PC'
]):
hdu1.header[cards1[i].keyword] = (cards1[i].value,
cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].keyword not in list(hdu2.header.keys()):
hdu2.header[cards2[i].keyword] = (cards2[i].value,
cards2[i].comment)
else:
hdu2.header.cards[
cards2[i].keyword].comment = cards2[i].comment
outstr.append(hdu2)
# construct principal component table
if status == 0:
cols = [
Column(name='TIME', format='E', unit='BJD - 2454833', array=time)
]
for i in range(len(pcar[0, :])):
colname = 'PC' + str(i + 1)
col = Column(name=colname, format='E', array=pcar[:, i])
cols.append(col)
hdu3 = new_table(ColDefs(cols))
hdu3.header['EXTNAME'] = ('PRINCIPAL_COMPONENTS', 'name of extension')
hdu3.header['TTYPE1'] = ('TIME', 'column title: data time stamps')
hdu3.header['TFORM1'] = ('D', 'data type: float64')
hdu3.header['TUNIT1'] = ('BJD - 2454833',
'column units: barycenter corrected JD')
hdu3.header['TDISP1'] = ('D12.7', 'column display format')
for i in range(len(pcar[0, :])):
hdu3.header['TTYPE' + str(i + 2)] = \
('PC' + str(i + 1), 'column title: principal component number' + str(i + 1))
hdu3.header['TFORM' + str(i + 2)] = ('E', 'column format: float32')
outstr.append(hdu3)
# write output file
if status == 0:
outstr.writeto(outfile)
# close input structure
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
# Create PCA report
if status == 0 and plotpca:
npp = 7 # Number of plots per page
l = 1
repcnt = 1
for k in range(nreps):
# First plot of every pagewith flux image, flux and calibrated time series
status = kepplot.define(16, 12, logfile, verbose)
if (k % (npp - 1) == 0):
pylab.figure(figsize=[10, 16])
subplot2grid((npp, 6), (0, 0), colspan=2)
# imshow(log10(pixMean.reshape(xdim,ydim).T-min(pixMean)+1),interpolation="nearest",cmap='RdYlBu')
imshow(log10(
flipud(pixMean.reshape(ydim, xdim)) - min(pixMean) + 1),
interpolation="nearest",
cmap='RdYlBu')
xticks([])
yticks([])
ax1 = subplot2grid((npp, 6), (0, 2), colspan=4)
px = copy(time) + bjdref
py = copy(pixseriessum)
px, xlab, status = kepplot.cleanx(px, logfile, verbose)
py, ylab, status = kepplot.cleany(py, 1.0, logfile, verbose)
kepplot.RangeOfPlot(px, py, 0.01, False)
kepplot.plot1d(px, py, cadence, lcolor, lwidth, fcolor, falpha,
True)
py = copy(fluxcor)
py, ylab, status = kepplot.cleany(py, 1.0, logfile, verbose)
plot(px,
py,
marker='.',
color='r',
linestyle='',
markersize=1.0)
kepplot.labels('', re.sub('\)', '',
re.sub('Flux \(', '', ylab)), 'k',
18)
grid()
setp(ax1.get_xticklabels(), visible=False)
# plot principal components
subplot2grid((npp, 6), (l, 0), colspan=2)
imshow(eigvec[k], interpolation="nearest", cmap='RdYlBu')
xlim(-0.5, xdim - 0.5)
ylim(-0.5, ydim - 0.5)
xticks([])
yticks([])
# The last plot on the page that should have the xlabel
if (k % (npp - 1) == npp - 2 or k == nvecin - 1):
subplot2grid((npp, 6), (l, 2), colspan=4)
py = copy(model[:, k])
kepplot.RangeOfPlot(px, py, 0.01, False)
kepplot.plot1d(px, py, cadence, 'r', lwidth, 'g', falpha, True)
kepplot.labels(xlab, 'PC ' + str(k + 1), 'k', 18)
pylab.grid()
pylab.tight_layout()
l = 1
pylab.savefig(re.sub('.png', '_%d.png' % repcnt, repname))
if not cmdLine: kepplot.render(cmdLine)
repcnt += 1
# The other plots on the page that should have no xlabel
else:
ax2 = subplot2grid((npp, 6), (l, 2), colspan=4)
py = copy(model[:, k])
kepplot.RangeOfPlot(px, py, 0.01, False)
kepplot.plot1d(px, py, cadence, 'r', lwidth, 'g', falpha, True)
kepplot.labels('', 'PC ' + str(k + 1), 'k', 18)
grid()
setp(ax2.get_xticklabels(), visible=False)
pylab.tight_layout()
l = l + 1
pylab.savefig(re.sub('.png', '_%d.png' % repcnt, repname))
if not cmdLine: kepplot.render(cmdLine)
# plot style and size
if status == 0 and plotpca:
status = kepplot.define(labelsize, ticksize, logfile, verbose)
pylab.figure(figsize=[xsize, ysize])
pylab.clf()
# plot aperture photometry and PCA corrected data
if status == 0 and plotpca:
ax = kepplot.location([0.06, 0.54, 0.93, 0.43])
px = copy(time) + bjdref
py = copy(pixseriessum)
px, xlab, status = kepplot.cleanx(px, logfile, verbose)
py, ylab, status = kepplot.cleany(py, 1.0, logfile, verbose)
kepplot.RangeOfPlot(px, py, 0.01, False)
kepplot.plot1d(px, py, cadence, lcolor, lwidth, fcolor, falpha, True)
py = copy(fluxcor)
py, ylab, status = kepplot.cleany(py, 1.0, logfile, verbose)
kepplot.plot1d(px, py, cadence, 'r', 2, fcolor, 0.0, True)
pylab.setp(pylab.gca(), xticklabels=[])
kepplot.labels('', ylab, 'k', 24)
pylab.grid()
# plot aperture photometry and PCA corrected data
if status == 0 and plotpca:
ax = kepplot.location([0.06, 0.09, 0.93, 0.43])
yr = array([], 'float32')
npc = min([6, nrem])
for i in range(npc - 1, -1, -1):
py = pcar[:, i] * c[i]
py, ylab, status = kepplot.cleany(py, 1.0, logfile, verbose)
cl = float(i) / (float(npc))
kepplot.plot1d(px, py, cadence, [1.0 - cl, 0.0, cl], 2, fcolor,
0.0, True)
yr = append(yr, py)
y1 = max(yr)
y2 = -min(yr)
kepplot.RangeOfPlot(px, array([-y1, y1, -y2, y2]), 0.01, False)
kepplot.labels(xlab, 'Principal Components', 'k', 24)
pylab.grid()
# save plot to file
if status == 0 and plotpca:
pylab.savefig(repname)
# render plot
if status == 0 and plotpca:
kepplot.render(cmdLine)
# stop time
if status == 0:
kepmsg.clock('KEPPCA ended at', logfile, verbose)
return
def keptrial(infile,
outfile,
datacol,
errcol,
fmin,
fmax,
nfreq,
method,
ntrials,
plot,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 18
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPTRIAL -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'datacol=' + datacol + ' '
call += 'errcol=' + errcol + ' '
call += 'fmin=' + str(fmin) + ' '
call += 'fmax=' + str(fmax) + ' '
call += 'nfreq=' + str(nfreq) + ' '
call += 'method=' + method + ' '
call += 'ntrials=' + str(ntrials) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPTRIAL started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPTRIAL: ' + outfile + ' exists. Use clobber=yes'
kepmsg.err(logfile, message, verbose)
status = 1
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
# input data
if status == 0:
try:
barytime = instr[1].data.field('barytime')
except:
barytime, status = kepio.readfitscol(infile, instr[1].data, 'time',
logfile, verbose)
if status == 0:
signal, status = kepio.readfitscol(infile, instr[1].data, datacol,
logfile, verbose)
if status == 0:
err, status = kepio.readfitscol(infile, instr[1].data, errcol, logfile,
verbose)
# remove infinite data from time series
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
incols = [barytime, signal, err]
[barytime, signal, err] = kepstat.removeinfinlc(signal, incols)
# set up plot
if status == 0:
plotLatex = True
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
print('WARNING: install latex for scientific plotting')
plotLatex = False
# frequency steps and Monte Carlo iterations
if status == 0:
deltaf = (fmax - fmin) / nfreq
freq = []
pmax = []
trial = []
for i in range(ntrials):
trial.append(i + 1)
# adjust data within the error bars
work1 = kepstat.randarray(signal, err)
# determine FT power
fr, power = kepfourier.ft(barytime, work1, fmin, fmax, deltaf,
False)
# determine peak in FT
pmax.append(-1.0e30)
for j in range(len(fr)):
if (power[j] > pmax[-1]):
pmax[-1] = power[j]
f1 = fr[j]
freq.append(f1)
# plot stop-motion histogram
pylab.ion()
pylab.figure(1, figsize=[7, 10])
clf()
pylab.axes([0.08, 0.08, 0.88, 0.89])
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
n, bins, patches = pylab.hist(freq,
bins=nfreq,
range=[fmin, fmax],
align='mid',
rwidth=1,
ec='#0000ff',
fc='#ffff00',
lw=2)
# fit normal distribution to histogram
x = zeros(len(bins))
for j in range(1, len(bins)):
x[j] = (bins[j] + bins[j - 1]) / 2
pinit = numpy.array([float(i), freq[-1], deltaf])
if i > 3:
n = array(n, dtype='float32')
coeffs, errors, covar, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.leastsquare('gauss',pinit,x[1:],n,None,logfile,verbose)
fitfunc = kepfunc.gauss()
f = arange(fmin, fmax, (fmax - fmin) / 100)
fit = fitfunc(coeffs, f)
pylab.plot(f, fit, 'r-', linewidth=2)
if plotLatex:
xlabel(r'Frequency (d$^{-1}$)', {'color': 'k'})
else:
xlabel(r'Frequency (1/d)', {'color': 'k'})
ylabel('N', {'color': 'k'})
xlim(fmin, fmax)
grid()
# render plot
if plot:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# period results
if status == 0:
p = 1.0 / coeffs[1]
perr = p * coeffs[2] / coeffs[1]
f1 = fmin
f2 = fmax
gotbin = False
for i in range(len(n)):
if n[i] > 0 and not gotbin:
f1 = bins[i]
gotbin = True
gotbin = False
for i in range(len(n) - 1, 0, -1):
if n[i] > 0 and not gotbin:
f2 = bins[i + 1]
gotbin = True
powave, powstdev = kepstat.stdev(pmax)
# print result
if status == 0:
print(' best period: %.10f days (%.7f min)' %
(p, p * 1440.0))
print(' 1-sigma period error: %.10f days (%.7f min)' %
(perr, perr * 1440.0))
print(' search range: %.10f - %.10f days ' %
(1.0 / fmax, 1.0 / fmin))
print(' 100%% confidence range: %.10f - %.10f days ' %
(1.0 / f2, 1.0 / f1))
# print ' detection confidence: %.2f sigma' % (powave / powstdev)
print(' number of trials: %d' % ntrials)
print(' number of frequency bins: %d' % nfreq)
# history keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
## write output file
if status == 0:
col1 = Column(name='TRIAL', format='J', array=trial)
col2 = Column(name='FREQUENCY', format='E', unit='1/day', array=freq)
col3 = Column(name='POWER', format='E', array=pmax)
cols = ColDefs([col1, col2, col3])
instr.append(new_table(cols))
try:
instr[-1].header.update('EXTNAME', 'TRIALS', 'Extension name')
except:
status = 1
try:
instr[-1].header.update('SEARCHR1', 1.0 / fmax,
'Search range lower bound (days)')
except:
status = 1
try:
instr[-1].header.update('SEARCHR2', 1.0 / fmin,
'Search range upper bound (days)')
except:
status = 1
try:
instr[-1].header.update('NFREQ', nfreq, 'Number of frequency bins')
except:
status = 1
try:
instr[-1].header.update('PERIOD', p, 'Best period (days)')
except:
status = 1
try:
instr[-1].header.update('PERIODE', perr,
'1-sigma period error (days)')
except:
status = 1
# instr[-1].header.update('DETNCONF',powave/powstdev,'Detection significance (sigma)')
try:
instr[-1].header.update('CONFIDR1', 1.0 / f2,
'Trial confidence lower bound (days)')
except:
status = 1
try:
instr[-1].header.update('CONFIDR2', 1.0 / f1,
'Trial confidence upper bound (days)')
except:
status = 1
try:
instr[-1].header.update('NTRIALS', ntrials, 'Number of trials')
except:
status = 1
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
## end time
if (status == 0):
message = 'KEPTRAIL completed at'
else:
message = '\nKEPTRIAL aborted at'
kepmsg.clock(message, logfile, verbose)
def kepfold(infile,outfile,period,phasezero,bindata,binmethod,threshold,niter,nbins,
rejqual,plottype,plotlab,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 32; ticksize = 18; xsize = 18; ysize = 10
lcolor = '#0000ff'; lwidth = 2.0; fcolor = '#ffff00'; falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFOLD -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'period='+str(period)+' '
call += 'phasezero='+str(phasezero)+' '
binit = 'n'
if (bindata): binit = 'y'
call += 'bindata='+binit+' '
call += 'binmethod='+binmethod+' '
call += 'threshold='+str(threshold)+' '
call += 'niter='+str(niter)+' '
call += 'nbins='+str(nbins)+' '
qflag = 'n'
if (rejqual): qflag = 'y'
call += 'rejqual='+qflag+ ' '
call += 'plottype='+plottype+ ' '
call += 'plotlab='+plotlab+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPFOLD started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFOLD: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# input data
if status == 0:
table = instr[1].data
incards = instr[1].header.cards
try:
sap = instr[1].data.field('SAP_FLUX')
except:
try:
sap = instr[1].data.field('ap_raw_flux')
except:
sap = zeros(len(table.field(0)))
try:
saperr = instr[1].data.field('SAP_FLUX_ERR')
except:
try:
saperr = instr[1].data.field('ap_raw_err')
except:
saperr = zeros(len(table.field(0)))
try:
pdc = instr[1].data.field('PDCSAP_FLUX')
except:
try:
pdc = instr[1].data.field('ap_corr_flux')
except:
pdc = zeros(len(table.field(0)))
try:
pdcerr = instr[1].data.field('PDCSAP_FLUX_ERR')
except:
try:
pdcerr = instr[1].data.field('ap_corr_err')
except:
pdcerr = zeros(len(table.field(0)))
try:
cbv = instr[1].data.field('CBVSAP_FLUX')
except:
cbv = zeros(len(table.field(0)))
if 'cbv' in plottype:
txt = 'ERROR -- KEPFOLD: CBVSAP_FLUX column is not populated. Use kepcotrend'
status = kepmsg.err(logfile,txt,verbose)
try:
det = instr[1].data.field('DETSAP_FLUX')
except:
det = zeros(len(table.field(0)))
if 'det' in plottype:
txt = 'ERROR -- KEPFOLD: DETSAP_FLUX column is not populated. Use kepflatten'
status = kepmsg.err(logfile,txt,verbose)
try:
deterr = instr[1].data.field('DETSAP_FLUX_ERR')
except:
deterr = zeros(len(table.field(0)))
if 'det' in plottype:
txt = 'ERROR -- KEPFOLD: DETSAP_FLUX_ERR column is not populated. Use kepflatten'
status = kepmsg.err(logfile,txt,verbose)
try:
quality = instr[1].data.field('SAP_QUALITY')
except:
quality = zeros(len(table.field(0)))
if qualflag:
txt = 'WARNING -- KEPFOLD: Cannot find a QUALITY data column'
kepmsg.warn(logfile,txt)
if status == 0:
barytime, status = kepio.readtimecol(infile,table,logfile,verbose)
barytime1 = copy(barytime)
# filter out NaNs and quality > 0
work1 = []; work2 = []; work3 = []; work4 = []; work5 = []; work6 = []; work8 = []; work9 = []
if status == 0:
if 'sap' in plottype:
datacol = copy(sap)
errcol = copy(saperr)
if 'pdc' in plottype:
datacol = copy(pdc)
errcol = copy(pdcerr)
if 'cbv' in plottype:
datacol = copy(cbv)
errcol = copy(saperr)
if 'det' in plottype:
datacol = copy(det)
errcol = copy(deterr)
for i in range(len(barytime)):
if (numpy.isfinite(barytime[i]) and
numpy.isfinite(datacol[i]) and datacol[i] != 0.0 and
numpy.isfinite(errcol[i]) and errcol[i] > 0.0):
if rejqual and quality[i] == 0:
work1.append(barytime[i])
work2.append(sap[i])
work3.append(saperr[i])
work4.append(pdc[i])
work5.append(pdcerr[i])
work6.append(cbv[i])
work8.append(det[i])
work9.append(deterr[i])
elif not rejqual:
work1.append(barytime[i])
work2.append(sap[i])
work3.append(saperr[i])
work4.append(pdc[i])
work5.append(pdcerr[i])
work6.append(cbv[i])
work8.append(det[i])
work9.append(deterr[i])
barytime = array(work1,dtype='float64')
sap = array(work2,dtype='float32') / cadenom
saperr = array(work3,dtype='float32') / cadenom
pdc = array(work4,dtype='float32') / cadenom
pdcerr = array(work5,dtype='float32') / cadenom
cbv = array(work6,dtype='float32') / cadenom
det = array(work8,dtype='float32') / cadenom
deterr = array(work9,dtype='float32') / cadenom
# calculate phase
if status == 0:
if phasezero < bjdref:
phasezero += bjdref
date1 = (barytime1 + bjdref - phasezero)
phase1 = (date1 / period) - floor(date1/period)
date2 = (barytime + bjdref - phasezero)
phase2 = (date2 / period) - floor(date2/period)
phase2 = array(phase2,'float32')
# sort phases
if status == 0:
ptuple = []
phase3 = [];
sap3 = []; saperr3 = []
pdc3 = []; pdcerr3 = []
cbv3 = []; cbverr3 = []
det3 = []; deterr3 = []
for i in range(len(phase2)):
ptuple.append([phase2[i], sap[i], saperr[i], pdc[i], pdcerr[i], cbv[i], saperr[i], det[i], deterr[i]])
phsort = sorted(ptuple,key=lambda ph: ph[0])
for i in range(len(phsort)):
phase3.append(phsort[i][0])
sap3.append(phsort[i][1])
saperr3.append(phsort[i][2])
pdc3.append(phsort[i][3])
pdcerr3.append(phsort[i][4])
cbv3.append(phsort[i][5])
cbverr3.append(phsort[i][6])
det3.append(phsort[i][7])
deterr3.append(phsort[i][8])
phase3 = array(phase3,'float32')
sap3 = array(sap3,'float32')
saperr3 = array(saperr3,'float32')
pdc3 = array(pdc3,'float32')
pdcerr3 = array(pdcerr3,'float32')
cbv3 = array(cbv3,'float32')
cbverr3 = array(cbverr3,'float32')
det3 = array(det3,'float32')
deterr3 = array(deterr3,'float32')
# bin phases
if status == 0 and bindata:
work1 = array([sap3[0]],'float32')
work2 = array([saperr3[0]],'float32')
work3 = array([pdc3[0]],'float32')
work4 = array([pdcerr3[0]],'float32')
work5 = array([cbv3[0]],'float32')
work6 = array([cbverr3[0]],'float32')
work7 = array([det3[0]],'float32')
work8 = array([deterr3[0]],'float32')
phase4 = array([],'float32')
sap4 = array([],'float32')
saperr4 = array([],'float32')
pdc4 = array([],'float32')
pdcerr4 = array([],'float32')
cbv4 = array([],'float32')
cbverr4 = array([],'float32')
det4 = array([],'float32')
deterr4 = array([],'float32')
dt = 1.0 / nbins
nb = 0.0
rng = numpy.append(phase3,phase3[0]+1.0)
for i in range(len(rng)):
if rng[i] < nb * dt or rng[i] >= (nb + 1.0) * dt:
if len(work1) > 0:
phase4 = append(phase4,(nb + 0.5) * dt)
if (binmethod == 'mean'):
sap4 = append(sap4,kepstat.mean(work1))
saperr4 = append(saperr4,kepstat.mean_err(work2))
pdc4 = append(pdc4,kepstat.mean(work3))
pdcerr4 = append(pdcerr4,kepstat.mean_err(work4))
cbv4 = append(cbv4,kepstat.mean(work5))
cbverr4 = append(cbverr4,kepstat.mean_err(work6))
det4 = append(det4,kepstat.mean(work7))
deterr4 = append(deterr4,kepstat.mean_err(work8))
elif (binmethod == 'median'):
sap4 = append(sap4,kepstat.median(work1,logfile))
saperr4 = append(saperr4,kepstat.mean_err(work2))
pdc4 = append(pdc4,kepstat.median(work3,logfile))
pdcerr4 = append(pdcerr4,kepstat.mean_err(work4))
cbv4 = append(cbv4,kepstat.median(work5,logfile))
cbverr4 = append(cbverr4,kepstat.mean_err(work6))
det4 = append(det4,kepstat.median(work7,logfile))
deterr4 = append(deterr4,kepstat.mean_err(work8))
else:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work1)],arange(0.0,float(len(work1)),1.0),work1,work2,
threshold,threshold,niter,logfile,False)
sap4 = append(sap4,coeffs[0])
saperr4 = append(saperr4,kepstat.mean_err(work2))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work3)],arange(0.0,float(len(work3)),1.0),work3,work4,
threshold,threshold,niter,logfile,False)
pdc4 = append(pdc4,coeffs[0])
pdcerr4 = append(pdcerr4,kepstat.mean_err(work4))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work5)],arange(0.0,float(len(work5)),1.0),work5,work6,
threshold,threshold,niter,logfile,False)
cbv4 = append(cbv4,coeffs[0])
cbverr4 = append(cbverr4,kepstat.mean_err(work6))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work7)],arange(0.0,float(len(work7)),1.0),work7,work8,
threshold,threshold,niter,logfile,False)
det4 = append(det4,coeffs[0])
deterr4 = append(deterr4,kepstat.mean_err(work8))
work1 = array([],'float32')
work2 = array([],'float32')
work3 = array([],'float32')
work4 = array([],'float32')
work5 = array([],'float32')
work6 = array([],'float32')
work7 = array([],'float32')
work8 = array([],'float32')
nb += 1.0
else:
work1 = append(work1,sap3[i])
work2 = append(work2,saperr3[i])
work3 = append(work3,pdc3[i])
work4 = append(work4,pdcerr3[i])
work5 = append(work5,cbv3[i])
work6 = append(work6,cbverr3[i])
work7 = append(work7,det3[i])
work8 = append(work8,deterr3[i])
# update HDU1 for output file
if status == 0:
cols = (instr[1].columns + ColDefs([Column(name='PHASE',format='E',array=phase1)]))
instr[1] = pyfits.new_table(cols)
instr[1].header.cards['TTYPE'+str(len(instr[1].columns))].comment = 'column title: phase'
instr[1].header.cards['TFORM'+str(len(instr[1].columns))].comment = 'data type: float32'
for i in range(len(incards)):
if incards[i].key not in instr[1].header.keys():
instr[1].header.update(incards[i].key, incards[i].value, incards[i].comment)
else:
instr[1].header.cards[incards[i].key].comment = incards[i].comment
instr[1].header.update('PERIOD',period,'period defining the phase [d]')
instr[1].header.update('BJD0',phasezero,'time of phase zero [BJD]')
# write new phased data extension for output file
if status == 0 and bindata:
col1 = Column(name='PHASE',format='E',array=phase4)
col2 = Column(name='SAP_FLUX',format='E',unit='e/s',array=sap4/cadenom)
col3 = Column(name='SAP_FLUX_ERR',format='E',unit='e/s',array=saperr4/cadenom)
col4 = Column(name='PDC_FLUX',format='E',unit='e/s',array=pdc4/cadenom)
col5 = Column(name='PDC_FLUX_ERR',format='E',unit='e/s',array=pdcerr4/cadenom)
col6 = Column(name='CBV_FLUX',format='E',unit='e/s',array=cbv4/cadenom)
col7 = Column(name='DET_FLUX',format='E',array=det4/cadenom)
col8 = Column(name='DET_FLUX_ERR',format='E',array=deterr4/cadenom)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8])
instr.append(new_table(cols))
instr[-1].header.cards['TTYPE1'].comment = 'column title: phase'
instr[-1].header.cards['TTYPE2'].comment = 'column title: simple aperture photometry'
instr[-1].header.cards['TTYPE3'].comment = 'column title: SAP 1-sigma error'
instr[-1].header.cards['TTYPE4'].comment = 'column title: pipeline conditioned photometry'
instr[-1].header.cards['TTYPE5'].comment = 'column title: PDC 1-sigma error'
instr[-1].header.cards['TTYPE6'].comment = 'column title: cotrended basis vector photometry'
instr[-1].header.cards['TTYPE7'].comment = 'column title: Detrended aperture photometry'
instr[-1].header.cards['TTYPE8'].comment = 'column title: DET 1-sigma error'
instr[-1].header.cards['TFORM1'].comment = 'column type: float32'
instr[-1].header.cards['TFORM2'].comment = 'column type: float32'
instr[-1].header.cards['TFORM3'].comment = 'column type: float32'
instr[-1].header.cards['TFORM4'].comment = 'column type: float32'
instr[-1].header.cards['TFORM5'].comment = 'column type: float32'
instr[-1].header.cards['TFORM6'].comment = 'column type: float32'
instr[-1].header.cards['TFORM7'].comment = 'column type: float32'
instr[-1].header.cards['TFORM8'].comment = 'column type: float32'
instr[-1].header.cards['TUNIT2'].comment = 'column units: electrons per second'
instr[-1].header.cards['TUNIT3'].comment = 'column units: electrons per second'
instr[-1].header.cards['TUNIT4'].comment = 'column units: electrons per second'
instr[-1].header.cards['TUNIT5'].comment = 'column units: electrons per second'
instr[-1].header.cards['TUNIT6'].comment = 'column units: electrons per second'
instr[-1].header.update('EXTNAME','FOLDED','extension name')
instr[-1].header.update('PERIOD',period,'period defining the phase [d]')
instr[-1].header.update('BJD0',phasezero,'time of phase zero [BJD]')
instr[-1].header.update('BINMETHD',binmethod,'phase binning method')
if binmethod =='sigclip':
instr[-1].header.update('THRSHOLD',threshold,'sigma-clipping threshold [sigma]')
instr[-1].header.update('NITER',niter,'max number of sigma-clipping iterations')
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
instr.writeto(outfile)
# clean up x-axis unit
if status == 0:
ptime1 = array([],'float32')
ptime2 = array([],'float32')
pout1 = array([],'float32')
pout2 = array([],'float32')
if bindata:
work = sap4
if plottype == 'pdc':
work = pdc4
if plottype == 'cbv':
work = cbv4
if plottype == 'det':
work = det4
for i in range(len(phase4)):
if (phase4[i] > 0.5):
ptime2 = append(ptime2,phase4[i] - 1.0)
pout2 = append(pout2,work[i])
ptime2 = append(ptime2,phase4)
pout2 = append(pout2,work)
for i in range(len(phase4)):
if (phase4[i] <= 0.5):
ptime2 = append(ptime2,phase4[i] + 1.0)
pout2 = append(pout2,work[i])
work = sap3
if plottype == 'pdc':
work = pdc3
if plottype == 'cbv':
work = cbv3
if plottype == 'det':
work = det3
for i in range(len(phase3)):
if (phase3[i] > 0.5):
ptime1 = append(ptime1,phase3[i] - 1.0)
pout1 = append(pout1,work[i])
ptime1 = append(ptime1,phase3)
pout1 = append(pout1,work)
for i in range(len(phase3)):
if (phase3[i] <= 0.5):
ptime1 = append(ptime1,phase3[i] + 1.0)
pout1 = append(pout1,work[i])
xlab = 'Orbital Phase ($\phi$)'
# clean up y-axis units
if status == 0:
nrm = len(str(int(pout1[isfinite(pout1)].max())))-1
pout1 = pout1 / 10**nrm
pout2 = pout2 / 10**nrm
if nrm == 0:
ylab = plotlab
else:
ylab = '10$^%d$ %s' % (nrm, plotlab)
# data limits
xmin = ptime1.min()
xmax = ptime1.max()
ymin = pout1[isfinite(pout1)].min()
ymax = pout1[isfinite(pout1)].max()
xr = xmax - xmin
yr = ymax - ymin
ptime1 = insert(ptime1,[0],[ptime1[0]])
ptime1 = append(ptime1,[ptime1[-1]])
pout1 = insert(pout1,[0],[0.0])
pout1 = append(pout1,0.0)
if bindata:
ptime2 = insert(ptime2,[0],ptime2[0] - 1.0 / nbins)
ptime2 = insert(ptime2,[0],ptime2[0])
ptime2 = append(ptime2,[ptime2[-1] + 1.0 / nbins, ptime2[-1] + 1.0 / nbins])
pout2 = insert(pout2,[0],[pout2[-1]])
pout2 = insert(pout2,[0],[0.0])
pout2 = append(pout2,[pout2[2],0.0])
# plot new light curve
if status == 0 and plottype != 'none':
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 18,
'legend.fontsize': 18,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
pylab.rcParams.update(params)
except:
print 'ERROR -- KEPFOLD: install latex for scientific plotting'
status = 1
if status == 0 and plottype != 'none':
pylab.figure(figsize=[17,7])
pylab.clf()
ax = pylab.axes([0.06,0.11,0.93,0.86])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90)
if bindata:
pylab.fill(ptime2,pout2,color=fcolor,linewidth=0.0,alpha=falpha)
else:
if 'det' in plottype:
pylab.fill(ptime1,pout1,color=fcolor,linewidth=0.0,alpha=falpha)
pylab.plot(ptime1,pout1,color=lcolor,linestyle='',linewidth=lwidth,marker='.')
if bindata:
pylab.plot(ptime2[1:-1],pout2[1:-1],color='r',linestyle='-',linewidth=lwidth,marker='')
xlabel(xlab, {'color' : 'k'})
ylabel(ylab, {'color' : 'k'})
xlim(-0.49999,1.49999)
if ymin >= 0.0:
ylim(ymin-yr*0.01,ymax+yr*0.01)
# ylim(0.96001,1.03999)
else:
ylim(1.0e-10,ymax+yr*0.01)
grid()
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# stop time
kepmsg.clock('KEPFOLD ended at: ',logfile,verbose)
def kepcotrendsc(infile,outfile,bvfile,listbv,fitmethod,fitpower,iterate,sigma,maskfile,scinterp,plot,clobber,verbose,logfile,
status,cmdLine=False):
"""
Setup the kepcotrend environment
infile:
the input file in the FITS format obtained from MAST
outfile:
The output will be a fits file in the same style as the input file but with two additional columns: CBVSAP_MODL and CBVSAP_FLUX. The first of these is the best fitting linear combination of basis vectors. The second is the new flux with the basis vector sum subtracted. This is the new flux value.
plot:
either True or False if you want to see a plot of the light curve
The top plot shows the original light curve in blue and the sum of basis vectors in red
The bottom plot has had the basis vector sum subracted
bvfile:
the name of the FITS file containing the basis vectors
listbv:
the basis vectors to fit to the data
fitmethod:
fit using either the 'llsq' or the 'simplex' method. 'llsq' is usually the correct one to use because as the basis vectors are orthogonal. Simplex gives you option of using a different merit function - ie. you can minimise the least absolute residual instead of the least squares which weights outliers less
fitpower:
if using a simplex you can chose your own power in the metir function - i.e. the merit function minimises abs(Obs - Mod)^P. P=2 is least squares, P = 1 minimises least absolutes
iterate:
should the program fit the basis vectors to the light curve data then remove data points further than 'sigma' from the fit and then refit
maskfile:
this is the name of a mask file which can be used to define regions of the flux time series to exclude from the fit. The easiest way to create this is by using keprange from the PyKE set of tools. You can also make this yourself with two BJDs on each line in the file specifying the beginning and ending date of the region to exclude.
scinterp:
the basis vectors are only calculated for long cadence data, therefore if you want to use short cadence data you have to interpolate the basis vectors. There are several methods to do this, the best of these probably being nearest which picks the value of the nearest long cadence data point.
The options available are None|linear|nearest|zero|slinear|quadratic|cubic
If you are using short cadence data don't choose none
"""
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPCOTREND -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'bvfile='+bvfile+' '
# call += 'numpcomp= '+str(numpcomp)+' '
call += 'listbv= '+str(listbv)+' '
call += 'fitmethod=' +str(fitmethod)+ ' '
call += 'fitpower=' + str(fitpower)+ ' '
iterateit = 'n'
if (iterate): iterateit = 'y'
call += 'iterate='+iterateit+ ' '
call += 'sigma_clip='+str(sigma)+' '
call += 'mask_file='+maskfile+' '
call += 'scinterp=' + str(scinterp)+ ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPCOTREND started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber:
status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPCOTREND: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,
infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
if status == 0:
if not kepio.fileexists(bvfile):
message = 'ERROR -- KEPCOTREND: ' + bvfile + ' does not exist.'
status = kepmsg.err(logfile,message,verbose)
#lsq_sq - nonlinear least squares fitting and simplex_abs have been
#removed from the options in PyRAF but they are still in the code!
if status == 0:
if fitmethod not in ['llsq','matrix','lst_sq','simplex_abs','simplex']:
message = 'Fit method must either: llsq, matrix, lst_sq or simplex'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if not is_numlike(fitpower) and fitpower is not None:
message = 'Fit power must be an real number or None'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if fitpower is None:
fitpower = 1.
# input data
if status == 0:
short = False
try:
test = str(instr[0].header['FILEVER'])
version = 2
except KeyError:
version = 1
table = instr[1].data
if version == 1:
if str(instr[1].header['DATATYPE']) == 'long cadence':
#print 'Light curve was taken in Lond Cadence mode!'
quarter = str(instr[1].header['QUARTER'])
module = str(instr[1].header['MODULE'])
output = str(instr[1].header['OUTPUT'])
channel = str(instr[1].header['CHANNEL'])
lc_cad_o = table.field('cadence_number')
lc_date_o = table.field('barytime')
lc_flux_o = table.field('ap_raw_flux') / 1625.3468 #convert to e-/s
lc_err_o = table.field('ap_raw_err') / 1625.3468 #convert to e-/s
elif str(instr[1].header['DATATYPE']) == 'short cadence':
short = True
#print 'Light curve was taken in Short Cadence mode!'
quarter = str(instr[1].header['QUARTER'])
module = str(instr[1].header['MODULE'])
output = str(instr[1].header['OUTPUT'])
channel = str(instr[1].header['CHANNEL'])
lc_cad_o = table.field('cadence_number')
lc_date_o = table.field('barytime')
lc_flux_o = table.field('ap_raw_flux') / 54.178 #convert to e-/s
lc_err_o = table.field('ap_raw_err') / 54.178 #convert to e-/s
elif version >= 2:
if str(instr[0].header['OBSMODE']) == 'long cadence':
#print 'Light curve was taken in Long Cadence mode!'
quarter = str(instr[0].header['QUARTER'])
module = str(instr[0].header['MODULE'])
output = str(instr[0].header['OUTPUT'])
channel = str(instr[0].header['CHANNEL'])
lc_cad_o = table.field('CADENCENO')
lc_date_o = table.field('TIME')
lc_flux_o = table.field('SAP_FLUX')
lc_err_o = table.field('SAP_FLUX_ERR')
elif str(instr[0].header['OBSMODE']) == 'short cadence':
#print 'Light curve was taken in Short Cadence mode!'
short = True
quarter = str(instr[0].header['QUARTER'])
module = str(instr[0].header['MODULE'])
output = str(instr[0].header['OUTPUT'])
channel = str(instr[0].header['CHANNEL'])
lc_cad_o = table.field('CADENCENO')
lc_date_o = table.field('TIME')
lc_flux_o = table.field('SAP_FLUX')
lc_err_o = table.field('SAP_FLUX_ERR')
if str(quarter) == str(4) and version == 1:
lc_cad_o = lc_cad_o[lc_cad_o >= 11914]
lc_date_o = lc_date_o[lc_cad_o >= 11914]
lc_flux_o = lc_flux_o[lc_cad_o >= 11914]
lc_err_o = lc_err_o[lc_cad_o >= 11914]
# bvfilename = '%s/Q%s_%s_%s_map.txt' %(bvfile,quarter,module,output)
# if str(quarter) == str(5):
# bvdata = genfromtxt(bvfilename)
# elif str(quarter) == str(3) or str(quarter) == str(4):
# bvdata = genfromtxt(bvfilename,skip_header=22)
# elif str(quarter) == str(1):
# bvdata = genfromtxt(bvfilename,skip_header=10)
# else:
# bvdata = genfromtxt(bvfilename,skip_header=13)
if short and scinterp == 'None':
message = 'You cannot select None as the interpolation method because you are using short cadence data and therefore must use some form of interpolation. I reccommend nearest if you are unsure.'
status = kepmsg.err(logfile,message,verbose)
bvfiledata = pyfits.open(bvfile)
bvdata = bvfiledata['MODOUT_%s_%s' %(module,output)].data
if int(bvfiledata[0].header['QUARTER']) != int(quarter):
message = 'CBV file and light curve file are from different quarters. CBV file is from Q%s and light curve is from Q%s' %(int(bvfiledata[0].header['QUARTER']),int(quarter))
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if int(quarter) == 4 and int(module) == 3:
message = 'Approximately twenty days into Q4 Module 3 failed. As a result, Q4 light curves contain these 20 day of data. However, we do not calculate CBVs for this section of data.'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
#cut out infinites and zero flux columns
lc_cad,lc_date,lc_flux,lc_err,bad_data = cutBadData(lc_cad_o,
lc_date_o,lc_flux_o,lc_err_o)
#get a list of basis vectors to use from the list given
#accept different seperators
listbv = listbv.strip()
if listbv[1] in [' ',',',':',';','|',', ']:
separator = str(listbv)[1]
else:
message = 'You must separate your basis vector numbers to use with \' \' \',\' \':\' \';\' or \'|\' and the first basis vector to use must be between 1 and 9'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
bvlist = fromstring(listbv,dtype=int,sep=separator)
if bvlist[0] == 0:
message = 'Must use at least one basis vector'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
#pcomps = get_pcomp(pcompdata,n_comps,lc_cad)
# if str(quarter) == str(5):
# bvectors = get_pcomp_list(bvdata,bvlist,lc_cad)
# else:
# bvectors = get_pcomp_list_newformat(bvdata,bvlist,lc_cad)
if short:
bvdata.field('CADENCENO')[:] = (((bvdata.field('CADENCENO')[:] + (7.5/15.) )* 30.) - 11540.).round()
bvectors,in1derror = get_pcomp_list_newformat(bvdata,bvlist,lc_cad,short,scinterp)
if in1derror:
message = 'It seems that you have an old version of numpy which does not have the in1d function included. Please update your version of numpy to a version 1.4.0 or later'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
medflux = median(lc_flux)
n_flux = (lc_flux /medflux)-1
n_err = sqrt(pow(lc_err,2)/ pow(medflux,2))
#plt.errorbar(lc_cad,n_flux,yerr=n_err)
#plt.errorbar(lc_cad,lc_flux,yerr=lc_err)
#n_err = median(lc_err/lc_flux) * n_flux
#print n_err
#does an iterative least squares fit
#t1 = do_leastsq(pcomps,lc_cad,n_flux)
#
if maskfile != '':
domasking = True
if not kepio.fileexists(maskfile):
message = 'Maskfile %s does not exist' %maskfile
status = kepmsg.err(logfile,message,verbose)
else:
domasking = False
if status == 0:
if domasking:
lc_date_masked = copy(lc_date)
n_flux_masked = copy(n_flux)
lc_cad_masked = copy(lc_cad)
n_err_masked = copy(n_err)
maskdata = atleast_2d(genfromtxt(maskfile,delimiter=','))
#make a mask of True values incase there are not regions in maskfile to exclude.
mask = zeros(len(lc_date_masked)) == 0.
for maskrange in maskdata:
if version == 1:
start = maskrange[0] - 2400000.0
end = maskrange[1] - 2400000.0
elif version == 2:
start = maskrange[0] - 2454833.
end = maskrange[1] - 2454833.
masknew = logical_xor(lc_date < start,lc_date > end)
mask = logical_and(mask,masknew)
lc_date_masked = lc_date_masked[mask]
n_flux_masked = n_flux_masked[mask]
lc_cad_masked = lc_cad_masked[mask]
n_err_masked = n_err_masked[mask]
else:
lc_date_masked = copy(lc_date)
n_flux_masked = copy(n_flux)
lc_cad_masked = copy(lc_cad)
n_err_masked = copy(n_err)
#pcomps = get_pcomp(pcompdata,n_comps,lc_cad)
bvectors_masked,hasin1d = get_pcomp_list_newformat(bvdata,bvlist,lc_cad_masked,short,scinterp)
if (iterate) and sigma is None:
message = 'If fitting iteratively you must specify a clipping range'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
#uses Pvals = yhat * U_transpose
if (iterate):
coeffs,fittedmask = do_lst_iter(bvectors_masked,lc_cad_masked
,n_flux_masked,sigma,50.,fitmethod,fitpower)
else:
if fitmethod == 'matrix' and domasking:
coeffs = do_lsq_uhat(bvectors_masked,lc_cad_masked,n_flux_masked,False)
if fitmethod == 'llsq' and domasking:
coeffs = do_lsq_uhat(bvectors_masked,lc_cad_masked,n_flux_masked,False)
elif fitmethod == 'lst_sq':
coeffs = do_lsq_nlin(bvectors_masked,lc_cad_masked,n_flux_masked)
elif fitmethod == 'simplex_abs':
coeffs = do_lsq_fmin(bvectors_masked,lc_cad_masked,n_flux_masked)
elif fitmethod == 'simplex':
coeffs = do_lsq_fmin_pow(bvectors_masked,lc_cad_masked,n_flux_masked,fitpower)
else:
coeffs = do_lsq_uhat(bvectors_masked,lc_cad_masked,n_flux_masked)
flux_after = (get_newflux(n_flux,bvectors,coeffs) +1) * medflux
flux_after_masked = (get_newflux(n_flux_masked,bvectors_masked,coeffs) +1) * medflux
bvsum = get_pcompsum(bvectors,coeffs)
bvsum_masked = get_pcompsum(bvectors_masked,coeffs)
#print 'chi2: ' + str(chi2_gtf(n_flux,bvsum,n_err,2.*len(n_flux)-2))
#print 'rms: ' + str(rms(n_flux,bvsum))
bvsum_nans = putInNans(bad_data,bvsum)
flux_after_nans = putInNans(bad_data,flux_after)
if plot and status == 0:
newmedflux = median(flux_after + 1)
bvsum_un_norm = newmedflux*(1-bvsum)
#bvsum_un_norm = 0-bvsum
#lc_flux = n_flux
do_plot(lc_date,lc_flux,flux_after,
bvsum_un_norm,lc_cad,bad_data,lc_cad_o,version,cmdLine)
if status== 0:
make_outfile(instr,outfile,flux_after_nans,bvsum_nans,version)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
#print some results to screen:
print ' ----- '
if iterate:
flux_fit = n_flux_masked[fittedmask]
sum_fit = bvsum_masked[fittedmask]
err_fit = n_err_masked[fittedmask]
else:
flux_fit = n_flux_masked
sum_fit = bvsum_masked
err_fit = n_err_masked
print 'reduced chi2: ' + str(chi2_gtf(flux_fit,sum_fit,err_fit,len(flux_fit)-len(coeffs)))
print 'rms: ' + str(medflux*rms(flux_fit,sum_fit))
for i in range(len(coeffs)):
print 'Coefficient of CBV #%s: %s' %(i+1,coeffs[i])
print ' ----- '
# end time
if (status == 0):
message = 'KEPCOTREND completed at'
else:
message = '\nKEPCOTTREND aborted at'
kepmsg.clock(message,logfile,verbose)
return
def keptimefix(infile,
outfile,
clobber,
verbose,
logfile,
status,
cmdLine=False):
"""
All Kepler light curve and target pixel files with version numbers 5.0 contain an error in
the time stamps. This was fixed in the light curve with version 5.0 (at MAST after May 2013).
The timescale for fixing the target pixel files is unclear but in the mean time this script will
fix the target pixel file time stamps and make the times consistent with the light curve files.
The error in Q0-13 can be corrected by adding 66.184s. During Q14 there was a leap second added
Q15+ can be corrected by adding 67.184s. This tool fixes the time stamp accordingly.
inputs
infile - the name of the input target pixel file
output - the name of the output target pixel file
optional
clobber (default=False) - overwrite a file with the stame name as outfile.
"""
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPTIMEFIX -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPTIMEFIX started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
if clobber:
status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPTIMEFIX: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
creator = instr[0].header['CREATOR']
if creator.find('TargetPixelExporterPipelineModule') < 0:
message = 'ERROR -- KEPTIMEFIX: this file is not a target pixel file'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
header_ext1 = instr[1].header.cards
data_ext1 = instr[1].data
fileversion = instr[0].header['FILEVER']
if float(fileversion) > 4.0:
message = 'ERROR -- KEPTIMEFIX: no time fix needed for this file. FILEVER > 4.0'
status = kepmsg.err(logfile, message, verbose)
sys.exit(0)
quarter = instr[0].header['QUARTER']
if instr[0].header['OBSMODE'] == 'long cadence':
cadencetype = 'L'
elif instr[0].header['OBSMODE'] == 'short cadence':
cadencetype = 'S'
TIME_wrong = data_ext1.field('TIME')
CADNUM = data_ext1.field('CADENCENO')
TIMECORR_old = data_ext1.field('TIMECORR')
## update headers
##TSTART, TSTART, EXPOSURE, TELAPSE, LIVETIME
##DATE-OBS, DATE-END
if cadencetype == 'L':
offset = np.where(CADNUM <= 57139, 66.184, 67.184) / 86400.
elif cadencetype == 'S':
offset = np.where(CADNUM <= 1702663, 66.184, 67.184) / 86400.
TIME_right = TIME_wrong + offset
TIMECORR_new = TIMECORR_old + offset
#tcol = pyfits.Column(name='TIME',format='D14.7',
# array=TIME_right, unit = 'BJD - 2454833', disp='D14.7')
#instr[1].columns.change_attrib('TIME',array,TIME_right)
#cols = instr[1].data.columns + tcol
instr[1].data['TIME'][:] = TIME_right
#we decided not to use the updated timecorr because
#it is different from the LC FITS files by ~1 ms.
instr[1].data['TIMECORR'][:] = np.nan * np.empty(len(TIMECORR_old))
#instr[1] = pyfits.new_table(cols,header=instr[1].header)
#now to fix the header
tstart_right = instr[1].header['TSTART'] + offset[0]
tstop_right = instr[1].header['TSTOP'] + offset[-1]
telapse_right = tstop_right - tstart_right
instr[1].header['TSTART'] = tstart_right
instr[1].header['TSTOP'] = tstop_right
instr[1].header['TELAPSE'] = telapse_right
deadc = instr[1].header['DEADC']
instr[1].header['LIVETIME'] = telapse_right * deadc
#get the date-obs
dstart = instr[1].header['DATE-OBS']
dend = instr[1].header['DATE-END']
## This datetime stuff is not nessessary!!!!
#dts = datetime.datetime.strptime(dstart, "%Y-%m-%dT%H:%M:%S.%fZ")
#dte = datetime.datetime.strptime(dend, "%Y-%m-%dT%H:%M:%S.%fZ")
#offset_s1 = datetime.timedelta(seconds=66.184)
#offset_s2 = datetime.timedelta(seconds=67.184)
#if quarter <14:
# date_obs_new = dts + offset_s1
# date_end_new = dte + offset_s1
#if quarter > 14:
# date_obs_new = dts + offset_s2
# date_end_new = dte + offset_s2
#if quarter == 14:
# date_obs_new = dts + offset_s1
# date_end_new = dte + offset_s2
#instr[1].header['DATE-OBS'] = str(date_obs_new)[:-3] + 'Z'
#instr[1].header['DATE-END'] = str(date_end_new)[:-3] + 'Z'
instr.writeto(outfile)
#if quarter == 14:
# livtime = instr[1].header['LIVTIME']
# livtime += 1.
# exposure += 1.
# end time
if (status == 0):
message = 'KEPTIMEFIX completed at'
else:
message = '\nKEPTIMEFIX aborted at'
kepmsg.clock(message, logfile, verbose)
def kepextract(infile,maskfile,outfile,subback,clobber,verbose,logfile,status):
# startup parameters
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPEXTRACT -- '
call += 'infile='+infile+' '
call += 'maskfile='+maskfile+' '
call += 'outfile='+outfile+' '
backgr = 'n'
if (subback): backgr = 'y'
call += 'background='+backgr+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPEXTRACT started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPEXTRACT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
status = 0
instr = pyfits.open(infile,mode='readonly',memmap=True)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# input file data
if status == 0:
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
table = instr[1].data[:]
maskmap = copy(instr[2].data)
# input table data
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, time, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
time = numpy.array(time,dtype='float64')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, timecorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
timecorr = numpy.array(timecorr,dtype='float32')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadenceno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
cadenceno = numpy.array(cadenceno,dtype='int')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, raw_cnts, status = \
kepio.readTPF(infile,'RAW_CNTS',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_err, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg, status = \
kepio.readTPF(infile,'FLUX_BKG',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err, status = \
kepio.readTPF(infile,'FLUX_BKG_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cosmic_rays, status = \
kepio.readTPF(infile,'COSMIC_RAYS',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, quality, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
quality = numpy.array(quality,dtype='int')
if status == 0:
try:
pos_corr1 = numpy.array(table.field('POS_CORR1'),dtype='float64') # ---for FITS wave #2
except:
pos_corr1 = empty(len(time)); pos_corr1[:] = numpy.nan # ---temporary before FITS wave #2
try:
pos_corr2 = numpy.array(table.field('POS_CORR2'),dtype='float64') # ---for FITS wave #2
except:
pos_corr2 = empty(len(time)); pos_corr2[:] = numpy.nan # ---temporary before FITS wave #2
# dummy columns for output file
psf_centr1 = empty(len(time)); psf_centr1[:] = numpy.nan
psf_centr1_err = empty(len(time)); psf_centr1_err[:] = numpy.nan
psf_centr2 = empty(len(time)); psf_centr2[:] = numpy.nan
psf_centr2_err = empty(len(time)); psf_centr2_err[:] = numpy.nan
# mom_centr1 = empty(len(time)); mom_centr1[:] = numpy.nan
mom_centr1_err = empty(len(time)); mom_centr1_err[:] = numpy.nan
# mom_centr2 = empty(len(time)); mom_centr2[:] = numpy.nan
mom_centr2_err = empty(len(time)); mom_centr2_err[:] = numpy.nan
# read mask definition file
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
maskx = array([],'int')
masky = array([],'int')
lines, status = kepio.openascii(maskfile,'r',logfile,verbose)
for line in lines:
line = line.strip().split('|')
if len(line) == 6:
y0 = int(line[3])
x0 = int(line[4])
line = line[5].split(';')
for items in line:
try:
masky = append(masky,y0 + int(items.split(',')[0]))
maskx = append(maskx,x0 + int(items.split(',')[1]))
except:
continue
status = kepio.closeascii(lines,logfile,verbose)
if len(maskx) == 0 or len(masky) == 0:
message = 'ERROR -- KEPEXTRACT: ' + maskfile + ' contains no pixels.'
status = kepmsg.err(logfile,message,verbose)
# subimage physical WCS data
if status == 0:
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
# define new subimage bitmap...
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
aperx = array([],'int')
apery = array([],'int')
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
if maskmap[i,j] == 0:
aperb = append(aperb,0)
else:
aperb = append(aperb,1)
maskmap[i,j] = 1
for k in range(len(maskx)):
if aperx[-1] == maskx[k] and apery[-1] == masky[k]:
aperb[-1] = 3
maskmap[i,j] = 3
# trap case where no aperture needs to be defined but pixel positions are still required for centroiding
if status == 0 and maskfile.lower() == 'all':
aperx = array([],'int')
apery = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
# ...or use old subimage bitmap
if status == 0 and 'aper' in maskfile.lower():
aperx = array([],'int')
apery = array([],'int')
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperb = append(aperb,maskmap[i,j])
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
# ...or use all pixels
if status == 0 and maskfile.lower() == 'all':
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
if maskmap[i,j] == 0:
aperb = append(aperb,0)
else:
aperb = append(aperb,3)
maskmap[i,j] = 3
# subtract median pixel value for background?
if status == 0:
sky = array([],'float32')
for i in range(len(time)):
sky = append(sky,median(flux[i,:]))
if not subback:
sky[:] = 0.0
# legal mask defined?
if status == 0:
if len(aperb) == 0:
message = 'ERROR -- KEPEXTRACT: no legal pixels within the subimage are defined.'
status = kepmsg.err(logfile,message,verbose)
# construct new table flux data
if status == 0:
naper = (aperb == 3).sum()
ntime = len(time)
sap_flux = array([],'float32')
sap_flux_err = array([],'float32')
sap_bkg = array([],'float32')
sap_bkg_err = array([],'float32')
raw_flux = array([],'float32')
for i in range(len(time)):
work1 = array([],'float64')
work2 = array([],'float64')
work3 = array([],'float64')
work4 = array([],'float64')
work5 = array([],'float64')
for j in range(len(aperb)):
if (aperb[j] == 3):
work1 = append(work1,flux[i,j]-sky[i])
work2 = append(work2,flux_err[i,j])
work3 = append(work3,flux_bkg[i,j])
work4 = append(work4,flux_bkg_err[i,j])
work5 = append(work5,raw_cnts[i,j])
sap_flux = append(sap_flux,kepstat.sum(work1))
sap_flux_err = append(sap_flux_err,kepstat.sumerr(work2))
sap_bkg = append(sap_bkg,kepstat.sum(work3))
sap_bkg_err = append(sap_bkg_err,kepstat.sumerr(work4))
raw_flux = append(raw_flux,kepstat.sum(work5))
# construct new table moment data
if status == 0:
mom_centr1 = zeros(shape=(ntime))
mom_centr2 = zeros(shape=(ntime))
mom_centr1_err = zeros(shape=(ntime))
mom_centr2_err = zeros(shape=(ntime))
for i in range(ntime):
xf = zeros(shape=(naper))
yf = zeros(shape=(naper))
f = zeros(shape=(naper))
xfe = zeros(shape=(naper))
yfe = zeros(shape=(naper))
fe = zeros(shape=(naper))
k = -1
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
xf[k] = aperx[j] * flux[i,j]
xfe[k] = aperx[j] * flux_err[i,j]
yf[k] = apery[j] * flux[i,j]
yfe[k] = apery[j] * flux_err[i,j]
f[k] = flux[i,j]
fe[k] = flux_err[i,j]
xfsum = kepstat.sum(xf)
yfsum = kepstat.sum(yf)
fsum = kepstat.sum(f)
xfsume = sqrt(kepstat.sum(square(xfe)) / naper)
yfsume = sqrt(kepstat.sum(square(yfe)) / naper)
fsume = sqrt(kepstat.sum(square(fe)) / naper)
mom_centr1[i] = xfsum / fsum
mom_centr2[i] = yfsum / fsum
mom_centr1_err[i] = sqrt((xfsume / xfsum)**2 + ((fsume / fsum)**2))
mom_centr2_err[i] = sqrt((yfsume / yfsum)**2 + ((fsume / fsum)**2))
mom_centr1_err = mom_centr1_err * mom_centr1
mom_centr2_err = mom_centr2_err * mom_centr2
# construct new table PSF data
if status == 0:
psf_centr1 = zeros(shape=(ntime))
psf_centr2 = zeros(shape=(ntime))
psf_centr1_err = zeros(shape=(ntime))
psf_centr2_err = zeros(shape=(ntime))
modx = zeros(shape=(naper))
mody = zeros(shape=(naper))
k = -1
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
modx[k] = aperx[j]
mody[k] = apery[j]
for i in range(ntime):
modf = zeros(shape=(naper))
k = -1
guess = [mom_centr1[i], mom_centr2[i], nanmax(flux[i:]), 1.0, 1.0, 0.0, 0.0]
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
modf[k] = flux[i,j]
args = (modx, mody, modf)
try:
ans = leastsq(kepfunc.PRFgauss2d,guess,args=args,xtol=1.0e-8,ftol=1.0e-4,full_output=True)
s_sq = (ans[2]['fvec']**2).sum() / (ntime-len(guess))
psf_centr1[i] = ans[0][0]
psf_centr2[i] = ans[0][1]
except:
pass
try:
psf_centr1_err[i] = sqrt(diag(ans[1] * s_sq))[0]
except:
psf_centr1_err[i] = numpy.nan
try:
psf_centr2_err[i] = sqrt(diag(ans[1] * s_sq))[1]
except:
psf_centr2_err[i] = numpy.nan
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].key not in hdu0.header.keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='SAP_FLUX',format='E',array=sap_flux)
col5 = Column(name='SAP_FLUX_ERR',format='E',array=sap_flux_err)
col6 = Column(name='SAP_BKG',format='E',array=sap_bkg)
col7 = Column(name='SAP_BKG_ERR',format='E',array=sap_bkg_err)
col8 = Column(name='PDCSAP_FLUX',format='E',array=sap_flux)
col9 = Column(name='PDCSAP_FLUX_ERR',format='E',array=sap_flux_err)
col10 = Column(name='SAP_QUALITY',format='J',array=quality)
col11 = Column(name='PSF_CENTR1',format='E',unit='pixel',array=psf_centr1)
col12 = Column(name='PSF_CENTR1_ERR',format='E',unit='pixel',array=psf_centr1_err)
col13 = Column(name='PSF_CENTR2',format='E',unit='pixel',array=psf_centr2)
col14 = Column(name='PSF_CENTR2_ERR',format='E',unit='pixel',array=psf_centr2_err)
col15 = Column(name='MOM_CENTR1',format='E',unit='pixel',array=mom_centr1)
col16 = Column(name='MOM_CENTR1_ERR',format='E',unit='pixel',array=mom_centr1_err)
col17 = Column(name='MOM_CENTR2',format='E',unit='pixel',array=mom_centr2)
col18 = Column(name='MOM_CENTR2_ERR',format='E',unit='pixel',array=mom_centr2_err)
col19 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col20 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
col21 = Column(name='RAW_FLUX',format='E',array=raw_flux)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11, \
col12,col13,col14,col15,col16,col17,col18,col19,col20,col21])
hdu1 = new_table(cols)
hdu1.header.update('TTYPE1','TIME','column title: data time stamps')
hdu1.header.update('TFORM1','D','data type: float64')
hdu1.header.update('TUNIT1','BJD - 2454833','column units: barycenter corrected JD')
hdu1.header.update('TDISP1','D12.7','column display format')
hdu1.header.update('TTYPE2','TIMECORR','column title: barycentric-timeslice correction')
hdu1.header.update('TFORM2','E','data type: float32')
hdu1.header.update('TUNIT2','d','column units: days')
hdu1.header.update('TTYPE3','CADENCENO','column title: unique cadence number')
hdu1.header.update('TFORM3','J','column format: signed integer32')
hdu1.header.update('TTYPE4','SAP_FLUX','column title: aperture photometry flux')
hdu1.header.update('TFORM4','E','column format: float32')
hdu1.header.update('TUNIT4','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE5','SAP_FLUX_ERR','column title: aperture phot. flux error')
hdu1.header.update('TFORM5','E','column format: float32')
hdu1.header.update('TUNIT5','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE6','SAP_BKG','column title: aperture phot. background flux')
hdu1.header.update('TFORM6','E','column format: float32')
hdu1.header.update('TUNIT6','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE7','SAP_BKG_ERR','column title: ap. phot. background flux error')
hdu1.header.update('TFORM7','E','column format: float32')
hdu1.header.update('TUNIT7','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE8','PDCSAP_FLUX','column title: PDC photometry flux')
hdu1.header.update('TFORM8','E','column format: float32')
hdu1.header.update('TUNIT8','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE9','PDCSAP_FLUX_ERR','column title: PDC flux error')
hdu1.header.update('TFORM9','E','column format: float32')
hdu1.header.update('TUNIT9','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE10','SAP_QUALITY','column title: aperture photometry quality flag')
hdu1.header.update('TFORM10','J','column format: signed integer32')
hdu1.header.update('TTYPE11','PSF_CENTR1','column title: PSF fitted column centroid')
hdu1.header.update('TFORM11','E','column format: float32')
hdu1.header.update('TUNIT11','pixel','column units: pixel')
hdu1.header.update('TTYPE12','PSF_CENTR1_ERR','column title: PSF fitted column error')
hdu1.header.update('TFORM12','E','column format: float32')
hdu1.header.update('TUNIT12','pixel','column units: pixel')
hdu1.header.update('TTYPE13','PSF_CENTR2','column title: PSF fitted row centroid')
hdu1.header.update('TFORM13','E','column format: float32')
hdu1.header.update('TUNIT13','pixel','column units: pixel')
hdu1.header.update('TTYPE14','PSF_CENTR2_ERR','column title: PSF fitted row error')
hdu1.header.update('TFORM14','E','column format: float32')
hdu1.header.update('TUNIT14','pixel','column units: pixel')
hdu1.header.update('TTYPE15','MOM_CENTR1','column title: moment-derived column centroid')
hdu1.header.update('TFORM15','E','column format: float32')
hdu1.header.update('TUNIT15','pixel','column units: pixel')
hdu1.header.update('TTYPE16','MOM_CENTR1_ERR','column title: moment-derived column error')
hdu1.header.update('TFORM16','E','column format: float32')
hdu1.header.update('TUNIT16','pixel','column units: pixel')
hdu1.header.update('TTYPE17','MOM_CENTR2','column title: moment-derived row centroid')
hdu1.header.update('TFORM17','E','column format: float32')
hdu1.header.update('TUNIT17','pixel','column units: pixel')
hdu1.header.update('TTYPE18','MOM_CENTR2_ERR','column title: moment-derived row error')
hdu1.header.update('TFORM18','E','column format: float32')
hdu1.header.update('TUNIT18','pixel','column units: pixel')
hdu1.header.update('TTYPE19','POS_CORR1','column title: col correction for vel. abbern')
hdu1.header.update('TFORM19','E','column format: float32')
hdu1.header.update('TUNIT19','pixel','column units: pixel')
hdu1.header.update('TTYPE20','POS_CORR2','column title: row correction for vel. abbern')
hdu1.header.update('TFORM20','E','column format: float32')
hdu1.header.update('TUNIT20','pixel','column units: pixel')
hdu1.header.update('TTYPE21','RAW_FLUX','column title: raw aperture photometry flux')
hdu1.header.update('TFORM21','E','column format: float32')
hdu1.header.update('TUNIT21','e-/s','column units: electrons per second')
hdu1.header.update('EXTNAME','LIGHTCURVE','name of extension')
for i in range(len(cards1)):
if (cards1[i].key not in hdu1.header.keys() and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].key not in hdu2.header.keys():
hdu2.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
else:
hdu2.header.cards[cards2[i].key].comment = cards2[i].comment
outstr.append(hdu2)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
kepmsg.clock('KEPEXTRACT finished at',logfile,verbose)
def kepbinary(infile,outfile,datacol,m1,m2,r1,r2,period,bjd0,eccn,omega,inclination,
c1,c2,c3,c4,albedo,depth,contamination,gamma,fitparams,eclipses,dopboost,
tides,job,clobber,verbose,logfile,status):
# startup parameters
status = 0
labelsize = 24; ticksize = 16; xsize = 17; ysize = 7
lcolor = '#0000ff'; lwidth = 1.0; fcolor = '#ffff00'; falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPBINARY -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
call += 'm1='+str(m1)+' '
call += 'm2='+str(m2)+' '
call += 'r1='+str(r1)+' '
call += 'r2='+str(r2)+' '
call += 'period='+str(period)+' '
call += 'bjd0='+str(bjd0)+' '
call += 'eccn='+str(eccn)+' '
call += 'omega='+str(omega)+' '
call += 'inclination='+str(inclination)+' '
call += 'c1='+str(c1)+' '
call += 'c2='+str(c2)+' '
call += 'c3='+str(c3)+' '
call += 'c4='+str(c4)+' '
call += 'albedo='+str(albedo)+' '
call += 'depth='+str(depth)+' '
call += 'contamination='+str(contamination)+' '
call += 'gamma='+str(gamma)+' '
call += 'fitparams='+str(fitparams)+' '
eclp = 'n'
if (eclipses): eclp = 'y'
call += 'eclipses='+eclp+ ' '
boost = 'n'
if (dopboost): boost = 'y'
call += 'dopboost='+boost+ ' '
distort = 'n'
if (tides): distort = 'y'
call += 'tides='+distort+ ' '
call += 'job='+str(job)+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPBINARY started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# check and format the list of fit parameters
if status == 0 and job == 'fit':
allParams = [m1,m2,r1,r2,period,bjd0,eccn,omega,inclination]
allNames = ['m1','m2','r1','r2','period','bjd0','eccn','omega','inclination']
fitparams = re.sub('\|',',',fitparams.strip())
fitparams = re.sub('\.',',',fitparams.strip())
fitparams = re.sub(';',',',fitparams.strip())
fitparams = re.sub(':',',',fitparams.strip())
fitparams = re.sub('\s+',',',fitparams.strip())
fitparams, status = kepio.parselist(fitparams,logfile,verbose)
for fitparam in fitparams:
if fitparam.strip() not in allNames:
message = 'ERROR -- KEPBINARY: unknown field in list of fit parameters'
status = kepmsg.err(logfile,message,verbose)
# clobber output file
if status == 0:
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPBINARY: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# check the data column exists
if status == 0:
try:
instr[1].data.field(datacol)
except:
message = 'ERROR -- KEPBINARY: ' + datacol + ' column does not exist in ' + infile + '[1]'
status = kepmsg.err(logfile,message,verbose)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# filter input data table
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
naxis2 = 0
try:
for i in range(len(table.field(0))):
if numpy.isfinite(table.field('barytime')[i]) and \
numpy.isfinite(table.field(datacol)[i]):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
except:
for i in range(len(table.field(0))):
if numpy.isfinite(table.field('time')[i]) and \
numpy.isfinite(table.field(datacol)[i]):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN',True,comment,instr[1],outfile,logfile,verbose)
# read table columns
if status == 0:
try:
time = instr[1].data.field('barytime')
except:
time, status = kepio.readfitscol(infile,instr[1].data,'time',logfile,verbose)
indata, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
if status == 0:
time = time + bjdref
indata = indata / cadenom
# limb-darkening cofficients
if status == 0:
limbdark = numpy.array([c1,c2,c3,c4],dtype='float32')
# time details for model
if status == 0:
npt = len(time)
exptime = numpy.zeros((npt),dtype='float64')
dtype = numpy.zeros((npt),dtype='int')
for i in range(npt):
try:
exptime[i] = time[i+1] - time[i]
except:
exptime[i] = time[i] - time[i-1]
# calculate binary model
if status == 0:
tmodel = kepsim.transitModel(1.0,m1,m2,r1,r2,period,inclination,bjd0,eccn,omega,depth,
albedo,c1,c2,c3,c4,gamma,contamination,npt,time,exptime,
dtype,eclipses,dopboost,tides)
# re-normalize binary model to data
if status == 0 and (job == 'overlay' or job == 'fit'):
dmedian = numpy.median(indata)
tmodel = tmodel / numpy.median(tmodel) * dmedian
# define arrays of floating and frozen parameters
if status == 0 and job =='fit':
params = []; paramNames = []; arguments = []; argNames = []
for i in range(len(allNames)):
if allNames[i] in fitparams:
params.append(allParams[i])
paramNames.append(allNames[i])
else:
arguments.append(allParams[i])
argNames.append(allNames[i])
params.append(dmedian)
params = numpy.array(params,dtype='float32')
# subtract model from data
if status == 0 and job == 'fit':
deltam = numpy.abs(indata - tmodel)
# fit statistics
if status == 0 and job == 'fit':
aveDelta = numpy.sum(deltam) / npt
chi2 = math.sqrt(numpy.sum((indata - tmodel) * (indata - tmodel) / (npt - len(params))))
# fit model to data using downhill simplex
if status == 0 and job == 'fit':
print ''
print '%4s %11s %11s' % ('iter', 'delta', 'chi^2')
print '----------------------------'
print '%4d %.5E %.5E' % (0,aveDelta,chi2)
bestFit = scipy.optimize.fmin(fitModel,params,args=(paramNames,dmedian,m1,m2,r1,r2,period,bjd0,eccn,
omega,inclination,depth,albedo,c1,c2,c3,c4,
gamma,contamination,npt,time,exptime,indata,
dtype,eclipses,dopboost,tides),maxiter=1e4)
# calculate best fit binary model
if status == 0 and job == 'fit':
print ''
for i in range(len(paramNames)):
if 'm1' in paramNames[i].lower():
m1 = bestFit[i]
print ' M1 = %.3f Msun' % bestFit[i]
elif 'm2' in paramNames[i].lower():
m2 = bestFit[i]
print ' M2 = %.3f Msun' % bestFit[i]
elif 'r1' in paramNames[i].lower():
r1 = bestFit[i]
print ' R1 = %.4f Rsun' % bestFit[i]
elif 'r2' in paramNames[i].lower():
r2 = bestFit[i]
print ' R2 = %.4f Rsun' % bestFit[i]
elif 'period' in paramNames[i].lower():
period = bestFit[i]
elif 'bjd0' in paramNames[i].lower():
bjd0 = bestFit[i]
print 'BJD0 = %.8f' % bestFit[i]
elif 'eccn' in paramNames[i].lower():
eccn = bestFit[i]
print ' e = %.3f' % bestFit[i]
elif 'omega' in paramNames[i].lower():
omega = bestFit[i]
print ' w = %.3f deg' % bestFit[i]
elif 'inclination' in paramNames[i].lower():
inclination = bestFit[i]
print ' i = %.3f deg' % bestFit[i]
flux = bestFit[-1]
print ''
tmodel = kepsim.transitModel(flux,m1,m2,r1,r2,period,inclination,bjd0,eccn,omega,depth,
albedo,c1,c2,c3,c4,gamma,contamination,npt,time,exptime,
dtype,eclipses,dopboost,tides)
# subtract model from data
if status == 0:
deltaMod = indata - tmodel
# standard deviation of model
if status == 0:
stdDev = math.sqrt(numpy.sum((indata - tmodel) * (indata - tmodel)) / npt)
# clean up x-axis unit
if status == 0:
time0 = float(int(tstart / 100) * 100.0)
ptime = time - time0
xlab = 'BJD $-$ %d' % time0
# clean up y-axis units
if status == 0:
nrm = len(str(int(indata.max())))-1
pout = indata / 10**nrm
pmod = tmodel / 10**nrm
pres = deltaMod / stdDev
if job == 'fit' or job == 'overlay':
try:
ylab1 = 'Flux (10$^%d$ e$^-$ s$^{-1}$)' % nrm
ylab2 = 'Residual ($\sigma$)'
except:
ylab1 = 'Flux (10**%d e-/s)' % nrm
ylab2 = 'Residual (sigma)'
else:
ylab1 = 'Normalized Flux'
# dynamic range of model plot
if status == 0 and job == 'model':
xmin = ptime.min()
xmax = ptime.max()
ymin = tmodel.min()
ymax = tmodel.max()
# dynamic range of model/data overlay or fit
if status == 0 and (job == 'overlay' or job == 'fit'):
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
tmin = pmod.min()
tmax = pmod.max()
ymin = numpy.array([ymin,tmin]).min()
ymax = numpy.array([ymax,tmax]).max()
rmin = pres.min()
rmax = pres.max()
# pad the dynamic range
if status == 0:
xr = (xmax - xmin) / 80
yr = (ymax - ymin) / 40
if job == 'overlay' or job == 'fit':
rr = (rmax - rmin) / 40
# set up plot style
if status == 0:
labelsize = 24; ticksize = 16; xsize = 17; ysize = 7
lcolor = '#0000ff'; lwidth = 1.0; fcolor = '#ffff00'; falpha = 0.2
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 16,
'ytick.labelsize': 16}
pylab.rcParams.update(params)
pylab.figure(figsize=[14,10])
pylab.clf()
# main plot window
ax = pylab.axes([0.05,0.3,0.94,0.68])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
# plot model time series
if status == 0 and job == 'model':
pylab.plot(ptime,tmodel,color='#0000ff',linestyle='-',linewidth=1.0)
ptime = numpy.insert(ptime,[0.0],ptime[0])
ptime = numpy.append(ptime,ptime[-1])
tmodel = numpy.insert(tmodel,[0.0],0.0)
tmodel = numpy.append(tmodel,0.0)
pylab.fill(ptime,tmodel,fc='#ffff00',linewidth=0.0,alpha=0.2)
# plot data time series and best fit
if status == 0 and (job == 'overlay' or job == 'fit'):
pylab.plot(ptime,pout,color='#0000ff',linestyle='-',linewidth=1.0)
ptime = numpy.insert(ptime,[0.0],ptime[0])
ptime = numpy.append(ptime,ptime[-1])
pout = numpy.insert(pout,[0],0.0)
pout = numpy.append(pout,0.0)
pylab.fill(ptime,pout,fc='#ffff00',linewidth=0.0,alpha=0.2)
pylab.plot(ptime[1:-1],pmod,color='r',linestyle='-',linewidth=2.0)
# ranges and labels
if status == 0:
pylab.xlim(xmin-xr,xmax+xr)
pylab.ylim(ymin-yr,ymax+yr)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab1, {'color' : 'k'})
# residual plot window
if status == 0 and (job == 'overlay' or job == 'fit'):
ax = pylab.axes([0.05,0.07,0.94,0.23])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
# plot residual time series
if status == 0 and (job == 'overlay' or job == 'fit'):
pylab.plot([ptime[0],ptime[-1]],[0.0,0.0],color='r',linestyle='--',linewidth=1.0)
pylab.plot([ptime[0],ptime[-1]],[-1.0,-1.0],color='r',linestyle='--',linewidth=1.0)
pylab.plot([ptime[0],ptime[-1]],[1.0,1.0],color='r',linestyle='--',linewidth=1.0)
pylab.plot(ptime[1:-1],pres,color='#0000ff',linestyle='-',linewidth=1.0)
pres = numpy.insert(pres,[0],rmin)
pres = numpy.append(pres,rmin)
pylab.fill(ptime,pres,fc='#ffff00',linewidth=0.0,alpha=0.2)
# ranges and labels of residual time series
if status == 0 and (job == 'overlay' or job == 'fit'):
pylab.xlim(xmin-xr,xmax+xr)
pylab.ylim(rmin-rr,rmax+rr)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab2, {'color' : 'k'})
# display the plot
if status == 0:
pylab.draw()
def kephead(infile,outfile,keyname,clobber,verbose,logfile,status):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPHEAD -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'keyname='+keyname+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPHEAD started at: ',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPHEAD: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# Is there an output file?
if status == 0:
if outfile.lower() == 'none':
ofile = False
else:
ofile = outfile
# open input FITS file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
# number of HDU in input file
if status == 0:
nhdu = kepio.HDUnum(instr)
# loop through each HDU in infile
if status == 0:
kepmsg.log(ofile,'',True)
for hdu in range(nhdu):
# how many keywords in the HDU?
keylist = instr[hdu].header.cards
nkeys = len(keylist)
# print header number
prhead = False
for i in range(nkeys):
if (keyname.upper() == 'ALL' or \
keyname.upper() in instr[hdu].header.keys()[i]):
prhead = True
if prhead:
dashes = ''
title = infile + '[' + str(hdu) + ']'
for j in range(len(title)):
dashes += '-'
kepmsg.log(ofile,dashes,True)
kepmsg.log(ofile,title,True)
kepmsg.log(ofile,dashes,True)
kepmsg.log(ofile,'',True)
# print keywords
for i in range(nkeys):
if ((keyname.upper() == 'ALL' or \
keyname.upper() in instr[hdu].header.keys()[i]) and \
'COMMENT' not in instr[hdu].header.keys()[i]):
kepmsg.log(ofile,str(keylist[i]),True)
kepmsg.log(ofile,'',True)
# stop time
kepmsg.clock('KEPHEAD ended at: ',logfile,verbose)
return
def kepdraw(infile,outfile,datacol,ploterr,errcol,quality,
lcolor,lwidth,fcolor,falpha,labelsize,ticksize,
xsize,ysize,fullrange,chooserange,y1,y2,plotgrid,
ylabel,plottype,verbose,logfile,status,cmdLine=False):
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPDRAW -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
perr = 'n'
if (ploterr): perr = 'y'
call += 'ploterr='+perr+ ' '
call += 'errcol='+errcol+' '
qual = 'n'
if (quality): qual = 'y'
call += 'quality='+qual+ ' '
call += 'lcolor='+str(lcolor)+' '
call += 'lwidth='+str(lwidth)+' '
call += 'fcolor='+str(fcolor)+' '
call += 'falpha='+str(falpha)+' '
call += 'labelsize='+str(labelsize)+' '
call += 'ticksize='+str(ticksize)+' '
call += 'xsize='+str(xsize)+' '
call += 'ysize='+str(ysize)+' '
frange = 'n'
if (fullrange): frange = 'y'
call += 'fullrange='+frange+ ' '
crange = 'n'
if (chooserange): crange = 'y'
call += 'chooserange='+crange+ ' '
call += 'ymin='+str(y1)+' '
call += 'ymax='+str(y2)+' '
pgrid = 'n'
if (plotgrid): pgrid = 'y'
call += 'plotgrid='+pgrid+ ' '
call += 'ylabel='+str(ylabel)+' '
call += 'plottype='+plottype+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPDRAW started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# open input file
if status == 0:
struct, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(struct,infile,logfile,verbose,status)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,struct[1],logfile,verbose)
# read table columns
if status == 0:
intime, status = kepio.readtimecol(infile,table,logfile,verbose)
intime += bjdref
indata, status = kepio.readfitscol(infile,table,datacol,logfile,verbose)
indataerr, status = kepio.readfitscol(infile,table,errcol,logfile,verbose)
# read table quality column
if status == 0 and quality:
try:
qualtest = table.field('SAP_QUALITY')
except:
message = 'ERROR -- KEPDRAW: no SAP_QUALITY column found in file ' + infile
message += '. Use kepdraw quality=n'
status = kepmsg.err(logfile,message,verbose)
# close infile
if status == 0:
status = kepio.closefits(struct,logfile,verbose)
# remove infinities and bad data
if status == 0:
if numpy.isnan(numpy.nansum(indataerr)):
indataerr[:] = 1.0e-5
work1 = numpy.array([intime, indata, indataerr],dtype='float64')
work1 = numpy.rot90(work1,3)
work1 = work1[~numpy.isnan(work1).any(1)]
work1 = work1[~numpy.isinf(work1).any(1)]
barytime = numpy.array(work1[:,2],dtype='float64')
data = numpy.array(work1[:,1],dtype='float32')
dataerr = numpy.array(work1[:,0],dtype='float32')
if len(barytime) == 0:
message = 'ERROR -- KEPDRAW: Plotting arrays are full of NaN'
status = kepmsg.err(logfile,message,verbose)
# clean up x-axis unit
if status == 0:
barytime0 = float(int(tstart / 100) * 100.0)
barytime -= barytime0
xlab = 'BJD $-$ %d' % barytime0
# clean up y-axis units
try:
nrm = len(str(int(numpy.nanmax(data))))-1
except:
nrm = 0
data = data / 10**nrm
if 'e$^-$ s$^{-1}$' in ylabel or 'default' in ylabel:
if nrm == 0:
ylab1 = 'e$^-$ s$^{-1}$'
else:
ylab1 = '10$^%d$ e$^-$ s$^{-1}$' % nrm
else:
ylab1 = re.sub('_','-',ylabel)
# data limits
xmin = numpy.nanmin(barytime)
xmax = numpy.nanmax(barytime)
ymin = numpy.nanmin(data)
ymax = numpy.nanmax(data)
xr = xmax - xmin
yr = ymax - ymin
barytime = insert(barytime,[0],[barytime[0]])
barytime = append(barytime,[barytime[-1]])
data = insert(data,[0],[0.0])
data = append(data,0.0)
# define plot formats
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
pylab.rcParams.update(params)
except:
pass
# define size of plot on monitor screen
pylab.figure(figsize=[xsize,ysize])
# delete any fossil plots in the matplotlib window
pylab.clf()
# position axes inside the plotting window
ax = pylab.subplot(111)
pylab.subplots_adjust(0.07,0.1,0.92,0.88)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=ticksize)
# if plot type is 'fast' plot data time series as points
if plottype == 'fast':
pylab.plot(barytime,data,'o',color=lcolor)
# if plot type is 'pretty' plot data time series as an unbroken line, retaining data gaps
else:
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for i in range(1,len(data)-1):
dt = barytime[i] - barytime[i-1]
if dt < work1:
ltime = numpy.append(ltime,barytime[i])
ldata = numpy.append(ldata,data[i])
else:
pylab.plot(ltime,ldata,color=lcolor,linestyle='-',linewidth=lwidth)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
pylab.plot(ltime,ldata,color=lcolor,linestyle='-',linewidth=lwidth)
# plot the fill color below data time series, with no data gaps
pylab.fill(barytime,data,fc=fcolor,linewidth=0.0,alpha=falpha)
# define plot x and y limits
pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin-yr*0.01 <= 0.0 or fullrange:
pylab.ylim(1.0e-10,ymax+yr*0.01)
else:
pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
if chooserange:
pylab.ylim(y1,y2)
# plot labels
pylab.xlabel(xlab, {'color' : 'k'})
try:
pylab.ylabel(ylab1, {'color' : 'k'})
except:
ylab1 = '10**%d e-/s' % nrm
pylab.ylabel(ylab1, {'color' : 'k'})
# make grid on plot
if plotgrid: pylab.grid()
# save plot to file
if status == 0 and outfile.lower() != 'none':
pylab.savefig(outfile)
# render plot
if cmdLine:
# pylab.show()
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# end time
if (status == 0):
message = 'KEPDRAW completed at'
else:
message = '\nKEPDRAW aborted at'
kepmsg.clock(message,logfile,verbose)
def kepfold(infile,
outfile,
period,
phasezero,
bindata,
binmethod,
threshold,
niter,
nbins,
rejqual,
plottype,
plotlab,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# startup parameters
status = 0
labelsize = 32
ticksize = 18
xsize = 18
ysize = 10
lcolor = '#0000ff'
lwidth = 2.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPFOLD -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'period=' + str(period) + ' '
call += 'phasezero=' + str(phasezero) + ' '
binit = 'n'
if (bindata): binit = 'y'
call += 'bindata=' + binit + ' '
call += 'binmethod=' + binmethod + ' '
call += 'threshold=' + str(threshold) + ' '
call += 'niter=' + str(niter) + ' '
call += 'nbins=' + str(nbins) + ' '
qflag = 'n'
if (rejqual): qflag = 'y'
call += 'rejqual=' + qflag + ' '
call += 'plottype=' + plottype + ' '
call += 'plotlab=' + plotlab + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPFOLD started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFOLD: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
# input data
if status == 0:
table = instr[1].data
incards = instr[1].header.cards
try:
sap = instr[1].data.field('SAP_FLUX')
except:
try:
sap = instr[1].data.field('ap_raw_flux')
except:
sap = zeros(len(table.field(0)))
try:
saperr = instr[1].data.field('SAP_FLUX_ERR')
except:
try:
saperr = instr[1].data.field('ap_raw_err')
except:
saperr = zeros(len(table.field(0)))
try:
pdc = instr[1].data.field('PDCSAP_FLUX')
except:
try:
pdc = instr[1].data.field('ap_corr_flux')
except:
pdc = zeros(len(table.field(0)))
try:
pdcerr = instr[1].data.field('PDCSAP_FLUX_ERR')
except:
try:
pdcerr = instr[1].data.field('ap_corr_err')
except:
pdcerr = zeros(len(table.field(0)))
try:
cbv = instr[1].data.field('CBVSAP_FLUX')
except:
cbv = zeros(len(table.field(0)))
if 'cbv' in plottype:
txt = 'ERROR -- KEPFOLD: CBVSAP_FLUX column is not populated. Use kepcotrend'
status = kepmsg.err(logfile, txt, verbose)
try:
det = instr[1].data.field('DETSAP_FLUX')
except:
det = zeros(len(table.field(0)))
if 'det' in plottype:
txt = 'ERROR -- KEPFOLD: DETSAP_FLUX column is not populated. Use kepflatten'
status = kepmsg.err(logfile, txt, verbose)
try:
deterr = instr[1].data.field('DETSAP_FLUX_ERR')
except:
deterr = zeros(len(table.field(0)))
if 'det' in plottype:
txt = 'ERROR -- KEPFOLD: DETSAP_FLUX_ERR column is not populated. Use kepflatten'
status = kepmsg.err(logfile, txt, verbose)
try:
quality = instr[1].data.field('SAP_QUALITY')
except:
quality = zeros(len(table.field(0)))
if qualflag:
txt = 'WARNING -- KEPFOLD: Cannot find a QUALITY data column'
kepmsg.warn(logfile, txt)
if status == 0:
barytime, status = kepio.readtimecol(infile, table, logfile, verbose)
barytime1 = copy(barytime)
# filter out NaNs and quality > 0
work1 = []
work2 = []
work3 = []
work4 = []
work5 = []
work6 = []
work8 = []
work9 = []
if status == 0:
if 'sap' in plottype:
datacol = copy(sap)
errcol = copy(saperr)
if 'pdc' in plottype:
datacol = copy(pdc)
errcol = copy(pdcerr)
if 'cbv' in plottype:
datacol = copy(cbv)
errcol = copy(saperr)
if 'det' in plottype:
datacol = copy(det)
errcol = copy(deterr)
for i in range(len(barytime)):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(datacol[i])
and datacol[i] != 0.0 and numpy.isfinite(errcol[i])
and errcol[i] > 0.0):
if rejqual and quality[i] == 0:
work1.append(barytime[i])
work2.append(sap[i])
work3.append(saperr[i])
work4.append(pdc[i])
work5.append(pdcerr[i])
work6.append(cbv[i])
work8.append(det[i])
work9.append(deterr[i])
elif not rejqual:
work1.append(barytime[i])
work2.append(sap[i])
work3.append(saperr[i])
work4.append(pdc[i])
work5.append(pdcerr[i])
work6.append(cbv[i])
work8.append(det[i])
work9.append(deterr[i])
barytime = array(work1, dtype='float64')
sap = array(work2, dtype='float32') / cadenom
saperr = array(work3, dtype='float32') / cadenom
pdc = array(work4, dtype='float32') / cadenom
pdcerr = array(work5, dtype='float32') / cadenom
cbv = array(work6, dtype='float32') / cadenom
det = array(work8, dtype='float32') / cadenom
deterr = array(work9, dtype='float32') / cadenom
# calculate phase
if status == 0:
if phasezero < bjdref:
phasezero += bjdref
date1 = (barytime1 + bjdref - phasezero)
phase1 = (date1 / period) - floor(date1 / period)
date2 = (barytime + bjdref - phasezero)
phase2 = (date2 / period) - floor(date2 / period)
phase2 = array(phase2, 'float32')
# sort phases
if status == 0:
ptuple = []
phase3 = []
sap3 = []
saperr3 = []
pdc3 = []
pdcerr3 = []
cbv3 = []
cbverr3 = []
det3 = []
deterr3 = []
for i in range(len(phase2)):
ptuple.append([
phase2[i], sap[i], saperr[i], pdc[i], pdcerr[i], cbv[i],
saperr[i], det[i], deterr[i]
])
phsort = sorted(ptuple, key=lambda ph: ph[0])
for i in range(len(phsort)):
phase3.append(phsort[i][0])
sap3.append(phsort[i][1])
saperr3.append(phsort[i][2])
pdc3.append(phsort[i][3])
pdcerr3.append(phsort[i][4])
cbv3.append(phsort[i][5])
cbverr3.append(phsort[i][6])
det3.append(phsort[i][7])
deterr3.append(phsort[i][8])
phase3 = array(phase3, 'float32')
sap3 = array(sap3, 'float32')
saperr3 = array(saperr3, 'float32')
pdc3 = array(pdc3, 'float32')
pdcerr3 = array(pdcerr3, 'float32')
cbv3 = array(cbv3, 'float32')
cbverr3 = array(cbverr3, 'float32')
det3 = array(det3, 'float32')
deterr3 = array(deterr3, 'float32')
# bin phases
if status == 0 and bindata:
work1 = array([sap3[0]], 'float32')
work2 = array([saperr3[0]], 'float32')
work3 = array([pdc3[0]], 'float32')
work4 = array([pdcerr3[0]], 'float32')
work5 = array([cbv3[0]], 'float32')
work6 = array([cbverr3[0]], 'float32')
work7 = array([det3[0]], 'float32')
work8 = array([deterr3[0]], 'float32')
phase4 = array([], 'float32')
sap4 = array([], 'float32')
saperr4 = array([], 'float32')
pdc4 = array([], 'float32')
pdcerr4 = array([], 'float32')
cbv4 = array([], 'float32')
cbverr4 = array([], 'float32')
det4 = array([], 'float32')
deterr4 = array([], 'float32')
dt = 1.0 / nbins
nb = 0.0
rng = numpy.append(phase3, phase3[0] + 1.0)
for i in range(len(rng)):
if rng[i] < nb * dt or rng[i] >= (nb + 1.0) * dt:
if len(work1) > 0:
phase4 = append(phase4, (nb + 0.5) * dt)
if (binmethod == 'mean'):
sap4 = append(sap4, kepstat.mean(work1))
saperr4 = append(saperr4, kepstat.mean_err(work2))
pdc4 = append(pdc4, kepstat.mean(work3))
pdcerr4 = append(pdcerr4, kepstat.mean_err(work4))
cbv4 = append(cbv4, kepstat.mean(work5))
cbverr4 = append(cbverr4, kepstat.mean_err(work6))
det4 = append(det4, kepstat.mean(work7))
deterr4 = append(deterr4, kepstat.mean_err(work8))
elif (binmethod == 'median'):
sap4 = append(sap4, kepstat.median(work1, logfile))
saperr4 = append(saperr4, kepstat.mean_err(work2))
pdc4 = append(pdc4, kepstat.median(work3, logfile))
pdcerr4 = append(pdcerr4, kepstat.mean_err(work4))
cbv4 = append(cbv4, kepstat.median(work5, logfile))
cbverr4 = append(cbverr4, kepstat.mean_err(work6))
det4 = append(det4, kepstat.median(work7, logfile))
deterr4 = append(deterr4, kepstat.mean_err(work8))
else:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work1)],arange(0.0,float(len(work1)),1.0),work1,work2,
threshold,threshold,niter,logfile,False)
sap4 = append(sap4, coeffs[0])
saperr4 = append(saperr4, kepstat.mean_err(work2))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work3)],arange(0.0,float(len(work3)),1.0),work3,work4,
threshold,threshold,niter,logfile,False)
pdc4 = append(pdc4, coeffs[0])
pdcerr4 = append(pdcerr4, kepstat.mean_err(work4))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work5)],arange(0.0,float(len(work5)),1.0),work5,work6,
threshold,threshold,niter,logfile,False)
cbv4 = append(cbv4, coeffs[0])
cbverr4 = append(cbverr4, kepstat.mean_err(work6))
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[scipy.stats.nanmean(work7)],arange(0.0,float(len(work7)),1.0),work7,work8,
threshold,threshold,niter,logfile,False)
det4 = append(det4, coeffs[0])
deterr4 = append(deterr4, kepstat.mean_err(work8))
work1 = array([], 'float32')
work2 = array([], 'float32')
work3 = array([], 'float32')
work4 = array([], 'float32')
work5 = array([], 'float32')
work6 = array([], 'float32')
work7 = array([], 'float32')
work8 = array([], 'float32')
nb += 1.0
else:
work1 = append(work1, sap3[i])
work2 = append(work2, saperr3[i])
work3 = append(work3, pdc3[i])
work4 = append(work4, pdcerr3[i])
work5 = append(work5, cbv3[i])
work6 = append(work6, cbverr3[i])
work7 = append(work7, det3[i])
work8 = append(work8, deterr3[i])
# update HDU1 for output file
if status == 0:
cols = (instr[1].columns +
ColDefs([Column(name='PHASE', format='E', array=phase1)]))
instr[1] = pyfits.new_table(cols)
instr[1].header.cards[
'TTYPE' +
str(len(instr[1].columns))].comment = 'column title: phase'
instr[1].header.cards[
'TFORM' +
str(len(instr[1].columns))].comment = 'data type: float32'
for i in range(len(incards)):
if incards[i].key not in list(instr[1].header.keys()):
instr[1].header.update(incards[i].key, incards[i].value,
incards[i].comment)
else:
instr[1].header.cards[
incards[i].key].comment = incards[i].comment
instr[1].header.update('PERIOD', period,
'period defining the phase [d]')
instr[1].header.update('BJD0', phasezero, 'time of phase zero [BJD]')
# write new phased data extension for output file
if status == 0 and bindata:
col1 = Column(name='PHASE', format='E', array=phase4)
col2 = Column(name='SAP_FLUX',
format='E',
unit='e/s',
array=sap4 / cadenom)
col3 = Column(name='SAP_FLUX_ERR',
format='E',
unit='e/s',
array=saperr4 / cadenom)
col4 = Column(name='PDC_FLUX',
format='E',
unit='e/s',
array=pdc4 / cadenom)
col5 = Column(name='PDC_FLUX_ERR',
format='E',
unit='e/s',
array=pdcerr4 / cadenom)
col6 = Column(name='CBV_FLUX',
format='E',
unit='e/s',
array=cbv4 / cadenom)
col7 = Column(name='DET_FLUX', format='E', array=det4 / cadenom)
col8 = Column(name='DET_FLUX_ERR', format='E', array=deterr4 / cadenom)
cols = ColDefs([col1, col2, col3, col4, col5, col6, col7, col8])
instr.append(new_table(cols))
instr[-1].header.cards['TTYPE1'].comment = 'column title: phase'
instr[-1].header.cards[
'TTYPE2'].comment = 'column title: simple aperture photometry'
instr[-1].header.cards[
'TTYPE3'].comment = 'column title: SAP 1-sigma error'
instr[-1].header.cards[
'TTYPE4'].comment = 'column title: pipeline conditioned photometry'
instr[-1].header.cards[
'TTYPE5'].comment = 'column title: PDC 1-sigma error'
instr[-1].header.cards[
'TTYPE6'].comment = 'column title: cotrended basis vector photometry'
instr[-1].header.cards[
'TTYPE7'].comment = 'column title: Detrended aperture photometry'
instr[-1].header.cards[
'TTYPE8'].comment = 'column title: DET 1-sigma error'
instr[-1].header.cards['TFORM1'].comment = 'column type: float32'
instr[-1].header.cards['TFORM2'].comment = 'column type: float32'
instr[-1].header.cards['TFORM3'].comment = 'column type: float32'
instr[-1].header.cards['TFORM4'].comment = 'column type: float32'
instr[-1].header.cards['TFORM5'].comment = 'column type: float32'
instr[-1].header.cards['TFORM6'].comment = 'column type: float32'
instr[-1].header.cards['TFORM7'].comment = 'column type: float32'
instr[-1].header.cards['TFORM8'].comment = 'column type: float32'
instr[-1].header.cards[
'TUNIT2'].comment = 'column units: electrons per second'
instr[-1].header.cards[
'TUNIT3'].comment = 'column units: electrons per second'
instr[-1].header.cards[
'TUNIT4'].comment = 'column units: electrons per second'
instr[-1].header.cards[
'TUNIT5'].comment = 'column units: electrons per second'
instr[-1].header.cards[
'TUNIT6'].comment = 'column units: electrons per second'
instr[-1].header.update('EXTNAME', 'FOLDED', 'extension name')
instr[-1].header.update('PERIOD', period,
'period defining the phase [d]')
instr[-1].header.update('BJD0', phasezero, 'time of phase zero [BJD]')
instr[-1].header.update('BINMETHD', binmethod, 'phase binning method')
if binmethod == 'sigclip':
instr[-1].header.update('THRSHOLD', threshold,
'sigma-clipping threshold [sigma]')
instr[-1].header.update('NITER', niter,
'max number of sigma-clipping iterations')
# history keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
instr.writeto(outfile)
# clean up x-axis unit
if status == 0:
ptime1 = array([], 'float32')
ptime2 = array([], 'float32')
pout1 = array([], 'float32')
pout2 = array([], 'float32')
if bindata:
work = sap4
if plottype == 'pdc':
work = pdc4
if plottype == 'cbv':
work = cbv4
if plottype == 'det':
work = det4
for i in range(len(phase4)):
if (phase4[i] > 0.5):
ptime2 = append(ptime2, phase4[i] - 1.0)
pout2 = append(pout2, work[i])
ptime2 = append(ptime2, phase4)
pout2 = append(pout2, work)
for i in range(len(phase4)):
if (phase4[i] <= 0.5):
ptime2 = append(ptime2, phase4[i] + 1.0)
pout2 = append(pout2, work[i])
work = sap3
if plottype == 'pdc':
work = pdc3
if plottype == 'cbv':
work = cbv3
if plottype == 'det':
work = det3
for i in range(len(phase3)):
if (phase3[i] > 0.5):
ptime1 = append(ptime1, phase3[i] - 1.0)
pout1 = append(pout1, work[i])
ptime1 = append(ptime1, phase3)
pout1 = append(pout1, work)
for i in range(len(phase3)):
if (phase3[i] <= 0.5):
ptime1 = append(ptime1, phase3[i] + 1.0)
pout1 = append(pout1, work[i])
xlab = 'Orbital Phase ($\phi$)'
# clean up y-axis units
if status == 0:
nrm = len(str(int(pout1[isfinite(pout1)].max()))) - 1
pout1 = pout1 / 10**nrm
pout2 = pout2 / 10**nrm
if nrm == 0:
ylab = plotlab
else:
ylab = '10$^%d$ %s' % (nrm, plotlab)
# data limits
xmin = ptime1.min()
xmax = ptime1.max()
ymin = pout1[isfinite(pout1)].min()
ymax = pout1[isfinite(pout1)].max()
xr = xmax - xmin
yr = ymax - ymin
ptime1 = insert(ptime1, [0], [ptime1[0]])
ptime1 = append(ptime1, [ptime1[-1]])
pout1 = insert(pout1, [0], [0.0])
pout1 = append(pout1, 0.0)
if bindata:
ptime2 = insert(ptime2, [0], ptime2[0] - 1.0 / nbins)
ptime2 = insert(ptime2, [0], ptime2[0])
ptime2 = append(
ptime2, [ptime2[-1] + 1.0 / nbins, ptime2[-1] + 1.0 / nbins])
pout2 = insert(pout2, [0], [pout2[-1]])
pout2 = insert(pout2, [0], [0.0])
pout2 = append(pout2, [pout2[2], 0.0])
# plot new light curve
if status == 0 and plottype != 'none':
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 18,
'legend.fontsize': 18,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
pylab.rcParams.update(params)
except:
print('ERROR -- KEPFOLD: install latex for scientific plotting')
status = 1
if status == 0 and plottype != 'none':
pylab.figure(figsize=[17, 7])
pylab.clf()
ax = pylab.axes([0.06, 0.11, 0.93, 0.86])
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90)
if bindata:
pylab.fill(ptime2,
pout2,
color=fcolor,
linewidth=0.0,
alpha=falpha)
else:
if 'det' in plottype:
pylab.fill(ptime1,
pout1,
color=fcolor,
linewidth=0.0,
alpha=falpha)
pylab.plot(ptime1,
pout1,
color=lcolor,
linestyle='',
linewidth=lwidth,
marker='.')
if bindata:
pylab.plot(ptime2[1:-1],
pout2[1:-1],
color='r',
linestyle='-',
linewidth=lwidth,
marker='')
xlabel(xlab, {'color': 'k'})
ylabel(ylab, {'color': 'k'})
xlim(-0.49999, 1.49999)
if ymin >= 0.0:
ylim(ymin - yr * 0.01, ymax + yr * 0.01)
# ylim(0.96001,1.03999)
else:
ylim(1.0e-10, ymax + yr * 0.01)
grid()
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
# stop time
kepmsg.clock('KEPFOLD ended at: ', logfile, verbose)
def kephalophot(infile,
outfile,
plotfile,
plottype,
filter,
function,
cutoff,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPHALOPHOT -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'plottype=' + plottype + ' '
filt = 'n'
if (filter): filt = 'y'
call += 'filter=' + filt + ' '
call += 'function=' + function + ' '
call += 'cutoff=' + str(cutoff) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPHALOPHOT started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPHALOPHOT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(
infile, logfile, verbose)
# print target data
if status == 0:
print('')
print(' KepID: %s' % kepid)
print(' RA (J2000): %s' % ra)
print('Dec (J2000): %s' % dec)
print(' KepMag: %s' % kepmag)
print(' SkyGroup: %2s' % skygroup)
print(' Season: %2s' % str(season))
print(' Channel: %2s' % channel)
print(' Module: %2s' % module)
print(' Output: %1s' % output)
print('')
# how many quality = 0 rows? how many pixels?
if status == 0:
np = ydim * xdim
nrows = len(fluxpixels)
npts = 0
for i in range(nrows):
if qual[i] < 1e4 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,ydim*xdim/2]):
npts += 1
time = empty((npts))
timecorr = empty((npts))
cadenceno = empty((npts))
quality = empty((npts))
pixseries = zeros((npts, np))
errseries = zeros((npts, np))
# pixseries = empty((ydim,xdim,npts))
# errseries = empty((ydim,xdim,npts))
# construct output light curves
if status == 0:
for i in range(np):
npts = 0
for j in range(nrows):
if qual[j] < 1e4 and \
numpy.isfinite(barytime[j]) and \
numpy.isfinite(fluxpixels[j,i]):
time[npts] = barytime[j]
timecorr[npts] = tcorr[j]
cadenceno[npts] = cadno[j]
quality[npts] = qual[j]
pixseries[npts, i] = fluxpixels[j, i]
errseries[npts, i] = errpixels[j, i]
npts += 1
# define data sampling
if status == 0 and filter:
tpf, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0 and filter:
cadence, status = kepkey.cadence(tpf[1], infile, logfile, verbose)
tr = 1.0 / (cadence / 86400)
timescale = 1.0 / (cutoff / tr)
# define convolution function
if status == 0 and filter:
if function == 'boxcar':
filtfunc = numpy.ones(numpy.ceil(timescale))
elif function == 'gauss':
timescale /= 2
dx = numpy.ceil(timescale * 10 + 1)
filtfunc = kepfunc.gauss()
filtfunc = filtfunc([1.0, dx / 2 - 1.0, timescale],
linspace(0, dx - 1, dx))
elif function == 'sinc':
dx = numpy.ceil(timescale * 12 + 1)
fx = linspace(0, dx - 1, dx)
fx = fx - dx / 2 + 0.5
fx /= timescale
filtfunc = numpy.sinc(fx)
filtfunc /= numpy.sum(filtfunc)
# pad time series at both ends with noise model
if status == 0 and filter:
for i in range(ydim):
for j in range(xdim):
ave, sigma = kepstat.stdev(pixseries[i, j, :len(filtfunc)])
padded = numpy.append(kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma), pixseries[i,j,:])
ave, sigma = kepstat.stdev(pixseries[i, j, -len(filtfunc):])
padded = numpy.append(padded, kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma))
# convolve data
if status == 0:
convolved = convolve(padded, filtfunc, 'same')
# remove padding from the output array
if status == 0:
outdata = convolved[len(filtfunc):-len(filtfunc)]
# subtract low frequencies
if status == 0:
outmedian = median(outdata)
pixseries[i,
j, :] = pixseries[i, j, :] - outdata + outmedian
# construct weighted time series
if status == 0:
wgt = numpy.ones((np, 3))
twgt = numpy.ones((np, 3))
wgt /= sum(wgt, axis=0)
satlvl = 0.8 * numpy.max(numpy.max(pixseries, axis=1))
brk1 = 9.7257203
brk2 = 45.
ind1 = where(time - time[0] < brk1)
ind2 = where((time - time[0] >= brk1) & (time - time[0] < brk2))
ind3 = where(time - time[0] >= brk2)
z = numpy.array([0.0, 0.0, 0.0])
for i in range(np):
if max(pixseries[ind1, i].flatten()) > satlvl or max(
pixseries[ind1, i].flatten()) <= 100:
wgt[i, 0] = 0
z[0] += 1
if max(pixseries[ind2, i].flatten()) > satlvl or max(
pixseries[ind2, i].flatten()) <= 100:
wgt[i, 1] = 0
z[1] += 1
if max(pixseries[ind3, i].flatten()) > satlvl or max(
pixseries[ind3, i].flatten()) <= 100:
wgt[i, 2] = 0
z[2] += 1
print(z)
print(np - z)
sf1 = numpy.dot(pixseries[ind1, :], wgt[:, 0]).flatten()
sf2 = numpy.dot(pixseries[ind2, :], wgt[:, 1]).flatten()
sf3 = numpy.dot(pixseries[ind3, :], wgt[:, 2]).flatten()
sf1 /= numpy.median(sf1)
sf2 /= numpy.median(sf2)
sf3 /= numpy.median(sf3)
originalflux = numpy.concatenate([sf1, sf2, sf3])
# a=numpy.array([0.0,0.0,0.0])
# t=0
# ca = numpy.array([0.0,0.0,0.0])
# ct = 0
# sig1 = numpy.std(sf1)
# sig2 = numpy.std(sf2)
# sig3 = numpy.std(sf3)
# while 1:
# j = int(numpy.floor(numpy.random.random()*np))
# if sum(wgt[j,:]) == 0: continue
# if ct == 1000:
# print(ca)
# if ca[0] < 333 and ca[1] < 333 and ca[2] < 333: break
# ca = numpy.array([0.0,0.0,0.0])
# ct = 0
# t += 1
# ct += 1
# wgt /= sum(wgt,axis=0)
# twgt=copy(wgt)
# twgt[j,:]*=numpy.random.normal(1.0,0.05,3)
# twgt /= sum(twgt,axis=0)
# tsf1 = numpy.dot(pixseries[ind1,:],twgt[:,0]).flatten()
# tsf2 = numpy.dot(pixseries[ind2,:],twgt[:,1]).flatten()
# tsf3 = numpy.dot(pixseries[ind3,:],twgt[:,2]).flatten()
# tsf1 /= numpy.median(tsf1)
# tsf2 /= numpy.median(tsf2)
# tsf3 /= numpy.median(tsf3)
# tsig1 = numpy.std(tsf1)
# tsig2 = numpy.std(tsf2)
# tsig3 = numpy.std(tsf3)
# if tsig1 < sig1:
# wgt[:,0] = twgt[:,0]
# sig1 = tsig1
# a[0] += 1
# ca[0] += 1
# if tsig2 < sig2:
# wgt[:,1] = twgt[:,1]
# sig2 = tsig2
# a[1] += 1
# ca[1] += 1
# if tsig3 < sig3:
# wgt[:,2] = twgt[:,2]
# sig3 = tsig3
# a[2] += 1
# ca[2] += 1
# print(100*a/t)
# sf1 = numpy.dot(pixseries[ind1,:],wgt[:,0]).flatten()
# sf2 = numpy.dot(pixseries[ind2,:],wgt[:,1]).flatten()
# sf3 = numpy.dot(pixseries[ind3,:],wgt[:,2]).flatten()
# sf1 /= numpy.median(sf1)
# sf2 /= numpy.median(sf2)
# sf3 /= numpy.median(sf3)
#
# a=numpy.array([0.0,0.0,0.0])
# t=0
# ca = numpy.array([0.0,0.0,0.0])
# ct = 0
# sig1 = sum(numpy.fabs(sf1[1:]-sf1[:-1]))
# sig2 = sum(numpy.fabs(sf2[1:]-sf2[:-1]))
# sig3 = sum(numpy.fabs(sf3[1:]-sf3[:-1]))
# while 1:
# j = int(numpy.floor(numpy.random.random()*np))
# if sum(wgt[j,:]) == 0: continue
# if ct == 1000:
# print(ca)
# if ca[0] < 167 and ca[1] < 167 and ca[2] < 167: break#
# ca = numpy.array([0.0,0.0,0.0])
# ct = 0
# t += 1
# ct += 1
# wgt /= sum(wgt,axis=0)
# twgt=copy(wgt)
# twgt[j,:]*=numpy.random.normal(1.0,0.05,3)
# twgt /= sum(twgt,axis=0)
# tsf1 = numpy.dot(pixseries[ind1,:],twgt[:,0]).flatten()
# tsf2 = numpy.dot(pixseries[ind2,:],twgt[:,1]).flatten()
# tsf3 = numpy.dot(pixseries[ind3,:],twgt[:,2]).flatten()
# tsf1 /= numpy.median(tsf1)
# tsf2 /= numpy.median(tsf2)
# tsf3 /= numpy.median(tsf3)
# tsig1 = sum(numpy.fabs(tsf1[1:]-tsf1[:-1]))
# tsig2 = sum(numpy.fabs(tsf2[1:]-tsf2[:-1]))
# tsig3 = sum(numpy.fabs(tsf3[1:]-tsf3[:-1]))
# if tsig1 < sig1:
# wgt[:,0] = twgt[:,0]
# sig1 = tsig1
# a[0] += 1
# ca[0] += 1
# if tsig2 < sig2:
# wgt[:,1] = twgt[:,1]
# sig2 = tsig2
# a[1] += 1
# ca[1] += 1
# if tsig3 < sig3:
# wgt[:,2] = twgt[:,2]
# sig3 = tsig3
# a[2] += 1
# ca[2] += 1
# print(100*a/t)
# sf1 = numpy.dot(pixseries[ind1,:],wgt[:,0]).flatten()
# sf2 = numpy.dot(pixseries[ind2,:],wgt[:,1]).flatten()
# sf3 = numpy.dot(pixseries[ind3,:],wgt[:,2]).flatten()
# sf1 /= numpy.median(sf1)
# sf2 /= numpy.median(sf2)
# sf3 /= numpy.median(sf3)
a = numpy.array([0.0, 0.0, 0.0])
t = 0
ca = numpy.array([0.0, 0.0, 0.0])
ct = 0
sig1 = sum(numpy.fabs(sf1[2:] - 2 * sf1[1:-1] + sf1[:-2]))
sig2 = sum(numpy.fabs(sf2[2:] - 2 * sf2[1:-1] + sf2[:-2]))
sig3 = sum(numpy.fabs(sf3[2:] - 2 * sf3[1:-1] + sf3[:-2]))
while 1:
j = int(numpy.floor(numpy.random.random() * np))
if sum(wgt[j, :]) == 0: continue
if ct == 1000:
print(ca)
if ca[0] < 20 and ca[1] < 20 and ca[2] < 20: break
if t > 1000000: break
ca = numpy.array([0.0, 0.0, 0.0])
ct = 0
t += 1
ct += 1
wgt /= sum(wgt, axis=0)
twgt = copy(wgt)
twgt[j, :] *= numpy.random.normal(1.0, 0.05, 3)
twgt /= sum(twgt, axis=0)
tsf1 = numpy.dot(pixseries[ind1, :], twgt[:, 0]).flatten()
tsf2 = numpy.dot(pixseries[ind2, :], twgt[:, 1]).flatten()
tsf3 = numpy.dot(pixseries[ind3, :], twgt[:, 2]).flatten()
tsf1 /= numpy.median(tsf1)
tsf2 /= numpy.median(tsf2)
tsf3 /= numpy.median(tsf3)
tsig1 = sum(numpy.fabs(tsf1[2:] - 2 * tsf1[1:-1] + tsf1[:-2]))
tsig2 = sum(numpy.fabs(tsf2[2:] - 2 * tsf2[1:-1] + tsf2[:-2]))
tsig3 = sum(numpy.fabs(tsf3[2:] - 2 * tsf3[1:-1] + tsf3[:-2]))
if tsig1 < sig1:
wgt[:, 0] = twgt[:, 0]
sig1 = tsig1
a[0] += 1
ca[0] += 1
if tsig2 < sig2:
wgt[:, 1] = twgt[:, 1]
sig2 = tsig2
a[1] += 1
ca[1] += 1
if tsig3 < sig3:
wgt[:, 2] = twgt[:, 2]
sig3 = tsig3
a[2] += 1
ca[2] += 1
print(100 * a / t)
sf1 = numpy.dot(pixseries[ind1, :], wgt[:, 0]).flatten()
sf2 = numpy.dot(pixseries[ind2, :], wgt[:, 1]).flatten()
sf3 = numpy.dot(pixseries[ind3, :], wgt[:, 2]).flatten()
sf1 /= numpy.median(sf1)
sf2 /= numpy.median(sf2)
sf3 /= numpy.median(sf3)
finalflux = numpy.concatenate([sf1, sf2, sf3])
# construct output file
if status == 0:
instruct, status = kepio.openfits(infile, 'readonly', logfile, verbose)
status = kepkey.history(call, instruct[0], outfile, logfile, verbose)
hdulist = HDUList(instruct[0])
cols = []
cols.append(
Column(name='TIME',
format='D',
unit='BJD - 2454833',
disp='D12.7',
array=time))
cols.append(
Column(name='TIMECORR',
format='E',
unit='d',
disp='E13.6',
array=timecorr))
cols.append(
Column(name='CADENCENO', format='J', disp='I10', array=cadenceno))
cols.append(Column(name='QUALITY', format='J', array=quality))
cols.append(
Column(name='ORGFLUX',
format='E',
disp='E13.6',
array=originalflux))
cols.append(
Column(name='FLUX', format='E', disp='E13.6', array=finalflux))
# for i in range(ydim):
# for j in range(xdim):
# colname = 'COL%d_ROW%d' % (i+column,j+row)
# cols.append(Column(name=colname,format='E',disp='E13.6',array=pixseries[i,j,:]))
hdu1 = new_table(ColDefs(cols))
try:
hdu1.header.update('INHERIT', True, 'inherit the primary header')
except:
status = 0
try:
hdu1.header.update('EXTNAME', 'PIXELSERIES', 'name of extension')
except:
status = 0
try:
hdu1.header.update(
'EXTVER', instruct[1].header['EXTVER'],
'extension version number (not format version)')
except:
status = 0
try:
hdu1.header.update('TELESCOP', instruct[1].header['TELESCOP'],
'telescope')
except:
status = 0
try:
hdu1.header.update('INSTRUME', instruct[1].header['INSTRUME'],
'detector type')
except:
status = 0
try:
hdu1.header.update('OBJECT', instruct[1].header['OBJECT'],
'string version of KEPLERID')
except:
status = 0
try:
hdu1.header.update('KEPLERID', instruct[1].header['KEPLERID'],
'unique Kepler target identifier')
except:
status = 0
try:
hdu1.header.update('RADESYS', instruct[1].header['RADESYS'],
'reference frame of celestial coordinates')
except:
status = 0
try:
hdu1.header.update('RA_OBJ', instruct[1].header['RA_OBJ'],
'[deg] right ascension from KIC')
except:
status = 0
try:
hdu1.header.update('DEC_OBJ', instruct[1].header['DEC_OBJ'],
'[deg] declination from KIC')
except:
status = 0
try:
hdu1.header.update('EQUINOX', instruct[1].header['EQUINOX'],
'equinox of celestial coordinate system')
except:
status = 0
try:
hdu1.header.update('TIMEREF', instruct[1].header['TIMEREF'],
'barycentric correction applied to times')
except:
status = 0
try:
hdu1.header.update('TASSIGN', instruct[1].header['TASSIGN'],
'where time is assigned')
except:
status = 0
try:
hdu1.header.update('TIMESYS', instruct[1].header['TIMESYS'],
'time system is barycentric JD')
except:
status = 0
try:
hdu1.header.update('BJDREFI', instruct[1].header['BJDREFI'],
'integer part of BJD reference date')
except:
status = 0
try:
hdu1.header.update('BJDREFF', instruct[1].header['BJDREFF'],
'fraction of the day in BJD reference date')
except:
status = 0
try:
hdu1.header.update('TIMEUNIT', instruct[1].header['TIMEUNIT'],
'time unit for TIME, TSTART and TSTOP')
except:
status = 0
try:
hdu1.header.update('TSTART', instruct[1].header['TSTART'],
'observation start time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('TSTOP', instruct[1].header['TSTOP'],
'observation stop time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('LC_START', instruct[1].header['LC_START'],
'mid point of first cadence in MJD')
except:
status = 0
try:
hdu1.header.update('LC_END', instruct[1].header['LC_END'],
'mid point of last cadence in MJD')
except:
status = 0
try:
hdu1.header.update('TELAPSE', instruct[1].header['TELAPSE'],
'[d] TSTOP - TSTART')
except:
status = 0
try:
hdu1.header.update('LIVETIME', instruct[1].header['LIVETIME'],
'[d] TELAPSE multiplied by DEADC')
except:
status = 0
try:
hdu1.header.update('EXPOSURE', instruct[1].header['EXPOSURE'],
'[d] time on source')
except:
status = 0
try:
hdu1.header.update('DEADC', instruct[1].header['DEADC'],
'deadtime correction')
except:
status = 0
try:
hdu1.header.update('TIMEPIXR', instruct[1].header['TIMEPIXR'],
'bin time beginning=0 middle=0.5 end=1')
except:
status = 0
try:
hdu1.header.update('TIERRELA', instruct[1].header['TIERRELA'],
'[d] relative time error')
except:
status = 0
try:
hdu1.header.update('TIERABSO', instruct[1].header['TIERABSO'],
'[d] absolute time error')
except:
status = 0
try:
hdu1.header.update('INT_TIME', instruct[1].header['INT_TIME'],
'[s] photon accumulation time per frame')
except:
status = 0
try:
hdu1.header.update('READTIME', instruct[1].header['READTIME'],
'[s] readout time per frame')
except:
status = 0
try:
hdu1.header.update('FRAMETIM', instruct[1].header['FRAMETIM'],
'[s] frame time (INT_TIME + READTIME)')
except:
status = 0
try:
hdu1.header.update('NUM_FRM', instruct[1].header['NUM_FRM'],
'number of frames per time stamp')
except:
status = 0
try:
hdu1.header.update('TIMEDEL', instruct[1].header['TIMEDEL'],
'[d] time resolution of data')
except:
status = 0
try:
hdu1.header.update('DATE-OBS', instruct[1].header['DATE-OBS'],
'TSTART as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('DATE-END', instruct[1].header['DATE-END'],
'TSTOP as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('BACKAPP', instruct[1].header['BACKAPP'],
'background is subtracted')
except:
status = 0
try:
hdu1.header.update('DEADAPP', instruct[1].header['DEADAPP'],
'deadtime applied')
except:
status = 0
try:
hdu1.header.update('VIGNAPP', instruct[1].header['VIGNAPP'],
'vignetting or collimator correction applied')
except:
status = 0
try:
hdu1.header.update('GAIN', instruct[1].header['GAIN'],
'[electrons/count] channel gain')
except:
status = 0
try:
hdu1.header.update('READNOIS', instruct[1].header['READNOIS'],
'[electrons] read noise')
except:
status = 0
try:
hdu1.header.update('NREADOUT', instruct[1].header['NREADOUT'],
'number of read per cadence')
except:
status = 0
try:
hdu1.header.update('TIMSLICE', instruct[1].header['TIMSLICE'],
'time-slice readout sequence section')
except:
status = 0
try:
hdu1.header.update('MEANBLCK', instruct[1].header['MEANBLCK'],
'[count] FSW mean black level')
except:
status = 0
hdulist.append(hdu1)
hdulist.writeto(outfile)
status = kepkey.new('EXTNAME', 'APERTURE', 'name of extension',
instruct[2], outfile, logfile, verbose)
pyfits.append(outfile, instruct[2].data, instruct[2].header)
wgt1 = numpy.reshape(wgt[:, 0], (ydim, xdim))
wgt2 = numpy.reshape(wgt[:, 1], (ydim, xdim))
wgt3 = numpy.reshape(wgt[:, 2], (ydim, xdim))
hdu3 = ImageHDU(data=wgt1, header=instruct[2].header, name='WEIGHTS1')
hdu4 = ImageHDU(data=wgt2, header=instruct[2].header, name='WEIGHTS2')
hdu5 = ImageHDU(data=wgt3, header=instruct[2].header, name='WEIGHTS3')
pyfits.append(outfile, hdu3.data, hdu3.header)
pyfits.append(outfile, hdu4.data, hdu4.header)
pyfits.append(outfile, hdu5.data, hdu5.header)
status = kepio.closefits(instruct, logfile, verbose)
else:
message = 'WARNING -- KEPHALOPHOT: output FITS file requires > 999 columns. Non-compliant with FITS convention.'
kepmsg.warn(logfile, message)
# plot style
if status == 0:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.0,
'axes.labelsize': 32,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 8,
'legend.fontsize': 8,
'xtick.labelsize': 12,
'ytick.labelsize': 12
}
pylab.rcParams.update(params)
except:
pass
# plot pixel array
fmin = 1.0e33
fmax = -1.033
if status == 0:
pylab.figure(num=None, figsize=[12, 12])
pylab.clf()
dx = 0.93 #/ xdim
dy = 0.94 #/ ydim
ax = pylab.axes([0.06, 0.05, 0.93, 0.94])
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().xaxis.set_major_locator(
matplotlib.ticker.MaxNLocator(integer=True))
pylab.gca().yaxis.set_major_locator(
matplotlib.ticker.MaxNLocator(integer=True))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
pylab.xlim(numpy.min(pixcoord1) - 0.5, numpy.max(pixcoord1) + 0.5)
pylab.ylim(numpy.min(pixcoord2) - 0.5, numpy.max(pixcoord2) + 0.5)
pylab.xlabel('time', {'color': 'k'})
pylab.ylabel('arbitrary flux', {'color': 'k'})
tmin = amin(time)
tmax = amax(time)
try:
numpy.isfinite(amin(finalflux))
numpy.isfinite(amin(finalflux))
fmin = amin(finalflux)
fmax = amax(finalflux)
except:
ugh = 1
xmin = tmin - (tmax - tmin) / 40
xmax = tmax + (tmax - tmin) / 40
ymin = fmin - (fmax - fmin) / 20
ymax = fmax + (fmax - fmin) / 20
pylab.axes([0.06, 0.05, dx, dy])
pylab.setp(pylab.gca(), xticklabels=[], yticklabels=[])
ptime = time * 1.0
ptime = numpy.insert(ptime, [0], ptime[0])
ptime = numpy.append(ptime, ptime[-1])
pflux = finalflux * 1.0
pflux = numpy.insert(pflux, [0], -1000.0)
pflux = numpy.append(pflux, -1000.0)
pylab.plot(time,
finalflux,
color='#0000ff',
linestyle='-',
linewidth=0.5)
pylab.fill(ptime, pflux, fc='#FFF380', linewidth=0.0, alpha=1.0)
if 'loc' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(ymin, ymax)
if 'glob' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(1.0e-10, numpy.nanmax(pixseries) * 1.05)
if 'full' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(1.0e-10, ymax * 1.05)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
if plotfile.lower() != 'none':
pylab.savefig(plotfile)
# stop time
if status == 0:
kepmsg.clock('KEPHALOPHOT ended at', logfile, verbose)
return
def kepitermask(infile,
outfile,
plotfile,
column,
row,
timescale,
nsig,
stepsize,
winsize,
npoly,
niter,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPITERMASK -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'column=' + str(column) + ' '
call += 'row=' + str(row) + ' '
call += 'timescale=' + str(timescale) + ' '
call += 'nsig=' + str(nsig) + ' '
call += 'stepsize=' + str(stepsize) + ' '
call += 'winsize=' + str(winsize) + ' '
call += 'npoly=' + str(npoly) + ' '
call += 'niter=' + str(niter) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPITERMASK started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPITERMASK: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, co, ro, kepmag, xdim, ydim, work1, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPPRF: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile, message, verbose)
# print target data
if status == 0:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# read mask defintion data from TPF file
if status == 0:
maskmap, pixcoordx, pixcoordy, status = kepio.readMaskDefinition(
infile, logfile, verbose)
pixcoordx = rot90(pixcoordx)
pixcoordy = flipud(rot90(pixcoordy))
maskmap[:, :] = 0.0
# which pixel does the target reside on?
if status == 0:
x = where(pixcoordx == float(column))[1][0]
y = where(pixcoordy == float(row))[0][0]
maskmap[y, x] = 1.0
# read time series data
if status == 0:
instr = pyfits.open(infile, mode='readonly', memmap=True)
work1 = instr[1].data.field('TIME')[:]
work2 = instr[1].data.field('FLUX')[:]
work3 = instr[1].data.field('QUALITY')[:]
# how many quality = 0 rows?
if status == 0:
npts = 0
nrows = len(work1)
for i in range(nrows):
if work3[i] == 0 and numpy.isfinite(work1[i]):
npts += 1
time = empty((npts))
flux = empty((npts, ydim, xdim))
quality = empty((npts))
# construct pixel light curves from quality = 0 data
if status == 0:
n = 0
for i in range(nrows):
if work3[i] == 0 and numpy.isfinite(work1[i]):
time[n] = work1[i]
flux[n] = work2[i, :, :]
quality[n] = work3[i]
n += 1
# light curves from central pixel
if status == 0:
(pr, pc) = where(maskmap == 1.0)
best_lc = flux[:, pr[0], pc[0]]
# calculate median CDPP
if status == 0:
best_median_cdpp, best_cdpp, status = \
GetCDPP(time,best_lc,npoly,nsig,niter,winsize,stepsize,
timescale,logfile,verbose,status)
# does another pixel improve CDPP of the target?
if status == 0:
trial_med = best_median_cdpp
# while best_median_cdpp == trial_med:
for i in range(70):
trial_lc, trial_cdpp, trial_med, xpix, ypix, status = \
AddPixelToAperture(time,flux,maskmap,best_lc,npoly,nsig,niter,winsize,
stepsize,timescale,logfile,verbose)
# if trial_med < best_median_cdpp:
if trial_med < 1e10:
best_lc = trial_lc
best_cdpp = trial_cdpp
best_median_cdpp = trial_med
maskmap[ypix, xpix] = 1.0
print maskmap
print i, best_median_cdpp
# plot style
if status == 0:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.0,
'axes.labelsize': 32,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 8,
'legend.fontsize': 8,
'xtick.labelsize': 12,
'ytick.labelsize': 12
}
pylab.rcParams.update(params)
except:
pass
# tmp
pylab.plot(time,
best_lc,
color='#0000ff',
linestyle='-',
linewidth=1.0)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
if plotfile.lower() != 'none':
pylab.savefig(plotfile)
# stop time
if status == 0:
kepmsg.clock('KEPITERMASK ended at', logfile, verbose)
return
def kepfake(outfile,prfdir,module,output,column,row,kepmag,background,xdim,ydim,
clobber,verbose,logfile,status,cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFAKE -- '
call += 'outfile='+outfile+' '
call += 'prfdir='+prfdir+' '
call += 'module='+str(module)+' '
call += 'output='+str(output)+' '
call += 'column='+str(column)+' '
call += 'row='+str(row)+' '
call += 'kepmag='+str(kepmag)+' '
call += 'background='+str(background)+' '
call += 'xdim='+str(xdim)+' '
call += 'ydim='+str(ydim)+' '
clob = 'n'
if (clobber): clob = 'y'
call += 'clobber='+clob+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# test log file
logfile = kepmsg.test(logfile)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 10,
'ytick.labelsize': 10}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[12,12])
pylab.clf()
# start time
kepmsg.clock('KEPFAKE started at',logfile,verbose)
# clobber output file
if status == 0:
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPRFPHOT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# Create time-tagged arrays
if status == 0:
nobs = 192
time = zeros((nobs))
timecorr = zeros((nobs))
cadenceno = zeros((nobs))
raw_cnts = zeros((nobs,ydim,xdim))
flux = zeros((nobs,ydim,xdim))
flux_err = zeros((nobs,ydim,xdim))
flux_bkg = zeros((nobs,ydim,xdim))
flux_bkg_err = zeros((nobs,ydim,xdim))
cosmic_rays = zeros((nobs,ydim,xdim))
quality = zeros((nobs))
pos_corr1 = zeros((nobs))
pos_corr2 = zeros((nobs))
# Create aperture bit mqp
if status == 0:
aperture = ones((ydim,xdim)) * 3.0
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPFAKE: No PRF file found in ' + prfdir
status = kepmsg.err(logfile,message,verbose)
# read PRF images
if status == 0:
prfn = [0,0,0,0,0]
crpix1p = numpy.zeros((5),dtype='float32')
crpix2p = numpy.zeros((5),dtype='float32')
crval1p = numpy.zeros((5),dtype='float32')
crval2p = numpy.zeros((5),dtype='float32')
cdelt1p = numpy.zeros((5),dtype='float32')
cdelt2p = numpy.zeros((5),dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
PRFx = arange(0.5,shape(prfn[0])[1]+0.5)
PRFy = arange(0.5,shape(prfn[0])[0]+0.5)
PRFx = (PRFx - size(PRFx) / 2) * cdelt1p[0]
PRFy = (PRFy - size(PRFy) / 2) * cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
if status == 0:
prf = zeros(shape(prfn[0]),dtype='float32')
prfWeight = zeros((5),dtype='float32')
for i in range(5):
prfWeight[i] = sqrt((column - crval1p[i])**2 + (row - crval2p[i])**2)
if prfWeight[i] == 0.0: prfWeight[i] = 1.0e6
prf = prf + prfn[i] / prfWeight[i]
prf = prf / nansum(prf) / cdelt1p[0] / cdelt2p[0]
# interpolation function over the PRF
if status == 0:
splineInterpolation = scipy.interpolate.RectBivariateSpline(PRFx,PRFy,prf,kx=3,ky=3)
# flux from target
if status == 0:
zeropoint = 33.227
kepflux = 10.0**((zeropoint - kepmag) / 2.5)
# range of the output image in detector coordinates
if status == 0:
if xdim % 2 == 0: xdim += 1
if ydim % 2 == 0: ydim += 1
DATx = arange(round(column) - floor(xdim/2),round(column) + floor(xdim/2) + 1.0)
DATy = arange(round(row) - floor(ydim/2),round(row) + floor(ydim/2) + 1.0)
ax = pylab.axes([0.05,0.5,0.45,0.45])
pylab.imshow(log10(prf+0.001),aspect='auto',interpolation='nearest',origin='lower',cmap='jet',
extent=(min(PRFx),max(PRFx),min(PRFy),max(PRFy)))
pylab.plot([-100.,100.],[0.0,0.0],'k',ls='--')
pylab.plot([0.0,0.0],[-100.,100.],'k',ls='--')
pylab.xlim(min(PRFx),max(PRFx))
pylab.ylim(min(PRFy),max(PRFy))
ax = pylab.axes([0.5,0.5,0.45,0.45])
TMPx = arange(min(PRFx),max(PRFx),0.1) + floor(column)
TMPy = arange(min(PRFy),max(PRFy),0.1) + floor(row)
PRFfit = kepfunc.PRF2DET([kepflux],[column],[row],TMPx,TMPy,1.0,1.0,0.0,splineInterpolation)
PRFfit = PRFfit + background
pylab.imshow(log10(PRFfit),aspect='auto',interpolation='nearest',origin='lower',cmap='jet',
extent=(min(TMPx),max(TMPx),min(TMPy),max(TMPy)))
pylab.plot([column,column],[-100.,2000.],'k',ls='--')
pylab.plot([-100.,2000.],[row,row],'k',ls='--')
pylab.xlim(min(TMPx),max(TMPx))
pylab.ylim(min(TMPy),max(TMPy))
ax = pylab.axes([0.05,0.05,0.45,0.45])
TMPx = arange(min(PRFx),max(PRFx),0.5) + floor(column)
TMPy = arange(min(PRFy),max(PRFy),0.5) + floor(row)
PRFfit = kepfunc.PRF2DET([kepflux],[column],[row],TMPx,TMPy,1.0,1.0,0.0,splineInterpolation)
PRFfit = PRFfit + background
pylab.imshow(log10(PRFfit),aspect='auto',interpolation='nearest',origin='lower',cmap='jet',
extent=(min(TMPx),max(TMPx),min(TMPy),max(TMPy)))
pylab.plot([column,column],[-100.,2000.],'k',ls='--')
pylab.plot([-100.,2000.],[row,row],'k',ls='--')
pylab.xlim(min(TMPx),max(TMPx))
pylab.ylim(min(TMPy),max(TMPy))
ax = pylab.axes([0.5,0.05,0.45,0.45])
TMPx = arange(min(PRFx),max(PRFx+1.0),1.0) + floor(column) - 0.5
TMPy = arange(min(PRFy),max(PRFy+1.0),1.0) + floor(row) - 0.5
PRFfit = kepfunc.PRF2DET([kepflux],[column],[row],TMPx,TMPy,1.0,1.0,0.0,splineInterpolation)
PRFfit = PRFfit + background
pylab.imshow(log10(PRFfit),aspect='auto',interpolation='nearest',origin='lower',cmap='jet',
extent=(min(TMPx)-0.5,max(TMPx)-0.5,min(TMPy)-0.5,max(TMPy)-0.5))
pylab.plot([column,column],[-100.,2000.],'k',ls='--')
pylab.plot([-100.,2000.],[row,row],'k',ls='--')
pylab.xlim(min(TMPx),max(TMPx))
pylab.ylim(min(TMPy),max(TMPy))
pylab.ion()
pylab.plot([])
pylab.ioff()
# sys.exit()
# location of the data image centered on the PRF image (in PRF pixel units)
if status == 0:
prfDimY = int(ydim / cdelt1p[0])
prfDimX = int(xdim / cdelt2p[0])
PRFy0 = (shape(prf)[0] - prfDimY) / 2
PRFx0 = (shape(prf)[1] - prfDimX) / 2
# iterate over each exposure
if status == 0:
for i in range(nobs):
# for i in range(1):
# constuct model PRF in detector coordinates
if status == 0:
PRFfit = kepfunc.PRF2DET([kepflux],[column],[row],DATx,DATy,1.0,1.0,0.0,splineInterpolation)
PRFfit = PRFfit + background
# add noise to image
if status == 0:
for index,value in ndenumerate(PRFfit):
PRFfit[index] += sqrt(value) * kepfunc.inv_normal_cummulative_function(random.random())
# populate output array
if status == 0:
time[i] = 1500.2 + float(i) * 0.020416667
cadenceno[i] = 10000 + i
flux[i,:,:] = PRFfit
flux_err[i,:,:] = sqrt(PRFfit)
pylab.imshow(log10(PRFfit),aspect='auto',interpolation='nearest',origin='lower',cmap='jet',
extent=(min(DATx),max(DATx),min(DATy),max(DATy)))
pylab.ion()
pylab.plot([])
pylab.ioff()
# Create the outfile primary extension
if status == 0:
hdu0 = PrimaryHDU()
hdu0.header.update('EXTNAME','PRIMARY','name of extension')
hdu0.header.update('EXTEND',True,'file may contain standard extensions')
hdu0.header.update('EXTVER',1.0,'extension version number')
hdu0.header.update('ORIGIN','NASA/Ames','organization that generated this file')
hdu0.header.update('DATE','2014-04-08','file creation date')
hdu0.header.update('CREATOR','FluxExporter-91415','SW version used to create this file')
hdu0.header.update('PROCVER',11.0,'processing script version')
hdu0.header.update('FILEVER','COA','file format version')
hdu0.header.update('TIMVERSN','OGIP/93-003','OGIP memo number for file format')
hdu0.header.update('TELESCOP','Kepler','telescope')
hdu0.header.update('INSTRUME','Kepler photometer','detector type')
hdu0.header.update('OBJECT','KIC 12345678','string version of kepID')
hdu0.header.update('KEPLERID',1234567,'unique Kepler target identifier')
hdu0.header.update('CHANNEL',58,'CCD channel')
hdu0.header.update('SKYGROUP',32,'roll-independent location of channel')
hdu0.header.update('MODULE',17,'CCD module')
hdu0.header.update('OUTPUT',2,'CCD output')
hdu0.header.update('QUARTER',4,'mission quarter during which data was collected')
hdu0.header.update('SEASON',2,'mission season during which data was collected')
hdu0.header.update('DATA_REL',25,'version of data release notes describing data')
hdu0.header.update('OBSMODE','long cadence','observing mode')
hdu0.header.update('RADESYS','ICRS','reference frame of celestial coordinates')
hdu0.header.update('RA_OBJ',0.0,'[deg] right ascension from KIC')
hdu0.header.update('DEC_OBJ',0.0,'[deg] declination from KIC')
hdu0.header.update('EQUINOX',2000.0,'equinox of celestial coordinate system')
hdu0.header.update('PMRA',0.0,'[arcsec/yr] RA proper motion')
hdu0.header.update('PMDEC',0.0,'[arcsec/yr] Dec proper motion')
hdu0.header.update('PMTOTAL',0.0,'[arcsec/yr] total proper motion')
hdu0.header.update('PARALLAX',0.0,'[arcsec] parallax')
hdu0.header.update('GLON',0.0,'[deg] galactic longitude')
hdu0.header.update('GLAT',0.0,'[deg] galactic latitude')
hdu0.header.update('GMAG',kepmag,'[mag] SDSS g band magnitude from KIC')
hdu0.header.update('RMAG',kepmag,'[mag] SDSS r band magnitude from KIC')
hdu0.header.update('IMAG',kepmag,'[mag] SDSS i band magnitude from KIC')
hdu0.header.update('ZMAG',kepmag,'[mag] SDSS z band magnitude from KIC')
hdu0.header.update('D51MAG',kepmag,'[mag] D51 magnitude, from KIC')
hdu0.header.update('JMAG',kepmag,'[mag] J band magnitude from 2MASS')
hdu0.header.update('HMAG',kepmag,'[mag] H band magnitude from 2MASS')
hdu0.header.update('KMAG',kepmag,'[mag] K band magnitude from 2MASS')
hdu0.header.update('KEPMAG',kepmag,'[mag] Kepler magnitude (Kp) from KIC')
hdu0.header.update('GRCOLOR',0.0,'[mag] (g-r) color, SDSS bands')
hdu0.header.update('JKCOLOR',0.0,'[mag] (J-K) color, 2MASS bands')
hdu0.header.update('GKCOLOR',0.0,'[mag] (g-K) color, SDSS g - 2MASS K')
hdu0.header.update('TEFF',5000.0,'[K] effective temperature from KIC')
hdu0.header.update('LOGG',4.5,'[cm/s2] log10 surface gravity from KIC')
hdu0.header.update('FEH',0.0,'[log10([Fe/H])] metallicity from KIC')
hdu0.header.update('EBMINUSV',0.0,'[mag] E(B-V) redenning from KIC')
hdu0.header.update('AV',0.0,'[mag] A_v extinction from KIC')
hdu0.header.update('RADIUS',1.0,'[solar radii] stellar radius from KIC')
hdu0.header.update('TMINDEX',1117146912,'unique 2MASS catalog ID from KIC')
hdu0.header.update('SCPID',1117146912,'unique SCP processing ID from KIC')
hdulist = HDUList(hdu0)
# create the outfile table extension
if status == 0:
eformat = str(ydim*xdim) + 'E'
jformat = str(ydim*xdim) + 'J'
kformat = str(ydim*xdim) + 'K'
coldim = '(' + str(ydim) + ',' + str(ydim) + ')'
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='RAW_CNTS',format=jformat,unit='count',dim=coldim,array=raw_cnts)
col5 = Column(name='FLUX',format=eformat,unit='e-/s',dim=coldim,array=flux)
col6 = Column(name='FLUX_ERR',format=eformat,unit='e-/s',dim=coldim,array=flux_err)
col7 = Column(name='FLUX_BKG',format=eformat,unit='e-/s',dim=coldim,array=flux_bkg)
col8 = Column(name='FLUX_BKG_ERR',format=eformat,unit='e-/s',dim=coldim,array=flux_bkg_err)
col9 = Column(name='COSMIC_RAYS',format=eformat,unit='e-/s',dim=coldim,array=cosmic_rays)
col10 = Column(name='QUALITY',format='J',array=quality)
col11 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col12 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12])
hdu1 = new_table(cols)
hdu1.header.update('TTYPE1','TIME','column title: data time stamps')
hdu1.header.update('TFORM1','D','data type: float64')
hdu1.header.update('TUNIT1','BJD - 2454833','column units: barycenter corrected JD')
hdu1.header.update('TDISP1','D13.7','column display format')
hdu1.header.update('TTYPE2','TIMECORR','column title: barycentric correction')
hdu1.header.update('TFORM2','E','column format: float32')
hdu1.header.update('TUNIT2','d','column units: days')
hdu1.header.update('TDISP2','D12.7','column display format')
hdu1.header.update('TTYPE3','CADENCENO','column title: unique cadence number')
hdu1.header.update('TFORM3','J','column format: signed integer32')
hdu1.header.update('TTYPE4','RAW_CNTS','column title: raw pixel count')
hdu1.header.update('TFORM4',jformat,'column format: signed integer32')
hdu1.header.update('TDIM4',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT4','count','column units: count')
hdu1.header.update('TTYPE5','FLUX','column title: calibrated pixel flux')
hdu1.header.update('TFORM5',eformat,'column format: float32')
hdu1.header.update('TDIM5',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT5','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE6','FLUX_ERR','column title: 1-sigma calibrated uncertainty')
hdu1.header.update('TFORM6',eformat,'column format: float32')
hdu1.header.update('TDIM6',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT6','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE7','FLUX_BKG','column title: calibrated background flux')
hdu1.header.update('TFORM7',eformat,'column format: float32')
hdu1.header.update('TDIM7',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT7','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE8','FLUX_BKG_ERR','column title: 1-sigma cal. backgrnd uncertainty')
hdu1.header.update('TFORM8',eformat,'column format: float32')
hdu1.header.update('TDIM8',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT8','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE9','COSMIC_RAYS','column title: cosmic ray detections')
hdu1.header.update('TFORM9',eformat,'column format: float32')
hdu1.header.update('TDIM9',coldim,'column dimensions: pixel apeture array')
hdu1.header.update('TUNIT9','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE10','QUALITY','column title: pixel quality flags')
hdu1.header.update('TFORM10','J','column format: signed integer32')
hdu1.header.update('TTYPE11','POS_CORR1','column title: col correction for vel. abbern')
hdu1.header.update('TFORM11','E','column format: float32')
hdu1.header.update('TUNIT11','pixel','column units: pixel')
hdu1.header.update('TTYPE12','POS_CORR2','column title: row correction for vel. abbern')
hdu1.header.update('TFORM12','E','column format: float32')
hdu1.header.update('TUNIT12','pixel','column units: pixel')
hdu1.header.update('WCAX4',2,'number of WCS axes')
hdu1.header.update('1CTY4P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY4P','RAWY','declination coordinate type')
hdu1.header.update('1CRP4P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP4P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV4P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV4P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN4P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN4P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE4P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE4P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP4','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP4','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX4',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX4',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL4',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL4',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI4','deg','physical unit in column dimension')
hdu1.header.update('2CUNI4','deg','physical unit in row dimension')
hdu1.header.update('1CDLT4',-0.001106815552144,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT4',0.001106815552144,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC4',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC4',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC4',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC4',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX5',2,'number of WCS axes')
hdu1.header.update('1CTY5P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY5P','RAWY','declination coordinate type')
hdu1.header.update('1CRP5P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP5P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV5P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV5P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN5P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN5P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE5P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE5P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP5','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP5','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX5',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX5',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL5',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL5',43.80033,'[deg] declination at reference pixel [deg]')
hdu1.header.update('1CUNI5','deg','physical unit in column dimension')
hdu1.header.update('2CUNI5','deg','physical unit in row dimension')
hdu1.header.update('1CDLT5',-0.001106815552144,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT5',0.001106815552144,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC5',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC5',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC5',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC5',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX6',2,'number of WCS axes')
hdu1.header.update('1CTY6P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY6P','RAWY','declination coordinate type')
hdu1.header.update('1CRP6P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP6P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV6P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV6P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN6P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN6P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE6P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE6P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP6','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP6','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX6',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX6',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL6',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL6',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI6','deg','physical unit in column dimension')
hdu1.header.update('2CUNI6','deg','physical unit in row dimension')
hdu1.header.update('1CDLT6',-0.00110558987335788,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT6',0.00110558987335788,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC6',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC6',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC6',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC6',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX7',2,'number of WCS axes')
hdu1.header.update('1CTY7P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY7P','RAWY','declination coordinate type')
hdu1.header.update('1CRP7P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP7P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV7P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV7P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN7P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN7P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE7P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE7P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP7','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP7','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX7',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX7',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL7',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL7',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI7','deg','physical unit in column dimension')
hdu1.header.update('2CUNI7','deg','physical unit in row dimension')
hdu1.header.update('1CDLT7',-0.00110558987335788,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT7',0.00110558987335788,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC7',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC7',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC7',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC7',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX8',2,'number of WCS axes')
hdu1.header.update('1CTY8P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY8P','RAWY','declination coordinate type')
hdu1.header.update('1CRP8P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP8P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV8P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV8P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN8P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN8P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE8P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE8P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP8','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP8','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX8',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX8',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL8',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL8',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI8','deg','physical unit in column dimension')
hdu1.header.update('2CUNI8','deg','physical unit in row dimension')
hdu1.header.update('1CDLT8',-0.00110558987335788,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT8',0.00110558987335788,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC8',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC8',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC8',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC8',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX9',2,'number of WCS axes')
hdu1.header.update('1CTY9P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY9P','RAWY','declination coordinate type')
hdu1.header.update('1CRP9P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP9P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV9P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV9P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN9P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN9P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE9P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE9P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP9','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP9','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX9',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX9',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL9',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL9',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI9','deg','physical unit in column dimension')
hdu1.header.update('2CUNI9','deg','physical unit in row dimension')
hdu1.header.update('1CDLT9',-0.00110558987335788,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT9',0.00110558987335788,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC9',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC9',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC9',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC9',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('WCAX10',2,'number of WCS axes')
hdu1.header.update('1CTY10P','RAWX','right ascension coordinate type')
hdu1.header.update('2CTY10P','RAWY','declination coordinate type')
hdu1.header.update('1CRP10P',1,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRP10P',1,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV10P',DATx[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV10P',DATy[0],'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CUN10P','pixel','physical unit in column dimension')
hdu1.header.update('2CUN10P','pixel','physical unit in row dimension')
hdu1.header.update('1CDE10P',1.0,'[pixel] pixel scale in column dimension')
hdu1.header.update('2CDE10P',1.0,'[pixel] pixel scale in row dimension')
hdu1.header.update('1CTYP10','RA---TAN','right ascension coordinate type')
hdu1.header.update('2CTYP10','DEC--TAN','declination coordinate type')
hdu1.header.update('1CRPX10',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX10',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRVL10',294.94017,'[deg] right ascension at reference pixel')
hdu1.header.update('2CRVL10',43.80033,'[deg] declination at reference pixel')
hdu1.header.update('1CUNI10','deg','physical unit in column dimension')
hdu1.header.update('2CUNI10','deg','physical unit in row dimension')
hdu1.header.update('1CDLT10',-0.00110558987335788,'[deg] pixel scale in RA dimension')
hdu1.header.update('2CDLT10',0.00110558987335788,'[deg] pixel scale in Dec dimension')
hdu1.header.update('11PC10',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu1.header.update('12PC10',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu1.header.update('21PC10',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu1.header.update('22PC10',0.45860051653617395,'linear transformation matrix element cos(th)')
hdu1.header.update('INHERIT',True,'inherit primary keywords')
hdu1.header.update('EXTNAME','TARGETTABLES','name of extension')
hdu1.header.update('EXTVER',1,'extension version number')
hdu1.header.update('TELESCOP','Kepler','telescope')
hdu1.header.update('INSTRUME','Kepler photometer','detector type')
hdu1.header.update('OBJECT','KIC 12345678','string version of kepID')
hdu1.header.update('KEPLERID',12345678,'unique Kepler target identifier')
hdu1.header.update('RADESYS','ICRS','reference frame of celestial coordinates')
hdu1.header.update('RA_OBJ',0.0,'[deg] right ascension from KIC')
hdu1.header.update('DEC_OBJ',0.0,'[deg] declination from KIC')
hdu1.header.update('EQUINOX',2000.0,'equinox of celestial coordinate system')
hdu1.header.update('TIMEREF','SOLARSYSTEM','barycentric correction applied to times')
hdu1.header.update('TASSIGN','SPACECRAFT','where time is assigned')
hdu1.header.update('TIMESYS','TDB','time system is barycentric JD')
hdu1.header.update('BJDREFI',2454833,'integer part of BJD reference date')
hdu1.header.update('BJDREFF',0.0,'fraction of day in BJD reference date')
hdu1.header.update('TIMEUNIT','d','time unit for TIME, TSTART and TSTOP')
hdu1.header.update('TSTART',1500.0,'observation start time in JD - BJDREF')
hdu1.header.update('TSTOP',1504.0,'observation stop time in JD - BJDREF')
hdu1.header.update('LC_START',1500.0+54833.5,'observation start time in MJD')
hdu1.header.update('LC_END',1504.0+54833.5,'observation stop time in MJD')
hdu1.header.update('TELAPSE',93.0,'[d] TSTOP - TSTART')
hdu1.header.update('LIVETIME',82.7273,'[d] TELAPSE multiplied by DEADC')
hdu1.header.update('EXPOSURE',82.7273,'[d] time on source')
hdu1.header.update('DEADC',0.909091,'deadtime correction')
hdu1.header.update('TIMEPIXR',0.5,'bin time beginning=0 middle=0.5 end=1')
hdu1.header.update('TIERRELA',5.78e-7,'[d] relative time error')
hdu1.header.update('TIERABSO',5.78e-6,'[d] absolute time error')
hdu1.header.update('INT_TIME',6.0198,'[s] photon accumulation time per frame')
hdu1.header.update('READTIME',0.518948526144,'[s] readout time per frame')
hdu1.header.update('FRAMETIM',6.53875,'[s] frame time (INT_TIME + READTIME)')
hdu1.header.update('NUM_FRM',270,'number of frames per time stamp')
hdu1.header.update('TIMEDEL',30.0/1440,'[d] time resolution of data')
hdu1.header.update('DATE-OBS','2014-09-30T12:28:48.0','TSTART as UT calendar date')
hdu1.header.update('DATE-END','2014-10-02T11:02:24.0','TSTOP as UT calendar date')
hdu1.header.update('BACKAPP',True,'background is subtracted')
hdu1.header.update('DEADAPP',False,'deadtime applied')
hdu1.header.update('VIGNAPP',False,'vignetting or collimator correction applied')
hdu1.header.update('GAIN',104.88,'[electrons/count] channel gain')
hdu1.header.update('READNOIS',0.7845*104.88,'[electrons] read noise')
hdu1.header.update('NREADOUT',276,'number of reads per cadence')
hdu1.header.update('TIMSLICE',3,'time-slice readout sequence section')
hdu1.header.update('MEANBLCK',738,'[count] FSW mean black level')
hdulist.append(hdu1)
# create the outfile image extension
if status == 0:
hdu2 = ImageHDU(aperture)
hdu2.header.update('INHERIT',True,'inherit primary keywords')
hdu2.header.update('EXTNAME','APERTURE','extension name')
hdu2.header.update('EXTVER',1,'extension version number')
hdu2.header.update('TELESCOP','Kepler','telescope')
hdu2.header.update('INSTRUME','Kepler photometer','detector type')
hdu2.header.update('OBJECT','KIC 12345678','string version of kepID')
hdu2.header.update('KEPLERID',1234567,'unique Kepler target identifier')
hdu2.header.update('RADESYS','ICRS','reference frame of celestial coordinates')
hdu2.header.update('RA_OBJ',294.94017,'[deg] right ascension from KIC')
hdu2.header.update('DEC_OBJ',43.80033,'[deg] declination from KIC')
hdu2.header.update('EQUINOX',2000.0,'equinox of celestial coordinate system')
hdu2.header.update('WCSAXES',2,'number of WCS axes')
hdu2.header.update('CTYPE1P','RAWX','pixel coordinate type')
hdu2.header.update('CTYPE2P','RAWY','pixel coordinate type')
hdu2.header.update('CRPIX1P',1,'[pixel] reference pixel along image axis 1')
hdu2.header.update('CRPIX2P',1,'[pixel] reference pixel along image axis 2')
hdu2.header.update('CRVAL1P',DATx[0],'[pixel] column number at reference pixel')
hdu2.header.update('CRVAL2P',DATy[0],'[pixel] row number at reference pixel')
hdu2.header.update('CUNIT1P','pixel','physical unit in column dimension')
hdu2.header.update('CUNIT2P','pixel','physical unit in row dimension')
hdu2.header.update('CDELT1P',1.0,'[pixel] pixel scale along columns')
hdu2.header.update('CDELT2P',1.0,'[pixel] pixel scale along rows')
hdu2.header.update('CTYPE1','RA---TAN','right ascension coordinate type')
hdu2.header.update('CTYPE2','DEC--TAN','declination coordinate type')
hdu2.header.update('CRPIX1',int(xdim/2),'[pixel] reference pixel along image axis 1')
hdu2.header.update('CRPIX2',int(ydim/2),'[pixel] reference pixel along image axis 2')
hdu2.header.update('CRVAL1',294.94017,'right ascension at reference pixel [deg]')
hdu2.header.update('CRVAL2',43.80033,'declination at reference pixel [deg]')
hdu2.header.update('CUNIT1','deg','physical unit in column dimension')
hdu2.header.update('CUNIT2','deg','physical unit in row dimension')
hdu2.header.update('CDELT1',-0.001106815552144,'pixel scale in RA dimension')
hdu2.header.update('CDELT2',0.001106815552144,'pixel scale in Dec dimension')
hdu2.header.update('PC1_1',0.46086006096337634,'linear transformation matrix element cos(th)')
hdu2.header.update('PC1_2',-0.8897046441865888,'linear transformation matrix element -sin(th)')
hdu2.header.update('PC2_1',0.8864170184391076,'linear transformation matrix element sin(th)')
hdu2.header.update('PC2_2',0.45860051653617395,'linear transformation matrix element cos(th)')
hdulist.append(hdu2)
# write output file
if status == 0:
hdulist.writeto(outfile,checksum=True)
# stop time
kepmsg.clock('\nKEPFAKE ended at',logfile,verbose)
return
def keppca(infile,maskfile,outfile,components,plotpca,nreps,clobber,verbose,logfile,status,cmdLine=False):
try:
import mdp
except:
msg = 'ERROR -- KEPPCA: this task has an external python dependency to MDP, a Modular toolkit for Data Processing (http://mdp-toolkit.sourceforge.net). In order to take advantage of this PCA task, the user must first install MDP with their current python distribution. Note carefully that you may have more than python installation on your machine, and ensure that MDP is installed with the same version of python that the PyKE tools employ. Installation instructions for MDP can be found at the URL provided above.'
status = kepmsg.err(None,msg,True)
# startup parameters
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 10
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
seterr(all="ignore")
# log the call
if status == 0:
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPPCA -- '
call += 'infile='+infile+' '
call += 'maskfile='+maskfile+' '
call += 'outfile='+outfile+' '
call += 'components='+components+' '
ppca = 'n'
if (plotpca): ppca = 'y'
call += 'plotpca='+ppca+ ' '
call += 'nmaps='+str(nreps)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
if status == 0:
kepmsg.clock('KEPPCA started at',logfile,verbose)
# test log file
if status == 0:
logfile = kepmsg.test(logfile)
# clobber output file
if status == 0:
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPCA: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# Set output file names - text file with data and plot
if status == 0:
dataout = copy(outfile)
repname = re.sub('.fits','.png',outfile)
# open input file
if status == 0:
instr = pyfits.open(infile,mode='readonly',memmap=True)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg, status = \
kepio.readTPF(infile,'FLUX_BKG',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err, status = \
kepio.readTPF(infile,'FLUX_BKG_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr1, status = \
kepio.readTPF(infile,'POS_CORR1',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr2, status = \
kepio.readTPF(infile,'POS_CORR2',logfile,verbose)
# Save original data dimensions, in case of using maskfile
if status == 0:
xdimorig = xdim
ydimorig = ydim
# read mask definition file if it has been supplied
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
maskx = array([],'int')
masky = array([],'int')
lines, status = kepio.openascii(maskfile,'r',logfile,verbose)
for line in lines:
line = line.strip().split('|')
if len(line) == 6:
y0 = int(line[3])
x0 = int(line[4])
line = line[5].split(';')
for items in line:
try:
masky = numpy.append(masky,y0 + int(items.split(',')[0]))
maskx = numpy.append(maskx,x0 + int(items.split(',')[1]))
except:
continue
status = kepio.closeascii(lines,logfile,verbose)
if len(maskx) == 0 or len(masky) == 0:
message = 'ERROR -- KEPPCA: ' + maskfile + ' contains no pixels.'
status = kepmsg.err(logfile,message,verbose)
xdim = max(maskx) - min(maskx) + 1 # Find largest x dimension of mask
ydim = max(masky) - min(masky) + 1 # Find largest y dimension of mask
# pad mask to ensure it is rectangular
workx = array([],'int')
worky = array([],'int')
for ip in arange(min(maskx),max(maskx) + 1):
for jp in arange(min(masky),max(masky) + 1):
workx = append(workx,ip)
worky = append(worky,jp)
maskx = workx
masky = worky
# define new subimage bitmap...
if status == 0 and maskfile.lower() != 'all':
aperx = numpy.array([],'int')
apery = numpy.array([],'int')
aperb = maskx - x0 + xdimorig * (masky - y0) # aperb is an array that contains the pixel numbers in the mask
npix = len(aperb)
# ...or use all pixels
if status == 0 and maskfile.lower() == 'all':
npix = xdimorig*ydimorig
aperb = array([],'int')
aperb = numpy.r_[0:npix]
# legal mask defined?
if status == 0:
if len(aperb) == 0:
message = 'ERROR -- KEPPCA: no legal pixels within the subimage are defined.'
status = kepmsg.err(logfile,message,verbose)
# Identify principal components desired
if status == 0:
pcaout = []
txt = components.strip().split(',')
for work1 in txt:
try:
pcaout.append(int(work1.strip()))
except:
work2 = work1.strip().split('-')
try:
for work3 in range(int(work2[0]),int(work2[1]) + 1):
pcaout.append(work3)
except:
message = 'ERROR -- KEPPCA: cannot understand principal component list requested'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
pcaout = set(sort(pcaout))
pcarem = array(list(pcaout))-1 # The list of pca component numbers to be removed
# Initialize arrays and variables, and apply pixel mask to the data
if status == 0:
ntim = 0
time = numpy.array([],dtype='float64')
timecorr = numpy.array([],dtype='float32')
cadenceno = numpy.array([],dtype='int')
pixseries = numpy.array([],dtype='float32')
errseries = numpy.array([],dtype='float32')
bkgseries = numpy.array([],dtype='float32')
berseries = numpy.array([],dtype='float32')
quality = numpy.array([],dtype='float32')
pos_corr1 = numpy.array([],dtype='float32')
pos_corr2 = numpy.array([],dtype='float32')
nrows = numpy.size(fluxpixels,0)
# Apply the pixel mask so we are left with only the desired pixels
if status == 0:
pixseriesb = fluxpixels[:,aperb]
errseriesb = errpixels[:,aperb]
bkgseriesb = flux_bkg[:,aperb]
berseriesb = flux_bkg_err[:,aperb]
# Read in the data to various arrays
if status == 0:
for i in range(nrows):
if qual[i] < 10000 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,int(ydim*xdim/2+0.5)]) and \
numpy.isfinite(fluxpixels[i,1+int(ydim*xdim/2+0.5)]):
ntim += 1
time = numpy.append(time,barytime[i])
timecorr = numpy.append(timecorr,tcorr[i])
cadenceno = numpy.append(cadenceno,cadno[i])
pixseries = numpy.append(pixseries,pixseriesb[i])
errseries = numpy.append(errseries,errseriesb[i])
bkgseries = numpy.append(bkgseries,bkgseriesb[i])
berseries = numpy.append(berseries,berseriesb[i])
quality = numpy.append(quality,qual[i])
pos_corr1 = numpy.append(pos_corr1,pcorr1[i])
pos_corr2 = numpy.append(pos_corr2,pcorr2[i])
pixseries = numpy.reshape(pixseries,(ntim,npix))
errseries = numpy.reshape(errseries,(ntim,npix))
bkgseries = numpy.reshape(bkgseries,(ntim,npix))
berseries = numpy.reshape(berseries,(ntim,npix))
tmp = numpy.median(pixseries,axis=1)
for i in range(len(tmp)):
pixseries[i] = pixseries[i] - tmp[i]
# Figure out which pixels are undefined/nan and remove them. Keep track for adding back in later
if status == 0:
nanpixels = numpy.array([],dtype='int')
i = 0
while (i < npix):
if numpy.isnan(pixseries[0,i]):
nanpixels = numpy.append(nanpixels,i)
npix = npix - 1
i = i + 1
pixseries = numpy.delete(pixseries,nanpixels,1)
errseries = numpy.delete(errseries,nanpixels,1)
pixseries[numpy.isnan(pixseries)] = random.gauss(100,10)
errseries[numpy.isnan(errseries)] = 10
# Compute statistical weights, means, standard deviations
if status == 0:
weightseries = (pixseries/errseries)**2
pixMean = numpy.average(pixseries,axis=0,weights=weightseries)
pixStd = numpy.std(pixseries,axis=0)
# Normalize the input by subtracting the mean and divising by the standard deviation.
# This makes it a correlation-based PCA, which is what we want.
if status == 0:
pixseriesnorm = (pixseries - pixMean)/pixStd
# Number of principal components to compute. Setting it equal to the number of pixels
if status == 0:
nvecin = npix
# Run PCA using the MDP Whitening PCA, which produces normalized PCA components (zero mean and unit variance)
if status == 0:
pcan = mdp.nodes.WhiteningNode(svd=True)
pcar = pcan.execute(pixseriesnorm)
eigvec = pcan.get_recmatrix()
model = pcar
# Re-insert nan columns as zeros
if status == 0:
for i in range(0,len(nanpixels)):
nanpixels[i] = nanpixels[i]-i
eigvec = numpy.insert(eigvec,nanpixels,0,1)
pixMean = numpy.insert(pixMean,nanpixels,0,0)
# Make output eigenvectors (correlation images) into xpix by ypix images
if status == 0:
eigvec = eigvec.reshape(nvecin,ydim,xdim)
# Calculate sum of all pixels to display as raw lightcurve and other quantities
if status == 0:
pixseriessum = sum(pixseries,axis=1)
nrem=len(pcarem) # Number of components to remove
nplot = npix # Number of pcas to plot - currently set to plot all components, but could set
# nplot = nrem to just plot as many components as is being removed
# Subtract components by fitting them to the summed light curve
if status == 0:
x0 = numpy.tile(-1.0,1)
for k in range(0,nrem):
def f(x):
fluxcor = pixseriessum
for k in range(0,len(x)):
fluxcor = fluxcor - x[k]*model[:,pcarem[k]]
return mad(fluxcor)
if k==0:
x0 = array([-1.0])
else:
x0 = numpy.append(x0,1.0)
myfit = scipy.optimize.fmin(f,x0,maxiter=50000,maxfun=50000,disp=False)
x0 = myfit
# Now that coefficients for all components have been found, subtract them to produce a calibrated time-series,
# and then divide by the robust mean to produce a normalized time series as well
if status == 0:
c = myfit
fluxcor = pixseriessum
for k in range(0,nrem):
fluxcor = fluxcor - c[k]*model[:,pcarem[k]]
normfluxcor = fluxcor/mean(reject_outliers(fluxcor,2))
# input file data
if status == 0:
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
table = instr[1].data[:]
maskmap = copy(instr[2].data)
# subimage physical WCS data
if status == 0:
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
# dummy columns for output file
if status == 0:
sap_flux_err = numpy.empty(len(time)); sap_flux_err[:] = numpy.nan
sap_bkg = numpy.empty(len(time)); sap_bkg[:] = numpy.nan
sap_bkg_err = numpy.empty(len(time)); sap_bkg_err[:] = numpy.nan
pdc_flux = numpy.empty(len(time)); pdc_flux[:] = numpy.nan
pdc_flux_err = numpy.empty(len(time)); pdc_flux_err[:] = numpy.nan
psf_centr1 = numpy.empty(len(time)); psf_centr1[:] = numpy.nan
psf_centr1_err = numpy.empty(len(time)); psf_centr1_err[:] = numpy.nan
psf_centr2 = numpy.empty(len(time)); psf_centr2[:] = numpy.nan
psf_centr2_err = numpy.empty(len(time)); psf_centr2_err[:] = numpy.nan
mom_centr1 = numpy.empty(len(time)); mom_centr1[:] = numpy.nan
mom_centr1_err = numpy.empty(len(time)); mom_centr1_err[:] = numpy.nan
mom_centr2 = numpy.empty(len(time)); mom_centr2[:] = numpy.nan
mom_centr2_err = numpy.empty(len(time)); mom_centr2_err[:] = numpy.nan
# mask bitmap
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
if maskmap[i,j] == 0:
pass
else:
maskmap[i,j] = 1
for k in range(len(maskx)):
if aperx[-1] == maskx[k] and apery[-1] == masky[k]:
maskmap[i,j] = 3
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].keyword not in hdu0.header.keys():
hdu0.header[cards0[i].keyword] = (cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].keyword].comment = cards0[i].comment
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='SAP_FLUX',format='E',unit='e-/s',array=pixseriessum)
col5 = Column(name='SAP_FLUX_ERR',format='E',unit='e-/s',array=sap_flux_err)
col6 = Column(name='SAP_BKG',format='E',unit='e-/s',array=sap_bkg)
col7 = Column(name='SAP_BKG_ERR',format='E',unit='e-/s',array=sap_bkg_err)
col8 = Column(name='PDCSAP_FLUX',format='E',unit='e-/s',array=pdc_flux)
col9 = Column(name='PDCSAP_FLUX_ERR',format='E',unit='e-/s',array=pdc_flux_err)
col10 = Column(name='SAP_QUALITY',format='J',array=quality)
col11 = Column(name='PSF_CENTR1',format='E',unit='pixel',array=psf_centr1)
col12 = Column(name='PSF_CENTR1_ERR',format='E',unit='pixel',array=psf_centr1_err)
col13 = Column(name='PSF_CENTR2',format='E',unit='pixel',array=psf_centr2)
col14 = Column(name='PSF_CENTR2_ERR',format='E',unit='pixel',array=psf_centr2_err)
col15 = Column(name='MOM_CENTR1',format='E',unit='pixel',array=mom_centr1)
col16 = Column(name='MOM_CENTR1_ERR',format='E',unit='pixel',array=mom_centr1_err)
col17 = Column(name='MOM_CENTR2',format='E',unit='pixel',array=mom_centr2)
col18 = Column(name='MOM_CENTR2_ERR',format='E',unit='pixel',array=mom_centr2_err)
col19 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col20 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
col21 = Column(name='PCA_FLUX',format='E',unit='e-/s',array=fluxcor)
col22 = Column(name='PCA_FLUX_NRM',format='E',array=normfluxcor)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11, \
col12,col13,col14,col15,col16,col17,col18,col19,col20,col21,col22])
hdu1 = new_table(cols)
hdu1.header['TTYPE1'] = ('TIME','column title: data time stamps')
hdu1.header['TFORM1'] = ('D','data type: float64')
hdu1.header['TUNIT1'] = ('BJD - 2454833','column units: barycenter corrected JD')
hdu1.header['TDISP1'] = ('D12.7','column display format')
hdu1.header['TTYPE2'] = ('TIMECORR','column title: barycentric-timeslice correction')
hdu1.header['TFORM2'] = ('E','data type: float32')
hdu1.header['TUNIT2'] = ('d','column units: days')
hdu1.header['TTYPE3'] = ('CADENCENO','column title: unique cadence number')
hdu1.header['TFORM3'] = ('J','column format: signed integer32')
hdu1.header['TTYPE4'] = ('SAP_FLUX','column title: aperture photometry flux')
hdu1.header['TFORM4'] = ('E','column format: float32')
hdu1.header['TUNIT4'] = ('e-/s','column units: electrons per second')
hdu1.header['TTYPE5'] = ('SAP_FLUX_ERR','column title: aperture phot. flux error')
hdu1.header['TFORM5'] = ('E','column format: float32')
hdu1.header['TUNIT5'] = ('e-/s','column units: electrons per second (1-sigma)')
hdu1.header['TTYPE6'] = ('SAP_BKG','column title: aperture phot. background flux')
hdu1.header['TFORM6'] = ('E','column format: float32')
hdu1.header['TUNIT6'] = ('e-/s','column units: electrons per second')
hdu1.header['TTYPE7'] = ('SAP_BKG_ERR','column title: ap. phot. background flux error')
hdu1.header['TFORM7'] = ('E','column format: float32')
hdu1.header['TUNIT7'] = ('e-/s','column units: electrons per second (1-sigma)')
hdu1.header['TTYPE8'] = ('PDCSAP_FLUX','column title: PDC photometry flux')
hdu1.header['TFORM8'] = ('E','column format: float32')
hdu1.header['TUNIT8'] = ('e-/s','column units: electrons per second')
hdu1.header['TTYPE9'] = ('PDCSAP_FLUX_ERR','column title: PDC flux error')
hdu1.header['TFORM9'] = ('E','column format: float32')
hdu1.header['TUNIT9'] = ('e-/s','column units: electrons per second (1-sigma)')
hdu1.header['TTYPE10'] = ('SAP_QUALITY','column title: aperture photometry quality flag')
hdu1.header['TFORM10'] = ('J','column format: signed integer32')
hdu1.header['TTYPE11'] = ('PSF_CENTR1','column title: PSF fitted column centroid')
hdu1.header['TFORM11'] = ('E','column format: float32')
hdu1.header['TUNIT11'] = ('pixel','column units: pixel')
hdu1.header['TTYPE12'] = ('PSF_CENTR1_ERR','column title: PSF fitted column error')
hdu1.header['TFORM12'] = ('E','column format: float32')
hdu1.header['TUNIT12'] = ('pixel','column units: pixel')
hdu1.header['TTYPE13'] = ('PSF_CENTR2','column title: PSF fitted row centroid')
hdu1.header['TFORM13'] = ('E','column format: float32')
hdu1.header['TUNIT13'] = ('pixel','column units: pixel')
hdu1.header['TTYPE14'] = ('PSF_CENTR2_ERR','column title: PSF fitted row error')
hdu1.header['TFORM14'] = ('E','column format: float32')
hdu1.header['TUNIT14'] = ('pixel','column units: pixel')
hdu1.header['TTYPE15'] = ('MOM_CENTR1','column title: moment-derived column centroid')
hdu1.header['TFORM15'] = ('E','column format: float32')
hdu1.header['TUNIT15'] = ('pixel','column units: pixel')
hdu1.header['TTYPE16'] = ('MOM_CENTR1_ERR','column title: moment-derived column error')
hdu1.header['TFORM16'] = ('E','column format: float32')
hdu1.header['TUNIT16'] = ('pixel','column units: pixel')
hdu1.header['TTYPE17'] = ('MOM_CENTR2','column title: moment-derived row centroid')
hdu1.header['TFORM17'] = ('E','column format: float32')
hdu1.header['TUNIT17'] = ('pixel','column units: pixel')
hdu1.header['TTYPE18'] = ('MOM_CENTR2_ERR','column title: moment-derived row error')
hdu1.header['TFORM18'] = ('E','column format: float32')
hdu1.header['TUNIT18'] = ('pixel','column units: pixel')
hdu1.header['TTYPE19'] = ('POS_CORR1','column title: col correction for vel. abbern')
hdu1.header['TFORM19'] = ('E','column format: float32')
hdu1.header['TUNIT19'] = ('pixel','column units: pixel')
hdu1.header['TTYPE20'] = ('POS_CORR2','column title: row correction for vel. abbern')
hdu1.header['TFORM20'] = ('E','column format: float32')
hdu1.header['TUNIT20'] = ('pixel','column units: pixel')
hdu1.header['TTYPE21'] = ('PCA_FLUX','column title: PCA-corrected flux')
hdu1.header['TFORM21'] = ('E','column format: float32')
hdu1.header['TUNIT21'] = ('pixel','column units: e-/s')
hdu1.header['TTYPE22'] = ('PCA_FLUX_NRM','column title: normalized PCA-corrected flux')
hdu1.header['TFORM22'] = ('E','column format: float32')
hdu1.header['EXTNAME'] = ('LIGHTCURVE','name of extension')
for i in range(len(cards1)):
if (cards1[i].keyword not in hdu1.header.keys() and
cards1[i].keyword[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC']):
hdu1.header[cards1[i].keyword] = (cards1[i].value, cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].keyword not in hdu2.header.keys():
hdu2.header[cards2[i].keyword] = (cards2[i].value, cards2[i].comment)
else:
hdu2.header.cards[cards2[i].keyword].comment = cards2[i].comment
outstr.append(hdu2)
# construct principal component table
if status == 0:
cols = [Column(name='TIME',format='E',unit='BJD - 2454833',array=time)]
for i in range(len(pcar[0,:])):
colname = 'PC' + str(i + 1)
col = Column(name=colname,format='E',array=pcar[:,i])
cols.append(col)
hdu3 = new_table(ColDefs(cols))
hdu3.header['EXTNAME'] = ('PRINCIPAL_COMPONENTS','name of extension')
hdu3.header['TTYPE1'] = ('TIME','column title: data time stamps')
hdu3.header['TFORM1'] = ('D','data type: float64')
hdu3.header['TUNIT1'] = ('BJD - 2454833','column units: barycenter corrected JD')
hdu3.header['TDISP1'] = ('D12.7','column display format')
for i in range(len(pcar[0,:])):
hdu3.header['TTYPE' + str(i + 2)] = \
('PC' + str(i + 1), 'column title: principal component number' + str(i + 1))
hdu3.header['TFORM' + str(i + 2)] = ('E','column format: float32')
outstr.append(hdu3)
# write output file
if status == 0:
outstr.writeto(outfile)
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# Create PCA report
if status == 0 and plotpca:
npp = 7 # Number of plots per page
l = 1
repcnt = 1
for k in range(nreps):
# First plot of every pagewith flux image, flux and calibrated time series
status = kepplot.define(16,12,logfile,verbose)
if (k % (npp - 1) == 0):
pylab.figure(figsize=[10,16])
subplot2grid((npp,6),(0,0), colspan=2)
# imshow(log10(pixMean.reshape(xdim,ydim).T-min(pixMean)+1),interpolation="nearest",cmap='RdYlBu')
imshow(log10(flipud(pixMean.reshape(ydim,xdim))-min(pixMean)+1),interpolation="nearest",cmap='RdYlBu')
xticks([])
yticks([])
ax1 = subplot2grid((npp,6),(0,2), colspan=4)
px = copy(time) + bjdref
py = copy(pixseriessum)
px, xlab, status = kepplot.cleanx(px,logfile,verbose)
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose)
kepplot.RangeOfPlot(px,py,0.01,False)
kepplot.plot1d(px,py,cadence,lcolor,lwidth,fcolor,falpha,True)
py = copy(fluxcor)
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose)
plot(px,py,marker='.',color='r',linestyle='',markersize=1.0)
kepplot.labels('',re.sub('\)','',re.sub('Flux \(','',ylab)),'k',18)
grid()
setp(ax1.get_xticklabels(), visible=False)
# plot principal components
subplot2grid((npp,6),(l,0), colspan=2)
imshow(eigvec[k],interpolation="nearest",cmap='RdYlBu')
xlim(-0.5,xdim-0.5)
ylim(-0.5,ydim-0.5)
xticks([])
yticks([])
# The last plot on the page that should have the xlabel
if ( k% (npp - 1) == npp - 2 or k == nvecin - 1):
subplot2grid((npp,6),(l,2), colspan=4)
py = copy(model[:,k])
kepplot.RangeOfPlot(px,py,0.01,False)
kepplot.plot1d(px,py,cadence,'r',lwidth,'g',falpha,True)
kepplot.labels(xlab,'PC ' + str(k+1),'k',18)
pylab.grid()
pylab.tight_layout()
l = 1
pylab.savefig(re.sub('.png','_%d.png' % repcnt,repname))
if not cmdLine: kepplot.render(cmdLine)
repcnt += 1
# The other plots on the page that should have no xlabel
else:
ax2 = subplot2grid((npp,6),(l,2), colspan=4)
py = copy(model[:,k])
kepplot.RangeOfPlot(px,py,0.01,False)
kepplot.plot1d(px,py,cadence,'r',lwidth,'g',falpha,True)
kepplot.labels('','PC ' + str(k+1),'k',18)
grid()
setp(ax2.get_xticklabels(), visible=False)
pylab.tight_layout()
l=l+1
pylab.savefig(re.sub('.png','_%d.png' % repcnt,repname))
if not cmdLine: kepplot.render(cmdLine)
# plot style and size
if status == 0 and plotpca:
status = kepplot.define(labelsize,ticksize,logfile,verbose)
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
# plot aperture photometry and PCA corrected data
if status == 0 and plotpca:
ax = kepplot.location([0.06,0.54,0.93,0.43])
px = copy(time) + bjdref
py = copy(pixseriessum)
px, xlab, status = kepplot.cleanx(px,logfile,verbose)
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose)
kepplot.RangeOfPlot(px,py,0.01,False)
kepplot.plot1d(px,py,cadence,lcolor,lwidth,fcolor,falpha,True)
py = copy(fluxcor)
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose)
kepplot.plot1d(px,py,cadence,'r',2,fcolor,0.0,True)
pylab.setp(pylab.gca(),xticklabels=[])
kepplot.labels('',ylab,'k',24)
pylab.grid()
# plot aperture photometry and PCA corrected data
if status == 0 and plotpca:
ax = kepplot.location([0.06,0.09,0.93,0.43])
yr = array([],'float32')
npc = min([6,nrem])
for i in range(npc-1,-1,-1):
py = pcar[:,i] * c[i]
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose)
cl = float(i) / (float(npc))
kepplot.plot1d(px,py,cadence,[1.0-cl,0.0,cl],2,fcolor,0.0,True)
yr = append(yr,py)
y1 = max(yr)
y2 = -min(yr)
kepplot.RangeOfPlot(px,array([-y1,y1,-y2,y2]),0.01,False)
kepplot.labels(xlab,'Principal Components','k',24)
pylab.grid()
# save plot to file
if status == 0 and plotpca:
pylab.savefig(repname)
# render plot
if status == 0 and plotpca:
kepplot.render(cmdLine)
# stop time
if status == 0:
kepmsg.clock('KEPPCA ended at',logfile,verbose)
return
def kepfield(infile,plotfile,rownum,imscale,colmap,lcolor,srctab,verbose,logfile,status,cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFIELD -- '
call += 'infile='+infile+' '
call += 'plotfile='+plotfile+' '
call += 'rownum='+str(rownum)+' '
call += 'imscale='+imscale+' '
call += 'colmap='+colmap+' '
call += 'lcolor='+lcolor+' '
srct = 'n'
if (srctab): srct = 'y'
call += 'srctab='+srct+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPFIELD started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPFIELD: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile,message,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(infile,logfile,verbose)
# observed or simulated data?
if status == 0:
coa = False
instr = pyfits.open(infile,mode='readonly',memmap=True)
filever, status = kepkey.get(infile,instr[0],'FILEVER',logfile,verbose)
if filever == 'COA': coa = True
# print target data
if status == 0 and verbose:
print('')
print(' KepID: %s' % kepid)
print(' BJD: %.2f' % (barytime[rownum-1] + 2454833.0))
print(' RA (J2000): %s' % ra)
print('Dec (J2000): %s' % dec)
print(' KepMag: %s' % kepmag)
print(' SkyGroup: %2s' % skygroup)
print(' Season: %2s' % str(season))
print(' Channel: %2s' % channel)
print(' Module: %2s' % module)
print(' Output: %1s' % output)
print('')
# is this a good row with finite timestamp and pixels?
if status == 0:
if not numpy.isfinite(barytime[rownum-1]) or not numpy.nansum(fluxpixels[rownum-1,:]):
message = 'ERROR -- KEPFIELD: Row ' + str(rownum) + ' is a bad quality timestamp'
status = kepmsg.err(logfile,message,verbose)
# construct input pixel image
if status == 0:
flux = fluxpixels[rownum-1,:]
# image scale and intensity limits of pixel data
if status == 0:
flux_pl, zminfl, zmaxfl = kepplot.intScale1D(flux,imscale)
n = 0
imgflux_pl = empty((ydim+2,xdim+2))
for i in range(ydim+2):
for j in range(xdim+2):
imgflux_pl[i,j] = numpy.nan
for i in range(ydim):
for j in range(xdim):
imgflux_pl[i+1,j+1] = flux_pl[n]
n += 1
# cone search around target coordinates using the MAST target search form
if status == 0:
dr = max([ydim+2,xdim+2]) * 4.0
kepid,ra,dec,kepmag = MASTRADec(float(ra),float(dec),dr,srctab)
# convert celestial coordinates to detector coordinates
if status == 0:
sx = numpy.array([])
sy = numpy.array([])
inf, status = kepio.openfits(infile,'readonly',logfile,verbose)
try:
crpix1, crpix2, crval1, crval2, cdelt1, cdelt2, pc, status = \
kepkey.getWCSs(infile,inf['APERTURE'],logfile,verbose)
crpix1p, crpix2p, crval1p, crval2p, cdelt1p, cdelt2p, status = \
kepkey.getWCSp(infile,inf['APERTURE'],logfile,verbose)
for i in range(len(kepid)):
dra = (ra[i] - crval1) * math.cos(math.radians(dec[i])) / cdelt1
ddec = (dec[i] - crval2) / cdelt2
if coa:
sx = numpy.append(sx,-(pc[0,0] * dra + pc[0,1] * ddec) + crpix1 + crval1p - 1.0)
else:
sx = numpy.append(sx,pc[0,0] * dra + pc[0,1] * ddec + crpix1 + crval1p - 1.0)
sy = numpy.append(sy,pc[1,0] * dra + pc[1,1] * ddec + crpix2 + crval2p - 1.0)
except:
message = 'ERROR -- KEPFIELD: Non-compliant WCS information within file %s' % infile
status = kepmsg.err(logfile,message,verbose)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 48,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 20,
'ytick.labelsize': 20}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[10,10])
pylab.clf()
# pixel limits of the subimage
if status == 0:
ymin = copy(float(row))
ymax = ymin + ydim
xmin = copy(float(column))
xmax = xmin + xdim
# plot limits for flux image
if status == 0:
ymin = float(ymin) - 1.5
ymax = float(ymax) + 0.5
xmin = float(xmin) - 1.5
xmax = float(xmax) + 0.5
# plot the image window
if status == 0:
ax = pylab.axes([0.1,0.11,0.88,0.88])
pylab.imshow(imgflux_pl,aspect='auto',interpolation='nearest',origin='lower',
vmin=zminfl,vmax=zmaxfl,extent=(xmin,xmax,ymin,ymax),cmap=colmap)
pylab.gca().set_autoscale_on(False)
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90)
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.xlabel('Pixel Column Number', {'color' : 'k'})
pylab.ylabel('Pixel Row Number', {'color' : 'k'})
# plot mask borders
if status == 0:
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,1,lcolor,'--',0.5)
# plot aperture borders
if status == 0:
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,2,lcolor,'-',4.0)
# list sources
if status == 0:
print('Column Row RA J2000 Dec J2000 Kp Kepler ID')
print('----------------------------------------------------')
for i in range(len(sx)-1,-1,-1):
if sx[i] >= xmin and sx[i] < xmax and sy[i] >= ymin and sy[i] < ymax:
if kepid[i] != 0 and kepmag[i] != 0.0:
print('%6.1f %6.1f %9.5f %8.5f %5.2f KIC %d' % \
(float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i]),float(kepmag[i]),int(kepid[i])))
elif kepid[i] != 0 and kepmag[i] == 0.0:
print('%6.1f %6.1f %9.5f %8.5f KIC %d' % \
(float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i]),int(kepid[i])))
else:
print('%6.1f %6.1f %9.5f %8.5f' % (float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i])))
# plot sources
if status == 0:
for i in range(len(sx)-1,-1,-1):
if kepid[i] != 0 and kepmag[i] != 0.0:
size = max(array([80.0,80.0 + (2.5**(18.0 - max(12.0,float(kepmag[i])))) * 250.0]))
pylab.scatter(sx[i],sy[i],s=size,facecolors='g',edgecolors='k',alpha=0.4)
else:
pylab.scatter(sx[i],sy[i],s=80,facecolors='r',edgecolors='k',alpha=0.4)
# render plot
if status == 0 and len(plotfile) > 0 and plotfile.lower() != 'none':
pylab.savefig(plotfile)
if status == 0:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\nKEPFIELD ended at',logfile,verbose)
return
def kepfoldimg(infile,outfile,datacol,period,phasezero,binmethod,threshold,niter,nbins,
plot,plotlab,clobber,verbose,logfile,status):
# startup parameters
status = 0
labelsize = 24; ticksize = 16; xsize = 17; ysize = 7
lcolor = '#0000ff'; lwidth = 1.0; fcolor = '#ffff00'; falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFOLD -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
call += 'period='+str(period)+' '
call += 'phasezero='+str(phasezero)+' '
call += 'binmethod='+binmethod+' '
call += 'threshold='+str(threshold)+' '
call += 'niter='+str(niter)+' '
call += 'nbins='+str(nbins)+' '
plotres = 'n'
if (plot): plotres = 'y'
call += 'plot='+plotres+ ' '
call += 'plotlab='+plotlab+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPFOLDIMG started at: ',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFOLDIMG: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,infile,logfile,verbose)
# input data
if status == 0:
table = instr[1].data
incards = instr[1].header.cards
indata, status = kepio.readfitscol(infile,table,datacol,logfile,verbose)
barytime, status = kepio.readtimecol(infile,table,logfile,verbose)
# filter out NaNs
work1 = []; work2 = []
if status == 0:
for i in range(len(barytime)):
if (numpy.isfinite(barytime[i]) and
numpy.isfinite(indata[i]) and indata[i] != 0.0):
work1.append(barytime[i])
work2.append(indata[i])
barytime = array(work1,dtype='float64')
indata = array(work2,dtype='float32')
# calculate phase
if status == 0:
phase2 = []
phase1 = (barytime - phasezero) / period
for i in range(len(phase1)):
phase2.append(phase1[i] - int(phase1[i]))
if phase2[-1] < 0.0: phase2[-1] += 1.0
phase2 = array(phase2,'float32')
# sort phases
if status == 0:
ptuple = []
phase3 = []
data3 = []
for i in range(len(phase2)):
ptuple.append([phase2[i], indata[i]])
phsort = sorted(ptuple,key=lambda ph: ph[0])
for i in range(len(phsort)):
phase3.append(phsort[i][0])
data3.append(phsort[i][1])
phase3 = array(phase3,'float32')
data3 = array(data3,'float32')
# bin phases
if status == 0:
work1 = array([data3[0]],'float32')
phase4 = array([],'float32')
data4 = array([],'float32')
dt = (phase3[-1] - phase3[0]) / nbins
nb = 0.0
for i in range(len(phase3)):
if phase3[i] < phase3[0] + nb * dt or phase3[i] >= phase3[0] + (nb + 1.0) * dt:
if len(work1) > 0:
phase4 = append(phase4,phase3[0] + (nb + 0.5) * dt)
if (binmethod == 'mean'):
data4 = append(data4,kepstat.mean(work1))
elif (binmethod == 'median'):
data4 = append(data4,kepstat.median(work1,logfile))
else:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip('poly0',[1.0],arange(0.0,float(len(work1)),1.0),work1,None,
threshold,threshold,niter,logfile,verbose)
data4 = append(data4,coeffs[0])
work1 = array([],'float32')
nb += 1.0
else:
work1 = append(work1,data3[i])
# update HDU1 for output file
if status == 0:
cols = (instr[1].columns + ColDefs([Column(name='PHASE',format='E',array=phase1)]))
instr[1] = pyfits.new_table(cols)
instr[1].header.cards['TTYPE20'].comment = 'column title: phase'
instr[1].header.cards['TFORM20'].comment = 'data type: float32'
for i in range(len(incards)):
if incards[i].key not in instr[1].header.keys():
instr[1].header.update(incards[i].key, incards[i].value, incards[i].comment)
else:
instr[1].header.cards[incards[i].key].comment = incards[i].comment
instr[1].header.update('PERIOD',period,'period defining the phase [d]')
instr[1].header.update('BJD0',phasezero,'time of phase zero [BJD]')
# write new phased data extension for output file
if status == 0:
col1 = Column(name='PHASE',format='E',array=phase4)
col2 = Column(name=datacol,format='E',unit='e/s',array=data4/cadence)
cols = ColDefs([col1,col2])
instr.append(new_table(cols))
instr[-1].header.cards['TTYPE1'].comment = 'column title: phase'
instr[-1].header.cards['TTYPE2'].comment = 'column title: simple aperture photometry'
instr[-1].header.cards['TFORM1'].comment = 'column type: float32'
instr[-1].header.cards['TFORM2'].comment = 'column type: float32'
instr[-1].header.cards['TUNIT2'].comment = 'column units: electrons per second'
instr[-1].header.update('EXTNAME','FOLDED','extension name')
instr[-1].header.update('PERIOD',period,'period defining the phase [d]')
instr[-1].header.update('BJD0',phasezero,'time of phase zero [BJD]')
instr[-1].header.update('BINMETHD',binmethod,'phase binning method')
if binmethod =='sigclip':
instr[-1].header.update('THRSHOLD',threshold,'sigma-clipping threshold [sigma]')
instr[-1].header.update('NITER',niter,'max number of sigma-clipping iterations')
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# clean up x-axis unit
if status == 0:
ptime = array([],'float32')
pout = array([],'float32')
work = data4
for i in range(len(phase4)):
if (phase4[i] > 0.5):
ptime = append(ptime,phase4[i] - 1.0)
pout = append(pout,work[i] / cadence)
ptime = append(ptime,phase4)
pout = append(pout,work / cadence)
for i in range(len(phase4)):
if (phase4[i] <= 0.5):
ptime = append(ptime,phase4[i] + 1.0)
pout = append(pout,work[i] / cadence)
xlab = 'Phase ($\phi$)'
# clean up y-axis units
if status == 0:
nrm = len(str(int(pout.max())))-1
pout = pout / 10**nrm
ylab = '10$^%d$ %s' % (nrm, plotlab)
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
# plot new light curve
if status == 0 and plot:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
pylab.rcParams.update(params)
except:
print 'ERROR -- KEPFOLD: install latex for scientific plotting'
status = 1
if status == 0 and plot:
pylab.figure(1,figsize=[17,7])
pylab.clf()
pylab.axes([0.06,0.1,0.93,0.87])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.plot(ptime,pout,color=lcolor,linestyle='-',linewidth=lwidth)
fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
xlabel(xlab, {'color' : 'k'})
ylabel(ylab, {'color' : 'k'})
xlim(-0.49999,1.49999)
if ymin >= 0.0:
ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
ylim(1.0e-10,ymax+yr*0.01)
pylab.grid()
pylab.draw()
# stop time
kepmsg.clock('KEPFOLDIMG ended at: ',logfile,verbose)
def kepwindow(infile,
outfile,
fcol,
fmax,
nfreq,
plot,
clobber,
verbose,
logfile,
status,
cmdLine=False):
## startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 18
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
## log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPWINDOW -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'fcol=' + fcol + ' '
call += 'fmax=' + str(fmax) + ' '
call += 'nfreq=' + str(nfreq) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
## start time
kepmsg.clock('KEPWINDOW started at', logfile, verbose)
## test log file
logfile = kepmsg.test(logfile)
## clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPWINDOW: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile, message, verbose)
## open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
## fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
## read table columns
if status == 0:
try:
barytime = instr[1].data.field('barytime')
except:
barytime, status = kepio.readfitscol(infile, instr[1].data, 'time',
logfile, verbose)
signal, status = kepio.readfitscol(infile, instr[1].data, fcol,
logfile, verbose)
## remove infinite data from time series
if status == 0:
incols = [barytime, signal]
outcols = kepstat.removeinfinlc(signal, incols)
barytime = outcols[0]
signal = outcols[1]
## reset signal data to zero
if status == 0:
signal = ones(len(outcols[1]))
## frequency steps
if status == 0:
deltaf = fmax / nfreq
## loop through frequency steps; determine FT power
if status == 0:
fr, power = kepfourier.ft(barytime, signal, 0.0, fmax, deltaf, True)
power[0] = 1.0
## mirror window function around ordinate
if status == 0:
work1 = []
work2 = []
for i in range(len(fr) - 1, 0, -1):
work1.append(-fr[i])
work2.append(power[i])
for i in range(len(fr)):
work1.append(fr[i])
work2.append(power[i])
fr = array(work1, dtype='float32')
power = array(work2, dtype='float32')
## write output file
if status == 0:
col1 = Column(name='FREQUENCY', format='E', unit='days', array=fr)
col2 = Column(name='POWER', format='E', array=power)
cols = ColDefs([col1, col2])
instr.append(new_table(cols))
instr[-1].header.update('EXTNAME', 'WINDOW FUNCTION', 'extension name')
## comment keyword in output file
if status == 0:
status = kepkey.comment(call, instr[0], outfile, logfile, verbose)
instr.writeto(outfile)
## close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
## data limits
if status == 0:
nrm = len(str(int(power.max()))) - 1
power = power / 10**nrm
ylab = 'Power (x10$^%d$)' % nrm
xmin = fr.min()
xmax = fr.max()
ymin = power.min()
ymax = power.max()
xr = xmax - xmin
yr = ymax - ymin
fr = insert(fr, [0], fr[0])
fr = append(fr, fr[-1])
power = insert(power, [0], 0.0)
power = append(power, 0.0)
## plot power spectrum
if status == 0 and plot:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
print('ERROR -- KEPWINDOW: install latex for scientific plotting')
status = 1
if status == 0 and plot:
pylab.figure(1, figsize=[xsize, ysize])
pylab.axes([0.06, 0.113, 0.93, 0.86])
pylab.plot(fr, power, color=lcolor, linestyle='-', linewidth=lwidth)
fill(fr, power, color=fcolor, linewidth=0.0, alpha=falpha)
xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin - yr * 0.01 <= 0.0:
ylim(1.0e-10, ymax + yr * 0.01)
else:
ylim(ymin - yr * 0.01, ymax + yr * 0.01)
xlabel(r'Frequency (d$^{-1}$)', {'color': 'k'})
ylabel('Power', {'color': 'k'})
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
## end time
if (status == 0):
message = 'KEPWINDOW completed at'
else:
message = '\nKEPWINDOW aborted at'
kepmsg.clock(message, logfile, verbose)
def kepextract(infile,maskfile,outfile,subback,clobber,verbose,logfile,status):
# startup parameters
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPEXTRACT -- '
call += 'infile='+infile+' '
call += 'maskfile='+maskfile+' '
call += 'outfile='+outfile+' '
backgr = 'n'
if (subback): backgr = 'y'
call += 'background='+backgr+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPEXTRACT started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPEXTRACT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
status = 0
instr = pyfits.open(infile,mode='readonly',memmap=True)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# input file data
if status == 0:
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
table = instr[1].data[:]
maskmap = copy(instr[2].data)
# input table data
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, time, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
time = numpy.array(time,dtype='float64')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, timecorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
timecorr = numpy.array(timecorr,dtype='float32')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadenceno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
cadenceno = numpy.array(cadenceno,dtype='int')
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, raw_cnts, status = \
kepio.readTPF(infile,'RAW_CNTS',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_err, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg, status = \
kepio.readTPF(infile,'FLUX_BKG',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err, status = \
kepio.readTPF(infile,'FLUX_BKG_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cosmic_rays, status = \
kepio.readTPF(infile,'COSMIC_RAYS',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, quality, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
quality = numpy.array(quality,dtype='int')
if status == 0:
try:
pos_corr1 = numpy.array(table.field('POS_CORR1'),dtype='float64') # ---for FITS wave #2
except:
pos_corr1 = empty(len(time)); pos_corr1[:] = numpy.nan # ---temporary before FITS wave #2
try:
pos_corr2 = numpy.array(table.field('POS_CORR2'),dtype='float64') # ---for FITS wave #2
except:
pos_corr2 = empty(len(time)); pos_corr2[:] = numpy.nan # ---temporary before FITS wave #2
# dummy columns for output file
psf_centr1 = empty(len(time)); psf_centr1[:] = numpy.nan
psf_centr1_err = empty(len(time)); psf_centr1_err[:] = numpy.nan
psf_centr2 = empty(len(time)); psf_centr2[:] = numpy.nan
psf_centr2_err = empty(len(time)); psf_centr2_err[:] = numpy.nan
# mom_centr1 = empty(len(time)); mom_centr1[:] = numpy.nan
mom_centr1_err = empty(len(time)); mom_centr1_err[:] = numpy.nan
# mom_centr2 = empty(len(time)); mom_centr2[:] = numpy.nan
mom_centr2_err = empty(len(time)); mom_centr2_err[:] = numpy.nan
# read mask definition file
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
maskx = array([],'int')
masky = array([],'int')
lines, status = kepio.openascii(maskfile,'r',logfile,verbose)
for line in lines:
line = line.strip().split('|')
if len(line) == 6:
y0 = int(line[3])
x0 = int(line[4])
line = line[5].split(';')
for items in line:
try:
masky = append(masky,y0 + int(items.split(',')[0]))
maskx = append(maskx,x0 + int(items.split(',')[1]))
except:
continue
status = kepio.closeascii(lines,logfile,verbose)
if len(maskx) == 0 or len(masky) == 0:
message = 'ERROR -- KEPEXTRACT: ' + maskfile + ' contains no pixels.'
status = kepmsg.err(logfile,message,verbose)
# subimage physical WCS data
if status == 0:
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
# define new subimage bitmap...
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
aperx = array([],'int')
apery = array([],'int')
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
if maskmap[i,j] == 0:
aperb = append(aperb,0)
else:
aperb = append(aperb,1)
maskmap[i,j] = 1
for k in range(len(maskx)):
if aperx[-1] == maskx[k] and apery[-1] == masky[k]:
aperb[-1] = 3
maskmap[i,j] = 3
# trap case where no aperture needs to be defined but pixel positions are still required for centroiding
if status == 0 and maskfile.lower() == 'all':
aperx = array([],'int')
apery = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
# ...or use old subimage bitmap
if status == 0 and 'aper' in maskfile.lower():
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperb = append(aperb,maskmap[i,j])
# ...or use all pixels
if status == 0 and maskfile.lower() == 'all':
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
if maskmap[i,j] == 0:
aperb = append(aperb,0)
else:
aperb = append(aperb,3)
maskmap[i,j] = 3
# subtract median pixel value for background?
if status == 0:
sky = array([],'float32')
for i in range(len(time)):
sky = append(sky,median(flux[i,:]))
if not subback:
sky[:] = 0.0
# legal mask defined?
if status == 0:
if len(aperb) == 0:
message = 'ERROR -- KEPEXTRACT: no legal pixels within the subimage are defined.'
status = kepmsg.err(logfile,message,verbose)
# construct new table flux data
if status == 0:
naper = (aperb == 3).sum()
ntime = len(time)
sap_flux = array([],'float32')
sap_flux_err = array([],'float32')
sap_bkg = array([],'float32')
sap_bkg_err = array([],'float32')
raw_flux = array([],'float32')
for i in range(len(time)):
work1 = array([],'float64')
work2 = array([],'float64')
work3 = array([],'float64')
work4 = array([],'float64')
work5 = array([],'float64')
for j in range(len(aperb)):
if (aperb[j] == 3):
work1 = append(work1,flux[i,j]-sky[i])
work2 = append(work2,flux_err[i,j])
work3 = append(work3,flux_bkg[i,j])
work4 = append(work4,flux_bkg_err[i,j])
work5 = append(work5,raw_cnts[i,j])
sap_flux = append(sap_flux,kepstat.sum(work1))
sap_flux_err = append(sap_flux_err,kepstat.sumerr(work2))
sap_bkg = append(sap_bkg,kepstat.sum(work3))
sap_bkg_err = append(sap_bkg_err,kepstat.sumerr(work4))
raw_flux = append(raw_flux,kepstat.sum(work5))
# construct new table moment data
if status == 0:
mom_centr1 = zeros(shape=(ntime))
mom_centr2 = zeros(shape=(ntime))
mom_centr1_err = zeros(shape=(ntime))
mom_centr2_err = zeros(shape=(ntime))
for i in range(ntime):
xf = zeros(shape=(naper))
yf = zeros(shape=(naper))
f = zeros(shape=(naper))
xfe = zeros(shape=(naper))
yfe = zeros(shape=(naper))
fe = zeros(shape=(naper))
k = -1
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
xf[k] = aperx[j] * flux[i,j]
xfe[k] = aperx[j] * flux_err[i,j]
yf[k] = apery[j] * flux[i,j]
yfe[k] = apery[j] * flux_err[i,j]
f[k] = flux[i,j]
fe[k] = flux_err[i,j]
xfsum = kepstat.sum(xf)
yfsum = kepstat.sum(yf)
fsum = kepstat.sum(f)
xfsume = sqrt(kepstat.sum(square(xfe)) / naper)
yfsume = sqrt(kepstat.sum(square(yfe)) / naper)
fsume = sqrt(kepstat.sum(square(fe)) / naper)
mom_centr1[i] = xfsum / fsum
mom_centr2[i] = yfsum / fsum
mom_centr1_err[i] = sqrt((xfsume / xfsum)**2 + ((fsume / fsum)**2))
mom_centr2_err[i] = sqrt((yfsume / yfsum)**2 + ((fsume / fsum)**2))
mom_centr1_err = mom_centr1_err * mom_centr1
mom_centr2_err = mom_centr2_err * mom_centr2
# construct new table PSF data
if status == 0:
psf_centr1 = zeros(shape=(ntime))
psf_centr2 = zeros(shape=(ntime))
psf_centr1_err = zeros(shape=(ntime))
psf_centr2_err = zeros(shape=(ntime))
modx = zeros(shape=(naper))
mody = zeros(shape=(naper))
k = -1
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
modx[k] = aperx[j]
mody[k] = apery[j]
for i in range(ntime):
modf = zeros(shape=(naper))
k = -1
guess = [mom_centr1[i], mom_centr2[i], nanmax(flux[i:]), 1.0, 1.0, 0.0, 0.0]
for j in range(len(aperb)):
if (aperb[j] == 3):
k += 1
modf[k] = flux[i,j]
args = (modx, mody, modf)
ans = leastsq(kepfunc.PRFgauss2d,guess,args=args,xtol=1.0e-8,ftol=1.0e-4,full_output=True)
s_sq = (ans[2]['fvec']**2).sum() / (ntime-len(guess))
psf_centr1[i] = ans[0][0]
psf_centr2[i] = ans[0][1]
try:
psf_centr1_err[i] = sqrt(diag(ans[1] * s_sq))[0]
except:
psf_centr1_err[i] = numpy.nan
try:
psf_centr2_err[i] = sqrt(diag(ans[1] * s_sq))[1]
except:
psf_centr2_err[i] = numpy.nan
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].key not in hdu0.header.keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='SAP_FLUX',format='E',array=sap_flux)
col5 = Column(name='SAP_FLUX_ERR',format='E',array=sap_flux_err)
col6 = Column(name='SAP_BKG',format='E',array=sap_bkg)
col7 = Column(name='SAP_BKG_ERR',format='E',array=sap_bkg_err)
col8 = Column(name='PDCSAP_FLUX',format='E',array=sap_flux)
col9 = Column(name='PDCSAP_FLUX_ERR',format='E',array=sap_flux_err)
col10 = Column(name='SAP_QUALITY',format='J',array=quality)
col11 = Column(name='PSF_CENTR1',format='E',unit='pixel',array=psf_centr1)
col12 = Column(name='PSF_CENTR1_ERR',format='E',unit='pixel',array=psf_centr1_err)
col13 = Column(name='PSF_CENTR2',format='E',unit='pixel',array=psf_centr2)
col14 = Column(name='PSF_CENTR2_ERR',format='E',unit='pixel',array=psf_centr2_err)
col15 = Column(name='MOM_CENTR1',format='E',unit='pixel',array=mom_centr1)
col16 = Column(name='MOM_CENTR1_ERR',format='E',unit='pixel',array=mom_centr1_err)
col17 = Column(name='MOM_CENTR2',format='E',unit='pixel',array=mom_centr2)
col18 = Column(name='MOM_CENTR2_ERR',format='E',unit='pixel',array=mom_centr2_err)
col19 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col20 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
col21 = Column(name='RAW_FLUX',format='E',array=raw_flux)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11, \
col12,col13,col14,col15,col16,col17,col18,col19,col20,col21])
hdu1 = new_table(cols)
hdu1.header.update('TTYPE1','TIME','column title: data time stamps')
hdu1.header.update('TFORM1','D','data type: float64')
hdu1.header.update('TUNIT1','BJD - 2454833','column units: barycenter corrected JD')
hdu1.header.update('TDISP1','D12.7','column display format')
hdu1.header.update('TTYPE2','TIMECORR','column title: barycentric-timeslice correction')
hdu1.header.update('TFORM2','E','data type: float32')
hdu1.header.update('TUNIT2','d','column units: days')
hdu1.header.update('TTYPE3','CADENCENO','column title: unique cadence number')
hdu1.header.update('TFORM3','J','column format: signed integer32')
hdu1.header.update('TTYPE4','SAP_FLUX','column title: aperture photometry flux')
hdu1.header.update('TFORM4','E','column format: float32')
hdu1.header.update('TUNIT4','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE5','SAP_FLUX_ERR','column title: aperture phot. flux error')
hdu1.header.update('TFORM5','E','column format: float32')
hdu1.header.update('TUNIT5','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE6','SAP_BKG','column title: aperture phot. background flux')
hdu1.header.update('TFORM6','E','column format: float32')
hdu1.header.update('TUNIT6','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE7','SAP_BKG_ERR','column title: ap. phot. background flux error')
hdu1.header.update('TFORM7','E','column format: float32')
hdu1.header.update('TUNIT7','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE8','PDCSAP_FLUX','column title: PDC photometry flux')
hdu1.header.update('TFORM8','E','column format: float32')
hdu1.header.update('TUNIT8','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE9','PDCSAP_FLUX_ERR','column title: PDC flux error')
hdu1.header.update('TFORM9','E','column format: float32')
hdu1.header.update('TUNIT9','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE10','SAP_QUALITY','column title: aperture photometry quality flag')
hdu1.header.update('TFORM10','J','column format: signed integer32')
hdu1.header.update('TTYPE11','PSF_CENTR1','column title: PSF fitted column centroid')
hdu1.header.update('TFORM11','E','column format: float32')
hdu1.header.update('TUNIT11','pixel','column units: pixel')
hdu1.header.update('TTYPE12','PSF_CENTR1_ERR','column title: PSF fitted column error')
hdu1.header.update('TFORM12','E','column format: float32')
hdu1.header.update('TUNIT12','pixel','column units: pixel')
hdu1.header.update('TTYPE13','PSF_CENTR2','column title: PSF fitted row centroid')
hdu1.header.update('TFORM13','E','column format: float32')
hdu1.header.update('TUNIT13','pixel','column units: pixel')
hdu1.header.update('TTYPE14','PSF_CENTR2_ERR','column title: PSF fitted row error')
hdu1.header.update('TFORM14','E','column format: float32')
hdu1.header.update('TUNIT14','pixel','column units: pixel')
hdu1.header.update('TTYPE15','MOM_CENTR1','column title: moment-derived column centroid')
hdu1.header.update('TFORM15','E','column format: float32')
hdu1.header.update('TUNIT15','pixel','column units: pixel')
hdu1.header.update('TTYPE16','MOM_CENTR1_ERR','column title: moment-derived column error')
hdu1.header.update('TFORM16','E','column format: float32')
hdu1.header.update('TUNIT16','pixel','column units: pixel')
hdu1.header.update('TTYPE17','MOM_CENTR2','column title: moment-derived row centroid')
hdu1.header.update('TFORM17','E','column format: float32')
hdu1.header.update('TUNIT17','pixel','column units: pixel')
hdu1.header.update('TTYPE18','MOM_CENTR2_ERR','column title: moment-derived row error')
hdu1.header.update('TFORM18','E','column format: float32')
hdu1.header.update('TUNIT18','pixel','column units: pixel')
hdu1.header.update('TTYPE19','POS_CORR1','column title: col correction for vel. abbern')
hdu1.header.update('TFORM19','E','column format: float32')
hdu1.header.update('TUNIT19','pixel','column units: pixel')
hdu1.header.update('TTYPE20','POS_CORR2','column title: row correction for vel. abbern')
hdu1.header.update('TFORM20','E','column format: float32')
hdu1.header.update('TUNIT20','pixel','column units: pixel')
hdu1.header.update('TTYPE21','RAW_FLUX','column title: raw aperture photometry flux')
hdu1.header.update('TFORM21','E','column format: float32')
hdu1.header.update('TUNIT21','e-/s','column units: electrons per second')
hdu1.header.update('EXTNAME','LIGHTCURVE','name of extension')
for i in range(len(cards1)):
if (cards1[i].key not in hdu1.header.keys() and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].key not in hdu2.header.keys():
hdu2.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
else:
hdu2.header.cards[cards2[i].key].comment = cards2[i].comment
outstr.append(hdu2)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
kepmsg.clock('KEPEXTRACT finished at',logfile,verbose)
def kepcotrendsc(infile, outfile, bvfile, listbv, fitmethod, fitpower, iterate,
sigma, maskfile, scinterp, plot, clobber, verbose, logfile,
status):
"""
Setup the kepcotrend environment
infile:
the input file in the FITS format obtained from MAST
outfile:
The output will be a fits file in the same style as the input file but with two additional columns: CBVSAP_MODL and CBVSAP_FLUX. The first of these is the best fitting linear combination of basis vectors. The second is the new flux with the basis vector sum subtracted. This is the new flux value.
plot:
either True or False if you want to see a plot of the light curve
The top plot shows the original light curve in blue and the sum of basis vectors in red
The bottom plot has had the basis vector sum subracted
bvfile:
the name of the FITS file containing the basis vectors
listbv:
the basis vectors to fit to the data
fitmethod:
fit using either the 'llsq' or the 'simplex' method. 'llsq' is usually the correct one to use because as the basis vectors are orthogonal. Simplex gives you option of using a different merit function - ie. you can minimise the least absolute residual instead of the least squares which weights outliers less
fitpower:
if using a simplex you can chose your own power in the metir function - i.e. the merit function minimises abs(Obs - Mod)^P. P=2 is least squares, P = 1 minimises least absolutes
iterate:
should the program fit the basis vectors to the light curve data then remove data points further than 'sigma' from the fit and then refit
maskfile:
this is the name of a mask file which can be used to define regions of the flux time series to exclude from the fit. The easiest way to create this is by using keprange from the PyKE set of tools. You can also make this yourself with two BJDs on each line in the file specifying the beginning and ending date of the region to exclude.
scinterp:
the basis vectors are only calculated for long cadence data, therefore if you want to use short cadence data you have to interpolate the basis vectors. There are several methods to do this, the best of these probably being nearest which picks the value of the nearest long cadence data point.
The options available are None|linear|nearest|zero|slinear|quadratic|cubic
If you are using short cadence data don't choose none
"""
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPCOTREND -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'bvfile=' + bvfile + ' '
# call += 'numpcomp= '+str(numpcomp)+' '
call += 'listbv= ' + str(listbv) + ' '
call += 'fitmethod=' + str(fitmethod) + ' '
call += 'fitpower=' + str(fitpower) + ' '
iterateit = 'n'
if (iterate): iterateit = 'y'
call += 'iterate=' + iterateit + ' '
call += 'sigma_clip=' + str(sigma) + ' '
call += 'mask_file=' + maskfile + ' '
call += 'scinterp=' + str(scinterp) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPCOTREND started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber:
status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPCOTREND: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
if status == 0:
if not kepio.fileexists(bvfile):
message = 'ERROR -- KEPCOTREND: ' + bvfile + ' does not exist.'
status = kepmsg.err(logfile, message, verbose)
#lsq_sq - nonlinear least squares fitting and simplex_abs have been removed from the option in PyRAF but they are still in the code!
if status == 0:
if fitmethod not in [
'llsq', 'matrix', 'lst_sq', 'simplex_abs', 'simplex'
]:
message = 'Fit method must either: llsq, matrix, lst_sq or simplex'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
if not is_numlike(fitpower) and fitpower is not None:
message = 'Fit power must be an real number or None'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
if fitpower is None:
fitpower = 1.
# input data
if status == 0:
short = False
try:
test = str(instr[0].header['FILEVER'])
version = 2
except KeyError:
version = 1
table = instr[1].data
if version == 1:
if str(instr[1].header['DATATYPE']) == 'long cadence':
#print 'Light curve was taken in Lond Cadence mode!'
quarter = str(instr[1].header['QUARTER'])
module = str(instr[1].header['MODULE'])
output = str(instr[1].header['OUTPUT'])
channel = str(instr[1].header['CHANNEL'])
lc_cad_o = table.field('cadence_number')
lc_date_o = table.field('barytime')
lc_flux_o = table.field(
'ap_raw_flux') / 1625.3468 #convert to e-/s
lc_err_o = table.field(
'ap_raw_err') / 1625.3468 #convert to e-/s
elif str(instr[1].header['DATATYPE']) == 'short cadence':
short = True
#print 'Light curve was taken in Short Cadence mode!'
quarter = str(instr[1].header['QUARTER'])
module = str(instr[1].header['MODULE'])
output = str(instr[1].header['OUTPUT'])
channel = str(instr[1].header['CHANNEL'])
lc_cad_o = table.field('cadence_number')
lc_date_o = table.field('barytime')
lc_flux_o = table.field(
'ap_raw_flux') / 54.178 #convert to e-/s
lc_err_o = table.field('ap_raw_err') / 54.178 #convert to e-/s
elif version == 2:
if str(instr[0].header['OBSMODE']) == 'long cadence':
#print 'Light curve was taken in Long Cadence mode!'
quarter = str(instr[0].header['QUARTER'])
module = str(instr[0].header['MODULE'])
output = str(instr[0].header['OUTPUT'])
channel = str(instr[0].header['CHANNEL'])
lc_cad_o = table.field('CADENCENO')
lc_date_o = table.field('TIME')
lc_flux_o = table.field('SAP_FLUX')
lc_err_o = table.field('SAP_FLUX_ERR')
elif str(instr[0].header['OBSMODE']) == 'short cadence':
#print 'Light curve was taken in Short Cadence mode!'
short = True
quarter = str(instr[0].header['QUARTER'])
module = str(instr[0].header['MODULE'])
output = str(instr[0].header['OUTPUT'])
channel = str(instr[0].header['CHANNEL'])
lc_cad_o = table.field('CADENCENO')
lc_date_o = table.field('TIME')
lc_flux_o = table.field('SAP_FLUX')
lc_err_o = table.field('SAP_FLUX_ERR')
if str(quarter) == str(4) and version == 1:
lc_cad_o = lc_cad_o[lc_cad_o >= 11914]
lc_date_o = lc_date_o[lc_cad_o >= 11914]
lc_flux_o = lc_flux_o[lc_cad_o >= 11914]
lc_err_o = lc_err_o[lc_cad_o >= 11914]
# bvfilename = '%s/Q%s_%s_%s_map.txt' %(bvfile,quarter,module,output)
# if str(quarter) == str(5):
# bvdata = genfromtxt(bvfilename)
# elif str(quarter) == str(3) or str(quarter) == str(4):
# bvdata = genfromtxt(bvfilename,skip_header=22)
# elif str(quarter) == str(1):
# bvdata = genfromtxt(bvfilename,skip_header=10)
# else:
# bvdata = genfromtxt(bvfilename,skip_header=13)
if short and scinterp == 'None':
message = 'You cannot select None as the interpolation method because you are using short cadence data and therefore must use some form of interpolation. I reccommend nearest if you are unsure.'
status = kepmsg.err(logfile, message, verbose)
bvfiledata = pyfits.open(bvfile)
bvdata = bvfiledata['MODOUT_%s_%s' % (module, output)].data
if int(bvfiledata[0].header['QUARTER']) != int(quarter):
message = 'CBV file and light curve file are from different quarters. CBV file is from Q%s and light curve is from Q%s' % (
int(bvfiledata[0].header['QUARTER']), int(quarter))
status = kepmsg.err(logfile, message, verbose)
if status == 0:
if int(quarter) == 4 and int(module) == 3:
message = 'Approximately twenty days into Q4 Module 3 failed. As a result, Q4 light curves contain these 20 day of data. However, we do not calculate CBVs for this section of data.'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
#cut out infinites and zero flux columns
lc_cad, lc_date, lc_flux, lc_err, bad_data = cutBadData(
lc_cad_o, lc_date_o, lc_flux_o, lc_err_o)
#get a list of basis vectors to use from the list given
#accept different seperators
listbv = listbv.strip()
if listbv[1] in [' ', ',', ':', ';', '|', ', ']:
separator = str(listbv)[1]
else:
message = 'You must separate your basis vector numbers to use with \' \' \',\' \':\' \';\' or \'|\' and the first basis vector to use must be between 1 and 9'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
bvlist = fromstring(listbv, dtype=int, sep=separator)
if bvlist[0] == 0:
message = 'Must use at least one basis vector'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
#pcomps = get_pcomp(pcompdata,n_comps,lc_cad)
# if str(quarter) == str(5):
# bvectors = get_pcomp_list(bvdata,bvlist,lc_cad)
# else:
# bvectors = get_pcomp_list_newformat(bvdata,bvlist,lc_cad)
if short:
bvdata.field('CADENCENO')[:] = (((bvdata.field('CADENCENO')[:] +
(7.5 / 15.)) * 30.) -
11540.).round()
bvectors, in1derror = get_pcomp_list_newformat(bvdata, bvlist, lc_cad,
short, scinterp)
if in1derror:
message = 'It seems that you have an old version of numpy which does not have the in1d function included. Please update your version of numpy to a version 1.4.0 or later'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
medflux = median(lc_flux)
n_flux = (lc_flux / medflux) - 1
n_err = sqrt(pow(lc_err, 2) / pow(medflux, 2))
#plt.errorbar(lc_cad,n_flux,yerr=n_err)
#plt.errorbar(lc_cad,lc_flux,yerr=lc_err)
#n_err = median(lc_err/lc_flux) * n_flux
#print n_err
#does an iterative least squares fit
#t1 = do_leastsq(pcomps,lc_cad,n_flux)
#
if maskfile != '':
domasking = True
if not kepio.fileexists(maskfile):
message = 'Maskfile %s does not exist' % maskfile
status = kepmsg.err(logfile, message, verbose)
else:
domasking = False
if status == 0:
if domasking:
lc_date_masked = copy(lc_date)
n_flux_masked = copy(n_flux)
lc_cad_masked = copy(lc_cad)
n_err_masked = copy(n_err)
maskdata = atleast_2d(genfromtxt(maskfile, delimiter=','))
#make a mask of True values incase there are not regions in maskfile to exclude.
mask = zeros(len(lc_date_masked)) == 0.
for maskrange in maskdata:
if version == 1:
start = maskrange[0] - 2400000.0
end = maskrange[1] - 2400000.0
elif version == 2:
start = maskrange[0] - 2454833.
end = maskrange[1] - 2454833.
masknew = logical_xor(lc_date < start, lc_date > end)
mask = logical_and(mask, masknew)
lc_date_masked = lc_date_masked[mask]
n_flux_masked = n_flux_masked[mask]
lc_cad_masked = lc_cad_masked[mask]
n_err_masked = n_err_masked[mask]
else:
lc_date_masked = copy(lc_date)
n_flux_masked = copy(n_flux)
lc_cad_masked = copy(lc_cad)
n_err_masked = copy(n_err)
#pcomps = get_pcomp(pcompdata,n_comps,lc_cad)
bvectors_masked, hasin1d = get_pcomp_list_newformat(
bvdata, bvlist, lc_cad_masked, short, scinterp)
if (iterate) and sigma is None:
message = 'If fitting iteratively you must specify a clipping range'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
#uses Pvals = yhat * U_transpose
if (iterate):
coeffs, fittedmask = do_lst_iter(bvectors_masked, lc_cad_masked,
n_flux_masked, sigma, 50.,
fitmethod, fitpower)
else:
if fitmethod == 'matrix' and domasking:
coeffs = do_lsq_uhat(bvectors_masked, lc_cad_masked,
n_flux_masked, False)
if fitmethod == 'llsq' and domasking:
coeffs = do_lsq_uhat(bvectors_masked, lc_cad_masked,
n_flux_masked, False)
elif fitmethod == 'lst_sq':
coeffs = do_lsq_nlin(bvectors_masked, lc_cad_masked,
n_flux_masked)
elif fitmethod == 'simplex_abs':
coeffs = do_lsq_fmin(bvectors_masked, lc_cad_masked,
n_flux_masked)
elif fitmethod == 'simplex':
coeffs = do_lsq_fmin_pow(bvectors_masked, lc_cad_masked,
n_flux_masked, fitpower)
else:
coeffs = do_lsq_uhat(bvectors_masked, lc_cad_masked,
n_flux_masked)
flux_after = (get_newflux(n_flux, bvectors, coeffs) + 1) * medflux
flux_after_masked = (
get_newflux(n_flux_masked, bvectors_masked, coeffs) + 1) * medflux
bvsum = get_pcompsum(bvectors, coeffs)
bvsum_masked = get_pcompsum(bvectors_masked, coeffs)
#print 'chi2: ' + str(chi2_gtf(n_flux,bvsum,n_err,2.*len(n_flux)-2))
#print 'rms: ' + str(rms(n_flux,bvsum))
bvsum_nans = putInNans(bad_data, bvsum)
flux_after_nans = putInNans(bad_data, flux_after)
if plot and status == 0:
bvsum_un_norm = medflux * (1 - bvsum)
#bvsum_un_norm = 0-bvsum
#lc_flux = n_flux
do_plot(lc_date, lc_flux, flux_after, bvsum_un_norm, lc_cad, bad_data,
lc_cad_o, version)
if status == 0:
make_outfile(instr, outfile, flux_after_nans, bvsum_nans, version)
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
#print some results to screen:
print(' ----- ')
if iterate:
flux_fit = n_flux_masked[fittedmask]
sum_fit = bvsum_masked[fittedmask]
err_fit = n_err_masked[fittedmask]
else:
flux_fit = n_flux_masked
sum_fit = bvsum_masked
err_fit = n_err_masked
print('reduced chi2: ' + str(
chi2_gtf(flux_fit, sum_fit, err_fit,
len(flux_fit) - len(coeffs))))
print('rms: ' + str(medflux * rms(flux_fit, sum_fit)))
for i in range(len(coeffs)):
print('Coefficient of CBV #%s: %s' % (i + 1, coeffs[i]))
print(' ----- ')
# end time
if (status == 0):
message = 'KEPCOTREND completed at'
else:
message = '\nKEPCOTTREND aborted at'
kepmsg.clock(message, logfile, verbose)
return
def keppca(infile,maskfile,outfile,components,clobber,verbose,logfile,status):
# startup parameters
cmdLine=False
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 10
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPPCA -- '
call += 'infile='+infile+' '
call += 'maskfile='+maskfile+' '
call += 'outfile='+outfile+' '
call += 'components='+components+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPPCA started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPCA: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
status = 0
instr = pyfits.open(infile,mode='readonly',memmap=True)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# input file data
if status == 0:
cards0 = instr[0].header.ascardlist()
cards1 = instr[1].header.ascardlist()
cards2 = instr[2].header.ascardlist()
table = instr[1].data[:]
maskmap = copy(instr[2].data)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg, status = \
kepio.readTPF(infile,'FLUX_BKG',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err, status = \
kepio.readTPF(infile,'FLUX_BKG_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr1, status = \
kepio.readTPF(infile,'POS_CORR1',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pcorr2, status = \
kepio.readTPF(infile,'POS_CORR2',logfile,verbose)
# read mask definition file
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
maskx = array([],'int')
masky = array([],'int')
lines, status = kepio.openascii(maskfile,'r',logfile,verbose)
for line in lines:
line = line.strip().split('|')
if len(line) == 6:
y0 = int(line[3])
x0 = int(line[4])
line = line[5].split(';')
for items in line:
try:
masky = numpy.append(masky,y0 + int(items.split(',')[0]))
maskx = numpy.append(maskx,x0 + int(items.split(',')[1]))
except:
continue
status = kepio.closeascii(lines,logfile,verbose)
if len(maskx) == 0 or len(masky) == 0:
message = 'ERROR -- KEPPCA: ' + maskfile + ' contains no pixels.'
status = kepmsg.err(logfile,message,verbose)
# subimage physical WCS data
if status == 0:
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
# define new subimage bitmap...
if status == 0 and 'aper' not in maskfile.lower() and maskfile.lower() != 'all':
aperx = numpy.array([],'int')
apery = numpy.array([],'int')
aperb = numpy.array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperx = numpy.append(aperx,crval1p + (j + 1 - crpix1p) * cdelt1p)
apery = numpy.append(apery,crval2p + (i + 1 - crpix2p) * cdelt2p)
if maskmap[i,j] == 0:
aperb = numpy.append(aperb,0)
else:
aperb = numpy.append(aperb,1)
maskmap[i,j] = 1
for k in range(len(maskx)):
if aperx[-1] == maskx[k] and apery[-1] == masky[k]:
aperb[-1] = 3
maskmap[i,j] = 3
# ...or use old subimage bitmap
if status == 0 and 'aper' in maskfile.lower():
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
aperb = numpy.append(aperb,maskmap[i,j])
# ...or use all pixels
if status == 0 and maskfile.lower() == 'all':
aperb = array([],'int')
for i in range(maskmap.shape[0]):
for j in range(maskmap.shape[1]):
if maskmap[i,j] == 0:
aperb = numpy.append(aperb,0)
else:
aperb = numpy.append(aperb,3)
maskmap[i,j] = 3
# legal mask defined?
if status == 0:
if len(aperb) == 0:
message = 'ERROR -- KEPPCA: no legal pixels within the subimage are defined.'
status = kepmsg.err(logfile,message,verbose)
# identify principal components to be combined
if status == 0:
pcaout = []
txt = components.strip().split(',')
for work1 in txt:
try:
pcaout.append(int(work1.strip()))
except:
work2 = work1.strip().split('-')
try:
for work3 in range(int(work2[0]),int(work2[1]) + 1):
pcaout.append(work3)
except:
message = 'ERROR -- KEPPCA: cannot understand principal component list requested'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
pcaout = set(sort(pcaout))
# flux pixel array size
if status == 0:
ntim = 0
time = numpy.array([],dtype='float64')
timecorr = numpy.array([],dtype='float32')
cadenceno = numpy.array([],dtype='int')
pixseries = numpy.array([],dtype='float32')
errseries = numpy.array([],dtype='float32')
bkgseries = numpy.array([],dtype='float32')
berseries = numpy.array([],dtype='float32')
quality = numpy.array([],dtype='float32')
pos_corr1 = numpy.array([],dtype='float32')
pos_corr2 = numpy.array([],dtype='float32')
nrows = numpy.size(fluxpixels,0)
npix = numpy.size(fluxpixels,1)
# remove NaN timestamps
for i in range(nrows):
if qual[i] == 0 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,ydim*xdim/2]) and \
numpy.isfinite(fluxpixels[i,1+ydim*xdim/2]):
ntim += 1
time = numpy.append(time,barytime[i])
timecorr = numpy.append(timecorr,tcorr[i])
cadenceno = numpy.append(cadenceno,cadno[i])
pixseries = numpy.append(pixseries,fluxpixels[i])
errseries = numpy.append(errseries,errpixels[i])
bkgseries = numpy.append(bkgseries,flux_bkg[i])
berseries = numpy.append(berseries,flux_bkg_err[i])
quality = numpy.append(quality,qual[i])
pos_corr1 = numpy.append(pos_corr1,pcorr1[i])
pos_corr2 = numpy.append(pos_corr2,pcorr2[i])
pixseries = numpy.reshape(pixseries,(-1,npix))
errseries = numpy.reshape(errseries,(-1,npix))
bkgseries = numpy.reshape(bkgseries,(-1,npix))
berseries = numpy.reshape(berseries,(-1,npix))
# dummy columns for output file
if status == 0:
pdc_flux = numpy.empty(len(time)); pdc_flux[:] = numpy.nan
pdc_flux_err = numpy.empty(len(time)); pdc_flux_err[:] = numpy.nan
psf_centr1 = numpy.empty(len(time)); psf_centr1[:] = numpy.nan
psf_centr1_err = numpy.empty(len(time)); psf_centr1_err[:] = numpy.nan
psf_centr2 = numpy.empty(len(time)); psf_centr2[:] = numpy.nan
psf_centr2_err = numpy.empty(len(time)); psf_centr2_err[:] = numpy.nan
mom_centr1 = numpy.empty(len(time)); mom_centr1[:] = numpy.nan
mom_centr1_err = numpy.empty(len(time)); mom_centr1_err[:] = numpy.nan
mom_centr2 = numpy.empty(len(time)); mom_centr2[:] = numpy.nan
mom_centr2_err = numpy.empty(len(time)); mom_centr2_err[:] = numpy.nan
# subtract mean over time from each pixel in the mask
if status == 0:
nmask = 0
for i in range(npix):
if aperb[i] == 3:
nmask += 1
work1 = numpy.zeros((len(pixseries),nmask))
nmask = -1
for i in range(npix):
if aperb[i] == 3:
nmask += 1
maskedFlux = numpy.ma.masked_invalid(pixseries[:,i])
pixMean = numpy.mean(maskedFlux)
if numpy.isfinite(pixMean):
work1[:,nmask] = maskedFlux - pixMean
else:
work1[:,nmask] = numpy.zeros((ntim))
# calculate covariance matrix
if status == 0:
work2 = work1.T
covariance = numpy.cov(work2)
# determine eigenfunctions and eigenvectors of the covariance matrix
if status == 0:
[latent,coeff] = numpy.linalg.eig(covariance)
# projection of the data in the new space
if status == 0:
score = numpy.dot(coeff.T,work2).T
# construct new table data
if status == 0:
sap_flux = numpy.array([],'float32')
sap_flux_err = numpy.array([],'float32')
sap_bkg = numpy.array([],'float32')
sap_bkg_err = numpy.array([],'float32')
for i in range(len(time)):
work1 = numpy.array([],'float64')
work2 = numpy.array([],'float64')
work3 = numpy.array([],'float64')
work4 = numpy.array([],'float64')
work5 = numpy.array([],'float64')
for j in range(len(aperb)):
if (aperb[j] == 3):
work1 = numpy.append(work1,pixseries[i,j])
work2 = numpy.append(work2,errseries[i,j])
work3 = numpy.append(work3,bkgseries[i,j])
work4 = numpy.append(work4,berseries[i,j])
sap_flux = numpy.append(sap_flux,kepstat.sum(work1))
sap_flux_err = numpy.append(sap_flux_err,kepstat.sumerr(work2))
sap_bkg = numpy.append(sap_bkg,kepstat.sum(work3))
sap_bkg_err = numpy.append(sap_bkg_err,kepstat.sumerr(work4))
sap_mean = scipy.stats.stats.nanmean(sap_flux)
# coadd principal components
if status == 0:
pca_flux = numpy.zeros((len(sap_flux)))
for i in range(nmask):
if (i + 1) in pcaout:
pca_flux = pca_flux + score[:,i]
pca_flux += sap_mean
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].key not in hdu0.header.ascardlist().keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.ascardlist()[cards0[i].key].comment = cards0[i].comment
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='SAP_FLUX',format='E',array=sap_flux)
col5 = Column(name='SAP_FLUX_ERR',format='E',array=sap_flux_err)
col6 = Column(name='SAP_BKG',format='E',array=sap_bkg)
col7 = Column(name='SAP_BKG_ERR',format='E',array=sap_bkg_err)
col8 = Column(name='PDCSAP_FLUX',format='E',array=pdc_flux)
col9 = Column(name='PDCSAP_FLUX_ERR',format='E',array=pdc_flux_err)
col10 = Column(name='SAP_QUALITY',format='J',array=quality)
col11 = Column(name='PSF_CENTR1',format='E',unit='pixel',array=psf_centr1)
col12 = Column(name='PSF_CENTR1_ERR',format='E',unit='pixel',array=psf_centr1_err)
col13 = Column(name='PSF_CENTR2',format='E',unit='pixel',array=psf_centr2)
col14 = Column(name='PSF_CENTR2_ERR',format='E',unit='pixel',array=psf_centr2_err)
col15 = Column(name='MOM_CENTR1',format='E',unit='pixel',array=mom_centr1)
col16 = Column(name='MOM_CENTR1_ERR',format='E',unit='pixel',array=mom_centr1_err)
col17 = Column(name='MOM_CENTR2',format='E',unit='pixel',array=mom_centr2)
col18 = Column(name='MOM_CENTR2_ERR',format='E',unit='pixel',array=mom_centr2_err)
col19 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col20 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11, \
col12,col13,col14,col15,col16,col17,col18,col19,col20])
hdu1 = new_table(cols)
hdu1.header.update('TTYPE1','TIME','column title: data time stamps')
hdu1.header.update('TFORM1','D','data type: float64')
hdu1.header.update('TUNIT1','BJD - 2454833','column units: barycenter corrected JD')
hdu1.header.update('TDISP1','D12.7','column display format')
hdu1.header.update('TTYPE2','TIMECORR','column title: barycentric-timeslice correction')
hdu1.header.update('TFORM2','E','data type: float32')
hdu1.header.update('TUNIT2','d','column units: days')
hdu1.header.update('TTYPE3','CADENCENO','column title: unique cadence number')
hdu1.header.update('TFORM3','J','column format: signed integer32')
hdu1.header.update('TTYPE4','SAP_FLUX','column title: aperture photometry flux')
hdu1.header.update('TFORM4','E','column format: float32')
hdu1.header.update('TUNIT4','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE5','SAP_FLUX_ERR','column title: aperture phot. flux error')
hdu1.header.update('TFORM5','E','column format: float32')
hdu1.header.update('TUNIT5','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE6','SAP_BKG','column title: aperture phot. background flux')
hdu1.header.update('TFORM6','E','column format: float32')
hdu1.header.update('TUNIT6','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE7','SAP_BKG_ERR','column title: ap. phot. background flux error')
hdu1.header.update('TFORM7','E','column format: float32')
hdu1.header.update('TUNIT7','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE8','PDCSAP_FLUX','column title: PDC photometry flux')
hdu1.header.update('TFORM8','E','column format: float32')
hdu1.header.update('TUNIT8','e-/s','column units: electrons per second')
hdu1.header.update('TTYPE9','PDCSAP_FLUX_ERR','column title: PDC flux error')
hdu1.header.update('TFORM9','E','column format: float32')
hdu1.header.update('TUNIT9','e-/s','column units: electrons per second (1-sigma)')
hdu1.header.update('TTYPE10','SAP_QUALITY','column title: aperture photometry quality flag')
hdu1.header.update('TFORM10','J','column format: signed integer32')
hdu1.header.update('TTYPE11','PSF_CENTR1','column title: PSF fitted column centroid')
hdu1.header.update('TFORM11','E','column format: float32')
hdu1.header.update('TUNIT11','pixel','column units: pixel')
hdu1.header.update('TTYPE12','PSF_CENTR1_ERR','column title: PSF fitted column error')
hdu1.header.update('TFORM12','E','column format: float32')
hdu1.header.update('TUNIT12','pixel','column units: pixel')
hdu1.header.update('TTYPE13','PSF_CENTR2','column title: PSF fitted row centroid')
hdu1.header.update('TFORM13','E','column format: float32')
hdu1.header.update('TUNIT13','pixel','column units: pixel')
hdu1.header.update('TTYPE14','PSF_CENTR2_ERR','column title: PSF fitted row error')
hdu1.header.update('TFORM14','E','column format: float32')
hdu1.header.update('TUNIT14','pixel','column units: pixel')
hdu1.header.update('TTYPE15','MOM_CENTR1','column title: moment-derived column centroid')
hdu1.header.update('TFORM15','E','column format: float32')
hdu1.header.update('TUNIT15','pixel','column units: pixel')
hdu1.header.update('TTYPE16','MOM_CENTR1_ERR','column title: moment-derived column error')
hdu1.header.update('TFORM16','E','column format: float32')
hdu1.header.update('TUNIT16','pixel','column units: pixel')
hdu1.header.update('TTYPE17','MOM_CENTR2','column title: moment-derived row centroid')
hdu1.header.update('TFORM17','E','column format: float32')
hdu1.header.update('TUNIT17','pixel','column units: pixel')
hdu1.header.update('TTYPE18','MOM_CENTR2_ERR','column title: moment-derived row error')
hdu1.header.update('TFORM18','E','column format: float32')
hdu1.header.update('TUNIT18','pixel','column units: pixel')
hdu1.header.update('TTYPE19','POS_CORR1','column title: col correction for vel. abbern')
hdu1.header.update('TFORM19','E','column format: float32')
hdu1.header.update('TUNIT19','pixel','column units: pixel')
hdu1.header.update('TTYPE20','POS_CORR2','column title: row correction for vel. abbern')
hdu1.header.update('TFORM20','E','column format: float32')
hdu1.header.update('TUNIT20','pixel','column units: pixel')
hdu1.header.update('EXTNAME','LIGHTCURVE','name of extension')
for i in range(len(cards1)):
if (cards1[i].key not in hdu1.header.ascardlist().keys() and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].key not in hdu2.header.ascardlist().keys():
hdu2.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
else:
hdu2.header.ascardlist()[cards2[i].key].comment = cards2[i].comment
outstr.append(hdu2)
# construct principal component table
if status == 0:
cols = []
for i in range(nmask):
colname = 'PC' + str(i + 1)
col = Column(name=colname,format='E',unit='e-/s',array=score[:,i])
cols.append(col)
hdu3 = new_table(ColDefs(cols))
hdu3.header.update('EXTNAME','PRINCIPAL_COMPONENTS','name of extension')
for i in range(nmask):
hdu3.header.update('TTYPE' + str(i + 1),'PC' + str(i + 1),'column title: principal component number' + str(i + 1))
hdu3.header.update('TFORM' + str(i + 1),'E','column format: float32')
hdu3.header.update('TUNIT' + str(i + 1),'e-/s','column units: electrons per sec')
outstr.append(hdu3)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# plotting defaults
if status == 0:
plotLatex = True
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
plotLatex = False
if status == 0:
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
# clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
ptime = time + bjdref - intime0
xlab = 'BJD $-$ %d' % intime0
# clean up y-axis units
if status == 0:
pout = copy(score)
nrm = len(str(int(pout.max())))-1
pout = pout / 10**nrm
ylab = '10$^%d$ e$^-$ s$^{-1}$' % nrm
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
# plot window
ax = pylab.axes([0.06,0.54,0.93,0.43])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90)
pylab.setp(pylab.gca(),xticklabels=[])
# plot principal components
for i in range(nmask):
pylab.plot(ptime,pout[:,i],linestyle='-',linewidth=lwidth)
if not plotLatex:
ylab = '10**%d electrons/sec' % nrm
ylabel(ylab, {'color' : 'k'})
grid()
# plot ranges
pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
# plot output data
ax = pylab.axes([0.06,0.09,0.93,0.43])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90)
# clean up y-axis units
if status == 0:
pout = copy(pca_flux)
nrm = len(str(int(pout.max())))-1
pout = pout / 10**nrm
ylab = '10$^%d$ e$^-$ s$^{-1}$' % nrm
# data limits
ymin = pout.min()
ymax = pout.max()
yr = ymax - ymin
ptime = numpy.insert(ptime,[0],[ptime[0]])
ptime = numpy.append(ptime,[ptime[-1]])
pout = numpy.insert(pout,[0],[0.0])
pout = numpy.append(pout,0.0)
# plot time coadded principal component series
pylab.plot(ptime[1:-1],pout[1:-1],color=lcolor,linestyle='-',linewidth=lwidth)
pylab.fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab, {'color' : 'k'})
pylab.grid()
# plot ranges
pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin >= 0.0:
pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
pylab.ylim(1.0e-10,ymax+yr*0.01)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
if status == 0:
kepmsg.clock('KEPPCA ended at',logfile,verbose)
return
def kepstitch(infiles,outfile,clobber,verbose,logfile,status):
# startup parameters
status = 0
lct = []; bjd = []
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPSTITCH -- '
call += 'infiles='+infiles+' '
call += 'outfile='+outfile+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPSTITCH started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# parse input file list
infiles, status = kepio.parselist(infiles,logfile,verbose)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPSTITCH: ' + outfile + ' exists. Use clobber=yes'
kepmsg.err(logfile,message,verbose)
status = 1
# open output file
if status == 0:
outstr, status = kepio.openfits(infiles[0],'readonly',logfile,verbose)
nrows1 = outstr[1].data.shape[0]
# fudge non-compliant FITS keywords with no values
if status == 0:
outstr = kepkey.emptykeys(outstr,file,logfile,verbose)
head0 = outstr[0].header
head1 = outstr[1].header
# open input files
nfiles = 0
if status == 0:
for infile in infiles:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
# append table data
if nfiles > 0:
nrows2 = instr[1].data.shape[0]
nrows = nrows1 + nrows2
outtab = pyfits.new_table(outstr[1].columns,nrows=nrows)
for name in outstr[1].columns.names:
try:
outtab.data.field(name)[nrows1:]=instr[1].data.field(name)
except:
message = 'ERROR -- KEPSTITCH: column ' + name + ' missing from some files.'
kepmsg.warn(logfile,message)
pass
outstr[1] = outtab
outstr[0].header = head0
outstr[1].header = head1
nrows1 = nrows
# start and stop times of data
fitsvers = 1.0
lc_start, status = kepkey.get(infile,instr[1],'LC_START',logfile,verbose)
lc_end, status = kepkey.get(infile,instr[1],'LC_END',logfile,verbose)
try:
startbjd = instr[1].header['STARTBJD']
except:
startbjd, status = kepkey.get(infile,instr[1],'TSTART',logfile,verbose)
fitsvers = 2.0
try:
endbjd = instr[1].header['ENDBJD']
except:
endbjd, status = kepkey.get(infile,instr[1],'TSTOP',logfile,verbose)
fitsvers = 2.0
lct.append(lc_start); lct.append(lc_end)
bjd.append(startbjd); bjd.append(endbjd)
# close input files
status = kepio.closefits(instr,logfile,verbose)
nfiles += 1
# maxmimum and minimum times in file sample
if status == 0:
lc_start = kepstat.min(lct)
lc_end = kepstat.max(lct)
startbjd = kepstat.min(bjd)
endbjd = kepstat.max(bjd)
status = kepkey.change('LC_START',lc_start,outstr[1],outfile,logfile,verbose)
status = kepkey.change('LC_END',lc_end,outstr[1],outfile,logfile,verbose)
if fitsvers == 1.0:
status = kepkey.change('STARTBJD',startbjd,outstr[1],outfile,logfile,verbose)
status = kepkey.change('ENDBJD',endbjd,outstr[1],outfile,logfile,verbose)
else:
status = kepkey.change('TSTART',startbjd,outstr[1],outfile,logfile,verbose)
status = kepkey.change('TSTOP',endbjd,outstr[1],outfile,logfile,verbose)
# comment keyword in output file
if status == 0:
status = kepkey.comment(call,outstr[0],outfile,logfile,verbose)
# close output file
if status == 0:
outstr.writeto(outfile)
status = kepio.closefits(outstr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPSTITCH completed at'
else:
message = '\nKEPSTITCH aborted at'
kepmsg.clock(message,logfile,verbose)
def kepfilter(infile,outfile,datacol,function,cutoff,passband,plot,plotlab,
clobber,verbose,logfile,status,cmdLine=False):
## startup parameters
status = 0
numpy.seterr(all="ignore")
labelsize = 24
ticksize = 16
xsize = 16
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
## log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFILTER -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'function='+str(function)+' '
call += 'cutoff='+str(cutoff)+' '
call += 'passband='+str(passband)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
call += 'plotlab='+str(plotlab)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
## start time
kepmsg.clock('KEPFILTER started at',logfile,verbose)
## test log file
logfile = kepmsg.test(logfile)
## clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFILTER: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
## open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
## fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
## read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# read time and flux columns
if status == 0:
barytime, status = kepio.readtimecol(infile,table,logfile,verbose)
flux, status = kepio.readsapcol(infile,table,logfile,verbose)
# filter input data table
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
naxis2 = 0
for i in range(len(table.field(0))):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(flux[i]) and flux[i] != 0.0):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN',True,comment,instr[1],outfile,logfile,verbose)
## read table columns
if status == 0:
intime, status = kepio.readtimecol(infile,instr[1].data,logfile,verbose)
if status == 0:
indata, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
## define data sampling
if status == 0:
tr = 1.0 / (cadence / 86400)
timescale = 1.0 / (cutoff / tr)
## define convolution function
if status == 0:
if function == 'boxcar':
filtfunc = numpy.ones(numpy.ceil(timescale))
elif function == 'gauss':
timescale /= 2
dx = numpy.ceil(timescale * 10 + 1)
filtfunc = kepfunc.gauss()
filtfunc = filtfunc([1.0,dx/2-1.0,timescale],linspace(0,dx-1,dx))
elif function == 'sinc':
dx = numpy.ceil(timescale * 12 + 1)
fx = linspace(0,dx-1,dx)
fx = fx - dx / 2 + 0.5
fx /= timescale
filtfunc = numpy.sinc(fx)
filtfunc /= numpy.sum(filtfunc)
## pad time series at both ends with noise model
if status == 0:
ave, sigma = kepstat.stdev(indata[:len(filtfunc)])
padded = append(kepstat.randarray(np.ones(len(filtfunc)) * ave,
np.ones(len(filtfunc)) * sigma), indata)
ave, sigma = kepstat.stdev(indata[-len(filtfunc):])
padded = append(padded, kepstat.randarray(np.ones(len(filtfunc)) * ave,
np.ones(len(filtfunc)) * sigma))
## convolve data
if status == 0:
convolved = convolve(padded,filtfunc,'same')
## remove padding from the output array
if status == 0:
if function == 'boxcar':
outdata = convolved[len(filtfunc):-len(filtfunc)]
else:
outdata = convolved[len(filtfunc):-len(filtfunc)]
## subtract low frequencies
if status == 0 and passband == 'high':
outmedian = median(outdata)
outdata = indata - outdata + outmedian
## comment keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
## clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
if intime0 < 2.4e6: intime0 += 2.4e6
ptime = intime - intime0
xlab = 'BJD $-$ %d' % intime0
## clean up y-axis units
if status == 0:
pout = indata * 1.0
pout2 = outdata * 1.0
nrm = len(str(int(numpy.nanmax(pout))))-1
pout = pout / 10**nrm
pout2 = pout2 / 10**nrm
ylab = '10$^%d$ %s' % (nrm, plotlab)
## data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = numpy.nanmin(pout)
ymax = numpy.nanmax(pout)
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
pout2 = insert(pout2,[0],[0.0])
pout2 = append(pout2,0.0)
## plot light curve
if status == 0 and plot:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
print 'ERROR -- KEPFILTER: install latex for scientific plotting'
status = 1
if status == 0 and plot:
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
## plot filtered data
ax = pylab.axes([0.06,0.1,0.93,0.87])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
pylab.plot(ptime,pout,color='#ff9900',linestyle='-',linewidth=lwidth)
fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
if passband == 'low':
pylab.plot(ptime[1:-1],pout2[1:-1],color=lcolor,linestyle='-',linewidth=lwidth)
else:
pylab.plot(ptime,pout2,color=lcolor,linestyle='-',linewidth=lwidth)
fill(ptime,pout2,color=lcolor,linewidth=0.0,alpha=falpha)
xlabel(xlab, {'color' : 'k'})
ylabel(ylab, {'color' : 'k'})
xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin >= 0.0:
ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
ylim(1.0e-10,ymax+yr*0.01)
pylab.grid()
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
## write output file
if status == 0:
for i in range(len(outdata)):
instr[1].data.field(datacol)[i] = outdata[i]
instr.writeto(outfile)
## close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPFILTER completed at'
else:
message = '\nKEPFILTER aborted at'
kepmsg.clock(message,logfile,verbose)
def kepmask(infile,
mfile,
pfile,
tabrow,
imin,
imax,
iscale,
cmap,
verbose,
logfile,
status,
cLine=False):
global pimg, zscale, zmin, zmax, xmin, xmax, ymin, ymax, quarter
global pxdim, pydim, kepmag, skygroup, season, channel
global module, output, row, column, maskfile, plotfile
global pkepid, pkepmag, pra, pdec, colmap, cmdLine
# input arguments
status = 0
numpy.seterr(all="ignore")
zmin = imin
zmax = imax
zscale = iscale
colmap = cmap
maskfile = mfile
plotfile = pfile
cmdLine = cLine
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPMASK -- '
call += 'infile=' + infile + ' '
call += 'maskfile=' + mfile + ' '
call += 'plotfile=' + pfile + ' '
call += 'tabrow=' + str(tabrow) + ' '
call += 'imin=' + str(imin) + ' '
call += 'imax=' + str(imax) + ' '
call += 'iscale=' + str(iscale) + ' '
call += 'cmap=' + str(cmap) + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPMASK started at', logfile, verbose)
# reference color map
if cmap == 'browse':
status = cmap_plot()
# open TPF FITS file and check tabrow exists
if status == 0:
tpf, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0:
try:
naxis2 = tpf['TARGETTABLES'].header['NAXIS2']
except:
txt = 'ERROR -- KEPMASK: No NAXIS2 keyword in ' + infile + '[TARGETTABLES]'
status = kepmsg.err(logfile, txt, True)
if status == 0 and tabrow > naxis2:
txt = 'ERROR -- KEPMASK: tabrow is too large. There are ' + str(
naxis2) + ' rows in the table.'
status = kepmsg.err(logfile, txt, True)
if status == 0:
status = kepio.closefits(tpf, logfile, verbose)
# read TPF data pixel image
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
img = pixels[tabrow]
pkepid = copy(kepid)
pra = copy(ra)
pdec = copy(dec)
pkepmag = copy(kepmag)
pxdim = copy(xdim)
pydim = copy(ydim)
pimg = copy(img)
# print target data
if status == 0:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# subimage of channel for plot
if status == 0:
ymin = copy(row)
ymax = ymin + ydim
xmin = copy(column)
xmax = xmin + xdim
# intensity scale
if status == 0:
pimg, imin, imax = kepplot.intScale1D(pimg, zscale)
if zmin and zmax and 'log' in zscale:
zmin = log10(zmin)
zmax = log10(zmax)
elif zmin and zmax and 'sq' in zscale:
zmin = sqrt(zmin)
zmax = sqrt(zmax)
elif zmin and zmax and 'li' in zscale:
zmin *= 1.0
zmax *= 1.0
else:
zmin = copy(imin)
zmax = copy(imax)
# nstat = 2; pixels = []
# work = array(sort(img),dtype=float32)
# for i in range(len(work)):
# if 'nan' not in str(work[i]):
# pixels.append(work[i])
# pixels = array(pixels,dtype=float32)
# if int(float(len(pixels)) / 10 + 0.5) > nstat:
# nstat = int(float(len(pixels)) / 10 + 0.5)
# if not zmin:
# zmin = median(pixels[:nstat])
# if not zmax:
# zmax = median(pixels[-nstat:])
# if 'log' in zscale:
# pimg = log10(pimg)
# if 'sq' in zscale:
# pimg = sqrt(pimg)
# plot limits
ymin = float(ymin) - 0.5
ymax = float(ymax) - 0.5
xmin = float(xmin) - 0.5
xmax = float(xmax) - 0.5
# plot style
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 14,
'ytick.labelsize': 14
}
pylab.rcParams.update(params)
except:
pass
if status == 0:
pylab.figure(figsize=[10, 7])
plotimage(cmdLine)
return
def keptrial(infile,outfile,datacol,errcol,fmin,fmax,nfreq,method,
ntrials,plot,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 18
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPTRIAL -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
call += 'errcol='+errcol+' '
call += 'fmin='+str(fmin)+' '
call += 'fmax='+str(fmax)+' '
call += 'nfreq='+str(nfreq)+' '
call += 'method='+method+' '
call += 'ntrials='+str(ntrials)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPTRIAL started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPTRIAL: ' + outfile + ' exists. Use clobber=yes'
kepmsg.err(logfile,message,verbose)
status = 1
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# input data
if status == 0:
try:
barytime = instr[1].data.field('barytime')
except:
barytime, status = kepio.readfitscol(infile,instr[1].data,'time',logfile,verbose)
if status == 0:
signal, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
if status == 0:
err, status = kepio.readfitscol(infile,instr[1].data,errcol,logfile,verbose)
# remove infinite data from time series
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
incols = [barytime, signal, err]
[barytime, signal, err] = kepstat.removeinfinlc(signal, incols)
# set up plot
if status == 0:
plotLatex = True
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
print('WARNING: install latex for scientific plotting')
plotLatex = False
# frequency steps and Monte Carlo iterations
if status == 0:
deltaf = (fmax - fmin) / nfreq
freq = []; pmax = []; trial = []
for i in range(ntrials):
trial.append(i+1)
# adjust data within the error bars
work1 = kepstat.randarray(signal,err)
# determine FT power
fr, power = kepfourier.ft(barytime,work1,fmin,fmax,deltaf,False)
# determine peak in FT
pmax.append(-1.0e30)
for j in range(len(fr)):
if (power[j] > pmax[-1]):
pmax[-1] = power[j]
f1 = fr[j]
freq.append(f1)
# plot stop-motion histogram
pylab.ion()
pylab.figure(1,figsize=[7,10])
clf()
pylab.axes([0.08,0.08,0.88,0.89])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
n,bins,patches = pylab.hist(freq,bins=nfreq,range=[fmin,fmax],
align='mid',rwidth=1,ec='#0000ff',
fc='#ffff00',lw=2)
# fit normal distribution to histogram
x = zeros(len(bins))
for j in range(1,len(bins)):
x[j] = (bins[j] + bins[j-1]) / 2
pinit = numpy.array([float(i),freq[-1],deltaf])
if i > 3:
n = array(n,dtype='float32')
coeffs, errors, covar, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.leastsquare('gauss',pinit,x[1:],n,None,logfile,verbose)
fitfunc = kepfunc.gauss()
f = arange(fmin,fmax,(fmax-fmin)/100)
fit = fitfunc(coeffs,f)
pylab.plot(f,fit,'r-',linewidth=2)
if plotLatex:
xlabel(r'Frequency (d$^{-1}$)', {'color' : 'k'})
else:
xlabel(r'Frequency (1/d)', {'color' : 'k'})
ylabel('N', {'color' : 'k'})
xlim(fmin,fmax)
grid()
# render plot
if plot:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# period results
if status == 0:
p = 1.0 / coeffs[1]
perr = p * coeffs[2] / coeffs[1]
f1 = fmin; f2 = fmax
gotbin = False
for i in range(len(n)):
if n[i] > 0 and not gotbin:
f1 = bins[i]
gotbin = True
gotbin = False
for i in range(len(n)-1,0,-1):
if n[i] > 0 and not gotbin:
f2 = bins[i+1]
gotbin = True
powave, powstdev = kepstat.stdev(pmax)
# print result
if status == 0:
print(' best period: %.10f days (%.7f min)' % (p, p * 1440.0))
print(' 1-sigma period error: %.10f days (%.7f min)' % (perr, perr * 1440.0))
print(' search range: %.10f - %.10f days ' % (1.0 / fmax, 1.0 / fmin))
print(' 100%% confidence range: %.10f - %.10f days ' % (1.0 / f2, 1.0 / f1))
# print ' detection confidence: %.2f sigma' % (powave / powstdev)
print(' number of trials: %d' % ntrials)
print(' number of frequency bins: %d' % nfreq)
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
## write output file
if status == 0:
col1 = Column(name='TRIAL',format='J',array=trial)
col2 = Column(name='FREQUENCY',format='E',unit='1/day',array=freq)
col3 = Column(name='POWER',format='E',array=pmax)
cols = ColDefs([col1,col2,col3])
instr.append(new_table(cols))
try:
instr[-1].header.update('EXTNAME','TRIALS','Extension name')
except:
status = 1
try:
instr[-1].header.update('SEARCHR1',1.0 / fmax,'Search range lower bound (days)')
except:
status = 1
try:
instr[-1].header.update('SEARCHR2',1.0 / fmin,'Search range upper bound (days)')
except:
status = 1
try:
instr[-1].header.update('NFREQ',nfreq,'Number of frequency bins')
except:
status = 1
try:
instr[-1].header.update('PERIOD',p,'Best period (days)')
except:
status = 1
try:
instr[-1].header.update('PERIODE',perr,'1-sigma period error (days)')
except:
status = 1
# instr[-1].header.update('DETNCONF',powave/powstdev,'Detection significance (sigma)')
try:
instr[-1].header.update('CONFIDR1',1.0 / f2,'Trial confidence lower bound (days)')
except:
status = 1
try:
instr[-1].header.update('CONFIDR2',1.0 / f1,'Trial confidence upper bound (days)')
except:
status = 1
try:
instr[-1].header.update('NTRIALS',ntrials,'Number of trials')
except:
status = 1
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPTRAIL completed at'
else:
message = '\nKEPTRIAL aborted at'
kepmsg.clock(message,logfile,verbose)
def kepstddev(infile,outfile,datacol,timescale,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 44
ticksize = 36
xsize = 16
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPSTDDEV -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'timescale='+str(timescale)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPSTDDEV started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPSTDDEV: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# filter input data table
if status == 0:
work1 = numpy.array([table.field('time'), table.field(datacol)])
work1 = numpy.rot90(work1,3)
work1 = work1[~numpy.isnan(work1).any(1)]
# read table columns
if status == 0:
intime = work1[:,1] + bjdref
indata = work1[:,0]
# calculate STDDEV in units of ppm
if status == 0:
stddev = running_frac_std(intime,indata,timescale/24) * 1.0e6
astddev = numpy.std(indata) * 1.0e6
cdpp = stddev / sqrt(timescale * 3600.0 / cadence)
# filter cdpp
if status == 0:
for i in range(len(cdpp)):
if cdpp[i] > median(cdpp) * 10.0: cdpp[i] = cdpp[i-1]
# calculate median STDDEV
if status == 0:
medcdpp = ones((len(cdpp)),dtype='float32') * median(cdpp[:])
# print '\nMedian %.1fhr standard deviation = %d ppm' % (timescale, median(stddev[:]))
print '\nStandard deviation = %d ppm' % astddev
# calculate median STDDEV
if status == 0:
medcdpp = ones((len(cdpp)),dtype='float32') * median(cdpp[:])
print 'Median %.1fhr CDPP = %d ppm' % (timescale, median(cdpp[:]))
# calculate RMS STDDEV
if status == 0:
rms, status = kepstat.rms(cdpp,zeros(len(stddev)),logfile,verbose)
rmscdpp = ones((len(cdpp)),dtype='float32') * rms
print ' RMS %.1fhr CDPP = %d ppm\n' % (timescale, rms)
# clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
ptime = intime - intime0
xlab = 'BJD $-$ %d' % intime0
# clean up y-axis units
if status == 0:
pout = copy(cdpp)
nrm = math.ceil(math.log10(median(cdpp))) - 1.0
# pout = pout / 10**nrm
# ylab = '%.1fhr $\sigma$ (10$^%d$ ppm)' % (timescale,nrm)
ylab = '%.1fhr $\sigma$ (ppm)' % timescale
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 36,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 32,
'ytick.labelsize': 36}
pylab.rcParams.update(params)
except:
pass
# define size of plot on monitor screen
pylab.figure(figsize=[xsize,ysize])
# delete any fossil plots in the matplotlib window
pylab.clf()
# position first axes inside the plotting window
ax = pylab.axes([0.07,0.15,0.92,0.83])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
ax.yaxis.set_major_locator(MaxNLocator(5))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90,fontsize=36)
# plot flux vs time
ltime = array([],dtype='float64')
ldata = array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for i in range(1,len(ptime)-1):
dt = ptime[i] - ptime[i-1]
if dt < work1:
ltime = append(ltime,ptime[i])
ldata = append(ldata,pout[i])
else:
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
ltime = array([],dtype='float64')
ldata = array([],dtype='float32')
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(ptime,pout,fc='#ffff00',linewidth=0.0,alpha=0.2)
# plot median CDPP
# pylab.plot(intime - intime0,medcdpp / 10**nrm,color='r',linestyle='-',linewidth=2.0)
# pylab.plot(intime - intime0,medcdpp,color='r',linestyle='-',linewidth=2.0)
# plot RMS CDPP
# pylab.plot(intime - intime0,rmscdpp / 10**nrm,color='r',linestyle='--',linewidth=2.0)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin - yr * 0.01 <= 0.0:
pylab.ylim(1.0e-10, ymax + yr * 0.01)
else:
pylab.ylim(ymin - yr * 0.01, ymax + yr * 0.01)
# plot labels
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab, {'color' : 'k'})
# make grid on plot
pylab.grid()
# render plot
if status == 0:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# add NaNs back into data
if status == 0:
n = 0
work1 = array([],dtype='float32')
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
for i in range(len(table.field(0))):
if isfinite(table.field('time')[i]) and isfinite(table.field(datacol)[i]):
work1 = append(work1,cdpp[n])
n += 1
else:
work1 = append(work1,nan)
# write output file
if status == 0:
status = kepkey.new('MCDPP%d' % (timescale * 10.0),medcdpp[0],
'Median %.1fhr CDPP (ppm)' % timescale,
instr[1],outfile,logfile,verbose)
status = kepkey.new('RCDPP%d' % (timescale * 10.0),rmscdpp[0],
'RMS %.1fhr CDPP (ppm)' % timescale,
instr[1],outfile,logfile,verbose)
colname = 'CDPP_%d' % (timescale * 10)
col1 = pyfits.Column(name=colname,format='E13.7',array=work1)
cols = instr[1].data.columns + col1
instr[1] = pyfits.new_table(cols,header=instr[1].header)
instr.writeto(outfile)
# comment keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
# close FITS
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
if (status == 0):
message = 'KEPSTDDEV completed at'
else:
message = '\nKEPSTDDEV aborted at'
kepmsg.clock(message,logfile,verbose)
def kepdip(infile,outfile,datacol,dmethod,kneighb,hstd,plot,plotlab,
clobber,verbose,logfile,status):
"""
Perform a k-nearest neighbor regression analysis.
"""
## startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 16
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#9AFF9A'
falpha = 0.3
## log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPDIP -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'dmethod='+dmethod+' '
call += 'hstd='+str(hstd)+' '
call += 'kneighb='+str(kneighb)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
call += 'plotlab='+str(plotlab)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
## start time
kepmsg.clock('KEPDIP started at',logfile,verbose)
## test log file
logfile = kepmsg.test(logfile)
## clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPDIP: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
## open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if cadence == 0.0:
tstart, tstop, ncad, cadence, status = kepio.cadence(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
## fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
## read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# read time and flux columns
if status == 0:
barytime, status = kepio.readtimecol(infile,table,logfile,verbose)
if status == 0:
flux, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
# filter input data table
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
naxis2 = 0
for i in range(len(table.field(0))):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(flux[i]) and flux[i] != 0.0):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN',True,comment,instr[1],outfile,logfile,verbose)
## read table columns
if status == 0:
try:
intime = instr[1].data.field('barytime')
except:
intime, status = kepio.readfitscol(infile,instr[1].data,'time',logfile,verbose)
indata, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
## smooth data
if status == 0:
# outdata = knn_predict(intime, indata, kmethod, kneighb)
outdata_t, outdata_l, outdata_fmt = _find_dips(intime, indata, dmethod, kneighb, hstd)
## comment keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
## clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
if intime0 < 2.4e6: intime0 += 2.4e6
ptime = intime - intime0
ptime2 = outdata_t - intime0
# print ptime,intime,intime0
xlab = 'BJD $-$ %d' % intime0
## clean up y-axis units
if status == 0:
pout = indata * 1.0
pout2 = outdata_l * 1.0
nrm = len(str(int(numpy.nanmax(pout))))-1
pout = pout / 10**nrm
pout2 = pout2 / 10**nrm
ylab = '10$^%d$ %s' % (nrm, plotlab)
## data limits
xmin = numpy.nanmin(ptime)
xmax = numpy.nanmax(ptime)
ymin = numpy.min(pout)
ymax = numpy.nanmax(pout)
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
if (len(ptime2) > 0):
ptime2 = insert(ptime2,[0],[ptime2[0]])
ptime2 = append(ptime2,[ptime2[-1]])
pout2 = insert(pout2,[0],[0.0])
pout2 = append(pout2,0.0)
## plot light curve
if status == 0 and plot:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
print('ERROR -- KEPDIP: install latex for scientific plotting')
status = 1
if status == 0 and plot:
pylab.figure(1,figsize=[xsize,ysize])
## plot regression data
ax = pylab.axes([0.06,0.1,0.93,0.87])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.scatter(ptime, pout, color='#214CAE', s=2)
if (len(ptime2) > 0):
pylab.scatter(ptime2, pout2, color='#47AE10', s=35, marker='o', linewidths=2, alpha=0.4)
xlabel(xlab, {'color' : 'k'})
ylabel(ylab, {'color' : 'k'})
xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin >= 0.0:
ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
ylim(1.0e-10,ymax+yr*0.01)
pylab.grid()
pylab.draw()
pylab.savefig(re.sub('\.\S+','.png',outfile),dpi=100)
## write output file
if status == 0:
for i in range(len(outdata_fmt)):
instr[1].data.field(datacol)[i] = outdata_fmt[i]
instr.writeto(outfile)
## close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPDIP completed at'
else:
message = '\nKEPDIP aborted at'
kepmsg.clock(message,logfile,verbose)
def keppixseries(infile,outfile,plotfile,plottype,filter,function,cutoff,clobber,verbose,logfile,status, cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPPIXSERIES -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'plotfile='+plotfile+' '
call += 'plottype='+plottype+' '
filt = 'n'
if (filter): filt = 'y'
call += 'filter='+filt+ ' '
call += 'function='+function+' '
call += 'cutoff='+str(cutoff)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPPIXSERIES started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPIXSERIES: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(infile,logfile,verbose)
# print target data
if status == 0:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# how many quality = 0 rows?
if status == 0:
npts = 0
nrows = len(fluxpixels)
for i in range(nrows):
if qual[i] == 0 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,ydim*xdim/2]):
npts += 1
time = empty((npts))
timecorr = empty((npts))
cadenceno = empty((npts))
quality = empty((npts))
pixseries = empty((ydim,xdim,npts))
errseries = empty((ydim,xdim,npts))
# construct output light curves
if status == 0:
np = 0
for i in range(ydim):
for j in range(xdim):
npts = 0
for k in range(nrows):
if qual[k] == 0 and \
numpy.isfinite(barytime[k]) and \
numpy.isfinite(fluxpixels[k,ydim*xdim/2]):
time[npts] = barytime[k]
timecorr[npts] = tcorr[k]
cadenceno[npts] = cadno[k]
quality[npts] = qual[k]
pixseries[i,j,npts] = fluxpixels[k,np]
errseries[i,j,npts] = errpixels[k,np]
npts += 1
np += 1
# define data sampling
if status == 0 and filter:
tpf, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0 and filter:
cadence, status = kepkey.cadence(tpf[1],infile,logfile,verbose)
tr = 1.0 / (cadence / 86400)
timescale = 1.0 / (cutoff / tr)
# define convolution function
if status == 0 and filter:
if function == 'boxcar':
filtfunc = numpy.ones(numpy.ceil(timescale))
elif function == 'gauss':
timescale /= 2
dx = numpy.ceil(timescale * 10 + 1)
filtfunc = kepfunc.gauss()
filtfunc = filtfunc([1.0,dx/2-1.0,timescale],linspace(0,dx-1,dx))
elif function == 'sinc':
dx = numpy.ceil(timescale * 12 + 1)
fx = linspace(0,dx-1,dx)
fx = fx - dx / 2 + 0.5
fx /= timescale
filtfunc = numpy.sinc(fx)
filtfunc /= numpy.sum(filtfunc)
# pad time series at both ends with noise model
if status == 0 and filter:
for i in range(ydim):
for j in range(xdim):
ave, sigma = kepstat.stdev(pixseries[i,j,:len(filtfunc)])
padded = numpy.append(kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma), pixseries[i,j,:])
ave, sigma = kepstat.stdev(pixseries[i,j,-len(filtfunc):])
padded = numpy.append(padded, kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma))
# convolve data
if status == 0:
convolved = convolve(padded,filtfunc,'same')
# remove padding from the output array
if status == 0:
outdata = convolved[len(filtfunc):-len(filtfunc)]
# subtract low frequencies
if status == 0:
outmedian = median(outdata)
pixseries[i,j,:] = pixseries[i,j,:] - outdata + outmedian
# construct output file
if status == 0 and ydim*xdim < 1000:
instruct, status = kepio.openfits(infile,'readonly',logfile,verbose)
status = kepkey.history(call,instruct[0],outfile,logfile,verbose)
hdulist = HDUList(instruct[0])
cols = []
cols.append(Column(name='TIME',format='D',unit='BJD - 2454833',disp='D12.7',array=time))
cols.append(Column(name='TIMECORR',format='E',unit='d',disp='E13.6',array=timecorr))
cols.append(Column(name='CADENCENO',format='J',disp='I10',array=cadenceno))
cols.append(Column(name='QUALITY',format='J',array=quality))
for i in range(ydim):
for j in range(xdim):
colname = 'COL%d_ROW%d' % (i+column,j+row)
cols.append(Column(name=colname,format='E',disp='E13.6',array=pixseries[i,j,:]))
hdu1 = new_table(ColDefs(cols))
try:
hdu1.header.update('INHERIT',True,'inherit the primary header')
except:
status = 0
try:
hdu1.header.update('EXTNAME','PIXELSERIES','name of extension')
except:
status = 0
try:
hdu1.header.update('EXTVER',instruct[1].header['EXTVER'],'extension version number (not format version)')
except:
status = 0
try:
hdu1.header.update('TELESCOP',instruct[1].header['TELESCOP'],'telescope')
except:
status = 0
try:
hdu1.header.update('INSTRUME',instruct[1].header['INSTRUME'],'detector type')
except:
status = 0
try:
hdu1.header.update('OBJECT',instruct[1].header['OBJECT'],'string version of KEPLERID')
except:
status = 0
try:
hdu1.header.update('KEPLERID',instruct[1].header['KEPLERID'],'unique Kepler target identifier')
except:
status = 0
try:
hdu1.header.update('RADESYS',instruct[1].header['RADESYS'],'reference frame of celestial coordinates')
except:
status = 0
try:
hdu1.header.update('RA_OBJ',instruct[1].header['RA_OBJ'],'[deg] right ascension from KIC')
except:
status = 0
try:
hdu1.header.update('DEC_OBJ',instruct[1].header['DEC_OBJ'],'[deg] declination from KIC')
except:
status = 0
try:
hdu1.header.update('EQUINOX',instruct[1].header['EQUINOX'],'equinox of celestial coordinate system')
except:
status = 0
try:
hdu1.header.update('TIMEREF',instruct[1].header['TIMEREF'],'barycentric correction applied to times')
except:
status = 0
try:
hdu1.header.update('TASSIGN',instruct[1].header['TASSIGN'],'where time is assigned')
except:
status = 0
try:
hdu1.header.update('TIMESYS',instruct[1].header['TIMESYS'],'time system is barycentric JD')
except:
status = 0
try:
hdu1.header.update('BJDREFI',instruct[1].header['BJDREFI'],'integer part of BJD reference date')
except:
status = 0
try:
hdu1.header.update('BJDREFF',instruct[1].header['BJDREFF'],'fraction of the day in BJD reference date')
except:
status = 0
try:
hdu1.header.update('TIMEUNIT',instruct[1].header['TIMEUNIT'],'time unit for TIME, TSTART and TSTOP')
except:
status = 0
try:
hdu1.header.update('TSTART',instruct[1].header['TSTART'],'observation start time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('TSTOP',instruct[1].header['TSTOP'],'observation stop time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('LC_START',instruct[1].header['LC_START'],'mid point of first cadence in MJD')
except:
status = 0
try:
hdu1.header.update('LC_END',instruct[1].header['LC_END'],'mid point of last cadence in MJD')
except:
status = 0
try:
hdu1.header.update('TELAPSE',instruct[1].header['TELAPSE'],'[d] TSTOP - TSTART')
except:
status = 0
try:
hdu1.header.update('LIVETIME',instruct[1].header['LIVETIME'],'[d] TELAPSE multiplied by DEADC')
except:
status = 0
try:
hdu1.header.update('EXPOSURE',instruct[1].header['EXPOSURE'],'[d] time on source')
except:
status = 0
try:
hdu1.header.update('DEADC',instruct[1].header['DEADC'],'deadtime correction')
except:
status = 0
try:
hdu1.header.update('TIMEPIXR',instruct[1].header['TIMEPIXR'],'bin time beginning=0 middle=0.5 end=1')
except:
status = 0
try:
hdu1.header.update('TIERRELA',instruct[1].header['TIERRELA'],'[d] relative time error')
except:
status = 0
try:
hdu1.header.update('TIERABSO',instruct[1].header['TIERABSO'],'[d] absolute time error')
except:
status = 0
try:
hdu1.header.update('INT_TIME',instruct[1].header['INT_TIME'],'[s] photon accumulation time per frame')
except:
status = 0
try:
hdu1.header.update('READTIME',instruct[1].header['READTIME'],'[s] readout time per frame')
except:
status = 0
try:
hdu1.header.update('FRAMETIM',instruct[1].header['FRAMETIM'],'[s] frame time (INT_TIME + READTIME)')
except:
status = 0
try:
hdu1.header.update('NUM_FRM',instruct[1].header['NUM_FRM'],'number of frames per time stamp')
except:
status = 0
try:
hdu1.header.update('TIMEDEL',instruct[1].header['TIMEDEL'],'[d] time resolution of data')
except:
status = 0
try:
hdu1.header.update('DATE-OBS',instruct[1].header['DATE-OBS'],'TSTART as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('DATE-END',instruct[1].header['DATE-END'],'TSTOP as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('BACKAPP',instruct[1].header['BACKAPP'],'background is subtracted')
except:
status = 0
try:
hdu1.header.update('DEADAPP',instruct[1].header['DEADAPP'],'deadtime applied')
except:
status = 0
try:
hdu1.header.update('VIGNAPP',instruct[1].header['VIGNAPP'],'vignetting or collimator correction applied')
except:
status = 0
try:
hdu1.header.update('GAIN',instruct[1].header['GAIN'],'[electrons/count] channel gain')
except:
status = 0
try:
hdu1.header.update('READNOIS',instruct[1].header['READNOIS'],'[electrons] read noise')
except:
status = 0
try:
hdu1.header.update('NREADOUT',instruct[1].header['NREADOUT'],'number of read per cadence')
except:
status = 0
try:
hdu1.header.update('TIMSLICE',instruct[1].header['TIMSLICE'],'time-slice readout sequence section')
except:
status = 0
try:
hdu1.header.update('MEANBLCK',instruct[1].header['MEANBLCK'],'[count] FSW mean black level')
except:
status = 0
hdulist.append(hdu1)
hdulist.writeto(outfile)
status = kepkey.new('EXTNAME','APERTURE','name of extension',instruct[2],outfile,logfile,verbose)
pyfits.append(outfile,instruct[2].data,instruct[2].header)
status = kepio.closefits(instruct,logfile,verbose)
else:
message = 'WARNING -- KEPPIXSERIES: output FITS file requires > 999 columns. Non-compliant with FITS convention.'
kepmsg.warn(logfile,message)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.0,
'axes.labelsize': 32,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 8,
'legend.fontsize': 8,
'xtick.labelsize': 12,
'ytick.labelsize': 12}
pylab.rcParams.update(params)
except:
pass
# plot pixel array
fmin = 1.0e33
fmax = -1.033
if status == 0:
pylab.figure(num=None,figsize=[12,12])
pylab.clf()
dx = 0.93 / xdim
dy = 0.94 / ydim
ax = pylab.axes([0.06,0.05,0.93,0.94])
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().xaxis.set_major_locator(matplotlib.ticker.MaxNLocator(integer=True))
pylab.gca().yaxis.set_major_locator(matplotlib.ticker.MaxNLocator(integer=True))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
pylab.xlim(numpy.min(pixcoord1) - 0.5,numpy.max(pixcoord1) + 0.5)
pylab.ylim(numpy.min(pixcoord2) - 0.5,numpy.max(pixcoord2) + 0.5)
pylab.xlabel('time', {'color' : 'k'})
pylab.ylabel('arbitrary flux', {'color' : 'k'})
for i in range(ydim):
for j in range(xdim):
tmin = amin(time)
tmax = amax(time)
try:
numpy.isfinite(amin(pixseries[i,j,:]))
numpy.isfinite(amin(pixseries[i,j,:]))
fmin = amin(pixseries[i,j,:])
fmax = amax(pixseries[i,j,:])
except:
ugh = 1
xmin = tmin - (tmax - tmin) / 40
xmax = tmax + (tmax - tmin) / 40
ymin = fmin - (fmax - fmin) / 20
ymax = fmax + (fmax - fmin) / 20
if kepstat.bitInBitmap(maskimg[i,j],2):
pylab.axes([0.06+float(j)*dx,0.05+i*dy,dx,dy],axisbg='lightslategray')
elif maskimg[i,j] == 0:
pylab.axes([0.06+float(j)*dx,0.05+i*dy,dx,dy],axisbg='black')
else:
pylab.axes([0.06+float(j)*dx,0.05+i*dy,dx,dy])
if j == int(xdim / 2) and i == 0:
pylab.setp(pylab.gca(),xticklabels=[],yticklabels=[])
elif j == 0 and i == int(ydim / 2):
pylab.setp(pylab.gca(),xticklabels=[],yticklabels=[])
else:
pylab.setp(pylab.gca(),xticklabels=[],yticklabels=[])
ptime = time * 1.0
ptime = numpy.insert(ptime,[0],ptime[0])
ptime = numpy.append(ptime,ptime[-1])
pflux = pixseries[i,j,:] * 1.0
pflux = numpy.insert(pflux,[0],-1000.0)
pflux = numpy.append(pflux,-1000.0)
pylab.plot(time,pixseries[i,j,:],color='#0000ff',linestyle='-',linewidth=0.5)
if not kepstat.bitInBitmap(maskimg[i,j],2):
pylab.fill(ptime,pflux,fc='lightslategray',linewidth=0.0,alpha=1.0)
pylab.fill(ptime,pflux,fc='#FFF380',linewidth=0.0,alpha=1.0)
if 'loc' in plottype:
pylab.xlim(xmin,xmax)
pylab.ylim(ymin,ymax)
if 'glob' in plottype:
pylab.xlim(xmin,xmax)
pylab.ylim(1.0e-10,numpy.nanmax(pixseries) * 1.05)
if 'full' in plottype:
pylab.xlim(xmin,xmax)
pylab.ylim(1.0e-10,ymax * 1.05)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
if plotfile.lower() != 'none':
pylab.savefig(plotfile)
# stop time
if status == 0:
kepmsg.clock('KEPPIXSERIES ended at',logfile,verbose)
return
def kepregr(infile, outfile, datacol, kmethod, kneighb, plot, plotlab, clobber,
verbose, logfile, status):
"""
Perform a k-nearest neighbor regression analysis.
"""
## startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 16
ysize = 6
lcolor = '#47AE10'
lwidth = 1.0
fcolor = '#9AFF9A'
falpha = 0.3
## log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPREGR -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'datacol=' + str(datacol) + ' '
call += 'kmethod=' + str(kmethod) + ' '
call += 'kneighb=' + str(kneighb) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
call += 'plotlab=' + str(plotlab) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
## start time
kepmsg.clock('KEPREGR started at', logfile, verbose)
## test log file
logfile = kepmsg.test(logfile)
## clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPREGR: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile, message, verbose)
## open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
if cadence == 0.0:
tstart, tstop, ncad, cadence, status = kepio.cadence(
instr, infile, logfile, verbose, status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
## fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
## read table structure
if status == 0:
table, status = kepio.readfitstab(infile, instr[1], logfile, verbose)
# read time and flux columns
if status == 0:
barytime, status = kepio.readtimecol(infile, table, logfile, verbose)
if status == 0:
flux, status = kepio.readfitscol(infile, instr[1].data, datacol,
logfile, verbose)
# filter input data table
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
naxis2 = 0
for i in range(len(table.field(0))):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(flux[i])
and flux[i] != 0.0):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN', True, comment, instr[1], outfile,
logfile, verbose)
## read table columns
if status == 0:
try:
intime = instr[1].data.field('barytime')
except:
intime, status = kepio.readfitscol(infile, instr[1].data, 'time',
logfile, verbose)
indata, status = kepio.readfitscol(infile, instr[1].data, datacol,
logfile, verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
if status == 0:
outdata = knn_predict(intime, indata, kmethod, kneighb)
## comment keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
## clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
if intime0 < 2.4e6: intime0 += 2.4e6
ptime = intime - intime0
# print ptime,intime,intime0
xlab = 'BJD $-$ %d' % intime0
## clean up y-axis units
if status == 0:
pout = indata * 1.0
pout2 = outdata * 1.0
nrm = len(str(int(numpy.nanmax(pout)))) - 1
pout = pout / 10**nrm
pout2 = pout2 / 10**nrm
ylab = '10$^%d$ %s' % (nrm, plotlab)
## data limits
xmin = numpy.nanmin(ptime)
xmax = numpy.nanmax(ptime)
ymin = numpy.min(pout)
ymax = numpy.nanmax(pout)
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime, [0], [ptime[0]])
ptime = append(ptime, [ptime[-1]])
pout = insert(pout, [0], [0.0])
pout = append(pout, 0.0)
pout2 = insert(pout2, [0], [0.0])
pout2 = append(pout2, 0.0)
## plot light curve
if status == 0 and plot:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
print('ERROR -- KEPREGR: install latex for scientific plotting')
status = 1
if status == 0 and plot:
pylab.figure(1, figsize=[xsize, ysize])
## plot regression data
ax = pylab.axes([0.06, 0.1, 0.93, 0.87])
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
# pylab.plot(ptime,pout,color='#ff9900',linestyle='-',linewidth=lwidth)
pylab.scatter(ptime, pout, color='#214CAE', s=5)
fill(ptime, pout, color=fcolor, linewidth=0.0, alpha=falpha)
pylab.plot(ptime[kneighb:-kneighb],
pout2[kneighb:-kneighb],
color=lcolor,
linestyle='-',
linewidth=lwidth * 2.0)
xlabel(xlab, {'color': 'k'})
ylabel(ylab, {'color': 'k'})
xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin >= 0.0:
ylim(ymin - yr * 0.01, ymax + yr * 0.01)
else:
ylim(1.0e-10, ymax + yr * 0.01)
pylab.grid()
pylab.draw()
pylab.savefig(re.sub('\.\S+', '.png', outfile), dpi=100)
## write output file
if status == 0:
for i in range(len(outdata)):
instr[1].data.field(datacol)[i] = outdata[i]
instr.writeto(outfile)
## close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
## end time
if (status == 0):
message = 'KEPREGR completed at'
else:
message = '\nKEPREGR aborted at'
kepmsg.clock(message, logfile, verbose)
def kepffi(ffifile,kepid,ra,dec,aperfile,imin,imax,iscale,cmap,npix,
verbose,logfile,status,cmdLine=False):
global pimg, zscale, zmin, zmax, xmin, xmax, ymin, ymax, quarter
global kepmag, skygroup, season, channel
global module, output, row, column, maskfile, plotfile
global pkepid, pkepmag, pra, pdec, colmap, mask
# input arguments
status = 0
seterr(all="ignore")
maskfile = 'kepffi-' + str(kepid) + '.txt'
plotfile = 'kepffi-' + str(kepid) + '.png'
zmin = imin; zmax = imax; zscale = iscale; colmap = cmap
# logg the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFFI -- '
call += 'ffifile='+ffifile+' '
call += 'kepid='+str(kepid)+' '
call += 'ra='+ra+' '
call += 'dec='+dec+' '
call += 'aperfile='+aperfile+' '
call += 'imin='+str(imin)+' '
call += 'imax='+str(imax)+' '
call += 'iscale='+str(iscale)+' '
call += 'cmap'+str(cmap)+' '
call += 'npix='+str(npix)+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPFFI started at',logfile,verbose)
# reference color map
if cmap == 'browse':
status = cmap_plot(cmdLine)
# open existing mask file
if kepio.fileexists(aperfile):
lines, status = kepio.openascii(aperfile,'r',logfile,verbose)
for line in lines:
line = line.strip().split('|')
y0 = int(line[3])
x0 = int(line[4])
pixels = line[5].split(';')
for pixel in pixels:
m = y0 + int(pixel.split(',')[0])
n = x0 + int(pixel.split(',')[1])
mask.append(str(m)+','+str(n))
status = kepio.closeascii(lines,logfile,verbose)
# RA and Dec conversion
if kepid == 'None' or kepid == 'none' or kepid.strip() == '':
try:
mra = float(ra)
mdec = float(dec)
except:
try:
mra,mdec = sex2dec(ra,dec)
except:
txt = 'ERROR -- no sensible RA and Dec coordinates provided'
sys.exit(txt)
# open FFI FITS file
if status == 0:
ffi, status = openfits(ffifile,'readonly')
try:
quarter = ffi[0].header['QUARTER']
except:
try:
dateobs = ffi[0].header['DATE-OBS']
if dateobs == '2009-04-24': quarter = 0
if dateobs == '2009-04-25': quarter = 0
if dateobs == '2009-04-26': quarter = 0
if dateobs == '2009-06-19': quarter = 2
if dateobs == '2009-08-19': quarter = 2
if dateobs == '2009-09-17': quarter = 2
if dateobs == '2009-10-19': quarter = 3
if dateobs == '2009-11-18': quarter = 3
if dateobs == '2009-12-17': quarter = 3
except:
txt = 'ERROR -- cannot determine quarter when FFI was taken. Either a\n'
txt += 'QUARTER or DATE-OBS keyword is expected in the primary header'
sys.exit(txt)
if quarter == 0: quarter = 1
if quarter < 0:
txt = 'ERROR -- cannot determine quarter from FFI. Try downloading a new\n'
txt += 'version of KeplerFFI.py from http://keplergo.arc.nasa.gov'
sys.exit()
if int(quarter) == 0:
season = 3
else:
season = (int(quarter) - 2) % 4
# locate target in MAST
try:
int(kepid)
kepid,ra,dec,kepmag,skygroup,channel,module,output,row,column \
= MASTKepID(kepid,season)
pkepmag = kepmag; pkepid = kepid
except:
kepid,ra,dec,kepmag,skygroup,channel,module,output,row,column \
= MASTRADec(mra,mdec,8.0,season)
ra,dec = dec2sex(ra,dec)
pra = ra; pdec = dec
print kepid,ra,dec,kepmag,skygroup,channel,module,output,row,column
# read and close FFI FITS file
img, status = readimage(ffi,int(channel))
status = closefits(ffi)
# print target data
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ' Column: %4s' % column
print ' Row: %4s' % row
print ''
# subimage of channel for plot
ymin = int(max([int(row)-npix/2,0]))
ymax = int(min([int(row)+npix/2+1,img.shape[0]]))
xmin = int(max([int(column)-npix/2,0]))
xmax = int(min([int(column)+npix/2+1,img.shape[1]]))
# intensity scale
nstat = 2; pixels = []
for i in range(ymin,ymax+1):
for j in range(xmin,xmax+1):
pixels.append(img[i,j])
pixels = array(sort(pixels),dtype=float32)
if int(float(len(pixels)) / 10 + 0.5) > nstat:
nstat = int(float(len(pixels)) / 10 + 0.5)
if not zmin:
zmin = median(pixels[:nstat])
if not zmax:
zmax = median(pixels[-nstat:])
if 'log' in zscale:
img = log10(img)
zmin = log10(zmin)
zmax = log10(zmax)
if ('sq' in zscale):
img = sqrt(img)
zmin = sqrt(zmin)
zmax = sqrt(zmax)
pimg = img[ymin:ymax,xmin:xmax]
# plot limits
ymin = float(ymin) - 0.5
ymax = float(ymax) - 0.5
xmin = float(xmin) - 0.5
xmax = float(xmax) - 0.5
# plot style
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 16,
'ytick.labelsize': 16}
pylab.rcParams.update(params)
except:
pass
if status == 0:
pylab.figure(figsize=[10,7])
plotimage(cmdLine)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
return
def kepdynamic(infile,outfile,fcol,pmin,pmax,nfreq,deltat,nslice,
plot,plotscale,cmap,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 12
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
numpy.seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPDYNAMIC -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'fcol='+fcol+' '
call += 'pmin='+str(pmin)+' '
call += 'pmax='+str(pmax)+' '
call += 'nfreq='+str(nfreq)+' '
call += 'deltat='+str(deltat)+' '
call += 'nslice='+str(nslice)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
call += 'plotscale='+plotscale+ ' '
call += 'cmap='+str(cmap)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('Start time is',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# error checking
if status == 0 and pmin >= pmax:
message = 'ERROR -- KEPDYNAMIC: PMIN must be less than PMAX'
status = kepmsg.err(logfile,message,verbose)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPDYNAMIC: ' + outfile + ' exists. Use clobber'
status = kepmsg.err(logfile,message,verbose)
# plot color map
if status == 0 and cmap == 'browse':
status = keplab.cmap_plot()
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table columns
if status == 0:
barytime, status = kepio.readtimecol(infile,instr[1].data,logfile,verbose)
if status == 0:
signal, status = kepio.readfitscol(infile,instr[1].data,fcol,logfile,verbose)
if status == 0:
barytime = barytime + bjdref
signal = signal / cadenom
# remove infinite data from time series
if status == 0:
incols = [barytime, signal]
outcols = kepstat.removeinfinlc(signal, incols)
barytime = outcols[0]
signal = outcols[1]
# period to frequency conversion
if status == 0:
fmin = 1.0 / pmax
fmax = 1.0 / pmin
deltaf = (fmax - fmin) / nfreq
# determine bounds of time slices
if status == 0:
t1 = []; t2 = []
dt = barytime[-1] - barytime[0]
dt -= deltat
if dt < 0:
message = 'ERROR -- KEPDYNAMIC: time slices are larger than data range'
status = kepmsg.err(logfile,message,verbose)
ds = dt / (nslice - 1)
for i in range(nslice):
t1.append(barytime[0] + ds * float(i))
t2.append(barytime[0] + deltat + ds * float(i))
# loop through time slices
if status == 0:
dynam = []
for i in range(nslice):
x = []; y = []
for j in range(len(barytime)):
if (barytime[j] >= t1[i] and barytime[j] <= t2[i]):
x.append(barytime[j])
y.append(signal[j])
x = array(x,dtype='float64')
y = array(y,dtype='float32')
y = y - median(y)
# determine FT power
fr, power = kepfourier.ft(x,y,fmin,fmax,deltaf,False)
for j in range(len(power)):
dynam.append(power[j])
print('Timeslice: %.4f Pmax: %.2E' % ((t2[i] + t1[i]) / 2, power.max()))
# define shape of results array
dynam = array(dynam,dtype='float64')
dynam.shape = len(t1),len(power)
# write output file
if status == 0:
instr.append(ImageHDU())
instr[-1].data = dynam.transpose()
instr[-1].header.update('EXTNAME','DYNAMIC FT','extension name')
instr[-1].header.update('WCSAXES',2,'number of WCS axes')
instr[-1].header.update('CRPIX1',0.5,'reference pixel along axis 1')
instr[-1].header.update('CRPIX2',0.5,'reference pixel along axis 2')
instr[-1].header.update('CRVAL1',t1[0],'time at reference pixel (BJD)')
instr[-1].header.update('CRVAL2',fmin,'frequency at reference pixel (1/day)')
instr[-1].header.update('CDELT1',(barytime[-1] - barytime[0]) / nslice,
'pixel scale in dimension 1 (days)')
instr[-1].header.update('CDELT2',deltaf,'pixel scale in dimension 2 (1/day)')
instr[-1].header.update('CTYPE1','BJD','data type of dimension 1')
instr[-1].header.update('CTYPE2','FREQUENCY','data type of dimension 2')
instr.writeto(outfile)
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# clean up x-axis unit
if status == 0:
time0 = float(int(barytime[0] / 100) * 100.0)
barytime = barytime - time0
xlab = 'BJD $-$ %d' % time0
# image intensity min and max
if status == 0:
if 'rithmic' in plotscale:
dynam = numpy.log10(dynam)
elif 'sq' in plotscale:
dynam = numpy.sqrt(dynam)
elif 'logoflog' in plotscale:
dynam = numpy.log10(numpy.abs(numpy.log10(dynam)))
# dynam = -dynam
nstat = 2; pixels = []
for i in range(dynam.shape[0]):
for j in range(dynam.shape[1]):
pixels.append(dynam[i,j])
pixels = array(sort(pixels),dtype=float32)
if int(float(len(pixels)) * 0.1 + 0.5) > nstat:
nstat = int(float(len(pixels)) * 0.1 + 0.5)
zmin = median(pixels[:nstat])
zmax = median(pixels[-1:])
if isnan(zmax):
zmax = median(pixels[-nstat/2:])
if isnan(zmax):
zmax = numpy.nanmax(pixels)
# plot power spectrum
if status == 0 and plot:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
pylab.figure(1,figsize=[xsize,ysize])
pylab.clf()
pylab.axes([0.08,0.113,0.91,0.86])
dynam = dynam.transpose()
pylab.imshow(dynam,origin='lower',aspect='auto',cmap=cmap,vmin=zmin,vmax=zmax,
extent=[barytime[0],barytime[-1],fmin,fmax],interpolation='bilinear')
xlabel(xlab, {'color' : 'k'})
ylabel(r'Frequency (d$^{-1}$)', {'color' : 'k'})
grid()
pylab.savefig(re.sub('\.\S+','.png',outfile),dpi=100)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
return status
## end time
if (status == 0):
message = 'KEPDYNAMIC completed at'
else:
message = '\nKEPDYNAMIC aborted at'
kepmsg.clock(message,logfile,verbose)
def keptransit(inputfile,outputfile,datacol,errorcol,periodini_d,rprsini,T0ini,
Eccini,arsini,incini,omegaini,LDparams,secini,fixperiod,fixrprs,fixT0,
fixEcc,fixars,fixinc,fixomega,fixsec,fixfluxoffset,removeflaggeddata,ftol=0.0001,fitter='nothing',norm=False,
clobber=False, plot=True,verbose=0,logfile='logfile.dat',status=0,cmdLine=False):
"""
tmod.lightcurve(xdata,period,rprs,T0,Ecc,ars, incl, omega, ld, sec)
input transit parameters are
Period in days
T0
rplanet / rstar
a / rstar
inclination
limb darkening code number:
0 = uniform
1 = linear
2 = quadratic
3 = square root
4 = non linear
LDarr:
u -- linear limb-darkening (set NL=1)
a, b -- quadratic limb-darkening (set NL=2)
c, d -- root-square limb-darkening (set NL= -2)
a1, a2, a3, a4 -- nonlinear limb-darkening (set NL=4)
Nothing at all -- uniform limb-darkening (set NL=0)
"""
np.seterr(all="ignore")
#write to a logfile
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPTRANSIT -- '
call += 'inputfile='+inputfile+' '
call += 'outputfile='+outputfile+' '
call += 'datacol='+str(datacol)+' '
call += 'errorcol='+str(errorcol)+' '
call += 'periodini_d='+str(periodini_d)+' '
call += 'rprsini='+str(rprsini)+' '
call += 'T0ini='+str(T0ini)+' '
call += 'Eccini='+str(Eccini)+' '
call += 'arsini='+str(arsini)+' '
call += 'incini='+str(incini)+' '
call += 'omegaini='+str(omegaini)+' '
call += 'LDparams='+str(LDparams)+' '
call += 'secini='+str(secini)+' '
call += 'fixperiod='+str(fixperiod)+' '
call += 'fixrprs='+str(fixrprs)+' '
call += 'fixT0='+str(fixT0)+' '
call += 'fixEcc='+str(fixEcc)+' '
call += 'fixars='+str(fixars)+' '
call += 'fixinc='+str(fixinc)+' '
call += 'fixomega='+str(fixomega)+' '
call += 'fixsec='+str(fixsec)+' '
call += 'fixfluxoffset='+str(fixfluxoffset)+' '
call += 'removeflaggeddata='+str(removeflaggeddata)+' '
call += 'ftol='+str(ftol)+' '
call += 'fitter='+str(fitter)+' '
call += 'norm='+str(norm)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
#chatter = 'n'
#if (verbose): chatter = 'y'
#call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
kepmsg.clock('KEPTRANSIT started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber:
status = kepio.clobber(outputfile,logfile,verbose)
if kepio.fileexists(outputfile):
message = 'ERROR -- KEPTRANSIT: ' + outputfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(inputfile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,
inputfile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(inputfile,instr[1],logfile,verbose)
if status == 0:
intime_o = table.field('time')
influx_o = table.field(datacol)
inerr_o = table.field(errorcol)
try:
qualflag = table.field('SAP_QUALITY')
except:
qualflag = np.zeros(len(intime_o))
if status == 0:
intime, indata, inerr, baddata = cutBadData(intime_o, influx_o, inerr_o,removeflaggeddata,qualflag)
if status == 0 and norm:
#first remove outliers before normalizing
threesig = 3.* np.std(indata)
mask = np.logical_and(indata< indata + threesig,indata > indata - threesig)
#now normalize
indata = indata / np.median(indata[mask])
if status == 0:
#need to check if LD params are sensible and in right format
LDparams = [float(i) for i in LDparams.split()]
incini = incini * np.pi / 180.
omegaini = omegaini * np.pi / 180.
if arsini*np.cos(incini) > 1.0 + rprsini:
message = 'The guess inclination and a/r* values result in a non-transing planet'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
fixed_dict = fix_params(fixperiod,fixrprs,fixT0,
fixEcc,fixars,fixinc,fixomega,fixsec,fixfluxoffset)
#force flux offset to be guessed at zero
fluxoffsetini = 0.0
if status == 0:
guess_params = [periodini_d,rprsini,T0ini,Eccini,arsini, incini, omegaini,
secini,fluxoffsetini]
print('cleaning done: about to fit transit')
if fitter == 'leastsq':
fit_output = leastsq(fit_tmod,guess_params,
args=[LDparams,intime,indata,inerr,fixed_dict,guess_params],
full_output=True,ftol=ftol)
elif fitter == 'fmin':
fit_output = fmin(fit_tmod2,guess_params,
args=[LDparams,intime,indata,inerr,fixed_dict,guess_params],
full_output=True,ftol=ftol,xtol=ftol)
elif fitter == 'anneal':
fit_output = anneal(fit_tmod2,guess_params,
args=[LDparams,intime,indata,inerr,fixed_dict,guess_params],
full_output=True)
if status == 0:
if fixed_dict['period'] == True:
newperiod = guess_params[0]
print('Fixed period (days) = ' + str(newperiod))
else:
newperiod = fit_output[0][0]
print('Fit period (days) = ' + str(newperiod))
if fixed_dict['rprs'] == True:
newrprs = guess_params[1]
print('Fixed R_planet / R_star = ' + str(newrprs))
else:
newrprs = fit_output[0][1]
print('Fit R_planet / R_star = ' + str(newrprs))
if fixed_dict['T0'] == True:
newT0 = guess_params[2]
print('Fixed T0 (BJD) = ' + str(newT0))
else:
newT0 = fit_output[0][2]
print('Fit T0 (BJD) = ' + str(newT0))
if fixed_dict['Ecc'] == True:
newEcc = guess_params[3]
print('Fixed eccentricity = ' + str(newEcc))
else:
newEcc = fit_output[0][3]
print('Fit eccentricity = ' + str(newEcc))
if fixed_dict['ars'] == True:
newars = guess_params[4]
print('Fixed a / R_star = ' + str(newars))
else:
newars = fit_output[0][4]
print('Fit a / R_star = ' + str(newars))
if fixed_dict['inc'] == True:
newinc = guess_params[5]
print('Fixed inclination (deg) = ' + str(newinc* 180. / np.pi))
else:
newinc = fit_output[0][5]
print('Fit inclination (deg) = ' + str(newinc* 180. / np.pi))
if fixed_dict['omega'] == True:
newomega = guess_params[6]
print('Fixed omega = ' + str(newomega))
else:
newomega = fit_output[0][6]
print('Fit omega = ' + str(newomega))
if fixed_dict['sec'] == True:
newsec = guess_params[7]
print('Fixed seconary eclipse depth = ' + str(newsec))
else:
newsec = fit_output[0][7]
print('Fit seconary eclipse depth = ' + str(newsec))
if fixfluxoffset == False:
newfluxoffset = fit_output[0][8]
print('Fit flux offset = ' + str(newfluxoffset))
modelfit = tmod.lightcurve(intime,newperiod,newrprs,newT0,newEcc,
newars,newinc,newomega,LDparams,newsec)
if fixfluxoffset == False:
modelfit += newfluxoffset
#output to a file
phi, fluxfold, modelfold, errorfold, phiNotFold = fold_data(intime,
modelfit,indata,inerr,newperiod,newT0)
make_outfile(instr,outputfile,phiNotFold,modelfit, baddata)
# end time
if (status == 0):
message = 'KEPTRANSIT completed at'
else:
message = '\nKEPTRANSIT aborted at'
kepmsg.clock(message,logfile,verbose)
if plot and status == 0:
do_plot(intime,modelfit,indata,inerr,newperiod,newT0,cmdLine)
def kepdraw(infile,outfile,datacol,ploterr,errcol,quality,
lcolor,lwidth,fcolor,falpha,labelsize,ticksize,
xsize,ysize,fullrange,chooserange,y1,y2,plotgrid,
ylabel,plottype,verbose,logfile,status,cmdLine=False):
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPDRAW -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
perr = 'n'
if (ploterr): perr = 'y'
call += 'ploterr='+perr+ ' '
call += 'errcol='+errcol+' '
qual = 'n'
if (quality): qual = 'y'
call += 'quality='+qual+ ' '
call += 'lcolor='+str(lcolor)+' '
call += 'lwidth='+str(lwidth)+' '
call += 'fcolor='+str(fcolor)+' '
call += 'falpha='+str(falpha)+' '
call += 'labelsize='+str(labelsize)+' '
call += 'ticksize='+str(ticksize)+' '
call += 'xsize='+str(xsize)+' '
call += 'ysize='+str(ysize)+' '
frange = 'n'
if (fullrange): frange = 'y'
call += 'fullrange='+frange+ ' '
crange = 'n'
if (chooserange): crange = 'y'
call += 'chooserange='+crange+ ' '
call += 'ymin='+str(y1)+' '
call += 'ymax='+str(y2)+' '
pgrid = 'n'
if (plotgrid): pgrid = 'y'
call += 'plotgrid='+pgrid+ ' '
call += 'ylabel='+str(ylabel)+' '
call += 'plottype='+plottype+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPDRAW started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# open input file
if status == 0:
struct, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(struct,infile,logfile,verbose,status)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,struct[1],logfile,verbose)
# read table columns
if status == 0:
intime, status = kepio.readtimecol(infile,table,logfile,verbose)
intime += bjdref
indata, status = kepio.readfitscol(infile,table,datacol,logfile,verbose)
indataerr, status = kepio.readfitscol(infile,table,errcol,logfile,verbose)
qualty, status = kepio.readfitscol(infile,table,'SAP_QUALITY',logfile,verbose)
# close infile
if status == 0:
status = kepio.closefits(struct,logfile,verbose)
# remove infinities and bad data
if status == 0:
if numpy.isnan(numpy.nansum(indataerr)):
indataerr[:] = 1.0e-5
work1 = numpy.array([intime, indata, indataerr, qualty],dtype='float64')
work1 = numpy.rot90(work1,3)
work1 = work1[~numpy.isnan(work1).any(1)]
work1 = work1[~numpy.isinf(work1).any(1)]
if quality:
work1 = work1[work1[:,0] == 0.0]
barytime = numpy.array(work1[:,3],dtype='float64')
data = numpy.array(work1[:,2],dtype='float32')
dataerr = numpy.array(work1[:,1],dtype='float32')
if len(barytime) == 0:
message = 'ERROR -- KEPDRAW: Plotting arrays are full of NaN'
status = kepmsg.err(logfile,message,verbose)
# clean up x-axis unit
if status == 0:
barytime0 = float(int(tstart / 100) * 100.0)
barytime -= barytime0
xlab = 'BJD $-$ %d' % barytime0
# clean up y-axis units
nrm = 0
try:
nrm = len(str(int(numpy.nanmax(data))))-1
except:
nrm = 0
data = data / 10**nrm
if 'e$^-$ s$^{-1}$' in ylabel or 'default' in ylabel:
if nrm == 0:
ylab1 = 'e$^-$ s$^{-1}$'
else:
ylab1 = '10$^{%d}$ e$^-$ s$^{-1}$' % nrm
else:
ylab1 = re.sub('_','-',ylabel)
# data limits
xmin = numpy.nanmin(barytime)
xmax = numpy.nanmax(barytime)
ymin = numpy.nanmin(data)
ymax = numpy.nanmax(data)
xr = xmax - xmin
yr = ymax - ymin
barytime = insert(barytime,[0],[barytime[0]])
barytime = append(barytime,[barytime[-1]])
data = insert(data,[0],[-10000.0])
data = append(data,-10000.0)
# define plot formats
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
pylab.rcParams.update(params)
except:
pass
# define size of plot on monitor screen
pylab.figure(figsize=[xsize,ysize])
# delete any fossil plots in the matplotlib window
pylab.clf()
# position axes inside the plotting window
# ax = pylab.axes([0.1,0.11,0.89,0.87])
ax = pylab.subplot(111)
pylab.subplots_adjust(0.06,0.15,0.92,0.83)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
ax.yaxis.set_major_locator(MaxNLocator(5))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=ticksize)
# if plot type is 'fast' plot data time series as points
if plottype == 'fast':
pylab.plot(barytime,data,'o',color=lcolor)
# if plot type is 'pretty' plot data time series as an unbroken line, retaining data gaps
else:
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for i in range(1,len(data)-1):
dt = barytime[i] - barytime[i-1]
if dt < work1:
ltime = numpy.append(ltime,barytime[i])
ldata = numpy.append(ldata,data[i])
else:
pylab.plot(ltime,ldata,color=lcolor,linestyle='-',linewidth=lwidth)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
pylab.plot(ltime,ldata,color=lcolor,linestyle='-',linewidth=lwidth)
# plot the fill color below data time series, with no data gaps
pylab.fill(barytime,data,fc=fcolor,linewidth=0.0,alpha=falpha)
# define plot x and y limits
pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin-yr*0.01 <= 0.0 or fullrange:
pylab.ylim(1.0e-10,ymax+yr*0.01)
else:
pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
if chooserange:
pylab.ylim(y1,y2)
# plot labels
pylab.xlabel(xlab, {'color' : 'k'})
try:
pylab.ylabel(ylab1, {'color' : 'k'})
except:
ylab1 = '10**%d e-/s' % nrm
pylab.ylabel(ylab1, {'color' : 'k'})
# make grid on plot
# if plotgrid: pylab.grid()
# TEMPORARY !!!!!!!!!!!!!!!!!!!
# btime = numpy.arange(barytime[0],barytime[-1],0.25) + 0.125
# bflux = numpy.zeros((len(btime)))
# j = 0
# work = numpy.array([])
# for i in range(1,len(barytime)-1):
# if barytime[i] >= btime[j] - 0.125 and barytime[i] < btime[j] + 0.125:
# work = numpy.append(work,data[i])
# else:
# bflux[j] = numpy.mean(work)
# work = numpy.array([])
# j += 1
# bflux[j] = numpy.mean(work)
#
# pylab.plot(btime,bflux,color='r',linestyle='',marker='D',markersize=20)
# print numpy.std(bflux)
#
# pylab.plot([0.0,10000.0],[-49.5,-49.5],color='k',linestyle='--',linewidth=2.0)
# pylab.plot([0.0,10000.0],[49.5,49.5],color='k',linestyle='--',linewidth=2.0)
## pylab.plot([0.0,10000.0],[15.5,15.5],color='k',linestyle=':',linewidth=4.0)
## pylab.plot([0.0,10000.0],[-15.5,-15.5],color='k',linestyle=':',linewidth=4.0)
## pylab.plot([0.0,10000.0],[-202,-202],color='k',linestyle='--',linewidth=2.0)
## pylab.plot([0.0,10000.0],[202,202],color='k',linestyle='--',linewidth=2.0)
## pylab.plot([0.0,10000.0],[0,0],color='k',linestyle=':',linewidth=4.0)
## pylab.plot([0.0,10000.0],[-81.*12.3,-81.*12.3],color='k',linestyle=':',linewidth=4.0)
ax.minorticks_on()
ax.tick_params('both', length=20, width=2, which='major')
ax.tick_params('both', length=10, width=1, which='minor')
# save plot to file
if status == 0 and outfile.lower() != 'none':
pylab.savefig(outfile)
# render plot
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# end time
if (status == 0):
message = 'KEPDRAW completed at'
else:
message = '\nKEPDRAW aborted at'
kepmsg.clock(message,logfile,verbose)
def kepdiffim(infile,
outfile,
plotfile,
imscale,
colmap,
filter,
function,
cutoff,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPDIFFIM -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'imscale=' + imscale + ' '
call += 'colmap=' + colmap + ' '
filt = 'n'
if (filter): filt = 'y'
call += 'filter=' + filt + ' '
call += 'function=' + function + ' '
call += 'cutoff=' + str(cutoff) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPDIFFIM started at: ', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPDIFFIM: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# reference color map
if colmap == 'browse':
status = cmap_plot()
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(
infile, logfile, verbose)
# print target data
if status == 0:
print('')
print(' KepID: %s' % kepid)
print(' RA (J2000): %s' % ra)
print('Dec (J2000): %s' % dec)
print(' KepMag: %s' % kepmag)
print(' SkyGroup: %2s' % skygroup)
print(' Season: %2s' % str(season))
print(' Channel: %2s' % channel)
print(' Module: %2s' % module)
print(' Output: %1s' % output)
print('')
# how many quality = 0 rows?
if status == 0:
npts = 0
nrows = len(fluxpixels)
for i in range(nrows):
if qual[i] == 0 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,ydim*xdim/2]):
npts += 1
time = empty((npts))
timecorr = empty((npts))
cadenceno = empty((npts))
quality = empty((npts))
pixseries = empty((ydim * xdim, npts))
errseries = empty((ydim * xdim, npts))
# construct output light curves
if status == 0:
np = 0
for i in range(ydim * xdim):
npts = 0
for k in range(nrows):
if qual[k] == 0 and \
numpy.isfinite(barytime[k]) and \
numpy.isfinite(fluxpixels[k,ydim*xdim/2]):
time[npts] = barytime[k]
timecorr[npts] = tcorr[k]
cadenceno[npts] = cadno[k]
quality[npts] = qual[k]
pixseries[i, npts] = fluxpixels[k, np]
errseries[i, npts] = errpixels[k, np]
npts += 1
np += 1
# define data sampling
if status == 0 and filter:
tpf, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0 and filter:
cadence, status = kepkey.cadence(tpf[1], infile, logfile, verbose)
tr = 1.0 / (cadence / 86400)
timescale = 1.0 / (cutoff / tr)
# define convolution function
if status == 0 and filter:
if function == 'boxcar':
filtfunc = numpy.ones(numpy.ceil(timescale))
elif function == 'gauss':
timescale /= 2
dx = numpy.ceil(timescale * 10 + 1)
filtfunc = kepfunc.gauss()
filtfunc = filtfunc([1.0, dx / 2 - 1.0, timescale],
linspace(0, dx - 1, dx))
elif function == 'sinc':
dx = numpy.ceil(timescale * 12 + 1)
fx = linspace(0, dx - 1, dx)
fx = fx - dx / 2 + 0.5
fx /= timescale
filtfunc = numpy.sinc(fx)
filtfunc /= numpy.sum(filtfunc)
# pad time series at both ends with noise model
if status == 0 and filter:
for i in range(ydim * xdim):
ave, sigma = kepstat.stdev(pixseries[i, :len(filtfunc)])
padded = numpy.append(kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma), pixseries[i,:])
ave, sigma = kepstat.stdev(pixseries[i, -len(filtfunc):])
padded = numpy.append(padded, kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma))
# convolve data
if status == 0:
convolved = convolve(padded, filtfunc, 'same')
# remove padding from the output array
if status == 0:
outdata = convolved[len(filtfunc):-len(filtfunc)]
# subtract low frequencies
if status == 0:
outmedian = median(outdata)
pixseries[i, :] = pixseries[i, :] - outdata + outmedian
# sum pixels over cadence
if status == 0:
np = 0
nrows = len(fluxpixels)
pixsum = zeros((ydim * xdim))
errsum = zeros((ydim * xdim))
for i in range(npts):
if quality[i] == 0:
pixsum += pixseries[:, i]
errsum += errseries[:, i]**2
np += 1
pixsum /= np
errsum = sqrt(errsum) / np
# calculate standard deviation pixels
if status == 0:
pixvar = zeros((ydim * xdim))
for i in range(npts):
if quality[i] == 0:
pixvar += (pixsum - pixseries[:, i] / errseries[:, i])**2
pixvar = numpy.sqrt(pixvar)
# median pixel errors
if status == 0:
errmed = empty((ydim * xdim))
for i in range(ydim * xdim):
errmed[i] = numpy.median(errseries[:, i])
# calculate chi distribution pixels
if status == 0:
pixdev = zeros((ydim * xdim))
for i in range(npts):
if quality[i] == 0:
pixdev += ((pixsum - pixseries[:, i]) / pixsum)**2
pixdev = numpy.sqrt(pixdev)
# pixdev = numpy.sqrt(pixvar) / errsum #errmed
# image scale and intensity limits
if status == 0:
pixsum_pl, zminsum, zmaxsum = kepplot.intScale1D(pixsum, imscale)
pixvar_pl, zminvar, zmaxvar = kepplot.intScale1D(pixvar, imscale)
pixdev_pl, zmindev, zmaxdev = kepplot.intScale1D(pixdev, imscale)
# construct output summed image
if status == 0:
imgsum = empty((ydim, xdim))
imgvar = empty((ydim, xdim))
imgdev = empty((ydim, xdim))
imgsum_pl = empty((ydim, xdim))
imgvar_pl = empty((ydim, xdim))
imgdev_pl = empty((ydim, xdim))
n = 0
for i in range(ydim):
for j in range(xdim):
imgsum[i, j] = pixsum[n]
imgvar[i, j] = pixvar[n]
imgdev[i, j] = pixdev[n]
imgsum_pl[i, j] = pixsum_pl[n]
imgvar_pl[i, j] = pixvar_pl[n]
imgdev_pl[i, j] = pixdev_pl[n]
n += 1
# construct output file
if status == 0:
instruct, status = kepio.openfits(infile, 'readonly', logfile, verbose)
status = kepkey.history(call, instruct[0], outfile, logfile, verbose)
hdulist = HDUList(instruct[0])
hdulist.writeto(outfile)
status = kepkey.new('EXTNAME', 'FLUX', 'name of extension',
instruct[2], outfile, logfile, verbose)
pyfits.append(outfile, imgsum, instruct[2].header)
status = kepkey.new('EXTNAME', 'CHI', 'name of extension', instruct[2],
outfile, logfile, verbose)
pyfits.append(outfile, imgvar, instruct[2].header)
status = kepkey.new('EXTNAME', 'STDDEV', 'name of extension',
instruct[2], outfile, logfile, verbose)
pyfits.append(outfile, imgdev, instruct[2].header)
status = kepkey.new('EXTNAME', 'APERTURE', 'name of extension',
instruct[2], outfile, logfile, verbose)
pyfits.append(outfile, instruct[2].data, instruct[2].header)
status = kepio.closefits(instruct, logfile, verbose)
# pixel limits of the subimage
if status == 0:
ymin = row
ymax = ymin + ydim
xmin = column
xmax = xmin + xdim
# plot limits for summed image
ymin = float(ymin) - 0.5
ymax = float(ymax) - 0.5
xmin = float(xmin) - 0.5
xmax = float(xmax) - 0.5
# plot style
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 10,
'ytick.labelsize': 10
}
pylab.rcParams.update(params)
except:
'ERROR -- KEPDIFFIM: install latex for scientific plotting'
status = 1
if status == 0:
plotimage(imgsum_pl, imgvar_pl, imgdev_pl, zminsum, zminvar, zmindev,
zmaxsum, zmaxvar, zmaxdev, xmin, xmax, ymin, ymax, colmap,
plotfile, cmdLine)
# stop time
kepmsg.clock('KEPDIFFIM ended at: ', logfile, verbose)
return
def kepstddev(infile,outfile,datacol,timescale,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 44
ticksize = 36
xsize = 16
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPSTDDEV -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'timescale='+str(timescale)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPSTDDEV started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPSTDDEV: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# filter input data table
if status == 0:
work1 = numpy.array([table.field('time'), table.field(datacol)])
work1 = numpy.rot90(work1,3)
work1 = work1[~numpy.isnan(work1).any(1)]
# read table columns
if status == 0:
intime = work1[:,1] + bjdref
indata = work1[:,0]
# calculate STDDEV in units of ppm
if status == 0:
stddev = running_frac_std(intime,indata,timescale/24) * 1.0e6
astddev = numpy.std(indata) * 1.0e6
cdpp = stddev / sqrt(timescale * 3600.0 / cadence)
# filter cdpp
if status == 0:
for i in range(len(cdpp)):
if cdpp[i] > median(cdpp) * 10.0: cdpp[i] = cdpp[i-1]
# calculate median STDDEV
if status == 0:
medcdpp = ones((len(cdpp)),dtype='float32') * median(cdpp[:])
# print '\nMedian %.1fhr standard deviation = %d ppm' % (timescale, median(stddev[:]))
print('\nStandard deviation = %d ppm' % astddev)
# calculate median STDDEV
if status == 0:
medcdpp = ones((len(cdpp)),dtype='float32') * median(cdpp[:])
print('Median %.1fhr CDPP = %d ppm' % (timescale, median(cdpp[:])))
# calculate RMS STDDEV
if status == 0:
rms, status = kepstat.rms(cdpp,zeros(len(stddev)),logfile,verbose)
rmscdpp = ones((len(cdpp)),dtype='float32') * rms
print(' RMS %.1fhr CDPP = %d ppm\n' % (timescale, rms))
# clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
ptime = intime - intime0
xlab = 'BJD $-$ %d' % intime0
# clean up y-axis units
if status == 0:
pout = copy(cdpp)
nrm = math.ceil(math.log10(median(cdpp))) - 1.0
# pout = pout / 10**nrm
# ylab = '%.1fhr $\sigma$ (10$^%d$ ppm)' % (timescale,nrm)
ylab = '%.1fhr $\sigma$ (ppm)' % timescale
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 36,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 32,
'ytick.labelsize': 36}
pylab.rcParams.update(params)
except:
pass
# define size of plot on monitor screen
pylab.figure(figsize=[xsize,ysize])
# delete any fossil plots in the matplotlib window
pylab.clf()
# position first axes inside the plotting window
ax = pylab.axes([0.07,0.15,0.92,0.83])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
ax.yaxis.set_major_locator(MaxNLocator(5))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90,fontsize=36)
# plot flux vs time
ltime = array([],dtype='float64')
ldata = array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for i in range(1,len(ptime)-1):
dt = ptime[i] - ptime[i-1]
if dt < work1:
ltime = append(ltime,ptime[i])
ldata = append(ldata,pout[i])
else:
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
ltime = array([],dtype='float64')
ldata = array([],dtype='float32')
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(ptime,pout,fc='#ffff00',linewidth=0.0,alpha=0.2)
# plot median CDPP
# pylab.plot(intime - intime0,medcdpp / 10**nrm,color='r',linestyle='-',linewidth=2.0)
# pylab.plot(intime - intime0,medcdpp,color='r',linestyle='-',linewidth=2.0)
# plot RMS CDPP
# pylab.plot(intime - intime0,rmscdpp / 10**nrm,color='r',linestyle='--',linewidth=2.0)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin - yr * 0.01 <= 0.0:
pylab.ylim(1.0e-10, ymax + yr * 0.01)
else:
pylab.ylim(ymin - yr * 0.01, ymax + yr * 0.01)
# plot labels
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab, {'color' : 'k'})
# make grid on plot
pylab.grid()
# render plot
if status == 0:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# add NaNs back into data
if status == 0:
n = 0
work1 = array([],dtype='float32')
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
for i in range(len(table.field(0))):
if isfinite(table.field('time')[i]) and isfinite(table.field(datacol)[i]):
work1 = append(work1,cdpp[n])
n += 1
else:
work1 = append(work1,nan)
# write output file
if status == 0:
status = kepkey.new('MCDPP%d' % (timescale * 10.0),medcdpp[0],
'Median %.1fhr CDPP (ppm)' % timescale,
instr[1],outfile,logfile,verbose)
status = kepkey.new('RCDPP%d' % (timescale * 10.0),rmscdpp[0],
'RMS %.1fhr CDPP (ppm)' % timescale,
instr[1],outfile,logfile,verbose)
colname = 'CDPP_%d' % (timescale * 10)
col1 = pyfits.Column(name=colname,format='E13.7',array=work1)
cols = instr[1].data.columns + col1
instr[1] = pyfits.new_table(cols,header=instr[1].header)
instr.writeto(outfile)
# comment keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
# close FITS
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
if (status == 0):
message = 'KEPSTDDEV completed at'
else:
message = '\nKEPSTDDEV aborted at'
kepmsg.clock(message,logfile,verbose)
def kepdetrend(infile,
outfile,
datacol,
errcol,
ranges1,
npoly1,
nsig1,
niter1,
ranges2,
npoly2,
nsig2,
niter2,
popnans,
plot,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 16
ysize = 9
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPDETREND -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'datacol=' + str(datacol) + ' '
call += 'errcol=' + str(errcol) + ' '
call += 'ranges1=' + str(ranges1) + ' '
call += 'npoly1=' + str(npoly1) + ' '
call += 'nsig1=' + str(nsig1) + ' '
call += 'niter1=' + str(niter1) + ' '
call += 'ranges2=' + str(ranges2) + ' '
call += 'npoly2=' + str(npoly2) + ' '
call += 'nsig2=' + str(nsig2) + ' '
call += 'niter2=' + str(niter2) + ' '
popn = 'n'
if (popnans): popn = 'y'
call += 'popnans=' + popn + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPDETREND started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPDETREND: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile, message, verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile, instr[1], logfile, verbose)
# filter input data table
if status == 0:
work1 = numpy.array(
[table.field('time'),
table.field(datacol),
table.field(errcol)])
work1 = numpy.rot90(work1, 3)
work1 = work1[~numpy.isnan(work1).any(1)]
# read table columns
if status == 0:
intime = work1[:, 2] + bjdref
indata = work1[:, 1]
inerr = work1[:, 0]
print intime
# time ranges for region 1 (region to be corrected)
if status == 0:
time1 = []
data1 = []
err1 = []
t1start, t1stop, status = kepio.timeranges(ranges1, logfile, verbose)
if status == 0:
cadencelis1, status = kepstat.filterOnRange(intime, t1start, t1stop)
if status == 0:
for i in range(len(cadencelis1)):
time1.append(intime[cadencelis1[i]])
data1.append(indata[cadencelis1[i]])
if errcol.lower() != 'none':
err1.append(inerr[cadencelis1[i]])
t0 = time1[0]
time1 = array(time1, dtype='float64') - t0
data1 = array(data1, dtype='float32')
if errcol.lower() != 'none':
err1 = array(err1, dtype='float32')
else:
err1 = None
# fit function to range 1
if status == 0:
functype = 'poly' + str(npoly1)
pinit = [data1.mean()]
if npoly1 > 0:
for i in range(npoly1):
pinit.append(0)
pinit = array(pinit, dtype='float32')
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx1, ploty1, status = \
kepfit.lsqclip(functype,pinit,time1,data1,err1,nsig1,nsig1,niter1,
logfile,verbose)
fit1 = indata * 0.0
for i in range(len(coeffs)):
fit1 += coeffs[i] * (intime - t0)**i
for i in range(len(intime)):
if i not in cadencelis1:
fit1[i] = 0.0
plotx1 += t0
print coeffs
# time ranges for region 2 (region that is correct)
if status == 0:
time2 = []
data2 = []
err2 = []
t2start, t2stop, status = kepio.timeranges(ranges2, logfile, verbose)
cadencelis2, status = kepstat.filterOnRange(intime, t2start, t2stop)
for i in range(len(cadencelis2)):
time2.append(intime[cadencelis2[i]])
data2.append(indata[cadencelis2[i]])
if errcol.lower() != 'none':
err2.append(inerr[cadencelis2[i]])
t0 = time2[0]
time2 = array(time2, dtype='float64') - t0
data2 = array(data2, dtype='float32')
if errcol.lower() != 'none':
err2 = array(err2, dtype='float32')
else:
err2 = None
# fit function to range 2
if status == 0:
functype = 'poly' + str(npoly2)
pinit = [data2.mean()]
if npoly2 > 0:
for i in range(npoly2):
pinit.append(0)
pinit = array(pinit, dtype='float32')
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx2, ploty2, status = \
kepfit.lsqclip(functype,pinit,time2,data2,err2,nsig2,nsig2,niter2,
logfile,verbose)
fit2 = indata * 0.0
for i in range(len(coeffs)):
fit2 += coeffs[i] * (intime - t0)**i
for i in range(len(intime)):
if i not in cadencelis1:
fit2[i] = 0.0
plotx2 += t0
# normalize data
if status == 0:
outdata = indata - fit1 + fit2
if errcol.lower() != 'none':
outerr = inerr * 1.0
# comment keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
# clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
if intime0 < 2.4e6: intime0 += 2.4e6
ptime = intime - intime0
plotx1 = plotx1 - intime0
plotx2 = plotx2 - intime0
xlab = 'BJD $-$ %d' % intime0
# clean up y-axis units
if status == 0:
pout = outdata
ploty1
ploty2
nrm = len(str(int(numpy.nanmax(indata)))) - 1
indata = indata / 10**nrm
pout = pout / 10**nrm
ploty1 = ploty1 / 10**nrm
ploty2 = ploty2 / 10**nrm
ylab = '10$^%d$ e$^-$ s$^{-1}$' % nrm
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = indata.min()
ymax = indata.max()
omin = pout.min()
omax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
oo = omax - omin
ptime = insert(ptime, [0], [ptime[0]])
ptime = append(ptime, [ptime[-1]])
indata = insert(indata, [0], [0.0])
indata = append(indata, [0.0])
pout = insert(pout, [0], [0.0])
pout = append(pout, 0.0)
# plot light curve
if status == 0 and plot:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
pass
pylab.figure(figsize=[xsize, ysize])
pylab.clf()
# plot original data
ax = pylab.axes([0.06, 0.523, 0.93, 0.45])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90, fontsize=12)
pylab.plot(ptime,
indata,
color=lcolor,
linestyle='-',
linewidth=lwidth)
pylab.fill(ptime, indata, color=fcolor, linewidth=0.0, alpha=falpha)
pylab.plot(plotx1, ploty1, color='r', linestyle='-', linewidth=2.0)
pylab.plot(plotx2, ploty2, color='g', linestyle='-', linewidth=2.0)
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin > 0.0:
pylab.ylim(ymin - yr * 0.01, ymax + yr * 0.01)
else:
pylab.ylim(1.0e-10, ymax + yr * 0.01)
pylab.ylabel(ylab, {'color': 'k'})
pylab.grid()
# plot detrended data
ax = pylab.axes([0.06, 0.073, 0.93, 0.45])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90, fontsize=12)
pylab.plot(ptime, pout, color=lcolor, linestyle='-', linewidth=lwidth)
pylab.fill(ptime, pout, color=fcolor, linewidth=0.0, alpha=falpha)
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin > 0.0:
pylab.ylim(omin - oo * 0.01, omax + oo * 0.01)
else:
pylab.ylim(1.0e-10, omax + oo * 0.01)
pylab.xlabel(xlab, {'color': 'k'})
try:
pylab.ylabel(ylab, {'color': 'k'})
except:
ylab = '10**%d e-/s' % nrm
pylab.ylabel(ylab, {'color': 'k'})
# render plot
if status == 0:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# write output file
if status == 0 and popnans:
instr[1].data.field(datacol)[good_data] = outdata
instr[1].data.field(errcol)[good_data] = outerr
instr[1].data.field(datacol)[bad_data] = None
instr[1].data.field(errcol)[bad_data] = None
instr.writeto(outfile)
elif status == 0 and not popnans:
for i in range(len(outdata)):
instr[1].data.field(datacol)[i] = outdata[i]
if errcol.lower() != 'none':
instr[1].data.field(errcol)[i] = outerr[i]
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
## end time
if (status == 0):
message = 'KEPDETREND completed at'
else:
message = '\nKEPDETREND aborted at'
kepmsg.clock(message, logfile, verbose)
def kepprfphot(infile,outroot,columns,rows,fluxes,border,background,focus,prfdir,ranges,
tolerance,ftolerance,qualflags,plt,clobber,verbose,logfile,status,cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPPRFPHOT -- '
call += 'infile='+infile+' '
call += 'outroot='+outroot+' '
call += 'columns='+columns+' '
call += 'rows='+rows+' '
call += 'fluxes='+fluxes+' '
call += 'border='+str(border)+' '
bground = 'n'
if (background): bground = 'y'
call += 'background='+bground+' '
focs = 'n'
if (focus): focs = 'y'
call += 'focus='+focs+' '
call += 'prfdir='+prfdir+' '
call += 'ranges='+ranges+' '
call += 'xtol='+str(tolerance)+' '
call += 'ftol='+str(ftolerance)+' '
quality = 'n'
if (qualflags): quality = 'y'
call += 'qualflags='+quality+' '
plotit = 'n'
if (plt): plotit = 'y'
call += 'plot='+plotit+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# test log file
logfile = kepmsg.test(logfile)
# start time
kepmsg.clock('KEPPRFPHOT started at',logfile,verbose)
# number of sources
if status == 0:
work = fluxes.strip()
work = re.sub(' ',',',work)
work = re.sub(';',',',work)
nsrc = len(work.split(','))
# construct inital guess vector for fit
if status == 0:
guess = []
try:
f = fluxes.strip().split(',')
x = columns.strip().split(',')
y = rows.strip().split(',')
for i in xrange(len(f)):
f[i] = float(f[i])
except:
f = fluxes
x = columns
y = rows
nsrc = len(f)
for i in xrange(nsrc):
try:
guess.append(float(f[i]))
except:
message = 'ERROR -- KEPPRF: Fluxes must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if len(x) != nsrc or len(y) != nsrc:
message = 'ERROR -- KEPFIT:FITMULTIPRF: Guesses for rows, columns and '
message += 'fluxes must have the same number of sources'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(x[i]))
except:
message = 'ERROR -- KEPPRF: Columns must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(y[i]))
except:
message = 'ERROR -- KEPPRF: Rows must be floating point numbers'
status = kepmsg.err(logfile,message,verbose)
if status == 0 and background:
if border == 0:
guess.append(0.0)
else:
for i in range((border+1)*2):
guess.append(0.0)
if status == 0 and focus:
guess.append(1.0); guess.append(1.0); guess.append(0.0)
# clobber output file
for i in range(nsrc):
outfile = '%s_%d.fits' % (outroot, i)
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPRFPHOT: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPPRFPHOT: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile,message,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, poscorr1, status = \
kepio.readTPF(infile,'POS_CORR1',logfile,verbose)
if status != 0:
poscorr1 = numpy.zeros((len(barytime)),dtype='float32')
poscorr1[:] = numpy.nan
status = 0
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, poscorr2, status = \
kepio.readTPF(infile,'POS_CORR2',logfile,verbose)
if status != 0:
poscorr2 = numpy.zeros((len(barytime)),dtype='float32')
poscorr2[:] = numpy.nan
status = 0
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
if status == 0:
struct, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(struct,infile,logfile,verbose,status)
# input file keywords and mask map
if status == 0:
cards0 = struct[0].header.cards
cards1 = struct[1].header.cards
cards2 = struct[2].header.cards
maskmap = copy(struct[2].data)
npix = numpy.size(numpy.nonzero(maskmap)[0])
# print target data
if status == 0 and verbose:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPPRFPHOT: No PRF file found in ' + prfdir
status = kepmsg.err(logfile,message,verbose)
# read PRF images
if status == 0:
prfn = [0,0,0,0,0]
crpix1p = numpy.zeros((5),dtype='float32')
crpix2p = numpy.zeros((5),dtype='float32')
crval1p = numpy.zeros((5),dtype='float32')
crval2p = numpy.zeros((5),dtype='float32')
cdelt1p = numpy.zeros((5),dtype='float32')
cdelt2p = numpy.zeros((5),dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
PRFx = arange(0.5,shape(prfn[0])[1]+0.5)
PRFy = arange(0.5,shape(prfn[0])[0]+0.5)
PRFx = (PRFx - size(PRFx) / 2) * cdelt1p[0]
PRFy = (PRFy - size(PRFy) / 2) * cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
if status == 0:
prf = zeros(shape(prfn[0]),dtype='float32')
prfWeight = zeros((5),dtype='float32')
for i in xrange(5):
prfWeight[i] = sqrt((column - crval1p[i])**2 + (row - crval2p[i])**2)
if prfWeight[i] == 0.0:
prfWeight[i] = 1.0e6
prf = prf + prfn[i] / prfWeight[i]
prf = prf / nansum(prf)
prf = prf / cdelt1p[0] / cdelt2p[0]
# location of the data image centered on the PRF image (in PRF pixel units)
if status == 0:
prfDimY = ydim / cdelt1p[0]
prfDimX = xdim / cdelt2p[0]
PRFy0 = (shape(prf)[0] - prfDimY) / 2
PRFx0 = (shape(prf)[1] - prfDimX) / 2
# construct input pixel image
if status == 0:
DATx = arange(column,column+xdim)
DATy = arange(row,row+ydim)
# interpolation function over the PRF
if status == 0:
splineInterpolation = scipy.interpolate.RectBivariateSpline(PRFx,PRFy,prf,kx=3,ky=3)
# construct mesh for background model
if status == 0:
bx = numpy.arange(1.,float(xdim+1))
by = numpy.arange(1.,float(ydim+1))
xx, yy = numpy.meshgrid(numpy.linspace(bx.min(), bx.max(), xdim),
numpy.linspace(by.min(), by.max(), ydim))
# Get time ranges for new photometry, flag good data
if status == 0:
barytime += bjdref
tstart,tstop,status = kepio.timeranges(ranges,logfile,verbose)
incl = numpy.zeros((len(barytime)),dtype='int')
for rownum in xrange(len(barytime)):
for winnum in xrange(len(tstart)):
if barytime[rownum] >= tstart[winnum] and \
barytime[rownum] <= tstop[winnum] and \
(qual[rownum] == 0 or qualflags) and \
numpy.isfinite(barytime[rownum]) and \
numpy.isfinite(numpy.nansum(fluxpixels[rownum,:])):
incl[rownum] = 1
if not numpy.in1d(1,incl):
message = 'ERROR -- KEPPRFPHOT: No legal data within the range ' + ranges
status = kepmsg.err(logfile,message,verbose)
# filter out bad data
if status == 0:
n = 0
nincl = (incl == 1).sum()
tim = zeros((nincl),'float64')
tco = zeros((nincl),'float32')
cad = zeros((nincl),'float32')
flu = zeros((nincl,len(fluxpixels[0])),'float32')
fer = zeros((nincl,len(fluxpixels[0])),'float32')
pc1 = zeros((nincl),'float32')
pc2 = zeros((nincl),'float32')
qua = zeros((nincl),'float32')
for rownum in xrange(len(barytime)):
if incl[rownum] == 1:
tim[n] = barytime[rownum]
tco[n] = tcorr[rownum]
cad[n] = cadno[rownum]
flu[n,:] = fluxpixels[rownum]
fer[n,:] = errpixels[rownum]
pc1[n] = poscorr1[rownum]
pc2[n] = poscorr2[rownum]
qua[n] = qual[rownum]
n += 1
barytime = tim * 1.0
tcorr = tco * 1.0
cadno = cad * 1.0
fluxpixels = flu * 1.0
errpixels = fer * 1.0
poscorr1 = pc1 * 1.0
poscorr2 = pc2 * 1.0
qual = qua * 1.0
# initialize plot arrays
if status == 0:
t = numpy.array([],dtype='float64')
fl = []; dx = []; dy = []; bg = []; fx = []; fy = []; fa = []; rs = []; ch = []
for i in range(nsrc):
fl.append(numpy.array([],dtype='float32'))
dx.append(numpy.array([],dtype='float32'))
dy.append(numpy.array([],dtype='float32'))
# Preparing fit data message
if status == 0:
progress = numpy.arange(nincl)
if verbose:
txt = 'Preparing...'
sys.stdout.write(txt)
sys.stdout.flush()
# single processor version
if status == 0:# and not cmdLine:
oldtime = 0.0
for rownum in xrange(numpy.min([80,len(barytime)])):
try:
if barytime[rownum] - oldtime > 0.5:
ftol = 1.0e-10; xtol = 1.0e-10
except:
pass
args = (fluxpixels[rownum,:],errpixels[rownum,:],DATx,DATy,nsrc,border,xx,yy,PRFx,PRFy,splineInterpolation,
guess,ftol,xtol,focus,background,rownum,80,float(x[i]),float(y[i]),False)
guess = PRFfits(args)
ftol = ftolerance; xtol = tolerance; oldtime = barytime[rownum]
# Fit the time series: multi-processing
if status == 0 and cmdLine:
anslist = []
cad1 = 0; cad2 = 50
for i in range(int(nincl/50) + 1):
try:
fluxp = fluxpixels[cad1:cad2,:]
errp = errpixels[cad1:cad2,:]
progress = numpy.arange(cad1,cad2)
except:
fluxp = fluxpixels[cad1:nincl,:]
errp = errpixels[cad1:nincl,:]
progress = numpy.arange(cad1,nincl)
try:
args = itertools.izip(fluxp,errp,itertools.repeat(DATx),itertools.repeat(DATy),
itertools.repeat(nsrc),itertools.repeat(border),itertools.repeat(xx),
itertools.repeat(yy),itertools.repeat(PRFx),itertools.repeat(PRFy),
itertools.repeat(splineInterpolation),itertools.repeat(guess),
itertools.repeat(ftolerance),itertools.repeat(tolerance),
itertools.repeat(focus),itertools.repeat(background),progress,
itertools.repeat(numpy.arange(cad1,nincl)[-1]),
itertools.repeat(float(x[0])),
itertools.repeat(float(y[0])),itertools.repeat(True))
p = multiprocessing.Pool()
model = [0.0]
model = p.imap(PRFfits,args,chunksize=1)
p.close()
p.join()
cad1 += 50; cad2 += 50
ans = array([array(item) for item in zip(*model)])
try:
anslist = numpy.concatenate((anslist,ans.transpose()),axis=0)
except:
anslist = ans.transpose()
guess = anslist[-1]
ans = anslist.transpose()
except:
pass
# single processor version
if status == 0 and not cmdLine:
oldtime = 0.0; ans = []
# for rownum in xrange(1,10):
for rownum in xrange(nincl):
proctime = time.time()
try:
if barytime[rownum] - oldtime > 0.5:
ftol = 1.0e-10; xtol = 1.0e-10
except:
pass
args = (fluxpixels[rownum,:],errpixels[rownum,:],DATx,DATy,nsrc,border,xx,yy,PRFx,PRFy,splineInterpolation,
guess,ftol,xtol,focus,background,rownum,nincl,float(x[0]),float(y[0]),True)
guess = PRFfits(args)
ans.append(guess)
ftol = ftolerance; xtol = tolerance; oldtime = barytime[rownum]
ans = array(ans).transpose()
# unpack the best fit parameters
if status == 0:
flux = []; OBJx = []; OBJy = []
na = shape(ans)[1]
for i in range(nsrc):
flux.append(ans[i,:])
OBJx.append(ans[nsrc+i,:])
OBJy.append(ans[nsrc*2+i,:])
try:
bterms = border + 1
if bterms == 1:
b = ans[nsrc*3,:]
else:
b = array([])
bkg = []
for i in range(na):
bcoeff = array([ans[nsrc*3:nsrc*3+bterms,i],ans[nsrc*3+bterms:nsrc*3+bterms*2,i]])
bkg.append(kepfunc.polyval2d(xx,yy,bcoeff))
b = numpy.append(b,nanmean(bkg[-1].reshape(bkg[-1].size)))
except:
b = zeros((na))
if focus:
wx = ans[-3,:]; wy = ans[-2,:]; angle = ans[-1,:]
else:
wx = ones((na)); wy = ones((na)); angle = zeros((na))
# constuct model PRF in detector coordinates
if status == 0:
residual = []; chi2 = []
for i in range(na):
f = empty((nsrc))
x = empty((nsrc))
y = empty((nsrc))
for j in range(nsrc):
f[j] = flux[j][i]
x[j] = OBJx[j][i]
y[j] = OBJy[j][i]
PRFfit = kepfunc.PRF2DET(f,x,y,DATx,DATy,wx[i],wy[i],angle[i],splineInterpolation)
if background and bterms == 1:
PRFfit = PRFfit + b[i]
if background and bterms > 1:
PRFfit = PRFfit + bkg[i]
# calculate residual of DATA - FIT
xdim = shape(xx)[1]
ydim = shape(yy)[0]
DATimg = numpy.empty((ydim,xdim))
n = 0
for k in range(ydim):
for j in range(xdim):
DATimg[k,j] = fluxpixels[i,n]
n += 1
PRFres = DATimg - PRFfit
residual.append(numpy.nansum(PRFres) / npix)
# calculate the sum squared difference between data and model
chi2.append(abs(numpy.nansum(numpy.square(DATimg - PRFfit) / PRFfit)))
# load the output arrays
if status == 0:
otime = barytime - bjdref
otimecorr = tcorr
ocadenceno = cadno
opos_corr1 = poscorr1
opos_corr2 = poscorr2
oquality = qual
opsf_bkg = b
opsf_focus1 = wx
opsf_focus2 = wy
opsf_rotation = angle
opsf_residual = residual
opsf_chi2 = chi2
opsf_flux_err = numpy.empty((na)); opsf_flux_err.fill(numpy.nan)
opsf_centr1_err = numpy.empty((na)); opsf_centr1_err.fill(numpy.nan)
opsf_centr2_err = numpy.empty((na)); opsf_centr2_err.fill(numpy.nan)
opsf_bkg_err = numpy.empty((na)); opsf_bkg_err.fill(numpy.nan)
opsf_flux = []
opsf_centr1 = []
opsf_centr2 = []
for i in range(nsrc):
opsf_flux.append(flux[i])
opsf_centr1.append(OBJx[i])
opsf_centr2.append(OBJy[i])
# load the plot arrays
if status == 0:
t = barytime
for i in range(nsrc):
fl[i] = flux[i]
dx[i] = OBJx[i]
dy[i] = OBJy[i]
bg = b
fx = wx
fy = wy
fa = angle
rs = residual
ch = chi2
# construct output primary extension
if status == 0:
for j in range(nsrc):
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
if cards0[i].key not in hdu0.header.keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=otime)
col2 = Column(name='TIMECORR',format='E',unit='d',array=otimecorr)
col3 = Column(name='CADENCENO',format='J',array=ocadenceno)
col4 = Column(name='PSF_FLUX',format='E',unit='e-/s',array=opsf_flux[j])
col5 = Column(name='PSF_FLUX_ERR',format='E',unit='e-/s',array=opsf_flux_err)
col6 = Column(name='PSF_BKG',format='E',unit='e-/s/pix',array=opsf_bkg)
col7 = Column(name='PSF_BKG_ERR',format='E',unit='e-/s',array=opsf_bkg_err)
col8 = Column(name='PSF_CENTR1',format='E',unit='pixel',array=opsf_centr1[j])
col9 = Column(name='PSF_CENTR1_ERR',format='E',unit='pixel',array=opsf_centr1_err)
col10 = Column(name='PSF_CENTR2',format='E',unit='pixel',array=opsf_centr2[j])
col11 = Column(name='PSF_CENTR2_ERR',format='E',unit='pixel',array=opsf_centr2_err)
col12 = Column(name='PSF_FOCUS1',format='E',array=opsf_focus1)
col13 = Column(name='PSF_FOCUS2',format='E',array=opsf_focus2)
col14 = Column(name='PSF_ROTATION',format='E',unit='deg',array=opsf_rotation)
col15 = Column(name='PSF_RESIDUAL',format='E',unit='e-/s',array=opsf_residual)
col16 = Column(name='PSF_CHI2',format='E',array=opsf_chi2)
col17 = Column(name='POS_CORR1',format='E',unit='pixel',array=opos_corr1)
col18 = Column(name='POS_CORR2',format='E',unit='pixel',array=opos_corr2)
col19 = Column(name='SAP_QUALITY',format='J',array=oquality)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,
col12,col13,col14,col15,col16,col17,col18,col19])
hdu1 = new_table(cols)
for i in range(len(cards1)):
if (cards1[i].key not in hdu1.header.keys() and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
outstr.append(hdu1)
# construct output mask bitmap extension
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
if cards2[i].key not in hdu2.header.keys():
hdu2.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
else:
hdu2.header.cards[cards2[i].key].comment = cards2[i].comment
outstr.append(hdu2)
# write output file
outstr.writeto(outroot + '_' + str(j) + '.fits',checksum=True)
# close input structure
status = kepio.closefits(struct,logfile,verbose)
# clean up x-axis unit
if status == 0:
barytime0 = float(int(t[0] / 100) * 100.0)
t -= barytime0
t = numpy.insert(t,[0],[t[0]])
t = numpy.append(t,[t[-1]])
xlab = 'BJD $-$ %d' % barytime0
# plot the light curves
if status == 0:
bg = numpy.insert(bg,[0],[-1.0e10])
bg = numpy.append(bg,-1.0e10)
fx = numpy.insert(fx,[0],[fx[0]])
fx = numpy.append(fx,fx[-1])
fy = numpy.insert(fy,[0],[fy[0]])
fy = numpy.append(fy,fy[-1])
fa = numpy.insert(fa,[0],[fa[0]])
fa = numpy.append(fa,fa[-1])
rs = numpy.insert(rs,[0],[-1.0e10])
rs = numpy.append(rs,-1.0e10)
ch = numpy.insert(ch,[0],[-1.0e10])
ch = numpy.append(ch,-1.0e10)
for i in range(nsrc):
# clean up y-axis units
nrm = math.ceil(math.log10(numpy.nanmax(fl[i]))) - 1.0
fl[i] /= 10**nrm
if nrm == 0:
ylab1 = 'e$^-$ s$^{-1}$'
else:
ylab1 = '10$^{%d}$ e$^-$ s$^{-1}$' % nrm
xx = copy(dx[i])
yy = copy(dy[i])
ylab2 = 'offset (pixels)'
# data limits
xmin = numpy.nanmin(t)
xmax = numpy.nanmax(t)
ymin1 = numpy.nanmin(fl[i])
ymax1 = numpy.nanmax(fl[i])
ymin2 = numpy.nanmin(xx)
ymax2 = numpy.nanmax(xx)
ymin3 = numpy.nanmin(yy)
ymax3 = numpy.nanmax(yy)
ymin4 = numpy.nanmin(bg[1:-1])
ymax4 = numpy.nanmax(bg[1:-1])
ymin5 = numpy.nanmin([numpy.nanmin(fx),numpy.nanmin(fy)])
ymax5 = numpy.nanmax([numpy.nanmax(fx),numpy.nanmax(fy)])
ymin6 = numpy.nanmin(fa[1:-1])
ymax6 = numpy.nanmax(fa[1:-1])
ymin7 = numpy.nanmin(rs[1:-1])
ymax7 = numpy.nanmax(rs[1:-1])
ymin8 = numpy.nanmin(ch[1:-1])
ymax8 = numpy.nanmax(ch[1:-1])
xr = xmax - xmin
yr1 = ymax1 - ymin1
yr2 = ymax2 - ymin2
yr3 = ymax3 - ymin3
yr4 = ymax4 - ymin4
yr5 = ymax5 - ymin5
yr6 = ymax6 - ymin6
yr7 = ymax7 - ymin7
yr8 = ymax8 - ymin8
fl[i] = numpy.insert(fl[i],[0],[0.0])
fl[i] = numpy.append(fl[i],0.0)
# plot style
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 12,
'ytick.labelsize': 12}
pylab.rcParams.update(params)
except:
pass
# define size of plot on monitor screen
pylab.figure(str(i+1) + ' ' + str(time.asctime(time.localtime())),figsize=[12,16])
# delete any fossil plots in the matplotlib window
pylab.clf()
# position first axes inside the plotting window
ax = pylab.axes([0.11,0.523,0.78,0.45])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# no x-label
pylab.setp(pylab.gca(),xticklabels=[])
# plot flux vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,fl[i][j])
else:
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
pylab.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(t,fl[i],fc='#ffff00',linewidth=0.0,alpha=0.2)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin1 - yr1 * 0.01 <= 0.0:
pylab.ylim(1.0e-10, ymax1 + yr1 * 0.01)
else:
pylab.ylim(ymin1 - yr1 * 0.01, ymax1 + yr1 * 0.01)
# plot labels
# pylab.xlabel(xlab, {'color' : 'k'})
try:
pylab.ylabel('Source (' + ylab1 + ')', {'color' : 'k'})
except:
ylab1 = '10**%d e-/s' % nrm
pylab.ylabel('Source (' + ylab1 + ')', {'color' : 'k'})
# make grid on plot
pylab.grid()
# plot centroid tracks - position second axes inside the plotting window
if focus and background:
axs = [0.11,0.433,0.78,0.09]
elif background or focus:
axs = [0.11,0.388,0.78,0.135]
else:
axs = [0.11,0.253,0.78,0.27]
ax1 = pylab.axes(axs)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot dx vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,xx[j-1])
else:
ax1.plot(ltime,ldata,color='r',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='r',linestyle='-',linewidth=1.0)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin2 - yr2 * 0.03, ymax2 + yr2 * 0.03)
# plot labels
ax1.set_ylabel('X-' + ylab2, color='k', fontsize=11)
# position second axes inside the plotting window
ax2 = ax1.twinx()
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot dy vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,yy[j-1])
else:
ax2.plot(ltime,ldata,color='g',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax2.plot(ltime,ldata,color='g',linestyle='-',linewidth=1.0)
# define plot y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin3 - yr3 * 0.03, ymax3 + yr3 * 0.03)
# plot labels
ax2.set_ylabel('Y-' + ylab2, color='k',fontsize=11)
# background - position third axes inside the plotting window
if background and focus:
axs = [0.11,0.343,0.78,0.09]
if background and not focus:
axs = [0.11,0.253,0.78,0.135]
if background:
ax1 = pylab.axes(axs)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot background vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,bg[j])
else:
ax1.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='#0000ff',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(t,bg,fc='#ffff00',linewidth=0.0,alpha=0.2)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin4 - yr4 * 0.03, ymax4 + yr4 * 0.03)
# plot labels
ax1.set_ylabel('Background \n(e$^-$ s$^{-1}$ pix$^{-1}$)',
multialignment='center', color='k',fontsize=11)
# make grid on plot
pylab.grid()
# position focus axes inside the plotting window
if focus and background:
axs = [0.11,0.253,0.78,0.09]
if focus and not background:
axs = [0.11,0.253,0.78,0.135]
if focus:
ax1 = pylab.axes(axs)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot x-axis PSF width vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,fx[j])
else:
ax1.plot(ltime,ldata,color='r',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='r',linestyle='-',linewidth=1.0)
# plot y-axis PSF width vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,fy[j])
else:
ax1.plot(ltime,ldata,color='g',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='g',linestyle='-',linewidth=1.0)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin5 - yr5 * 0.03, ymax5 + yr5 * 0.03)
# plot labels
ax1.set_ylabel('Pixel Scale\nFactor',
multialignment='center', color='k',fontsize=11)
# Focus rotation - position second axes inside the plotting window
ax2 = ax1.twinx()
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot dy vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,fa[j])
else:
ax2.plot(ltime,ldata,color='#000080',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax2.plot(ltime,ldata,color='#000080',linestyle='-',linewidth=1.0)
# define plot y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin6 - yr6 * 0.03, ymax6 + yr6 * 0.03)
# plot labels
ax2.set_ylabel('Rotation (deg)', color='k',fontsize=11)
# fit residuals - position fifth axes inside the plotting window
axs = [0.11,0.163,0.78,0.09]
ax1 = pylab.axes(axs)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.setp(pylab.gca(),xticklabels=[])
# plot residual vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,rs[j])
else:
ax1.plot(ltime,ldata,color='b',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='b',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(t,rs,fc='#ffff00',linewidth=0.0,alpha=0.2)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin7 - yr7 * 0.03, ymax7 + yr7 * 0.03)
# plot labels
ax1.set_ylabel('Residual \n(e$^-$ s$^{-1}$)',
multialignment='center', color='k',fontsize=11)
# make grid on plot
pylab.grid()
# fit chi square - position sixth axes inside the plotting window
axs = [0.11,0.073,0.78,0.09]
ax1 = pylab.axes(axs)
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# plot background vs time
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
dt = 0
work1 = 2.0 * cadence / 86400
for j in range(1,len(t)-1):
dt = t[j] - t[j-1]
if dt < work1:
ltime = numpy.append(ltime,t[j])
ldata = numpy.append(ldata,ch[j])
else:
ax1.plot(ltime,ldata,color='b',linestyle='-',linewidth=1.0)
ltime = numpy.array([],dtype='float64')
ldata = numpy.array([],dtype='float32')
ax1.plot(ltime,ldata,color='b',linestyle='-',linewidth=1.0)
# plot the fill color below data time series, with no data gaps
pylab.fill(t,ch,fc='#ffff00',linewidth=0.0,alpha=0.2)
# define plot x and y limits
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
pylab.ylim(ymin8 - yr8 * 0.03, ymax8 + yr8 * 0.03)
# plot labels
ax1.set_ylabel('$\chi^2$ (%d dof)' % (npix-len(guess)-1),color='k',fontsize=11)
pylab.xlabel(xlab, {'color' : 'k'})
# make grid on plot
pylab.grid()
# render plot
if status == 0:
pylab.savefig(outroot + '_' + str(i) + '.png')
if status == 0 and plt:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\n\nKEPPRFPHOT ended at',logfile,verbose)
return
def kepimages(infile,outfix,imtype,ranges,clobber,verbose,logfile,status):
# startup parameters
status = 0
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPIMAGES -- '
call += 'infile='+infile+' '
call += 'outfix='+outfix+' '
call += 'imtype='+imtype+' '
call += 'ranges='+str(ranges)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPIMAGES started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# open input file
status = 0
print ' '
instr = pyfits.open(infile,mode='readonly',memmap=True)
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# ingest time series data
if status == 0:
time = instr[1].data.field('TIME')[:] + 2454833.0
timecorr = instr[1].data.field('TIMECORR')[:]
cadenceno = instr[1].data.field('CADENCENO')[:]
raw_cnts = instr[1].data.field('RAW_CNTS')[:]
flux = instr[1].data.field('FLUX')[:]
flux_err = instr[1].data.field('FLUX_ERR')[:]
flux_bkg = instr[1].data.field('FLUX_BKG')[:]
flux_bkg_err = instr[1].data.field('FLUX_BKG_ERR')[:]
cosmic_rays = instr[1].data.field('COSMIC_RAYS')[:]
quality = instr[1].data.field('QUALITY')[:]
pos_corr1 = instr[1].data.field('POS_CORR1')[:]
pos_corr2 = instr[1].data.field('POS_CORR2')[:]
# choose output image
if status == 0:
if imtype.lower() == 'raw_cnts':
outim = raw_cnts
elif imtype.lower() == 'flux_err':
outim = flux_err
elif imtype.lower() == 'flux_bkg':
outim = flux_bkg
elif imtype.lower() == 'flux_bkg_err':
outim = flux_bkg_err
elif imtype.lower() == 'cosmic_rays':
outim = cosmic_rays
else:
outim = flux
# identify images to be exported
if status == 0:
tim = array([]); dat = array([]); err = array([])
tstart, tstop, status = kepio.timeranges(ranges,logfile,verbose)
if status == 0:
cadencelis, status = kepstat.filterOnRange(time,tstart,tstop)
# provide name for each output file and clobber if file exists
if status == 0:
for cadence in cadencelis:
outfile = outfix + '_BJD%.4f' % time[cadence] + '.fits'
if clobber and status == 0: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile) and status == 0:
message = 'ERROR -- KEPIMAGES: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,True)
# construct output primary extension
if status == 0:
ncad = 0
for cadence in cadencelis:
outfile = outfix + '_BJD%.4f' % time[cadence] + '.fits'
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
try:
if cards0[i].key not in hdu0.header.keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
except:
pass
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output image extension
hdu1 = ImageHDU(flux[cadence])
for i in range(len(cards2)):
try:
if cards2[i].key not in hdu1.header.keys():
hdu1.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
except:
pass
for i in range(len(cards1)):
if (cards1[i].key not in hdu1.header.keys() and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC','WCSN','TFIE']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
try:
int_time = cards1['INT_TIME'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find INT_TIME keyword')
try:
frametim = cards1['FRAMETIM'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find FRAMETIM keyword')
try:
num_frm = cards1['NUM_FRM'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find NUM_FRM keyword')
hdu1.header.update('EXTNAME','IMAGE','name of extension')
try:
hdu1.header.update('TELAPSE',frametim * num_frm,'[s] elapsed time for exposure')
except:
hdu1.header.update('TELAPSE',-999,'[s] elapsed time for exposure')
try:
hdu1.header.update('LIVETIME',int_time * num_frm,'[s] TELASPE multiplied by DEADC')
except:
hdu1.header.update('LIVETIME',-999,'[s] TELASPE multiplied by DEADC')
try:
hdu1.header.update('EXPOSURE',int_time * num_frm,'[s] time on source')
except:
hdu1.header.update('EXPOSURE',-999,'[s] time on source')
try:
hdu1.header.update('MIDTIME',time[cadence],'[BJD] mid-time of exposure')
except:
hdu1.header.update('MIDTIME',-999,'[BJD] mid-time of exposure')
try:
hdu1.header.update('TIMECORR',timecorr[cadence],'[d] barycenter - timeslice correction')
except:
hdu1.header.update('TIMECORR',-999,'[d] barycenter - timeslice correction')
try:
hdu1.header.update('CADENCEN',cadenceno[cadence],'unique cadence number')
except:
hdu1.header.update('CADENCEN',-999,'unique cadence number')
try:
hdu1.header.update('QUALITY',quality[cadence],'pixel quality flag')
except:
hdu1.header.update('QUALITY',-999,'pixel quality flag')
try:
if True in numpy.isfinite(cosmic_rays[cadence]):
hdu1.header.update('COSM_RAY',True,'cosmic ray detected?')
else:
hdu1.header.update('COSM_RAY',False,'cosmic ray detected?')
except:
hdu1.header.update('COSM_RAY',-999,'cosmic ray detected?')
try:
pc1 = str(pos_corr1[cadence])
pc2 = str(pos_corr2[cadence])
hdu1.header.update('POSCORR1',pc1,'[pix] column position correction')
hdu1.header.update('POSCORR2',pc2,'[pix] row position correction')
except:
hdu1.header.update('POSCORR1',-999,'[pix] column position correction')
hdu1.header.update('POSCORR2',-999,'[pix] row position correction')
outstr.append(hdu1)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
ncad += 1
txt = '\r%3d%% ' % (float(ncad) / float(len(cadencelis)) * 100.0)
txt += '%s ' % outfile
sys.stdout.write(txt)
sys.stdout.flush()
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
print '\n'
# end time
kepmsg.clock('KEPIMAGES finished at',logfile,verbose)
def kepbls(infile,
outfile,
datacol,
errcol,
minper,
maxper,
mindur,
maxdur,
nsearch,
nbins,
plot,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# startup parameters
numpy.seterr(all="ignore")
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 8
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPBLS -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'datacol=' + str(datacol) + ' '
call += 'errcol=' + str(errcol) + ' '
call += 'minper=' + str(minper) + ' '
call += 'maxper=' + str(maxper) + ' '
call += 'mindur=' + str(mindur) + ' '
call += 'maxdur=' + str(maxdur) + ' '
call += 'nsearch=' + str(nsearch) + ' '
call += 'nbins=' + str(nbins) + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPBLS started at', logfile, verbose)
# is duration greater than one bin in the phased light curve?
if float(nbins) * maxdur / 24.0 / maxper <= 1.0:
message = 'WARNING -- KEPBLS: ' + str(
maxdur) + ' hours transit duration < 1 phase bin when P = '
message += str(maxper) + ' days'
kepmsg.warn(logfile, message)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPBLS: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile, message, verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile, instr[1], logfile, verbose)
# filter input data table
if status == 0:
work1 = numpy.array(
[table.field('time'),
table.field(datacol),
table.field(errcol)])
work1 = numpy.rot90(work1, 3)
work1 = work1[~numpy.isnan(work1).any(1)]
# read table columns
if status == 0:
intime = work1[:, 2] + bjdref
indata = work1[:, 1]
inerr = work1[:, 0]
# test whether the period range is sensible
if status == 0:
tr = intime[-1] - intime[0]
if maxper > tr:
message = 'ERROR -- KEPBLS: maxper is larger than the time range of the input data'
status = kepmsg.err(logfile, message, verbose)
# prepare time series
if status == 0:
work1 = intime - intime[0]
work2 = indata - numpy.mean(indata)
# start period search
if status == 0:
srMax = numpy.array([], dtype='float32')
transitDuration = numpy.array([], dtype='float32')
transitPhase = numpy.array([], dtype='float32')
dPeriod = (maxper - minper) / nsearch
trialPeriods = numpy.arange(minper,
maxper + dPeriod,
dPeriod,
dtype='float32')
complete = 0
print ' '
for trialPeriod in trialPeriods:
fracComplete = float(complete) / float(len(trialPeriods) -
1) * 100.0
txt = '\r'
txt += 'Trial period = '
txt += str(int(trialPeriod))
txt += ' days ['
txt += str(int(fracComplete))
txt += '% complete]'
txt += ' ' * 20
sys.stdout.write(txt)
sys.stdout.flush()
complete += 1
srMax = numpy.append(srMax, 0.0)
transitDuration = numpy.append(transitDuration, numpy.nan)
transitPhase = numpy.append(transitPhase, numpy.nan)
trialFrequency = 1.0 / trialPeriod
# minimum and maximum transit durations in quantized phase units
duration1 = max(int(float(nbins) * mindur / 24.0 / trialPeriod), 2)
duration2 = max(
int(float(nbins) * maxdur / 24.0 / trialPeriod) + 1,
duration1 + 1)
# 30 minutes in quantized phase units
halfHour = int(0.02083333 / trialPeriod * nbins + 1)
# compute folded time series with trial period
work4 = numpy.zeros((nbins), dtype='float32')
work5 = numpy.zeros((nbins), dtype='float32')
phase = numpy.array(
((work1 * trialFrequency) -
numpy.floor(work1 * trialFrequency)) * float(nbins),
dtype='int')
ptuple = numpy.array([phase, work2, inerr])
ptuple = numpy.rot90(ptuple, 3)
phsort = numpy.array(sorted(ptuple, key=lambda ph: ph[2]))
for i in range(nbins):
elements = numpy.nonzero(phsort[:, 2] == float(i))[0]
work4[i] = numpy.mean(phsort[elements, 1])
work5[i] = math.sqrt(
numpy.sum(numpy.power(phsort[elements, 0], 2)) /
len(elements))
# extend the work arrays beyond nbins by wrapping
work4 = numpy.append(work4, work4[:duration2])
work5 = numpy.append(work5, work5[:duration2])
# calculate weights of folded light curve points
sigmaSum = numpy.nansum(numpy.power(work5, -2))
omega = numpy.power(work5, -2) / sigmaSum
# calculate weighted phased light curve
s = omega * work4
# iterate through trial period phase
for i1 in range(nbins):
# iterate through transit durations
for duration in range(duration1, duration2 + 1, int(halfHour)):
# calculate maximum signal residue
i2 = i1 + duration
sr1 = numpy.sum(numpy.power(s[i1:i2], 2))
sr2 = numpy.sum(omega[i1:i2])
sr = math.sqrt(sr1 / (sr2 * (1.0 - sr2)))
if sr > srMax[-1]:
srMax[-1] = sr
transitDuration[-1] = float(duration)
transitPhase[-1] = float((i1 + i2) / 2)
# normalize maximum signal residue curve
bestSr = numpy.max(srMax)
bestTrial = numpy.nonzero(srMax == bestSr)[0][0]
srMax /= bestSr
transitDuration *= trialPeriods / 24.0
BJD0 = numpy.array(transitPhase * trialPeriods / nbins,
dtype='float64') + intime[0] - 2454833.0
print '\n'
# clean up x-axis unit
if status == 0:
ptime = copy(trialPeriods)
xlab = 'Trial Period (days)'
# clean up y-axis units
if status == 0:
pout = copy(srMax)
ylab = 'Normalized Signal Residue'
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime, [0], [ptime[0]])
ptime = append(ptime, [ptime[-1]])
pout = insert(pout, [0], [0.0])
pout = append(pout, 0.0)
# plot light curve
if status == 0 and plot:
plotLatex = True
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
plotLatex = False
if status == 0 and plot:
pylab.figure(figsize=[xsize, ysize])
pylab.clf()
# plot data
ax = pylab.axes([0.06, 0.10, 0.93, 0.87])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90)
# plot curve
if status == 0 and plot:
pylab.plot(ptime[1:-1],
pout[1:-1],
color=lcolor,
linestyle='-',
linewidth=lwidth)
pylab.fill(ptime, pout, color=fcolor, linewidth=0.0, alpha=falpha)
pylab.xlabel(xlab, {'color': 'k'})
pylab.ylabel(ylab, {'color': 'k'})
pylab.grid()
# plot ranges
if status == 0 and plot:
pylab.xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin >= 0.0:
pylab.ylim(ymin - yr * 0.01, ymax + yr * 0.01)
else:
pylab.ylim(1.0e-10, ymax + yr * 0.01)
# render plot
if status == 0 and plot:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# append new BLS data extension to the output file
if status == 0:
col1 = Column(name='PERIOD',
format='E',
unit='days',
array=trialPeriods)
col2 = Column(name='BJD0',
format='D',
unit='BJD - 2454833',
array=BJD0)
col3 = Column(name='DURATION',
format='E',
unit='hours',
array=transitDuration)
col4 = Column(name='SIG_RES', format='E', array=srMax)
cols = ColDefs([col1, col2, col3, col4])
instr.append(new_table(cols))
instr[-1].header.cards['TTYPE1'].comment = 'column title: trial period'
instr[-1].header.cards[
'TTYPE2'].comment = 'column title: trial mid-transit zero-point'
instr[-1].header.cards[
'TTYPE3'].comment = 'column title: trial transit duration'
instr[-1].header.cards[
'TTYPE4'].comment = 'column title: normalized signal residue'
instr[-1].header.cards['TFORM1'].comment = 'column type: float32'
instr[-1].header.cards['TFORM2'].comment = 'column type: float64'
instr[-1].header.cards['TFORM3'].comment = 'column type: float32'
instr[-1].header.cards['TFORM4'].comment = 'column type: float32'
instr[-1].header.cards['TUNIT1'].comment = 'column units: days'
instr[-1].header.cards[
'TUNIT2'].comment = 'column units: BJD - 2454833'
instr[-1].header.cards['TUNIT3'].comment = 'column units: hours'
instr[-1].header.update('EXTNAME', 'BLS', 'extension name')
instr[-1].header.update('PERIOD', trialPeriods[bestTrial],
'most significant trial period [d]')
instr[-1].header.update('BJD0', BJD0[bestTrial] + 2454833.0,
'time of mid-transit [BJD]')
instr[-1].header.update('TRANSDUR', transitDuration[bestTrial],
'transit duration [hours]')
instr[-1].header.update('SIGNRES', srMax[bestTrial] * bestSr,
'maximum signal residue')
# history keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
# print best trial period results
if status == 0:
print ' Best trial period = %.5f days' % trialPeriods[bestTrial]
print ' Time of mid-transit = BJD %.5f' % (BJD0[bestTrial] +
2454833.0)
print ' Transit duration = %.5f hours' % transitDuration[
bestTrial]
print ' Maximum signal residue = %.4g \n' % (srMax[bestTrial] * bestSr)
# end time
if (status == 0):
message = 'KEPBLS completed at'
else:
message = '\nKEPBLS aborted at'
kepmsg.clock(message, logfile, verbose)
def kepprf(infile,
plotfile,
rownum,
columns,
rows,
fluxes,
border,
background,
focus,
prfdir,
xtol,
ftol,
imscale,
colmap,
labcol,
apercol,
plt,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPPRF -- '
call += 'infile=' + infile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'rownum=' + str(rownum) + ' '
call += 'columns=' + columns + ' '
call += 'rows=' + rows + ' '
call += 'fluxes=' + fluxes + ' '
call += 'border=' + str(border) + ' '
bground = 'n'
if (background): bground = 'y'
call += 'background=' + bground + ' '
focs = 'n'
if (focus): focs = 'y'
call += 'focus=' + focs + ' '
call += 'prfdir=' + prfdir + ' '
call += 'xtol=' + str(xtol) + ' '
call += 'ftol=' + str(xtol) + ' '
call += 'imscale=' + imscale + ' '
call += 'colmap=' + colmap + ' '
call += 'labcol=' + labcol + ' '
call += 'apercol=' + apercol + ' '
plotit = 'n'
if (plt): plotit = 'y'
call += 'plot=' + plotit + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# test log file
logfile = kepmsg.test(logfile)
# start time
kepmsg.clock('KEPPRF started at', logfile, verbose)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# construct inital guess vector for fit
if status == 0:
guess = []
try:
f = fluxes.strip().split(',')
x = columns.strip().split(',')
y = rows.strip().split(',')
for i in range(len(f)):
f[i] = float(f[i])
except:
f = fluxes
x = columns
y = rows
nsrc = len(f)
for i in range(nsrc):
try:
guess.append(float(f[i]))
except:
message = 'ERROR -- KEPPRF: Fluxes must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
if len(x) != nsrc or len(y) != nsrc:
message = 'ERROR -- KEPFIT:FITMULTIPRF: Guesses for rows, columns and '
message += 'fluxes must have the same number of sources'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
for i in range(nsrc):
try:
guess.append(float(x[i]))
except:
message = 'ERROR -- KEPPRF: Columns must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
for i in range(nsrc):
try:
guess.append(float(y[i]))
except:
message = 'ERROR -- KEPPRF: Rows must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0 and background:
if border == 0:
guess.append(0.0)
else:
for i in range((border + 1) * 2):
guess.append(0.0)
if status == 0 and focus:
guess.append(1.0)
guess.append(1.0)
guess.append(0.0)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPPRF: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile, message, verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(
infile, logfile, verbose)
npix = numpy.size(numpy.nonzero(maskimg)[0])
# print target data
if status == 0 and verbose:
print('')
print(' KepID: %s' % kepid)
print(' BJD: %.2f' % (barytime[rownum - 1] + 2454833.0))
print(' RA (J2000): %s' % ra)
print('Dec (J2000): %s' % dec)
print(' KepMag: %s' % kepmag)
print(' SkyGroup: %2s' % skygroup)
print(' Season: %2s' % str(season))
print(' Channel: %2s' % channel)
print(' Module: %2s' % module)
print(' Output: %1s' % output)
print('')
# is this a good row with finite timestamp and pixels?
if status == 0:
if not numpy.isfinite(barytime[rownum - 1]) or numpy.nansum(
fluxpixels[rownum - 1, :]) == numpy.nan:
message = 'ERROR -- KEPFIELD: Row ' + str(
rownum) + ' is a bad quality timestamp'
status = kepmsg.err(logfile, message, verbose)
# construct input pixel image
if status == 0:
flux = fluxpixels[rownum - 1, :]
ferr = errpixels[rownum - 1, :]
DATx = arange(column, column + xdim)
DATy = arange(row, row + ydim)
# if numpy.nanmin > 420000.0: flux -= 420000.0
# image scale and intensity limits of pixel data
if status == 0:
n = 0
DATimg = empty((ydim, xdim))
ERRimg = empty((ydim, xdim))
for i in range(ydim):
for j in range(xdim):
DATimg[i, j] = flux[n]
ERRimg[i, j] = ferr[n]
n += 1
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(
output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPPRF: No PRF file found in ' + prfdir
status = kepmsg.err(logfile, message, verbose)
# read PRF images
if status == 0:
prfn = [0, 0, 0, 0, 0]
crpix1p = numpy.zeros((5), dtype='float32')
crpix2p = numpy.zeros((5), dtype='float32')
crval1p = numpy.zeros((5), dtype='float32')
crval2p = numpy.zeros((5), dtype='float32')
cdelt1p = numpy.zeros((5), dtype='float32')
cdelt2p = numpy.zeros((5), dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
prfn = array(prfn)
PRFx = arange(0.5, shape(prfn[0])[1] + 0.5)
PRFy = arange(0.5, shape(prfn[0])[0] + 0.5)
PRFx = (PRFx - size(PRFx) / 2) * cdelt1p[0]
PRFy = (PRFy - size(PRFy) / 2) * cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
if status == 0:
prf = zeros(shape(prfn[0]), dtype='float32')
prfWeight = zeros((5), dtype='float32')
for i in range(5):
prfWeight[i] = sqrt((column - crval1p[i])**2 +
(row - crval2p[i])**2)
if prfWeight[i] == 0.0:
prfWeight[i] = 1.0e-6
prf = prf + prfn[i] / prfWeight[i]
prf = prf / nansum(prf) / cdelt1p[0] / cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
# if status == 0:
# prf = zeros(shape(prfn[0,:,:]),dtype='float32')
# px = crval1p + len(PRFx) / 2 * cdelt1p[0]
# py = crval2p + len(PRFy) / 2 * cdelt2p[0]
# pp = [[px[0],py[0]],
# [px[1],py[1]],
# [px[2],py[2]],
# [px[3],py[3]],
# [px[4],py[4]]]
# for index,value in ndenumerate(prf):
# pz = prfn[:,index[0],index[1]]
# prf[index] = griddata(pp, pz, ([column], [row]), method='linear')
# print shape(prf)
# location of the data image centered on the PRF image (in PRF pixel units)
if status == 0:
prfDimY = int(ydim / cdelt1p[0])
prfDimX = int(xdim / cdelt2p[0])
PRFy0 = (shape(prf)[0] - prfDimY) / 2
PRFx0 = (shape(prf)[1] - prfDimX) / 2
# interpolation function over the PRF
if status == 0:
splineInterpolation = scipy.interpolate.RectBivariateSpline(
PRFx, PRFy, prf)
# construct mesh for background model
if status == 0 and background:
bx = numpy.arange(1., float(xdim + 1))
by = numpy.arange(1., float(ydim + 1))
xx, yy = numpy.meshgrid(numpy.linspace(bx.min(), bx.max(), xdim),
numpy.linspace(by.min(), by.max(), ydim))
# fit PRF model to pixel data
if status == 0:
start = time.time()
if focus and background:
args = (DATx, DATy, DATimg, ERRimg, nsrc, border, xx, yy,
splineInterpolation, float(x[0]), float(y[0]))
ans = fmin_powell(kepfunc.PRFwithFocusAndBackground,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
elif focus and not background:
args = (DATx, DATy, DATimg, ERRimg, nsrc, splineInterpolation,
float(x[0]), float(y[0]))
ans = fmin_powell(kepfunc.PRFwithFocus,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
elif background and not focus:
args = (DATx, DATy, DATimg, ERRimg, nsrc, border, xx, yy,
splineInterpolation, float(x[0]), float(y[0]))
ans = fmin_powell(kepfunc.PRFwithBackground,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
else:
args = (DATx, DATy, DATimg, ERRimg, nsrc, splineInterpolation,
float(x[0]), float(y[0]))
ans = fmin_powell(kepfunc.PRF,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
print('Convergence time = %.2fs\n' % (time.time() - start))
# pad the PRF data if the PRF array is smaller than the data array
if status == 0:
flux = []
OBJx = []
OBJy = []
PRFmod = numpy.zeros((prfDimY, prfDimX))
if PRFy0 < 0 or PRFx0 < 0.0:
PRFmod = numpy.zeros((prfDimY, prfDimX))
superPRF = zeros((prfDimY + 1, prfDimX + 1))
superPRF[abs(PRFy0):abs(PRFy0) + shape(prf)[0],
abs(PRFx0):abs(PRFx0) + shape(prf)[1]] = prf
prf = superPRF * 1.0
PRFy0 = 0
PRFx0 = 0
# rotate the PRF model around its center
if focus:
angle = ans[-1]
prf = rotate(prf, -angle, reshape=False, mode='nearest')
# iterate through the sources in the best fit PSF model
for i in range(nsrc):
flux.append(ans[i])
OBJx.append(ans[nsrc + i])
OBJy.append(ans[nsrc * 2 + i])
# calculate best-fit model
y = (OBJy[i] - mean(DATy)) / cdelt1p[0]
x = (OBJx[i] - mean(DATx)) / cdelt2p[0]
prfTmp = shift(prf, [y, x], order=3, mode='constant')
prfTmp = prfTmp[PRFy0:PRFy0 + prfDimY, PRFx0:PRFx0 + prfDimX]
PRFmod = PRFmod + prfTmp * flux[i]
wx = 1.0
wy = 1.0
angle = 0
b = 0.0
# write out best fit parameters
if verbose:
txt = 'Flux = %10.2f e-/s ' % flux[i]
txt += 'X = %9.4f pix ' % OBJx[i]
txt += 'Y = %9.4f pix ' % OBJy[i]
kepmsg.log(logfile, txt, True)
#
# params = {'backend': 'png',
# 'axes.linewidth': 2.5,
# 'axes.labelsize': 24,
# 'axes.font': 'sans-serif',
# 'axes.fontweight' : 'bold',
# 'text.fontsize': 12,
# 'legend.fontsize': 12,
# 'xtick.labelsize': 24,
# 'ytick.labelsize': 24}
# pylab.rcParams.update(params)
#
# pylab.figure(figsize=[20,10])
# ax = pylab.axes([0.05,0.08,0.46,0.9])
# xxx = numpy.arange(397.5,402.5,0.02)
# yyy = numpy.sum(PRFmod,axis=0) / numpy.max(numpy.sum(PRFmod,axis=0))
# pylab.plot(xxx,yyy,color='b',linewidth=3.0)
# xxx = numpy.append(numpy.insert(xxx,[0],[xxx[0]]),xxx[-1])
# yyy = numpy.append(numpy.insert(yyy,[0],[0.0]),yyy[-1])
# pylab.fill(xxx,yyy,fc='y',linewidth=0.0,alpha=0.3)
# pylab.xlabel('Pixel Column Number')
# pylab.xlim(397.5,402.5)
# pylab.ylim(1.0e-30,1.02)
# for xmaj in numpy.arange(397.5,402.5,1.0):
# pylab.plot([xmaj,xmaj],[0.0,1.1],color='k',linewidth=0.5,linestyle=':')
# for xmaj in numpy.arange(0.2,1.2,0.2):
# pylab.plot([0.0,2000.0],[xmaj,xmaj],color='k',linewidth=0.5,linestyle=':')
#
#
# ax = pylab.axes([0.51,0.08,0.46,0.9])
# xxx = numpy.arange(32.5,37.5,0.02)
# yyy = numpy.sum(PRFmod,axis=1) / numpy.max(numpy.sum(PRFmod,axis=1))
# pylab.plot(xxx,yyy,color='b',linewidth=3.0)
# xxx = numpy.append(numpy.insert(xxx,[0],[xxx[0]]),xxx[-1])
# yyy = numpy.append(numpy.insert(yyy,[0],[0.0]),yyy[-1])
# pylab.fill(xxx,yyy,fc='y',linewidth=0.0,alpha=0.3)
# pylab.setp(pylab.gca(),yticklabels=[])
# pylab.xlabel('Pixel Row Number')
# pylab.xlim(32.5,37.5)
# pylab.ylim(1.0e-30,1.02)
# for xmaj in numpy.arange(32.5,37.5,1.0):
# pylab.plot([xmaj,xmaj],[0.0,1.1],color='k',linewidth=0.5,linestyle=':')
# for xmaj in numpy.arange(0.2,1.2,0.2):
# pylab.plot([0.0,2000.0],[xmaj,xmaj],color='k',linewidth=0.5,linestyle=':')
# pylab.ion()
# pylab.plot([])
# pylab.ioff()
if verbose and background:
bterms = border + 1
if bterms == 1:
b = ans[nsrc * 3]
else:
bcoeff = array([
ans[nsrc * 3:nsrc * 3 + bterms],
ans[nsrc * 3 + bterms:nsrc * 3 + bterms * 2]
])
bkg = kepfunc.polyval2d(xx, yy, bcoeff)
b = nanmean(bkg.reshape(bkg.size))
txt = '\n Mean background = %.2f e-/s' % b
kepmsg.log(logfile, txt, True)
if focus:
wx = ans[-3]
wy = ans[-2]
angle = ans[-1]
if verbose and focus:
if not background: kepmsg.log(logfile, '', True)
kepmsg.log(logfile, ' X/Y focus factors = %.3f/%.3f' % (wx, wy),
True)
kepmsg.log(logfile, 'PRF rotation angle = %.2f deg' % angle, True)
# measure flux fraction and contamination
# LUGER: This looks horribly bugged. ``PRFall`` is certainly NOT the sum of the all the sources.
if status == 0:
PRFall = kepfunc.PRF2DET(flux, OBJx, OBJy, DATx, DATy, wx, wy, angle,
splineInterpolation)
PRFone = kepfunc.PRF2DET([flux[0]], [OBJx[0]], [OBJy[0]], DATx, DATy,
wx, wy, angle, splineInterpolation)
# LUGER: Add up contaminant fluxes
PRFcont = np.zeros_like(PRFone)
for ncont in range(1, len(flux)):
PRFcont += kepfunc.PRF2DET([flux[ncont]], [OBJx[ncont]],
[OBJy[ncont]], DATx, DATy, wx, wy,
angle, splineInterpolation)
PRFcont[np.where(PRFcont < 0)] = 0
FluxInMaskAll = numpy.nansum(PRFall)
FluxInMaskOne = numpy.nansum(PRFone)
FluxInAperAll = 0.0
FluxInAperOne = 0.0
FluxInAperAllTrue = 0.0
for i in range(1, ydim):
for j in range(1, xdim):
if kepstat.bitInBitmap(maskimg[i, j], 2):
FluxInAperAll += PRFall[i, j]
FluxInAperOne += PRFone[i, j]
FluxInAperAllTrue += PRFone[i, j] + PRFcont[i, j]
FluxFraction = FluxInAperOne / flux[0]
try:
Contamination = (FluxInAperAll - FluxInAperOne) / FluxInAperAll
except:
Contamination = 0.0
# LUGER: Pixel crowding metrics
Crowding = PRFone / (PRFone + PRFcont)
# LUGER: Optimal aperture crowding metric
CrowdAper = FluxInAperOne / FluxInAperAllTrue
kepmsg.log(
logfile,
'\n Total flux in mask = %.2f e-/s' % FluxInMaskAll,
True)
kepmsg.log(
logfile,
' Target flux in mask = %.2f e-/s' % FluxInMaskOne,
True)
kepmsg.log(
logfile,
' Total flux in aperture = %.2f e-/s' % FluxInAperAll,
True)
kepmsg.log(
logfile,
' Target flux in aperture = %.2f e-/s' % FluxInAperOne,
True)
kepmsg.log(
logfile, ' Target flux fraction in aperture = %.2f%%' %
(FluxFraction * 100.0), True)
kepmsg.log(
logfile, 'Contamination fraction in aperture = %.2f%%' %
(Contamination * 100.0), True)
kepmsg.log(logfile,
' Crowding metric in aperture = %.4f' % (CrowdAper),
True)
# constuct model PRF in detector coordinates
if status == 0:
PRFfit = PRFall + 0.0
if background and bterms == 1:
PRFfit = PRFall + b
if background and bterms > 1:
PRFfit = PRFall + bkg
# calculate residual of DATA - FIT
if status == 0:
PRFres = DATimg - PRFfit
FLUXres = numpy.nansum(PRFres) / npix
# calculate the sum squared difference between data and model
if status == 0:
Pearson = abs(numpy.nansum(numpy.square(DATimg - PRFfit) / PRFfit))
Chi2 = numpy.nansum(
numpy.square(DATimg - PRFfit) / numpy.square(ERRimg))
DegOfFreedom = npix - len(guess) - 1
try:
kepmsg.log(logfile, '\n Residual flux = %.2f e-/s' % FLUXres,
True)
kepmsg.log(
logfile, 'Pearson\'s chi^2 test = %d for %d dof' %
(Pearson, DegOfFreedom), True)
except:
pass
kepmsg.log(
logfile,
' Chi^2 test = %d for %d dof' % (Chi2, DegOfFreedom),
True)
# image scale and intensity limits for plotting images
if status == 0:
imgdat_pl, zminfl, zmaxfl = kepplot.intScale2D(DATimg, imscale)
imgprf_pl, zminpr, zmaxpr = kepplot.intScale2D(PRFmod, imscale)
imgfit_pl, zminfi, zmaxfi = kepplot.intScale2D(PRFfit, imscale)
imgres_pl, zminre, zmaxre = kepplot.intScale2D(PRFres, 'linear')
if imscale == 'linear':
zmaxpr *= 0.9
elif imscale == 'logarithmic':
zmaxpr = numpy.max(zmaxpr)
zminpr = zmaxpr / 2
# plot style
if status == 0:
pylab.figure(figsize=[12, 10])
pylab.clf()
plotimage(imgdat_pl, zminfl, zmaxfl, 1, row, column, xdim, ydim, 0.07,
0.53, 'observation', colmap, labcol)
# pylab.text(830.0,242.1,'A',horizontalalignment='center',verticalalignment='center',
# fontsize=28,fontweight=500,color='white')
# pylab.text(831.1,240.62,'B',horizontalalignment='center',verticalalignment='center',
# fontsize=28,fontweight=500,color='white')
# plotimage(imgprf_pl,0.0,zmaxpr/0.5,2,row,column,xdim,ydim,0.52,0.52,'model',colmap)
plotimage(imgprf_pl, zminpr, zmaxpr, 2, row, column, xdim, ydim, 0.44,
0.53, 'model', colmap, labcol)
kepplot.borders(maskimg, xdim, ydim, pixcoord1, pixcoord2, 1, apercol,
'--', 0.5)
kepplot.borders(maskimg, xdim, ydim, pixcoord1, pixcoord2, 2, apercol,
'-', 3.0)
plotimage(imgfit_pl,
zminfl,
zmaxfl,
3,
row,
column,
xdim,
ydim,
0.07,
0.08,
'fit',
colmap,
labcol,
crowd=Crowding)
# plotimage(imgres_pl,-zmaxre,zmaxre,4,row,column,xdim,ydim,0.44,0.08,'residual',colmap,'k')
plotimage(imgres_pl, zminfl, zmaxfl, 4, row, column, xdim, ydim, 0.44,
0.08, 'residual', colmap, labcol)
# plot data color bar
# barwin = pylab.axes([0.84,0.53,0.06,0.45])
barwin = pylab.axes([0.84, 0.08, 0.06, 0.9])
if imscale == 'linear':
brange = numpy.arange(zminfl, zmaxfl, (zmaxfl - zminfl) / 1000)
elif imscale == 'logarithmic':
brange = numpy.arange(10.0**zminfl, 10.0**zmaxfl,
(10.0**zmaxfl - 10.0**zminfl) / 1000)
elif imscale == 'squareroot':
brange = numpy.arange(zminfl**2, zmaxfl**2,
(zmaxfl**2 - zminfl**2) / 1000)
if imscale == 'linear':
barimg = numpy.resize(brange, (1000, 1))
elif imscale == 'logarithmic':
barimg = numpy.log10(numpy.resize(brange, (1000, 1)))
elif imscale == 'squareroot':
barimg = numpy.sqrt(numpy.resize(brange, (1000, 1)))
try:
nrm = len(str(int(numpy.nanmax(brange)))) - 1
except:
nrm = 0
brange = brange / 10**nrm
pylab.imshow(barimg,
aspect='auto',
interpolation='nearest',
origin='lower',
vmin=numpy.nanmin(barimg),
vmax=numpy.nanmax(barimg),
extent=(0.0, 1.0, brange[0], brange[-1]),
cmap=colmap)
barwin.yaxis.tick_right()
barwin.yaxis.set_label_position('right')
barwin.yaxis.set_major_locator(MaxNLocator(7))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().set_autoscale_on(False)
pylab.setp(pylab.gca(), xticklabels=[], xticks=[])
pylab.ylabel('Flux (10$^%d$ e$^-$ s$^{-1}$)' % nrm)
setp(barwin.get_yticklabels(), 'rotation', 90)
barwin.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
# plot residual color bar
# barwin = pylab.axes([0.84,0.08,0.06,0.45])
# Brange = numpy.arange(-zmaxre,zmaxre,(zmaxre+zmaxre)/1000)
# try:
# nrm = len(str(int(numpy.nanmax(brange))))-1
# except:
# nrm = 0
# brange = brange / 10**nrm
# barimg = numpy.resize(brange,(1000,1))
# pylab.imshow(barimg,aspect='auto',interpolation='nearest',origin='lower',
# vmin=brange[0],vmax=brange[-1],extent=(0.0,1.0,brange[0],brange[-1]),cmap=colmap)
# barwin.yaxis.tick_right()
# barwin.yaxis.set_label_position('right')
# barwin.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
# barwin.yaxis.set_major_locator(MaxNLocator(7))
# pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# pylab.gca().set_autoscale_on(False)
# pylab.setp(pylab.gca(),xticklabels=[],xticks=[])
# pylab.ylabel('Residual (10$^%d$ e$^-$ s$^{-1}$)' % nrm)
# setp(barwin.get_yticklabels(), 'rotation', 90)
# render plot
if status == 0 and len(plotfile) > 0 and plotfile.lower() != 'none':
pylab.savefig(plotfile)
if status == 0 and plt:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\nKEPPRF ended at', logfile, verbose)
return
def keptrim(infile,outfile,kepid,column,row,imsize,clobber,verbose,logfile,status):
# startup parameters
status = 0
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPTRIM -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'kepid='+str(kepid)+' '
call += 'column='+str(column)+' '
call += 'row='+str(row)+' '
call += 'imsize='+str(imsize)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPTRIM started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPTRIM: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
# open input file
status = 0
instr = pyfits.open(infile,mode='readonly',memmap=True)
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# identify the season of observation
if status == 0:
try:
season = cards0['SEASON'].value
except:
season = 0
# retrieve column and row from KIC
try:
kic = FOVKepID(str(kepid))
column = int(kic[98 + season * 5])
row = int(kic[97 + season * 5])
except:
pass
# convert CCD column and row to image column and row
if status == 0:
if imsize % 2 == 0: imsize += 1
crpix1p = cards2['CRPIX1P'].value
crpix2p = cards2['CRPIX2P'].value
crval1p = cards2['CRVAL1P'].value
crval2p = cards2['CRVAL2P'].value
cdelt1p = cards2['CDELT1P'].value
cdelt2p = cards2['CDELT2P'].value
imcol = (column - crval1p) * cdelt1p + crpix1p - 1
imrow = (row - crval2p) * cdelt2p + crpix2p - 1
crval1p = column - imsize / 2 + 0.5
crval2p = row - imsize / 2 + 0.5
# check subimage is contained inside the input image
if status == 0:
naxis1 = cards2['NAXIS1'].value
naxis2 = cards2['NAXIS2'].value
x1 = imcol - imsize / 2 + 0.5; x2 = x1 + imsize
y1 = imrow - imsize / 2 + 0.5; y2 = y1 + imsize
if x1 < 0 or y1 < 0 or x2 > naxis1 or y2 > naxis2:
message = 'ERROR -- KEPTRIM: Requested pixel area falls outside of the pixel image in file ' + infile
message += '. Make the pixel area smaller or relocate it''s center.'
status = kepmsg.err(logfile,message,verbose)
# time series data
if status == 0:
time = instr[1].data.field('TIME')[:]
timecorr = instr[1].data.field('TIMECORR')[:]
cadenceno = instr[1].data.field('CADENCENO')[:]
raw_cnts = instr[1].data.field('RAW_CNTS')[:]
flux = instr[1].data.field('FLUX')[:]
flux_err = instr[1].data.field('FLUX_ERR')[:]
flux_bkg = instr[1].data.field('FLUX_BKG')[:]
flux_bkg_err = instr[1].data.field('FLUX_BKG_ERR')[:]
cosmic_rays = instr[1].data.field('COSMIC_RAYS')[:]
quality = instr[1].data.field('QUALITY')[:]
pos_corr1 = instr[1].data.field('POS_CORR1')[:]
pos_corr2 = instr[1].data.field('POS_CORR2')[:]
# resize time series
if status == 0:
raw_cnts = raw_cnts[:,y1:y2,x1:x2]
flux = flux[:,y1:y2,x1:x2]
flux_err = flux_err[:,y1:y2,x1:x2]
flux_bkg = flux_bkg[:,y1:y2,x1:x2]
flux_bkg_err = flux_bkg_err[:,y1:y2,x1:x2]
cosmic_rays = cosmic_rays[:,y1:y2,x1:x2]
# reshape time series images
if status == 0:
isize = numpy.shape(flux)[0]
jsize = numpy.shape(flux)[1]
ksize = numpy.shape(flux)[2]
raw_cnts = numpy.reshape(raw_cnts,(isize,jsize*ksize))
flux = numpy.reshape(flux,(isize,jsize*ksize))
flux_err = numpy.reshape(flux_err,(isize,jsize*ksize))
flux_bkg = numpy.reshape(flux_bkg,(isize,jsize*ksize))
flux_bkg_err = numpy.reshape(flux_bkg_err,(isize,jsize*ksize))
cosmic_rays = numpy.reshape(cosmic_rays,(isize,jsize*ksize))
# pixel map data
if status == 0:
maskmap = array(instr[2].data[y1:y2,x1:x2])
# construct output primary extension
if status == 0:
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
try:
if cards0[i].key not in hdu0.header.keys():
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
except:
pass
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output light curve extension
if status == 0:
coldim = '(' + str(imsize) + ',' + str(imsize) + ')'
eformat = str(imsize*imsize) + 'E'
jformat = str(imsize*imsize) + 'J'
kformat = str(imsize*imsize) + 'K'
col1 = Column(name='TIME',format='D',unit='BJD - 2454833',array=time)
col2 = Column(name='TIMECORR',format='E',unit='d',array=timecorr)
col3 = Column(name='CADENCENO',format='J',array=cadenceno)
col4 = Column(name='RAW_CNTS',format=jformat,unit='count',dim=coldim,array=raw_cnts)
col5 = Column(name='FLUX',format=eformat,unit='e-/s',dim=coldim,array=flux)
col6 = Column(name='FLUX_ERR',format=eformat,unit='e-/s',dim=coldim,array=flux_err)
col7 = Column(name='FLUX_BKG',format=eformat,unit='e-/s',dim=coldim,array=flux_bkg)
col8 = Column(name='FLUX_BKG_ERR',format=eformat,unit='e-/s',dim=coldim,array=flux_bkg_err)
col9 = Column(name='COSMIC_RAYS',format=eformat,unit='e-/s',dim=coldim,array=cosmic_rays)
col10 = Column(name='QUALITY',format='J',array=quality)
col11 = Column(name='POS_CORR1',format='E',unit='pixel',array=pos_corr1)
col12 = Column(name='POS_CORR2',format='E',unit='pixel',array=pos_corr2)
cols = ColDefs([col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12])
hdu1 = new_table(cols)
for i in range(len(cards1)):
try:
if cards1[i].key not in hdu1.header.keys():
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
else:
hdu1.header.cards[cards1[i].key].comment = cards1[i].comment
except:
pass
hdu1.header.update('1CRV4P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV4P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX4',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX4',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV5P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV5P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX5',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX5',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV6P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV6P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX6',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX6',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV7P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV7P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX7',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX7',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV8P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV8P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX8',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX8',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
hdu1.header.update('1CRV9P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('2CRV9P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu1.header.update('1CRPX9',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu1.header.update('2CRPX9',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
outstr.append(hdu1)
# construct output mask bitmap extension
if status == 0:
hdu2 = ImageHDU(maskmap)
for i in range(len(cards2)):
try:
if cards2[i].key not in hdu2.header.keys():
hdu2.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
else:
hdu2.header.cards[cards2[i].key].comment = cards2[i].comment
except:
pass
hdu2.header.update('NAXIS1',imsize,'')
hdu2.header.update('NAXIS2',imsize,'')
hdu2.header.update('CRVAL1P',crval1p,'[pixel] detector coordinate at reference pixel')
hdu2.header.update('CRVAL2P',crval2p,'[pixel] detector coordinate at reference pixel')
hdu2.header.update('CRPIX1',(imsize + 1) / 2,'[pixel] reference pixel along image axis 1')
hdu2.header.update('CRPIX2',(imsize + 1) / 2,'[pixel] reference pixel along image axis 2')
outstr.append(hdu2)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
kepmsg.clock('KEPTRIM finished at',logfile,verbose)
def kepbls(infile,outfile,datacol,errcol,minper,maxper,mindur,maxdur,nsearch,
nbins,plot,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
numpy.seterr(all="ignore")
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 8
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPBLS -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'errcol='+str(errcol)+' '
call += 'minper='+str(minper)+' '
call += 'maxper='+str(maxper)+' '
call += 'mindur='+str(mindur)+' '
call += 'maxdur='+str(maxdur)+' '
call += 'nsearch='+str(nsearch)+' '
call += 'nbins='+str(nbins)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPBLS started at',logfile,verbose)
# is duration greater than one bin in the phased light curve?
if float(nbins) * maxdur / 24.0 / maxper <= 1.0:
message = 'WARNING -- KEPBLS: ' + str(maxdur) + ' hours transit duration < 1 phase bin when P = '
message += str(maxper) + ' days'
kepmsg.warn(logfile,message)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPBLS: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# filter input data table
if status == 0:
work1 = numpy.array([table.field('time'), table.field(datacol), table.field(errcol)])
work1 = numpy.rot90(work1,3)
work1 = work1[~numpy.isnan(work1).any(1)]
# read table columns
if status == 0:
intime = work1[:,2] + bjdref
indata = work1[:,1]
inerr = work1[:,0]
# test whether the period range is sensible
if status == 0:
tr = intime[-1] - intime[0]
if maxper > tr:
message = 'ERROR -- KEPBLS: maxper is larger than the time range of the input data'
status = kepmsg.err(logfile,message,verbose)
# prepare time series
if status == 0:
work1 = intime - intime[0]
work2 = indata - numpy.mean(indata)
# start period search
if status == 0:
srMax = numpy.array([],dtype='float32')
transitDuration = numpy.array([],dtype='float32')
transitPhase = numpy.array([],dtype='float32')
dPeriod = (maxper - minper) / nsearch
trialPeriods = numpy.arange(minper,maxper+dPeriod,dPeriod,dtype='float32')
complete = 0
print ' '
for trialPeriod in trialPeriods:
fracComplete = float(complete) / float(len(trialPeriods) - 1) * 100.0
txt = '\r'
txt += 'Trial period = '
txt += str(int(trialPeriod))
txt += ' days ['
txt += str(int(fracComplete))
txt += '% complete]'
txt += ' ' * 20
sys.stdout.write(txt)
sys.stdout.flush()
complete += 1
srMax = numpy.append(srMax,0.0)
transitDuration = numpy.append(transitDuration,numpy.nan)
transitPhase = numpy.append(transitPhase,numpy.nan)
trialFrequency = 1.0 / trialPeriod
# minimum and maximum transit durations in quantized phase units
duration1 = max(int(float(nbins) * mindur / 24.0 / trialPeriod),2)
duration2 = max(int(float(nbins) * maxdur / 24.0 / trialPeriod) + 1,duration1 + 1)
# 30 minutes in quantized phase units
halfHour = int(0.02083333 / trialPeriod * nbins + 1)
# compute folded time series with trial period
work4 = numpy.zeros((nbins),dtype='float32')
work5 = numpy.zeros((nbins),dtype='float32')
phase = numpy.array(((work1 * trialFrequency) - numpy.floor(work1 * trialFrequency)) * float(nbins),dtype='int')
ptuple = numpy.array([phase, work2, inerr])
ptuple = numpy.rot90(ptuple,3)
phsort = numpy.array(sorted(ptuple,key=lambda ph: ph[2]))
for i in range(nbins):
elements = numpy.nonzero(phsort[:,2] == float(i))[0]
work4[i] = numpy.mean(phsort[elements,1])
work5[i] = math.sqrt(numpy.sum(numpy.power(phsort[elements,0], 2)) / len(elements))
# extend the work arrays beyond nbins by wrapping
work4 = numpy.append(work4,work4[:duration2])
work5 = numpy.append(work5,work5[:duration2])
# calculate weights of folded light curve points
sigmaSum = numpy.nansum(numpy.power(work5,-2))
omega = numpy.power(work5,-2) / sigmaSum
# calculate weighted phased light curve
s = omega * work4
# iterate through trial period phase
for i1 in range(nbins):
# iterate through transit durations
for duration in range(duration1,duration2+1,int(halfHour)):
# calculate maximum signal residue
i2 = i1 + duration
sr1 = numpy.sum(numpy.power(s[i1:i2],2))
sr2 = numpy.sum(omega[i1:i2])
sr = math.sqrt(sr1 / (sr2 * (1.0 - sr2)))
if sr > srMax[-1]:
srMax[-1] = sr
transitDuration[-1] = float(duration)
transitPhase[-1] = float((i1 + i2) / 2)
# normalize maximum signal residue curve
bestSr = numpy.max(srMax)
bestTrial = numpy.nonzero(srMax == bestSr)[0][0]
srMax /= bestSr
transitDuration *= trialPeriods / 24.0
BJD0 = numpy.array(transitPhase * trialPeriods / nbins,dtype='float64') + intime[0] - 2454833.0
print '\n'
# clean up x-axis unit
if status == 0:
ptime = copy(trialPeriods)
xlab = 'Trial Period (days)'
# clean up y-axis units
if status == 0:
pout = copy(srMax)
ylab = 'Normalized Signal Residue'
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
# plot light curve
if status == 0 and plot:
plotLatex = True
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
plotLatex = False
if status == 0 and plot:
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
# plot data
ax = pylab.axes([0.06,0.10,0.93,0.87])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
pylab.setp(labels, 'rotation', 90)
# plot curve
if status == 0 and plot:
pylab.plot(ptime[1:-1],pout[1:-1],color=lcolor,linestyle='-',linewidth=lwidth)
pylab.fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.ylabel(ylab, {'color' : 'k'})
pylab.grid()
# plot ranges
if status == 0 and plot:
pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin >= 0.0:
pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
pylab.ylim(1.0e-10,ymax+yr*0.01)
# render plot
if status == 0 and plot:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# append new BLS data extension to the output file
if status == 0:
col1 = Column(name='PERIOD',format='E',unit='days',array=trialPeriods)
col2 = Column(name='BJD0',format='D',unit='BJD - 2454833',array=BJD0)
col3 = Column(name='DURATION',format='E',unit='hours',array=transitDuration)
col4 = Column(name='SIG_RES',format='E',array=srMax)
cols = ColDefs([col1,col2,col3,col4])
instr.append(new_table(cols))
instr[-1].header.cards['TTYPE1'].comment = 'column title: trial period'
instr[-1].header.cards['TTYPE2'].comment = 'column title: trial mid-transit zero-point'
instr[-1].header.cards['TTYPE3'].comment = 'column title: trial transit duration'
instr[-1].header.cards['TTYPE4'].comment = 'column title: normalized signal residue'
instr[-1].header.cards['TFORM1'].comment = 'column type: float32'
instr[-1].header.cards['TFORM2'].comment = 'column type: float64'
instr[-1].header.cards['TFORM3'].comment = 'column type: float32'
instr[-1].header.cards['TFORM4'].comment = 'column type: float32'
instr[-1].header.cards['TUNIT1'].comment = 'column units: days'
instr[-1].header.cards['TUNIT2'].comment = 'column units: BJD - 2454833'
instr[-1].header.cards['TUNIT3'].comment = 'column units: hours'
instr[-1].header.update('EXTNAME','BLS','extension name')
instr[-1].header.update('PERIOD',trialPeriods[bestTrial],'most significant trial period [d]')
instr[-1].header.update('BJD0',BJD0[bestTrial] + 2454833.0,'time of mid-transit [BJD]')
instr[-1].header.update('TRANSDUR',transitDuration[bestTrial],'transit duration [hours]')
instr[-1].header.update('SIGNRES',srMax[bestTrial] * bestSr,'maximum signal residue')
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# print best trial period results
if status == 0:
print ' Best trial period = %.5f days' % trialPeriods[bestTrial]
print ' Time of mid-transit = BJD %.5f' % (BJD0[bestTrial] + 2454833.0)
print ' Transit duration = %.5f hours' % transitDuration[bestTrial]
print ' Maximum signal residue = %.4g \n' % (srMax[bestTrial] * bestSr)
# end time
if (status == 0):
message = 'KEPBLS completed at'
else:
message = '\nKEPBLS aborted at'
kepmsg.clock(message,logfile,verbose)
def kepimages(infile,outfix,imtype,ranges,clobber,verbose,logfile,status):
# startup parameters
status = 0
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPIMAGES -- '
call += 'infile='+infile+' '
call += 'outfix='+outfix+' '
call += 'imtype='+imtype+' '
call += 'ranges='+str(ranges)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPIMAGES started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# open input file
status = 0
print(' ')
instr = pyfits.open(infile,mode='readonly',memmap=True)
cards0 = instr[0].header.cards
cards1 = instr[1].header.cards
cards2 = instr[2].header.cards
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# ingest time series data
if status == 0:
time = instr[1].data.field('TIME')[:] + 2454833.0
timecorr = instr[1].data.field('TIMECORR')[:]
cadenceno = instr[1].data.field('CADENCENO')[:]
raw_cnts = instr[1].data.field('RAW_CNTS')[:]
flux = instr[1].data.field('FLUX')[:]
flux_err = instr[1].data.field('FLUX_ERR')[:]
flux_bkg = instr[1].data.field('FLUX_BKG')[:]
flux_bkg_err = instr[1].data.field('FLUX_BKG_ERR')[:]
cosmic_rays = instr[1].data.field('COSMIC_RAYS')[:]
quality = instr[1].data.field('QUALITY')[:]
pos_corr1 = instr[1].data.field('POS_CORR1')[:]
pos_corr2 = instr[1].data.field('POS_CORR2')[:]
# choose output image
if status == 0:
if imtype.lower() == 'raw_cnts':
outim = raw_cnts
elif imtype.lower() == 'flux_err':
outim = flux_err
elif imtype.lower() == 'flux_bkg':
outim = flux_bkg
elif imtype.lower() == 'flux_bkg_err':
outim = flux_bkg_err
elif imtype.lower() == 'cosmic_rays':
outim = cosmic_rays
else:
outim = flux
# identify images to be exported
if status == 0:
tim = array([]); dat = array([]); err = array([])
tstart, tstop, status = kepio.timeranges(ranges,logfile,verbose)
if status == 0:
cadencelis, status = kepstat.filterOnRange(time,tstart,tstop)
# provide name for each output file and clobber if file exists
if status == 0:
for cadence in cadencelis:
outfile = outfix + '_BJD%.4f' % time[cadence] + '.fits'
if clobber and status == 0: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile) and status == 0:
message = 'ERROR -- KEPIMAGES: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,True)
# construct output primary extension
if status == 0:
ncad = 0
for cadence in cadencelis:
outfile = outfix + '_BJD%.4f' % time[cadence] + '.fits'
hdu0 = pyfits.PrimaryHDU()
for i in range(len(cards0)):
try:
if cards0[i].key not in list(hdu0.header.keys()):
hdu0.header.update(cards0[i].key, cards0[i].value, cards0[i].comment)
else:
hdu0.header.cards[cards0[i].key].comment = cards0[i].comment
except:
pass
status = kepkey.history(call,hdu0,outfile,logfile,verbose)
outstr = HDUList(hdu0)
# construct output image extension
hdu1 = ImageHDU(flux[cadence])
for i in range(len(cards2)):
try:
if cards2[i].key not in list(hdu1.header.keys()):
hdu1.header.update(cards2[i].key, cards2[i].value, cards2[i].comment)
except:
pass
for i in range(len(cards1)):
if (cards1[i].key not in list(hdu1.header.keys()) and
cards1[i].key[:4] not in ['TTYP','TFOR','TUNI','TDIS','TDIM','WCAX','1CTY',
'2CTY','1CRP','2CRP','1CRV','2CRV','1CUN','2CUN',
'1CDE','2CDE','1CTY','2CTY','1CDL','2CDL','11PC',
'12PC','21PC','22PC','WCSN','TFIE']):
hdu1.header.update(cards1[i].key, cards1[i].value, cards1[i].comment)
try:
int_time = cards1['INT_TIME'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find INT_TIME keyword')
try:
frametim = cards1['FRAMETIM'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find FRAMETIM keyword')
try:
num_frm = cards1['NUM_FRM'].value
except:
kepmsg.warn(logfile,'WARNING -- KEPIMAGES: cannot find NUM_FRM keyword')
hdu1.header.update('EXTNAME','IMAGE','name of extension')
try:
hdu1.header.update('TELAPSE',frametim * num_frm,'[s] elapsed time for exposure')
except:
hdu1.header.update('TELAPSE',-999,'[s] elapsed time for exposure')
try:
hdu1.header.update('LIVETIME',int_time * num_frm,'[s] TELASPE multiplied by DEADC')
except:
hdu1.header.update('LIVETIME',-999,'[s] TELASPE multiplied by DEADC')
try:
hdu1.header.update('EXPOSURE',int_time * num_frm,'[s] time on source')
except:
hdu1.header.update('EXPOSURE',-999,'[s] time on source')
try:
hdu1.header.update('MIDTIME',time[cadence],'[BJD] mid-time of exposure')
except:
hdu1.header.update('MIDTIME',-999,'[BJD] mid-time of exposure')
try:
hdu1.header.update('TIMECORR',timecorr[cadence],'[d] barycenter - timeslice correction')
except:
hdu1.header.update('TIMECORR',-999,'[d] barycenter - timeslice correction')
try:
hdu1.header.update('CADENCEN',cadenceno[cadence],'unique cadence number')
except:
hdu1.header.update('CADENCEN',-999,'unique cadence number')
try:
hdu1.header.update('QUALITY',quality[cadence],'pixel quality flag')
except:
hdu1.header.update('QUALITY',-999,'pixel quality flag')
try:
if True in numpy.isfinite(cosmic_rays[cadence]):
hdu1.header.update('COSM_RAY',True,'cosmic ray detected?')
else:
hdu1.header.update('COSM_RAY',False,'cosmic ray detected?')
except:
hdu1.header.update('COSM_RAY',-999,'cosmic ray detected?')
try:
pc1 = str(pos_corr1[cadence])
pc2 = str(pos_corr2[cadence])
hdu1.header.update('POSCORR1',pc1,'[pix] column position correction')
hdu1.header.update('POSCORR2',pc2,'[pix] row position correction')
except:
hdu1.header.update('POSCORR1',-999,'[pix] column position correction')
hdu1.header.update('POSCORR2',-999,'[pix] row position correction')
outstr.append(hdu1)
# write output file
if status == 0:
outstr.writeto(outfile,checksum=True)
ncad += 1
txt = '\r%3d%% ' % (float(ncad) / float(len(cadencelis)) * 100.0)
txt += '%s ' % outfile
sys.stdout.write(txt)
sys.stdout.flush()
# close input structure
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
print('\n')
# end time
kepmsg.clock('KEPIMAGES finished at',logfile,verbose)
def kepoutlier(infile,outfile,datacol,nsig,stepsize,npoly,niter,
operation,ranges,plot,plotfit,clobber,verbose,logfile,status, cmdLine=False):
# startup parameters
status = 0
labelsize = 24
ticksize = 16
xsize = 16
ysize = 6
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPOUTLIER -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'nsig='+str(nsig)+' '
call += 'stepsize='+str(stepsize)+' '
call += 'npoly='+str(npoly)+' '
call += 'niter='+str(niter)+' '
call += 'operation='+str(operation)+' '
call += 'ranges='+str(ranges)+' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot='+plotit+ ' '
plotf = 'n'
if (plotfit): plotf = 'y'
call += 'plotfit='+plotf+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPOUTLIER started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPOUTLIER: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# filter input data table
if status == 0:
try:
nanclean = instr[1].header['NANCLEAN']
except:
naxis2 = 0
try:
for i in range(len(table.field(0))):
if numpy.isfinite(table.field('barytime')[i]) and \
numpy.isfinite(table.field(datacol)[i]):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
except:
for i in range(len(table.field(0))):
if numpy.isfinite(table.field('time')[i]) and \
numpy.isfinite(table.field(datacol)[i]):
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN',True,comment,instr[1],outfile,logfile,verbose)
# read table columns
if status == 0:
try:
intime = instr[1].data.field('barytime') + 2.4e6
except:
intime, status = kepio.readfitscol(infile,instr[1].data,'time',logfile,verbose)
indata, status = kepio.readfitscol(infile,instr[1].data,datacol,logfile,verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
# time ranges for region to be corrected
if status == 0:
t1, t2, status = kepio.timeranges(ranges,logfile,verbose)
cadencelis, status = kepstat.filterOnRange(intime,t1,t2)
# find limits of each time step
if status == 0:
tstep1 = []; tstep2 = []
work = intime[0]
while work < intime[-1]:
tstep1.append(work)
tstep2.append(array([work+stepsize,intime[-1]],dtype='float64').min())
work += stepsize
# find cadence limits of each time step
if status == 0:
cstep1 = []; cstep2 = []
work1 = 0; work2 = 0
for i in range(len(intime)):
if intime[i] >= intime[work1] and intime[i] < intime[work1] + stepsize:
work2 = i
else:
cstep1.append(work1)
cstep2.append(work2)
work1 = i; work2 = i
cstep1.append(work1)
cstep2.append(work2)
outdata = indata * 1.0
# comment keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
# clean up x-axis unit
if status == 0:
intime0 = float(int(tstart / 100) * 100.0)
ptime = intime - intime0
xlab = 'BJD $-$ %d' % intime0
# clean up y-axis units
if status == 0:
pout = indata * 1.0
nrm = len(str(int(pout.max())))-1
pout = pout / 10**nrm
ylab = '10$^%d$ e$^-$ s$^{-1}$' % nrm
# data limits
xmin = ptime.min()
xmax = ptime.max()
ymin = pout.min()
ymax = pout.max()
xr = xmax - xmin
yr = ymax - ymin
ptime = insert(ptime,[0],[ptime[0]])
ptime = append(ptime,[ptime[-1]])
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
# plot light curve
if status == 0 and plot:
plotLatex = True
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize}
rcParams.update(params)
except:
plotLatex = False
if status == 0 and plot:
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
# plot data
ax = pylab.axes([0.06,0.1,0.93,0.87])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
pylab.plot(ptime,pout,color=lcolor,linestyle='-',linewidth=lwidth)
fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
xlabel(xlab, {'color' : 'k'})
if not plotLatex:
ylab = '10**%d electrons/sec' % nrm
ylabel(ylab, {'color' : 'k'})
grid()
# loop over each time step, fit data, determine rms
if status == 0:
masterfit = indata * 0.0
mastersigma = zeros(len(masterfit))
functype = 'poly' + str(npoly)
for i in range(len(cstep1)):
pinit = [indata[cstep1[i]:cstep2[i]+1].mean()]
if npoly > 0:
for j in range(npoly):
pinit.append(0.0)
pinit = array(pinit,dtype='float32')
try:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip(functype,pinit,intime[cstep1[i]:cstep2[i]+1]-intime[cstep1[i]],
indata[cstep1[i]:cstep2[i]+1],None,nsig,nsig,niter,logfile,
verbose)
for j in range(len(coeffs)):
masterfit[cstep1[i]:cstep2[i]+1] += coeffs[j] * \
(intime[cstep1[i]:cstep2[i]+1] - intime[cstep1[i]])**j
for j in range(cstep1[i],cstep2[i]+1):
mastersigma[j] = sigma
if plotfit:
pylab.plot(plotx+intime[cstep1[i]]-intime0,ploty / 10**nrm,
'g',lw='3')
except:
for j in range(cstep1[i],cstep2[i]+1):
masterfit[j] = indata[j]
mastersigma[j] = 1.0e10
message = 'WARNING -- KEPOUTLIER: could not fit range '
message += str(intime[cstep1[i]]) + '-' + str(intime[cstep2[i]])
kepmsg.warn(None,message)
# reject outliers
if status == 0:
rejtime = []; rejdata = []; naxis2 = 0
for i in range(len(masterfit)):
if abs(indata[i] - masterfit[i]) > nsig * mastersigma[i] and i in cadencelis:
rejtime.append(intime[i])
rejdata.append(indata[i])
if operation == 'replace':
[rnd] = kepstat.randarray([masterfit[i]],[mastersigma[i]])
table[naxis2] = table[i]
table.field(datacol)[naxis2] = rnd
naxis2 += 1
else:
table[naxis2] = table[i]
naxis2 += 1
instr[1].data = table[:naxis2]
rejtime = array(rejtime,dtype='float64')
rejdata = array(rejdata,dtype='float32')
pylab.plot(rejtime-intime0,rejdata / 10**nrm,'ro')
# plot ranges
xlim(xmin-xr*0.01,xmax+xr*0.01)
if ymin >= 0.0:
ylim(ymin-yr*0.01,ymax+yr*0.01)
else:
ylim(1.0e-10,ymax+yr*0.01)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# write output file
if status == 0:
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPOUTLIER completed at'
else:
message = '\nKEPOUTLIER aborted at'
kepmsg.clock(message,logfile,verbose)
def kepsff(infile,outfile,datacol,cenmethod,stepsize,npoly_cxcy,sigma_cxcy,npoly_ardx,
npoly_dsdt,sigma_dsdt,npoly_arfl,sigma_arfl,plotres,clobber,verbose,logfile,
status,cmdLine=False):
# startup parameters
status = 0
labelsize = 16
ticksize = 14
xsize = 20
ysize = 8
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPSFF -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+datacol+' '
call += 'cenmethod='+cenmethod+' '
call += 'stepsize='+str(stepsize)+' '
call += 'npoly_cxcy='+str(npoly_cxcy)+' '
call += 'sigma_cxcy='+str(sigma_cxcy)+' '
call += 'npoly_ardx='+str(npoly_ardx)+' '
call += 'npoly_dsdt='+str(npoly_dsdt)+' '
call += 'sigma_dsdt='+str(sigma_dsdt)+' '
call += 'npoly_arfl='+str(npoly_arfl)+' '
call += 'sigma_arfl='+str(sigma_arfl)+' '
savep = 'n'
if (plotres): savep = 'y'
call += 'plotres='+savep+ ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPSFF started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPSFF: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
tstart, tstop, bjdref, cadence, status = kepio.timekeys(instr,infile,logfile,verbose,status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr,file,logfile,verbose)
# read table structure
if status == 0:
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
# determine sequence of windows in time
if status == 0:
frametim = instr[1].header['FRAMETIM']
num_frm = instr[1].header['NUM_FRM']
exptime = frametim * num_frm / 86400
tstart = table.field('TIME')[0]
tstop = table.field('TIME')[-1]
winedge = arange(tstart,tstop,stepsize)
if tstop > winedge[-1] + stepsize / 2:
winedge = append(winedge,tstop)
else:
winedge[-1] = tstop
winedge = (winedge - tstart) / exptime
winedge = winedge.astype(int)
if len(table.field('TIME')) > winedge[-1] + 1:
winedge = append(winedge,len(table.field('TIME')))
elif len(table.field('TIME')) < winedge[-1]:
winedge[-1] = len(table.field('TIME'))
# step through the time windows
if status == 0:
for iw in range(1,len(winedge)):
t1 = winedge[iw-1]
t2 = winedge[iw]
# filter input data table
work1 = numpy.array([table.field('TIME')[t1:t2], table.field('CADENCENO')[t1:t2],
table.field(datacol)[t1:t2],
table.field('MOM_CENTR1')[t1:t2], table.field('MOM_CENTR2')[t1:t2],
table.field('PSF_CENTR1')[t1:t2], table.field('PSF_CENTR2')[t1:t2],
table.field('SAP_QUALITY')[t1:t2]],'float64')
work1 = numpy.rot90(work1,3)
work2 = work1[~numpy.isnan(work1).any(1)]
work2 = work2[(work2[:,0] == 0.0) | (work2[:,0] > 1e5)]
# assign table columns
intime = work2[:,7] + bjdref
cadenceno = work2[:,6].astype(int)
indata = work2[:,5]
mom_centr1 = work2[:,4]
mom_centr2 = work2[:,3]
psf_centr1 = work2[:,2]
psf_centr2 = work2[:,1]
sap_quality = work2[:,0]
if cenmethod == 'moments':
centr1 = copy(mom_centr1)
centr2 = copy(mom_centr2)
else:
centr1 = copy(psf_centr1)
centr2 = copy(psf_centr2)
# fit centroid data with low-order polynomial
cfit = zeros((len(centr2)))
csig = zeros((len(centr2)))
functype = 'poly' + str(npoly_cxcy)
pinit = array([nanmean(centr2)])
if npoly_cxcy > 0:
for j in range(npoly_cxcy):
pinit = append(pinit,0.0)
try:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip(functype,pinit,centr1,centr2,None,sigma_cxcy,sigma_cxcy,10,logfile,verbose)
for j in range(len(coeffs)):
cfit += coeffs[j] * numpy.power(centr1,j)
csig[:] = sigma
except:
message = 'ERROR -- KEPSFF: could not fit centroid data with polynomial. There are no data points within the range of input rows %d - %d. Either increase the stepsize (with an appreciation of the effects on light curve quality this will have!), or better yet - cut the timeseries up to remove large gaps in the input light curve using kepclip.' % (t1,t2)
status = kepmsg.err(logfile,message,verbose)
# sys.exit('')
os._exit(1)
# reject outliers
time_good = array([],'float64')
centr1_good = array([],'float32')
centr2_good = array([],'float32')
flux_good = array([],'float32')
cad_good = array([],'int')
for i in range(len(cfit)):
if abs(centr2[i] - cfit[i]) < sigma_cxcy * csig[i]:
time_good = append(time_good,intime[i])
centr1_good = append(centr1_good,centr1[i])
centr2_good = append(centr2_good,centr2[i])
flux_good = append(flux_good,indata[i])
cad_good = append(cad_good,cadenceno[i])
# covariance matrix for centroid time series
centr = concatenate([[centr1_good] - mean(centr1_good), [centr2_good] - mean(centr2_good)])
covar = cov(centr)
# eigenvector eigenvalues of covariance matrix
[eval, evec] = numpy.linalg.eigh(covar)
ex = arange(-10.0,10.0,0.1)
epar = evec[1,1] / evec[0,1] * ex
enor = evec[1,0] / evec[0,0] * ex
ex = ex + mean(centr1)
epar = epar + mean(centr2_good)
enor = enor + mean(centr2_good)
# rotate centroid data
centr_rot = dot(evec.T,centr)
# fit polynomial to rotated centroids
rfit = zeros((len(centr2)))
rsig = zeros((len(centr2)))
functype = 'poly' + str(npoly_ardx)
pinit = array([nanmean(centr_rot[0,:])])
pinit = array([1.0])
if npoly_ardx > 0:
for j in range(npoly_ardx):
pinit = append(pinit,0.0)
try:
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip(functype,pinit,centr_rot[1,:],centr_rot[0,:],None,100.0,100.0,1,
logfile,verbose)
except:
message = 'ERROR -- KEPSFF: could not fit rotated centroid data with polynomial'
status = kepmsg.err(logfile,message,verbose)
rx = linspace(nanmin(centr_rot[1,:]),nanmax(centr_rot[1,:]),100)
ry = zeros((len(rx)))
for i in range(len(coeffs)):
ry = ry + coeffs[i] * numpy.power(rx,i)
# calculate arclength of centroids
s = zeros((len(rx)))
for i in range(1,len(s)):
work3 = ((ry[i] - ry[i-1]) / (rx[i] - rx[i-1]))**2
s[i] = s[i-1] + math.sqrt(1.0 + work3) * (rx[i] - rx[i-1])
# fit arclength as a function of strongest eigenvector
sfit = zeros((len(centr2)))
ssig = zeros((len(centr2)))
functype = 'poly' + str(npoly_ardx)
pinit = array([nanmean(s)])
if npoly_ardx > 0:
for j in range(npoly_ardx):
pinit = append(pinit,0.0)
try:
acoeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip(functype,pinit,rx,s,None,100.0,100.0,100,logfile,verbose)
except:
message = 'ERROR -- KEPSFF: could not fit rotated centroid data with polynomial'
status = kepmsg.err(logfile,message,verbose)
# correlate arclength with detrended flux
t = copy(time_good)
c = copy(cad_good)
y = copy(flux_good)
z = centr_rot[1,:]
x = zeros((len(z)))
for i in range(len(acoeffs)):
x = x + acoeffs[i] * numpy.power(z,i)
# calculate time derivative of arclength s
dx = zeros((len(x)))
for i in range(1,len(x)):
dx[i] = (x[i] - x[i-1]) / (t[i] - t[i-1])
dx[0] = dx[1]
# fit polynomial to derivative and flag outliers (thruster firings)
dfit = zeros((len(dx)))
dsig = zeros((len(dx)))
functype = 'poly' + str(npoly_dsdt)
pinit = array([nanmean(dx)])
if npoly_dsdt > 0:
for j in range(npoly_dsdt):
pinit = append(pinit,0.0)
try:
dcoeffs, errors, covar, iiter, dsigma, chi2, dof, fit, dumx, dumy, status = \
kepfit.lsqclip(functype,pinit,t,dx,None,3.0,3.0,10,logfile,verbose)
except:
message = 'ERROR -- KEPSFF: could not fit rotated centroid data with polynomial'
status = kepmsg.err(logfile,message,verbose)
for i in range(len(dcoeffs)):
dfit = dfit + dcoeffs[i] * numpy.power(t,i)
centr1_pnt = array([],'float32')
centr2_pnt = array([],'float32')
time_pnt = array([],'float64')
flux_pnt = array([],'float32')
dx_pnt = array([],'float32')
s_pnt = array([],'float32')
time_thr = array([],'float64')
flux_thr = array([],'float32')
dx_thr = array([],'float32')
thr_cadence = []
for i in range(len(t)):
if dx[i] < dfit[i] + sigma_dsdt * dsigma and dx[i] > dfit[i] - sigma_dsdt * dsigma:
time_pnt = append(time_pnt,time_good[i])
flux_pnt = append(flux_pnt,flux_good[i])
dx_pnt = append(dx_pnt,dx[i])
s_pnt = append(s_pnt,x[i])
centr1_pnt = append(centr1_pnt,centr1_good[i])
centr2_pnt = append(centr2_pnt,centr2_good[i])
else:
time_thr = append(time_thr,time_good[i])
flux_thr = append(flux_thr,flux_good[i])
dx_thr = append(dx_thr,dx[i])
thr_cadence.append(cad_good[i])
# fit arclength-flux correlation
cfit = zeros((len(time_pnt)))
csig = zeros((len(time_pnt)))
functype = 'poly' + str(npoly_arfl)
pinit = array([nanmean(flux_pnt)])
if npoly_arfl > 0:
for j in range(npoly_arfl):
pinit = append(pinit,0.0)
try:
ccoeffs, errors, covar, iiter, sigma, chi2, dof, fit, plx, ply, status = \
kepfit.lsqclip(functype,pinit,s_pnt,flux_pnt,None,sigma_arfl,sigma_arfl,100,logfile,verbose)
except:
message = 'ERROR -- KEPSFF: could not fit rotated centroid data with polynomial'
status = kepmsg.err(logfile,message,verbose)
# correction factors for unfiltered data
centr = concatenate([[centr1] - mean(centr1_good), [centr2] - mean(centr2_good)])
centr_rot = dot(evec.T,centr)
yy = copy(indata)
zz = centr_rot[1,:]
xx = zeros((len(zz)))
cfac = zeros((len(zz)))
for i in range(len(acoeffs)):
xx = xx + acoeffs[i] * numpy.power(zz,i)
for i in range(len(ccoeffs)):
cfac = cfac + ccoeffs[i] * numpy.power(xx,i)
# apply correction to flux time-series
out_detsap = indata / cfac
# split time-series data for plotting
tim_gd = array([],'float32')
flx_gd = array([],'float32')
tim_bd = array([],'float32')
flx_bd = array([],'float32')
for i in range(len(indata)):
if intime[i] in time_pnt:
tim_gd = append(tim_gd,intime[i])
flx_gd = append(flx_gd,out_detsap[i])
else:
tim_bd = append(tim_bd,intime[i])
flx_bd = append(flx_bd,out_detsap[i])
# plot style and size
status = kepplot.define(labelsize,ticksize,logfile,verbose)
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
# plot x-centroid vs y-centroid
ax = kepplot.location([0.04,0.57,0.16,0.41]) # plot location
px = copy(centr1) # clean-up x-axis units
py = copy(centr2) # clean-up y-axis units
pxmin = px.min()
pxmax = px.max()
pymin = py.min()
pymax = py.max()
pxr = pxmax - pxmin
pyr = pymax - pymin
pad = 0.05
if pxr > pyr:
dely = (pxr - pyr) / 2
xlim(pxmin - pxr * pad, pxmax + pxr * pad)
ylim(pymin - dely - pyr * pad, pymax + dely + pyr * pad)
else:
delx = (pyr - pxr) / 2
ylim(pymin - pyr * pad, pymax + pyr * pad)
xlim(pxmin - delx - pxr * pad, pxmax + delx + pxr * pad)
pylab.plot(px,py,color='#980000',markersize=5,marker='D',ls='') # plot data
pylab.plot(centr1_good,centr2_good,color='#009900',markersize=5,marker='D',ls='') # plot data
pylab.plot(ex,epar,color='k',ls='-')
pylab.plot(ex,enor,color='k',ls='-')
for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(14)
for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(14)
kepplot.labels('CCD Column','CCD Row','k',16) # labels
pylab.grid() # grid lines
# plot arclength fits vs drift along strongest eigenvector
ax = kepplot.location([0.24,0.57,0.16,0.41]) # plot location
px = rx - rx[0]
py = s - rx - (s[0] - rx[0]) # clean-up y-axis units
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose) # clean-up x-axis units
kepplot.RangeOfPlot(px,py,0.05,False) # data limits
pylab.plot(px,py,color='#009900',markersize=5,marker='D',ls='')
px = plotx - rx[0] # clean-up x-axis units
py = ploty-plotx - (s[0] - rx[0]) # clean-up y-axis units
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose) # clean-up x-axis units
pylab.plot(px,py,color='r',ls='-',lw=3)
for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(14)
for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(14)
ylab = re.sub(' e\S+',' pixels)',ylab)
ylab = re.sub(' s\S+','',ylab)
ylab = re.sub('Flux','s $-$ x\'',ylab)
kepplot.labels('Linear Drift [x\'] (pixels)',ylab,'k',16) # labels
pylab.grid() # grid lines
# plot time derivative of arclength s
ax = kepplot.location([0.04,0.08,0.16,0.41]) # plot location
px = copy(time_pnt)
py = copy(dx_pnt)
px, xlab, status = kepplot.cleanx(px,logfile,verbose) # clean-up x-axis units
kepplot.RangeOfPlot(px,dx,0.05,False) # data limits
pylab.plot(px,py,color='#009900',markersize=5,marker='D',ls='')
try:
px = copy(time_thr)
py = copy(dx_thr)
px, xlab, status = kepplot.cleanx(px,logfile,verbose) # clean-up x-axis units
pylab.plot(px,py,color='#980000',markersize=5,marker='D',ls='')
except:
pass
px = copy(t)
py = copy(dfit)
px, xlab, status = kepplot.cleanx(px,logfile,verbose) # clean-up x-axis units
pylab.plot(px,py,color='r',ls='-',lw=3)
py = copy(dfit+sigma_dsdt*dsigma)
pylab.plot(px,py,color='r',ls='--',lw=3)
py = copy(dfit-sigma_dsdt*dsigma)
pylab.plot(px,py,color='r',ls='--',lw=3)
for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(14)
for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(14)
kepplot.labels(xlab,'ds/dt (pixels day$^{-1}$)','k',16) # labels
pylab.grid() # grid lines
# plot relation of arclength vs detrended flux
ax = kepplot.location([0.24,0.08,0.16,0.41]) # plot location
px = copy(s_pnt)
py = copy(flux_pnt)
py, ylab, status = kepplot.cleany(py,1.0,logfile,verbose) # clean-up x-axis units
kepplot.RangeOfPlot(px,py,0.05,False) # data limits
pylab.plot(px,py,color='#009900',markersize=5,marker='D',ls='')
pylab.plot(plx,ply,color='r',ls='-',lw=3)
for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(14)
for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(14)
kepplot.labels('Arclength [s] (pixels)',ylab,'k',16) # labels
pylab.grid() # grid lines
# plot aperture photometry
kepplot.location([0.44,0.53,0.55,0.45]) # plot location
px, xlab, status = kepplot.cleanx(intime,logfile,verbose) # clean-up x-axis units
py, ylab, status = kepplot.cleany(indata,1.0,logfile,verbose) # clean-up x-axis units
kepplot.RangeOfPlot(px,py,0.01,True) # data limits
kepplot.plot1d(px,py,cadence,lcolor,lwidth,fcolor,falpha,True) # plot data
kepplot.labels(' ',ylab,'k',16) # labels
pylab.setp(pylab.gca(),xticklabels=[]) # remove x- or y-tick labels
kepplot.labels(xlab,re.sub('Flux','Aperture Flux',ylab),'k',16) # labels
pylab.grid() # grid lines
# Plot corrected photometry
kepplot.location([0.44,0.08,0.55,0.45]) # plot location
kepplot.RangeOfPlot(px,py,0.01,True) # data limits
px, xlab, status = kepplot.cleanx(tim_gd,logfile,verbose) # clean-up x-axis units
py, ylab, status = kepplot.cleany(flx_gd,1.0,logfile,verbose) # clean-up x-axis units
kepplot.plot1d(px,py,cadence,lcolor,lwidth,fcolor,falpha,True) # plot data
try:
px, xlab, status = kepplot.cleanx(tim_bd,logfile,verbose) # clean-up x-axis units
py = copy(flx_bd)
pylab.plot(px,py,color='#980000',markersize=5,marker='D',ls='')
except:
pass
kepplot.labels(xlab,re.sub('Flux','Corrected Flux',ylab),'k',16) # labels
pylab.grid() # grid lines
# render plot
if plotres:
kepplot.render(cmdLine)
# save plot to file
if plotres:
pylab.savefig(re.sub('.fits','_%d.png' % (iw + 1),outfile))
# correct fluxes within the output file
intime = work1[:,7] + bjdref
cadenceno = work1[:,6].astype(int)
indata = work1[:,5]
mom_centr1 = work1[:,4]
mom_centr2 = work1[:,3]
psf_centr1 = work1[:,2]
psf_centr2 = work1[:,1]
centr1 = copy(mom_centr1)
centr2 = copy(mom_centr2)
centr = concatenate([[centr1] - mean(centr1_good), [centr2] - mean(centr2_good)])
centr_rot = dot(evec.T,centr)
yy = copy(indata)
zz = centr_rot[1,:]
xx = zeros((len(zz)))
cfac = zeros((len(zz)))
for i in range(len(acoeffs)):
xx = xx + acoeffs[i] * numpy.power(zz,i)
for i in range(len(ccoeffs)):
cfac = cfac + ccoeffs[i] * numpy.power(xx,i)
out_detsap = yy / cfac
instr[1].data.field('SAP_FLUX')[t1:t2] /= cfac
instr[1].data.field('PDCSAP_FLUX')[t1:t2] /= cfac
try:
instr[1].data.field('DETSAP_FLUX')[t1:t2] /= cfac
except:
pass
# add quality flag to output file for thruster firings
for i in range(len(intime)):
if cadenceno[i] in thr_cadence:
instr[1].data.field('SAP_QUALITY')[t1+i] += 131072
# write output file
if status == 0:
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
if (status == 0):
message = 'KEPSFF completed at'
else:
message = '\nKEPSFF aborted at'
kepmsg.clock(message,logfile,verbose)
def kepprf(infile,
plotfile,
rownum,
columns,
rows,
fluxes,
border,
background,
focus,
prfdir,
xtol,
ftol,
imscale,
colmap,
plt,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
print "... input arguments"
status = 0
seterr(all="ignore")
# log the call
print "... logging the call"
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPPRF -- '
call += 'infile=' + infile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'rownum=' + str(rownum) + ' '
call += 'columns=' + columns + ' '
call += 'rows=' + rows + ' '
call += 'fluxes=' + fluxes + ' '
call += 'border=' + str(border) + ' '
bground = 'n'
if (background): bground = 'y'
call += 'background=' + bground + ' '
focs = 'n'
if (focus): focs = 'y'
call += 'focus=' + focs + ' '
call += 'prfdir=' + prfdir + ' '
call += 'xtol=' + str(xtol) + ' '
call += 'ftol=' + str(xtol) + ' '
call += 'imscale=' + imscale + ' '
call += 'colmap=' + colmap + ' '
plotit = 'n'
if (plt): plotit = 'y'
call += 'plot=' + plotit + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# test log file
logfile = kepmsg.test(logfile)
# start time
print "... starting kepler time"
kepmsg.clock('KEPPRF started at', logfile, verbose)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# construct inital guess vector for fit
print " status = " + str(status)
print "... initial guess"
if status == 0:
guess = []
try:
f = fluxes.strip().split(',')
x = columns.strip().split(',')
y = rows.strip().split(',')
for i in xrange(len(f)):
f[i] = float(f[i])
except:
f = fluxes
x = columns
y = rows
nsrc = len(f)
for i in xrange(nsrc):
try:
guess.append(float(f[i]))
except:
message = 'ERROR -- KEPPRF: Fluxes must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
if len(x) != nsrc or len(y) != nsrc:
message = 'ERROR -- KEPFIT:FITMULTIPRF: Guesses for rows, columns and '
message += 'fluxes must have the same number of sources'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(x[i]))
except:
message = 'ERROR -- KEPPRF: Columns must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0:
for i in xrange(nsrc):
try:
guess.append(float(y[i]))
except:
message = 'ERROR -- KEPPRF: Rows must be floating point numbers'
status = kepmsg.err(logfile, message, verbose)
if status == 0 and background:
if border == 0:
guess.append(0.0)
else:
for i in range((border + 1) * 2):
guess.append(0.0)
if status == 0 and focus:
guess.append(1.0)
guess.append(1.0)
guess.append(0.0)
# open TPF FITS file
print "... open tpf file"
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPPRF: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile, message, verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
print "... read mask definition"
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(
infile, logfile, verbose)
npix = numpy.size(numpy.nonzero(maskimg)[0])
# print target data
if status == 0 and verbose:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# is this a good row with finite timestamp and pixels?
if status == 0:
if not numpy.isfinite(barytime[rownum - 1]) or numpy.nansum(
fluxpixels[rownum - 1, :]) == numpy.nan:
message = 'ERROR -- KEPFIELD: Row ' + str(
rownum) + ' is a bad quality timestamp'
status = kepmsg.err(logfile, message, verbose)
# construct input pixel image
if status == 0:
flux = fluxpixels[rownum - 1, :]
ferr = errpixels[rownum - 1, :]
DATx = arange(column, column + xdim)
DATy = arange(row, row + ydim)
# image scale and intensity limits of pixel data
if status == 0:
n = 0
DATimg = empty((ydim, xdim))
ERRimg = empty((ydim, xdim))
for i in range(ydim):
for j in range(xdim):
DATimg[i, j] = flux[n]
ERRimg[i, j] = ferr[n]
n += 1
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(
output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPPRF: No PRF file found in ' + prfdir
status = kepmsg.err(logfile, message, verbose)
# read PRF images
if status == 0:
prfn = [0, 0, 0, 0, 0]
crpix1p = numpy.zeros((5), dtype='float32')
crpix2p = numpy.zeros((5), dtype='float32')
crval1p = numpy.zeros((5), dtype='float32')
crval2p = numpy.zeros((5), dtype='float32')
cdelt1p = numpy.zeros((5), dtype='float32')
cdelt2p = numpy.zeros((5), dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
PRFx = arange(0.5, shape(prfn[0])[1] + 0.5)
PRFy = arange(0.5, shape(prfn[0])[0] + 0.5)
PRFx = (PRFx - size(PRFx) / 2) * cdelt1p[0]
PRFy = (PRFy - size(PRFy) / 2) * cdelt2p[0]
# interpolate the calibrated PRF shape to the target position
if status == 0:
prf = zeros(shape(prfn[0]), dtype='float32')
prfWeight = zeros((5), dtype='float32')
for i in xrange(5):
prfWeight[i] = sqrt((column - crval1p[i])**2 +
(row - crval2p[i])**2)
if prfWeight[i] == 0.0:
prfWeight[i] = 1.0e6
prf = prf + prfn[i] / prfWeight[i]
prf = prf / nansum(prf)
prf = prf / cdelt1p[0] / cdelt2p[0]
# location of the data image centered on the PRF image (in PRF pixel units)
if status == 0:
prfDimY = int(ydim / cdelt1p[0])
prfDimX = int(xdim / cdelt2p[0])
PRFy0 = (shape(prf)[0] - prfDimY) / 2
PRFx0 = (shape(prf)[1] - prfDimX) / 2
# interpolation function over the PRF
if status == 0:
splineInterpolation = scipy.interpolate.RectBivariateSpline(
PRFx, PRFy, prf)
# construct mesh for background model
if status == 0 and background:
bx = numpy.arange(1., float(xdim + 1))
by = numpy.arange(1., float(ydim + 1))
xx, yy = numpy.meshgrid(numpy.linspace(bx.min(), bx.max(), xdim),
numpy.linspace(by.min(), by.max(), ydim))
# fit PRF model to pixel data
if status == 0:
start = time.time()
if focus and background:
args = (DATx, DATy, DATimg, nsrc, border, xx, yy, PRFx, PRFy,
splineInterpolation)
ans = fmin_powell(kepfunc.PRFwithFocusAndBackground,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
elif focus and not background:
args = (DATx, DATy, DATimg, nsrc, PRFx, PRFy, splineInterpolation)
ans = fmin_powell(kepfunc.PRFwithFocus,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
elif background and not focus:
args = (DATx, DATy, DATimg, nsrc, border, xx, yy,
splineInterpolation)
ans = fmin_powell(kepfunc.PRFwithBackground,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
else:
args = (DATx, DATy, DATimg, splineInterpolation)
ans = fmin_powell(kepfunc.PRF,
guess,
args=args,
xtol=xtol,
ftol=ftol,
disp=False)
print 'Convergence time = %.2fs\n' % (time.time() - start)
# pad the PRF data if the PRF array is smaller than the data array
if status == 0:
flux = []
OBJx = []
OBJy = []
PRFmod = numpy.zeros((prfDimY, prfDimX))
if PRFy0 < 0 or PRFx0 < 0.0:
PRFmod = numpy.zeros((prfDimY, prfDimX))
superPRF = zeros((prfDimY + 1, prfDimX + 1))
superPRF[abs(PRFy0):abs(PRFy0) + shape(prf)[0],
abs(PRFx0):abs(PRFx0) + shape(prf)[1]] = prf
prf = superPRF * 1.0
PRFy0 = 0
PRFx0 = 0
# rotate the PRF model around its center
if focus:
angle = ans[-1]
prf = rotate(prf, -angle, reshape=False, mode='nearest')
# iterate through the sources in the best fit PSF model
for i in range(nsrc):
flux.append(ans[i])
OBJx.append(ans[nsrc + i])
OBJy.append(ans[nsrc * 2 + i])
# calculate best-fit model
y = (OBJy[i] - mean(DATy)) / cdelt1p[0]
x = (OBJx[i] - mean(DATx)) / cdelt2p[0]
prfTmp = shift(prf, [y, x], order=1, mode='constant')
prfTmp = prfTmp[PRFy0:PRFy0 + prfDimY, PRFx0:PRFx0 + prfDimX]
PRFmod = PRFmod + prfTmp * flux[i]
wx = 1.0
wy = 1.0
angle = 0
b = 0.0
# write out best fit parameters
if verbose:
txt = 'Flux = %10.2f e-/s ' % flux[i]
txt += 'X = %9.4f pix ' % OBJx[i]
txt += 'Y = %9.4f pix ' % OBJy[i]
kepmsg.log(logfile, txt, True)
if verbose and background:
bterms = border + 1
if bterms == 1:
b = ans[nsrc * 3]
else:
bcoeff = array([
ans[nsrc * 3:nsrc * 3 + bterms],
ans[nsrc * 3 + bterms:nsrc * 3 + bterms * 2]
])
bkg = kepfunc.polyval2d(xx, yy, bcoeff)
b = nanmean(bkg.reshape(bkg.size))
txt = '\n Mean background = %.2f e-/s' % b
kepmsg.log(logfile, txt, True)
if focus:
wx = ans[-3]
wy = ans[-2]
angle = ans[-1]
if verbose and focus:
if not background: kepmsg.log(logfile, '', True)
kepmsg.log(logfile, ' X/Y focus factors = %.3f/%.3f' % (wx, wy),
True)
kepmsg.log(logfile, 'PRF rotation angle = %.2f deg' % angle, True)
# constuct model PRF in detector coordinates
if status == 0:
PRFfit = kepfunc.PRF2DET(flux, OBJx, OBJy, DATx, DATy, wx, wy, angle,
splineInterpolation)
if background and bterms == 1:
PRFfit = PRFfit + b
if background and bterms > 1:
PRFfit = PRFfit + bkg
# calculate residual of DATA - FIT
if status == 0:
PRFres = DATimg - PRFfit
FLUXres = numpy.nansum(PRFres)
# calculate the sum squared difference between data and model
if status == 0:
Pearson = abs(numpy.nansum(numpy.square(DATimg - PRFfit) / PRFfit))
Chi2 = numpy.nansum(
numpy.square(DATimg - PRFfit) / numpy.square(ERRimg))
DegOfFreedom = npix - len(guess)
try:
kepmsg.log(logfile, '\nResidual flux = %.6f e-/s' % FLUXres, True)
kepmsg.log(
logfile, 'Pearson\'s chi^2 test = %d for %d dof' %
(Pearson, DegOfFreedom), True)
except:
pass
# kepmsg.log(logfile,'Chi^2 test = %d for %d dof' % (Chi2,DegOfFreedom),True)
# image scale and intensity limits for plotting images
if status == 0:
imgdat_pl, zminfl, zmaxfl = kepplot.intScale2D(DATimg, imscale)
imgprf_pl, zminpr, zmaxpr = kepplot.intScale2D(PRFmod, imscale)
imgfit_pl, zminfi, zmaxfi = kepplot.intScale2D(PRFfit, imscale)
imgres_pl, zminre, zmaxre = kepplot.intScale2D(PRFres, imscale)
if imscale == 'linear':
zmaxpr *= 0.9
elif imscale == 'logarithmic':
print zminpr, zmaxpr, numpy.max(zmaxpr)
zmaxpr = numpy.max(zmaxpr)
zminpr = zmaxpr / 2
# plot style
if status == 0:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 10,
'ytick.labelsize': 10
}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[10, 10])
pylab.clf()
plotimage(imgdat_pl, zminfl, zmaxfl, 1, row, column, xdim, ydim, 0.06,
0.52, 'flux', colmap)
plotimage(imgprf_pl, zminpr, zmaxpr, 2, row, column, xdim, ydim, 0.52,
0.52, 'model', colmap)
kepplot.borders(maskimg, xdim, ydim, pixcoord1, pixcoord2, 1, 'b',
'--', 0.5)
kepplot.borders(maskimg, xdim, ydim, pixcoord1, pixcoord2, 2, 'b', '-',
3.0)
plotimage(imgfit_pl, zminfl, zmaxfl, 3, row, column, xdim, ydim, 0.06,
0.06, 'fit', colmap)
plotimage(imgres_pl, zminfl, zmaxfl, 4, row, column, xdim, ydim, 0.52,
0.06, 'residual', colmap)
# render plot
if status == 0 and len(plotfile) > 0 and plotfile.lower() != 'none':
pylab.savefig(plotfile)
if status == 0 and plt:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\nKEPPRF ended at', logfile, verbose)
return
def keppixseries(infile,
outfile,
plotfile,
plottype,
filter,
function,
cutoff,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPPIXSERIES -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'plotfile=' + plotfile + ' '
call += 'plottype=' + plottype + ' '
filt = 'n'
if (filter): filt = 'y'
call += 'filter=' + filt + ' '
call += 'function=' + function + ' '
call += 'cutoff=' + str(cutoff) + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPPIXSERIES started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPPIXSERIES: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# open TPF FITS file
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(
infile, logfile, verbose)
# print target data
if status == 0:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# how many quality = 0 rows?
if status == 0:
npts = 0
nrows = len(fluxpixels)
for i in range(nrows):
if qual[i] == 0 and \
numpy.isfinite(barytime[i]) and \
numpy.isfinite(fluxpixels[i,ydim*xdim/2]):
npts += 1
time = empty((npts))
timecorr = empty((npts))
cadenceno = empty((npts))
quality = empty((npts))
pixseries = empty((ydim, xdim, npts))
errseries = empty((ydim, xdim, npts))
# construct output light curves
if status == 0:
np = 0
for i in range(ydim):
for j in range(xdim):
npts = 0
for k in range(nrows):
if qual[k] == 0 and \
numpy.isfinite(barytime[k]) and \
numpy.isfinite(fluxpixels[k,ydim*xdim/2]):
time[npts] = barytime[k]
timecorr[npts] = tcorr[k]
cadenceno[npts] = cadno[k]
quality[npts] = qual[k]
pixseries[i, j, npts] = fluxpixels[k, np]
errseries[i, j, npts] = errpixels[k, np]
npts += 1
np += 1
# define data sampling
if status == 0 and filter:
tpf, status = kepio.openfits(infile, 'readonly', logfile, verbose)
if status == 0 and filter:
cadence, status = kepkey.cadence(tpf[1], infile, logfile, verbose)
tr = 1.0 / (cadence / 86400)
timescale = 1.0 / (cutoff / tr)
# define convolution function
if status == 0 and filter:
if function == 'boxcar':
filtfunc = numpy.ones(numpy.ceil(timescale))
elif function == 'gauss':
timescale /= 2
dx = numpy.ceil(timescale * 10 + 1)
filtfunc = kepfunc.gauss()
filtfunc = filtfunc([1.0, dx / 2 - 1.0, timescale],
linspace(0, dx - 1, dx))
elif function == 'sinc':
dx = numpy.ceil(timescale * 12 + 1)
fx = linspace(0, dx - 1, dx)
fx = fx - dx / 2 + 0.5
fx /= timescale
filtfunc = numpy.sinc(fx)
filtfunc /= numpy.sum(filtfunc)
# pad time series at both ends with noise model
if status == 0 and filter:
for i in range(ydim):
for j in range(xdim):
ave, sigma = kepstat.stdev(pixseries[i, j, :len(filtfunc)])
padded = numpy.append(kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma), pixseries[i,j,:])
ave, sigma = kepstat.stdev(pixseries[i, j, -len(filtfunc):])
padded = numpy.append(padded, kepstat.randarray(numpy.ones(len(filtfunc)) * ave, \
numpy.ones(len(filtfunc)) * sigma))
# convolve data
if status == 0:
convolved = convolve(padded, filtfunc, 'same')
# remove padding from the output array
if status == 0:
outdata = convolved[len(filtfunc):-len(filtfunc)]
# subtract low frequencies
if status == 0:
outmedian = median(outdata)
pixseries[i,
j, :] = pixseries[i, j, :] - outdata + outmedian
# construct output file
if status == 0 and ydim * xdim < 1000:
instruct, status = kepio.openfits(infile, 'readonly', logfile, verbose)
status = kepkey.history(call, instruct[0], outfile, logfile, verbose)
hdulist = HDUList(instruct[0])
cols = []
cols.append(
Column(name='TIME',
format='D',
unit='BJD - 2454833',
disp='D12.7',
array=time))
cols.append(
Column(name='TIMECORR',
format='E',
unit='d',
disp='E13.6',
array=timecorr))
cols.append(
Column(name='CADENCENO', format='J', disp='I10', array=cadenceno))
cols.append(Column(name='QUALITY', format='J', array=quality))
for i in range(ydim):
for j in range(xdim):
colname = 'COL%d_ROW%d' % (i + column, j + row)
cols.append(
Column(name=colname,
format='E',
disp='E13.6',
array=pixseries[i, j, :]))
hdu1 = new_table(ColDefs(cols))
try:
hdu1.header.update('INHERIT', True, 'inherit the primary header')
except:
status = 0
try:
hdu1.header.update('EXTNAME', 'PIXELSERIES', 'name of extension')
except:
status = 0
try:
hdu1.header.update(
'EXTVER', instruct[1].header['EXTVER'],
'extension version number (not format version)')
except:
status = 0
try:
hdu1.header.update('TELESCOP', instruct[1].header['TELESCOP'],
'telescope')
except:
status = 0
try:
hdu1.header.update('INSTRUME', instruct[1].header['INSTRUME'],
'detector type')
except:
status = 0
try:
hdu1.header.update('OBJECT', instruct[1].header['OBJECT'],
'string version of KEPLERID')
except:
status = 0
try:
hdu1.header.update('KEPLERID', instruct[1].header['KEPLERID'],
'unique Kepler target identifier')
except:
status = 0
try:
hdu1.header.update('RADESYS', instruct[1].header['RADESYS'],
'reference frame of celestial coordinates')
except:
status = 0
try:
hdu1.header.update('RA_OBJ', instruct[1].header['RA_OBJ'],
'[deg] right ascension from KIC')
except:
status = 0
try:
hdu1.header.update('DEC_OBJ', instruct[1].header['DEC_OBJ'],
'[deg] declination from KIC')
except:
status = 0
try:
hdu1.header.update('EQUINOX', instruct[1].header['EQUINOX'],
'equinox of celestial coordinate system')
except:
status = 0
try:
hdu1.header.update('TIMEREF', instruct[1].header['TIMEREF'],
'barycentric correction applied to times')
except:
status = 0
try:
hdu1.header.update('TASSIGN', instruct[1].header['TASSIGN'],
'where time is assigned')
except:
status = 0
try:
hdu1.header.update('TIMESYS', instruct[1].header['TIMESYS'],
'time system is barycentric JD')
except:
status = 0
try:
hdu1.header.update('BJDREFI', instruct[1].header['BJDREFI'],
'integer part of BJD reference date')
except:
status = 0
try:
hdu1.header.update('BJDREFF', instruct[1].header['BJDREFF'],
'fraction of the day in BJD reference date')
except:
status = 0
try:
hdu1.header.update('TIMEUNIT', instruct[1].header['TIMEUNIT'],
'time unit for TIME, TSTART and TSTOP')
except:
status = 0
try:
hdu1.header.update('TSTART', instruct[1].header['TSTART'],
'observation start time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('TSTOP', instruct[1].header['TSTOP'],
'observation stop time in BJD-BJDREF')
except:
status = 0
try:
hdu1.header.update('LC_START', instruct[1].header['LC_START'],
'mid point of first cadence in MJD')
except:
status = 0
try:
hdu1.header.update('LC_END', instruct[1].header['LC_END'],
'mid point of last cadence in MJD')
except:
status = 0
try:
hdu1.header.update('TELAPSE', instruct[1].header['TELAPSE'],
'[d] TSTOP - TSTART')
except:
status = 0
try:
hdu1.header.update('LIVETIME', instruct[1].header['LIVETIME'],
'[d] TELAPSE multiplied by DEADC')
except:
status = 0
try:
hdu1.header.update('EXPOSURE', instruct[1].header['EXPOSURE'],
'[d] time on source')
except:
status = 0
try:
hdu1.header.update('DEADC', instruct[1].header['DEADC'],
'deadtime correction')
except:
status = 0
try:
hdu1.header.update('TIMEPIXR', instruct[1].header['TIMEPIXR'],
'bin time beginning=0 middle=0.5 end=1')
except:
status = 0
try:
hdu1.header.update('TIERRELA', instruct[1].header['TIERRELA'],
'[d] relative time error')
except:
status = 0
try:
hdu1.header.update('TIERABSO', instruct[1].header['TIERABSO'],
'[d] absolute time error')
except:
status = 0
try:
hdu1.header.update('INT_TIME', instruct[1].header['INT_TIME'],
'[s] photon accumulation time per frame')
except:
status = 0
try:
hdu1.header.update('READTIME', instruct[1].header['READTIME'],
'[s] readout time per frame')
except:
status = 0
try:
hdu1.header.update('FRAMETIM', instruct[1].header['FRAMETIM'],
'[s] frame time (INT_TIME + READTIME)')
except:
status = 0
try:
hdu1.header.update('NUM_FRM', instruct[1].header['NUM_FRM'],
'number of frames per time stamp')
except:
status = 0
try:
hdu1.header.update('TIMEDEL', instruct[1].header['TIMEDEL'],
'[d] time resolution of data')
except:
status = 0
try:
hdu1.header.update('DATE-OBS', instruct[1].header['DATE-OBS'],
'TSTART as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('DATE-END', instruct[1].header['DATE-END'],
'TSTOP as UTC calendar date')
except:
status = 0
try:
hdu1.header.update('BACKAPP', instruct[1].header['BACKAPP'],
'background is subtracted')
except:
status = 0
try:
hdu1.header.update('DEADAPP', instruct[1].header['DEADAPP'],
'deadtime applied')
except:
status = 0
try:
hdu1.header.update('VIGNAPP', instruct[1].header['VIGNAPP'],
'vignetting or collimator correction applied')
except:
status = 0
try:
hdu1.header.update('GAIN', instruct[1].header['GAIN'],
'[electrons/count] channel gain')
except:
status = 0
try:
hdu1.header.update('READNOIS', instruct[1].header['READNOIS'],
'[electrons] read noise')
except:
status = 0
try:
hdu1.header.update('NREADOUT', instruct[1].header['NREADOUT'],
'number of read per cadence')
except:
status = 0
try:
hdu1.header.update('TIMSLICE', instruct[1].header['TIMSLICE'],
'time-slice readout sequence section')
except:
status = 0
try:
hdu1.header.update('MEANBLCK', instruct[1].header['MEANBLCK'],
'[count] FSW mean black level')
except:
status = 0
hdulist.append(hdu1)
hdulist.writeto(outfile)
status = kepkey.new('EXTNAME', 'APERTURE', 'name of extension',
instruct[2], outfile, logfile, verbose)
pyfits.append(outfile, instruct[2].data, instruct[2].header)
status = kepio.closefits(instruct, logfile, verbose)
else:
message = 'WARNING -- KEPPIXSERIES: output FITS file requires > 999 columns. Non-compliant with FITS convention.'
kepmsg.warn(logfile, message)
# plot style
if status == 0:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.0,
'axes.labelsize': 32,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 8,
'legend.fontsize': 8,
'xtick.labelsize': 12,
'ytick.labelsize': 12
}
pylab.rcParams.update(params)
except:
pass
# plot pixel array
fmin = 1.0e33
fmax = -1.033
if status == 0:
pylab.figure(num=None, figsize=[12, 12])
pylab.clf()
dx = 0.93 / xdim
dy = 0.94 / ydim
ax = pylab.axes([0.06, 0.05, 0.93, 0.94])
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().xaxis.set_major_locator(
matplotlib.ticker.MaxNLocator(integer=True))
pylab.gca().yaxis.set_major_locator(
matplotlib.ticker.MaxNLocator(integer=True))
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
pylab.xlim(numpy.min(pixcoord1) - 0.5, numpy.max(pixcoord1) + 0.5)
pylab.ylim(numpy.min(pixcoord2) - 0.5, numpy.max(pixcoord2) + 0.5)
pylab.xlabel('time', {'color': 'k'})
pylab.ylabel('arbitrary flux', {'color': 'k'})
for i in range(ydim):
for j in range(xdim):
tmin = amin(time)
tmax = amax(time)
try:
numpy.isfinite(amin(pixseries[i, j, :]))
numpy.isfinite(amin(pixseries[i, j, :]))
fmin = amin(pixseries[i, j, :])
fmax = amax(pixseries[i, j, :])
except:
ugh = 1
xmin = tmin - (tmax - tmin) / 40
xmax = tmax + (tmax - tmin) / 40
ymin = fmin - (fmax - fmin) / 20
ymax = fmax + (fmax - fmin) / 20
if kepstat.bitInBitmap(maskimg[i, j], 2):
pylab.axes([0.06 + float(j) * dx, 0.05 + i * dy, dx, dy],
axisbg='lightslategray')
elif maskimg[i, j] == 0:
pylab.axes([0.06 + float(j) * dx, 0.05 + i * dy, dx, dy],
axisbg='black')
else:
pylab.axes([0.06 + float(j) * dx, 0.05 + i * dy, dx, dy])
if j == int(xdim / 2) and i == 0:
pylab.setp(pylab.gca(), xticklabels=[], yticklabels=[])
elif j == 0 and i == int(ydim / 2):
pylab.setp(pylab.gca(), xticklabels=[], yticklabels=[])
else:
pylab.setp(pylab.gca(), xticklabels=[], yticklabels=[])
ptime = time * 1.0
ptime = numpy.insert(ptime, [0], ptime[0])
ptime = numpy.append(ptime, ptime[-1])
pflux = pixseries[i, j, :] * 1.0
pflux = numpy.insert(pflux, [0], -1000.0)
pflux = numpy.append(pflux, -1000.0)
pylab.plot(time,
pixseries[i, j, :],
color='#0000ff',
linestyle='-',
linewidth=0.5)
if not kepstat.bitInBitmap(maskimg[i, j], 2):
pylab.fill(ptime,
pflux,
fc='lightslategray',
linewidth=0.0,
alpha=1.0)
pylab.fill(ptime,
pflux,
fc='#FFF380',
linewidth=0.0,
alpha=1.0)
if 'loc' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(ymin, ymax)
if 'glob' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(1.0e-10, numpy.nanmax(pixseries) * 1.05)
if 'full' in plottype:
pylab.xlim(xmin, xmax)
pylab.ylim(1.0e-10, ymax * 1.05)
# render plot
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
if plotfile.lower() != 'none':
pylab.savefig(plotfile)
# stop time
if status == 0:
kepmsg.clock('KEPPIXSERIES ended at', logfile, verbose)
return
def kepmask(infile,mfile,pfile,tabrow,imin,imax,iscale,cmap,verbose,logfile,status,cLine=False):
global pimg, zscale, zmin, zmax, xmin, xmax, ymin, ymax, quarter
global pxdim, pydim, kepmag, skygroup, season, channel
global module, output, row, column, maskfile, plotfile
global pkepid, pkepmag, pra, pdec, colmap, cmdLine
# input arguments
status = 0
numpy.seterr(all="ignore")
zmin = imin; zmax = imax; zscale = iscale; colmap = cmap
maskfile = mfile; plotfile = pfile
cmdLine = cLine
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPMASK -- '
call += 'infile='+infile+' '
call += 'maskfile='+mfile+' '
call += 'plotfile='+pfile+' '
call += 'tabrow='+str(tabrow)+' '
call += 'imin='+str(imin)+' '
call += 'imax='+str(imax)+' '
call += 'iscale='+str(iscale)+' '
call += 'cmap='+str(cmap)+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPMASK started at',logfile,verbose)
# reference color map
if cmap == 'browse':
status = cmap_plot()
# open TPF FITS file and check tabrow exists
if status == 0:
tpf, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
try:
naxis2 = tpf['TARGETTABLES'].header['NAXIS2']
except:
txt = 'ERROR -- KEPMASK: No NAXIS2 keyword in ' + infile + '[TARGETTABLES]'
status = kepmsg.err(logfile,txt,True)
if status == 0 and tabrow > naxis2:
txt = 'ERROR -- KEPMASK: tabrow is too large. There are ' + str(naxis2) + ' rows in the table.'
status = kepmsg.err(logfile,txt,True)
if status == 0:
status = kepio.closefits(tpf,logfile,verbose)
# read TPF data pixel image
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, pixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
img = pixels[tabrow]
pkepid = copy(kepid)
pra = copy(ra)
pdec = copy(dec)
pkepmag = copy(kepmag)
pxdim = copy(xdim)
pydim = copy(ydim)
pimg = copy(img)
# print target data
if status == 0:
print('')
print(' KepID: %s' % kepid)
print(' RA (J2000): %s' % ra)
print('Dec (J2000): %s' % dec)
print(' KepMag: %s' % kepmag)
print(' SkyGroup: %2s' % skygroup)
print(' Season: %2s' % str(season))
print(' Channel: %2s' % channel)
print(' Module: %2s' % module)
print(' Output: %1s' % output)
print('')
# subimage of channel for plot
if status == 0:
ymin = copy(row)
ymax = ymin + ydim
xmin = copy(column)
xmax = xmin + xdim
# intensity scale
if status == 0:
pimg, imin, imax = kepplot.intScale1D(pimg,zscale)
if zmin and zmax and 'log' in zscale:
zmin = log10(zmin)
zmax = log10(zmax)
elif zmin and zmax and 'sq' in zscale:
zmin = sqrt(zmin)
zmax = sqrt(zmax)
elif zmin and zmax and 'li' in zscale:
zmin *= 1.0
zmax *= 1.0
else:
zmin = copy(imin)
zmax = copy(imax)
# nstat = 2; pixels = []
# work = array(sort(img),dtype=float32)
# for i in range(len(work)):
# if 'nan' not in str(work[i]):
# pixels.append(work[i])
# pixels = array(pixels,dtype=float32)
# if int(float(len(pixels)) / 10 + 0.5) > nstat:
# nstat = int(float(len(pixels)) / 10 + 0.5)
# if not zmin:
# zmin = median(pixels[:nstat])
# if not zmax:
# zmax = median(pixels[-nstat:])
# if 'log' in zscale:
# pimg = log10(pimg)
# if 'sq' in zscale:
# pimg = sqrt(pimg)
# plot limits
ymin = float(ymin) - 0.5
ymax = float(ymax) - 0.5
xmin = float(xmin) - 0.5
xmax = float(xmax) - 0.5
# plot style
try:
params = {'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 14,
'ytick.labelsize': 14}
pylab.rcParams.update(params)
except:
pass
if status == 0:
pylab.figure(figsize=[10,7])
plotimage(cmdLine)
return
def keptimefix(infile,outfile,clobber,verbose,logfile,status,cmdLine=False):
"""
All Kepler light curve and target pixel files with version numbers 5.0 contain an error in
the time stamps. This was fixed in the light curve with version 5.0 (at MAST after May 2013).
The timescale for fixing the target pixel files is unclear but in the mean time this script will
fix the target pixel file time stamps and make the times consistent with the light curve files.
The error in Q0-13 can be corrected by adding 66.184s. During Q14 there was a leap second added
Q15+ can be corrected by adding 67.184s. This tool fixes the time stamp accordingly.
inputs
infile - the name of the input target pixel file
output - the name of the output target pixel file
optional
clobber (default=False) - overwrite a file with the stame name as outfile.
"""
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPTIMEFIX -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPTIMEFIX started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
if clobber:
status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPTIMEFIX: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile,message,verbose)
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
creator = instr[0].header['CREATOR']
if creator.find('TargetPixelExporterPipelineModule') < 0:
message = 'ERROR -- KEPTIMEFIX: this file is not a target pixel file'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
header_ext1 = instr[1].header.ascardlist()
data_ext1 = instr[1].data
fileversion = instr[0].header['FILEVER']
if float(fileversion) > 4.0:
message = 'ERROR -- KEPTIMEFIX: no time fix needed for this file. FILEVER > 4.0'
status = kepmsg.err(logfile,message,verbose)
sys.exit(0)
quarter = instr[0].header['QUARTER']
if instr[0].header['OBSMODE'] == 'long cadence':
cadencetype = 'L'
elif instr[0].header['OBSMODE'] == 'short cadence':
cadencetype = 'S'
TIME_wrong = data_ext1.field('TIME')
CADNUM = data_ext1.field('CADENCENO')
TIMECORR_old = data_ext1.field('TIMECORR')
## update headers
##TSTART, TSTART, EXPOSURE, TELAPSE, LIVETIME
##DATE-OBS, DATE-END
if cadencetype == 'L':
offset = np.where(CADNUM <= 57139,66.184,67.184) / 86400.
elif cadencetype == 'S':
offset = np.where(CADNUM <= 1702663,66.184,67.184) / 86400.
TIME_right = TIME_wrong + offset
TIMECORR_new = TIMECORR_old + offset
#tcol = pyfits.Column(name='TIME',format='D14.7',
# array=TIME_right, unit = 'BJD - 2454833', disp='D14.7')
#instr[1].columns.change_attrib('TIME',array,TIME_right)
#cols = instr[1].data.columns + tcol
instr[1].data['TIME'][:] = TIME_right
#we decided not to use the updated timecorr because
#it is different from the LC FITS files by ~1 ms.
instr[1].data['TIMECORR'][:] = np.nan * np.empty(len(TIMECORR_old))
#instr[1] = pyfits.new_table(cols,header=instr[1].header)
#now to fix the header
tstart_right = instr[1].header['TSTART'] + offset[0]
tstop_right = instr[1].header['TSTOP'] + offset[-1]
telapse_right = tstop_right - tstart_right
instr[1].header['TSTART'] = tstart_right
instr[1].header['TSTOP'] = tstop_right
instr[1].header['TELAPSE'] = telapse_right
deadc = instr[1].header['DEADC']
instr[1].header['LIVETIME'] = telapse_right * deadc
#get the date-obs
dstart = instr[1].header['DATE-OBS']
dend = instr[1].header['DATE-END']
## This datetime stuff is not nessessary!!!!
#dts = datetime.datetime.strptime(dstart, "%Y-%m-%dT%H:%M:%S.%fZ")
#dte = datetime.datetime.strptime(dend, "%Y-%m-%dT%H:%M:%S.%fZ")
#offset_s1 = datetime.timedelta(seconds=66.184)
#offset_s2 = datetime.timedelta(seconds=67.184)
#if quarter <14:
# date_obs_new = dts + offset_s1
# date_end_new = dte + offset_s1
#if quarter > 14:
# date_obs_new = dts + offset_s2
# date_end_new = dte + offset_s2
#if quarter == 14:
# date_obs_new = dts + offset_s1
# date_end_new = dte + offset_s2
#instr[1].header['DATE-OBS'] = str(date_obs_new)[:-3] + 'Z'
#instr[1].header['DATE-END'] = str(date_end_new)[:-3] + 'Z'
instr.writeto(outfile)
#if quarter == 14:
# livtime = instr[1].header['LIVTIME']
# livtime += 1.
# exposure += 1.
# end time
if (status == 0):
message = 'KEPTIMEFIX completed at'
else:
message = '\nKEPTIMEFIX aborted at'
kepmsg.clock(message,logfile,verbose)
def kepdeltapix(infile,
nexp,
columns,
rows,
fluxes,
prfdir,
interpolation,
tolerance,
fittype,
imscale,
colmap,
verbose,
logfile,
status,
cmdLine=False):
# input arguments
status = 0
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPDELTAPIX -- '
call += 'infile=' + infile + ' '
call += 'nexp=' + str(nexp) + ' '
call += 'columns=' + columns + ' '
call += 'rows=' + rows + ' '
call += 'fluxes=' + fluxes + ' '
call += 'prfdir=' + prfdir + ' '
call += 'interpolation=' + interpolation + ' '
call += 'tolerance=' + str(tolerance) + ' '
call += 'fittype=' + str(fittype) + ' '
call += 'imscale=' + imscale + ' '
call += 'colmap=' + colmap + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# test log file
logfile = kepmsg.test(logfile)
# start time
kepmsg.clock('KEPDELTAPIX started at', logfile, verbose)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPDELTAPIX: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile, message, verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# print target data
if status == 0 and verbose:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# determine suitable PRF calibration file
if status == 0:
if int(module) < 10:
prefix = 'kplr0'
else:
prefix = 'kplr'
prfglob = prfdir + '/' + prefix + str(module) + '.' + str(
output) + '*' + '_prf.fits'
try:
prffile = glob.glob(prfglob)[0]
except:
message = 'ERROR -- KEPDELTAPIX: No PRF file found in ' + prfdir
status = kepmsg.err(logfile, message, verbose)
# read PRF images
if status == 0:
prfn = [0, 0, 0, 0, 0]
crpix1p = numpy.zeros((5), dtype='float32')
crpix2p = numpy.zeros((5), dtype='float32')
crval1p = numpy.zeros((5), dtype='float32')
crval2p = numpy.zeros((5), dtype='float32')
cdelt1p = numpy.zeros((5), dtype='float32')
cdelt2p = numpy.zeros((5), dtype='float32')
for i in range(5):
prfn[i], crpix1p[i], crpix2p[i], crval1p[i], crval2p[i], cdelt1p[i], cdelt2p[i], status \
= kepio.readPRFimage(prffile,i+1,logfile,verbose)
# choose rows in the TPF table at random
if status == 0:
i = 0
rownum = []
while i < nexp:
work = int(random.random() * len(barytime))
if numpy.isfinite(barytime[work]) and numpy.isfinite(
fluxpixels[work, ydim * xdim / 2]):
rownum.append(work)
i += 1
# construct input pixel image
if status == 0:
fscat = numpy.empty((len(fluxes), nexp), dtype='float32')
xscat = numpy.empty((len(columns), nexp), dtype='float32')
yscat = numpy.empty((len(rows), nexp), dtype='float32')
for irow in range(nexp):
flux = fluxpixels[rownum[irow], :]
# image scale and intensity limits of pixel data
if status == 0:
flux_pl, zminfl, zmaxfl = kepplot.intScale1D(flux, imscale)
n = 0
imgflux_pl = empty((ydim, xdim))
for i in range(ydim):
for j in range(xdim):
imgflux_pl[i, j] = flux_pl[n]
n += 1
# fit PRF model to pixel data
if status == 0:
start = time.time()
f, y, x, prfMod, prfFit, prfRes = kepfit.fitMultiPRF(
flux, ydim, xdim, column, row, prfn, crval1p, crval2p,
cdelt1p, cdelt2p, interpolation, tolerance, fluxes,
columns, rows, fittype, verbose, logfile)
if verbose:
print '\nConvergence time = %.1fs' % (time.time() - start)
# best fit parameters
if status == 0:
for i in range(len(f)):
fscat[i, irow] = f[i]
xscat[i, irow] = x[i]
yscat[i, irow] = y[i]
# replace starting guess with previous fit parameters
if status == 0:
fluxes = copy(f)
columns = copy(x)
rows = copy(y)
# mean and rms results
if status == 0:
fmean = []
fsig = []
xmean = []
xsig = []
ymean = []
ysig = []
for i in range(len(f)):
fmean.append(numpy.mean(fscat[i, :]))
xmean.append(numpy.mean(xscat[i, :]))
ymean.append(numpy.mean(yscat[i, :]))
fsig.append(numpy.std(fscat[i, :]))
xsig.append(numpy.std(xscat[i, :]))
ysig.append(numpy.std(yscat[i, :]))
txt = 'Flux = %10.2f e-/s ' % fmean[-1]
txt += 'X = %7.4f +/- %6.4f pix ' % (xmean[-1], xsig[i])
txt += 'Y = %7.4f +/- %6.4f pix' % (ymean[-1], ysig[i])
kepmsg.log(logfile, txt, True)
# output results for kepprfphot
if status == 0:
txt1 = 'columns=0.0'
txt2 = ' rows=0.0'
for i in range(1, len(f)):
txt1 += ',%.4f' % (xmean[i] - xmean[0])
txt2 += ',%.4f' % (ymean[i] - ymean[0])
kepmsg.log(logfile, '\nkepprfphot input fields:', True)
kepmsg.log(logfile, txt1, True)
kepmsg.log(logfile, txt2, True)
# image scale and intensity limits for PRF model image
if status == 0:
imgprf_pl, zminpr, zmaxpr = kepplot.intScale2D(prfMod, imscale)
# image scale and intensity limits for PRF fit image
if status == 0:
imgfit_pl, zminfi, zmaxfi = kepplot.intScale2D(prfFit, imscale)
# image scale and intensity limits for data - fit residual
if status == 0:
imgres_pl, zminre, zmaxre = kepplot.intScale2D(prfRes, imscale)
# plot style
if status == 0:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 10,
'ytick.labelsize': 10
}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[10, 10])
pylab.clf()
plotimage(imgflux_pl, zminfl, zmaxfl, 1, row, column, xdim, ydim, 0.06,
0.52, 'flux', colmap)
plotimage(imgfit_pl, zminfl, zmaxfl, 3, row, column, xdim, ydim, 0.06,
0.06, 'fit', colmap)
plotimage(imgres_pl, zminfl, zmaxfl, 4, row, column, xdim, ydim, 0.52,
0.06, 'residual', colmap)
plotimage(imgprf_pl, zminpr, zmaxpr * 0.9, 2, row, column, xdim, ydim,
0.52, 0.52, 'model', colmap)
for i in range(len(f)):
pylab.plot(xscat[i, :], yscat[i, :], 'o', color='k')
# Plot creep of target position over time, relative to the central source
# barytime0 = float(int(barytime[0] / 100) * 100.0)
# barytime -= barytime0
# xlab = 'BJD $-$ %d' % barytime0
# xmin = numpy.nanmin(barytime)
# xmax = numpy.nanmax(barytime)
# y1min = numpy.nanmin(data)
# y1max = numpy.nanmax(data)
# xr = xmax - xmin
# yr = ymax - ymin
# barytime = insert(barytime,[0],[barytime[0]])
# barytime = append(barytime,[barytime[-1]])
# data = insert(data,[0],[0.0])
# data = append(data,0.0)
#
# pylab.figure(2,figsize=[10,10])
# pylab.clf()
# ax = pylab.subplot(211)
# pylab.subplots_adjust(0.1,0.5,0.88,0.42)
# pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# labels = ax.get_yticklabels()
# setp(labels, 'rotation', 90, fontsize=ticksize)
# for i in range(1,len(f)):
# pylab.plot(rownum,xscat[i,:]-xscat[0,:],'o')
# pylab.ylabel('$\Delta$Columns', {'color' : 'k'})
# ax = pylab.subplot(211)
# pylab.subplots_adjust(0.1,0.1,0.88,0.42)
# pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
# labels = ax.get_yticklabels()
# setp(labels, 'rotation', 90, fontsize=ticksize)
# for i in range(1,len(f)):
# pylab.plot(rownum,yscat[i,:]-yscat[0,:],'o')
# pylab.xlim(xmin-xr*0.01,xmax+xr*0.01)
# if ymin-yr*0.01 <= 0.0 or fullrange:
# pylab.ylim(1.0e-10,ymax+yr*0.01)
# else:
# pylab.ylim(ymin-yr*0.01,ymax+yr*0.01)
# pylab.ylabel('$\Delta$Rows', {'color' : 'k'})
# pylab.xlabel(xlab, {'color' : 'k'})
# render plot
if status == 0:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# stop time
kepmsg.clock('\nKEPDELTAPIX ended at', logfile, verbose)
return
def kepaddconstant(infile,outfile,datacol,constant,constantval,sign
,clobber,verbose,logfile,status):
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPARITH -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'constant='+str(constant)+' '
call += 'constantval='+str(constantval)+' '
call += 'sign'+str(sign)+' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber='+overwrite+ ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPARITH started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPARITH: ' + outfile + ' exists. Use clobber=yes'
status = kepmsg.err(logfile,message,verbose)
## open input file
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
if status == 0:
try:
test = str(instr[0].header['FILEVER'])
version = 2
except KeyError:
version = 1
# if version == 1:
# #lc_flux = instr[1].data.field(datacol) + constant
# lc_flux = instr[1].data.field(datacol)
# instr[1].data.field(datacol)[:] = (lc_flux - median(lc_flux)) / MAD(lc_flux)
# elif version == 2:
# #lc_flux = instr[1].data.field(datacol) + constant
# lc_flux = instr[1].data.field(datacol)
# instr[1].data.field(datacol)[:] = (lc_flux - median(lc_flux)) / MAD(lc_flux)
lc_flux = instr[1].data.field(datacol)
if datacol == 'SAP_FLUX':
errcol = 'SAP_FLUX_ERR'
try:
lc_err = instr[1].data.field(errcol)
haveerr = True
except:
haveerr = False
elif datacol == 'PDCSAP_FLUX':
errcol = 'PDCSAP_FLUX_ERR'
try:
lc_err = instr[1].data.field(errcol)
haveerr = True
except:
haveerr = False
else:
errcol = datacol + '_ERR'
try:
lc_err = instr[1].data.field(errcol)
haveerr = True
except:
try:
errcol = datacol + '_err'
lc_err = instr[1].data.field(errcol)
haveerr = True
except:
haveerr = False
#subtractor he just refers to the number that will be added/subtracted
#divided or multiplied
if isinstance(constantval,(long,int,float)) and constant == 'None':
subtractor = float(constantval)
elif constant.lower() == 'median':
subtractor = float(median(lc_flux[isfinite(lc_flux)]))
elif constant.lower() == 'mean':
subtractor = float(mean(lc_flux[isfinite(lc_flux)]))
elif constant.lower() == 'std':
subtractor = float(std(lc_flux[isfinite(lc_flux)]))
elif constant.lower() == 'mad':
subtractor = float(MAD(lc_flux[isfinite(lc_flux)]))
elif constant.lower() == 'max':
subtractor = float(max(lc_flux[isfinite(lc_flux)]))
elif constant.lower() == 'range':
subtractor = float(max(lc_flux[isfinite(lc_flux)]) - min(lc_flux[isfinite(lc_flux)]))
elif str(constant).lower() == 'none':
subtractor = 0.
message = 'No operation will be performed if you select None for the function and do not give a constant value'
status = kepmsg.err(logfile,message,verbose)
else:
message = 'Your constant term is not in the list of possible functions'
status = kepmsg.err(logfile,message,verbose)
if subtractor == 0. and sign == 'divide' and status == 0:
message = 'You are trying to divide by zero: not a good idea.'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
if sign.lower() == 'add':
instr[1].data.field(datacol)[:] = where(isfinite(instr[1].data.field(datacol)[:]),(lc_flux + subtractor),nan)
elif sign.lower() == 'subtract':
instr[1].data.field(datacol)[:] = where(isfinite(instr[1].data.field(datacol)[:]),(lc_flux - subtractor),nan)
elif sign.lower() == 'divide':
instr[1].data.field(datacol)[:] = where(isfinite(instr[1].data.field(datacol)[:]),(lc_flux / subtractor),nan)
if haveerr:
instr[1].data.field(errcol)[:] = where(isfinite(instr[1].data.field(errcol)[:]),(lc_err / subtractor),nan)
elif sign.lower() == 'multiply':
instr[1].data.field(datacol)[:] = where(isfinite(instr[1].data.field(datacol)[:]),(lc_flux * subtractor),nan)
if haveerr:
instr[1].data.field(errcol)[:] = where(isfinite(instr[1].data.field(errcol)[:]),(lc_err * subtractor),nan)
else:
message = 'Your operation need to be one of: add, subtract, divide or multiply'
status = kepmsg.err(logfile,message,verbose)
if status == 0:
instr.writeto(outfile)
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPARITH completed at'
else:
message = '\nKEPARITH aborted at'
kepmsg.clock(message,logfile,verbose)
def kepclip(infile,
outfile,
ranges,
plot,
plotcol,
clobber,
verbose,
logfile,
status,
cmdLine=False):
# startup parameters
status = 0
labelsize = 32
ticksize = 24
xsize = 18
ysize = 10
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPCLIP -- '
call += 'infile=' + infile + ' '
call += 'outfile=' + outfile + ' '
call += 'ranges=' + ranges + ' '
plotit = 'n'
if (plot): plotit = 'y'
call += 'plot=' + plotit + ' '
call += 'plotcol=' + plotcol + ' '
overwrite = 'n'
if (clobber): overwrite = 'y'
call += 'clobber=' + overwrite + ' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose=' + chatter + ' '
call += 'logfile=' + logfile
kepmsg.log(logfile, call + '\n', verbose)
# start time
kepmsg.clock('KEPCLIP started at', logfile, verbose)
# test log file
logfile = kepmsg.test(logfile)
# clobber output file
if clobber: status = kepio.clobber(outfile, logfile, verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPCLIP: ' + outfile + ' exists. Use --clobber'
status = kepmsg.err(logfile, message, verbose)
# time ranges for region
if status == 0:
t1 = []
t2 = []
t1, t2, status = kepio.timeranges(ranges, logfile, verbose)
# open input file
if status == 0:
instr, status = kepio.openfits(infile, 'readonly', logfile, verbose)
tstart, tstop, bjdref, cadence, status = kepio.timekeys(
instr, infile, logfile, verbose, status)
if status == 0:
try:
work = instr[0].header['FILEVER']
cadenom = 1.0
except:
cadenom = cadence
# fudge non-compliant FITS keywords with no values
if status == 0:
instr = kepkey.emptykeys(instr, file, logfile, verbose)
# input data
if status == 0:
table = instr[1].data
# read time and flux columns
if status == 0:
barytime, status = kepio.readtimecol(infile, table, logfile, verbose)
if status == 0:
flux, status = kepio.readfitscol(infile, table, plotcol, logfile,
verbose)
if status == 0:
barytime = barytime + bjdref
if 'flux' in plotcol.lower():
flux = flux / cadenom
# filter input data table
if status == 0:
naxis2 = 0
work1 = array([], 'float64')
work2 = array([], 'float32')
for i in range(len(barytime)):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(flux[i])
and flux[i] != 0.0):
reject = False
for j in range(len(t1)):
if (barytime[i] >= t1[j] and barytime[i] <= t2[j]):
reject = True
if not reject:
table[naxis2] = table[i]
work1 = append(work1, barytime[i])
work2 = append(work2, flux[i])
naxis2 += 1
# comment keyword in output file
if status == 0:
status = kepkey.history(call, instr[0], outfile, logfile, verbose)
# write output file
if status == 0:
instr[1].data = table[:naxis2]
comment = 'NaN cadences removed from data'
status = kepkey.new('NANCLEAN', True, comment, instr[1], outfile,
logfile, verbose)
instr.writeto(outfile)
# clean up x-axis unit
if status == 0:
barytime0 = float(int(tstart / 100) * 100.0)
barytime = work1 - barytime0
xlab = 'BJD $-$ %d' % barytime0
# clean up y-axis units
if status == 0:
try:
nrm = len(str(int(work2.max()))) - 1
except:
nrm = 0
flux = work2 / 10**nrm
ylab = '10$^%d$ e$^-$ s$^{-1}$' % nrm
# data limits
xmin = barytime.min()
xmax = barytime.max()
ymin = flux.min()
ymax = flux.max()
xr = xmax - xmin
yr = ymax - ymin
# plotting arguments
if status == 0 and plot:
try:
params = {
'backend': 'png',
'axes.linewidth': 2.5,
'axes.labelsize': labelsize,
'axes.font': 'sans-serif',
'axes.fontweight': 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': ticksize,
'ytick.labelsize': ticksize
}
rcParams.update(params)
except:
print('ERROR -- KEPCLIP: install latex for scientific plotting')
status = 1
# clear window, plot box
if status == 0 and plot:
pylab.figure(figsize=[xsize, ysize])
pylab.clf()
ax = pylab.axes([0.05, 0.1, 0.94, 0.88])
# force tick labels to be absolute rather than relative
pylab.gca().xaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(
pylab.ScalarFormatter(useOffset=False))
# rotate y labels by 90 deg
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90, fontsize=12)
# plot line data
ltime = [barytime[0]]
ldata = [flux[0]]
for i in range(1, len(flux)):
if (barytime[i - 1] > barytime[i] - 0.025):
ltime.append(barytime[i])
ldata.append(flux[i])
else:
ltime = array(ltime, dtype=float64)
ldata = array(ldata, dtype=float64)
pylab.plot(ltime,
ldata,
color=lcolor,
linestyle='-',
linewidth=lwidth)
ltime = []
ldata = []
ltime = array(ltime, dtype=float64)
ldata = array(ldata, dtype=float64)
pylab.plot(ltime, ldata, color=lcolor, linestyle='-', linewidth=lwidth)
# plot fill data
barytime = insert(barytime, [0], [barytime[0]])
barytime = append(barytime, [barytime[-1]])
flux = insert(flux, [0], [0.0])
flux = append(flux, [0.0])
fill(barytime, flux, fc=fcolor, linewidth=0.0, alpha=falpha)
xlim(xmin - xr * 0.01, xmax + xr * 0.01)
if ymin - yr * 0.01 <= 0.0:
ylim(1.0e-10, ymax + yr * 0.01)
else:
ylim(ymin - yr * 0.01, ymax + yr * 0.01)
xlabel(xlab, {'color': 'k'})
ylabel(ylab, {'color': 'k'})
grid()
# render plot
if status == 0 and plot:
if cmdLine:
pylab.show()
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
# end time
if (status == 0):
message = 'KEPCLIP completed at'
else:
message = '\nKEPCLIP aborted at'
kepmsg.clock(message, logfile, verbose)
def kepfield(infile,plotfile,rownum,imscale='linear',colmap='YlOrBr',lcolor='gray',verbose=0,
logfile='kepfield.log',status=0,kic=0,cmdLine=False):
# input arguments
seterr(all="ignore")
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFIELD -- '
call += 'infile='+infile+' '
call += 'plotfile='+plotfile+' '
call += 'rownum='+str(rownum)+' '
call += 'imscale='+imscale+' '
call += 'colmap='+colmap+' '
call += 'lcolor='+lcolor+' '
chatter = 'n'
if (verbose): chatter = 'y'
call += 'verbose='+chatter+' '
call += 'logfile='+logfile
kepmsg.log(logfile,call+'\n',verbose)
# start time
kepmsg.clock('KEPFIELD started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# reference color map
if colmap == 'browse':
status = cmap_plot(cmdLine)
# open TPF FITS file
if status == 0:
try:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, barytime, status = \
kepio.readTPF(infile,'TIME',logfile,verbose)
except:
message = 'ERROR -- KEPFIELD: is %s a Target Pixel File? ' % infile
status = kepmsg.err(logfile,message,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, tcorr, status = \
kepio.readTPF(infile,'TIMECORR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, cadno, status = \
kepio.readTPF(infile,'CADENCENO',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, fluxpixels, status = \
kepio.readTPF(infile,'FLUX',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, errpixels, status = \
kepio.readTPF(infile,'FLUX_ERR',logfile,verbose)
if status == 0:
kepid, channel, skygroup, module, output, quarter, season, \
ra, dec, column, row, kepmag, xdim, ydim, qual, status = \
kepio.readTPF(infile,'QUALITY',logfile,verbose)
# read mask defintion data from TPF file
if status == 0:
maskimg, pixcoord1, pixcoord2, status = kepio.readMaskDefinition(infile,logfile,verbose)
# observed or simulated data?
if status == 0:
coa = False
instr = pyfits.open(infile,mode='readonly',memmap=True)
filever, status = kepkey.get(infile,instr[0],'FILEVER',logfile,verbose)
if filever == 'COA': coa = True
# print target data
if status == 0 and verbose:
print ''
print ' KepID: %s' % kepid
print ' RA (J2000): %s' % ra
print 'Dec (J2000): %s' % dec
print ' KepMag: %s' % kepmag
print ' SkyGroup: %2s' % skygroup
print ' Season: %2s' % str(season)
print ' Channel: %2s' % channel
print ' Module: %2s' % module
print ' Output: %1s' % output
print ''
# is this a good row with finite timestamp and pixels?
if status == 0:
if not numpy.isfinite(barytime[rownum-1]) or not numpy.nansum(fluxpixels[rownum-1,:]):
message = 'ERROR -- KEPFIELD: Row ' + str(rownum) + ' is a bad quality timestamp'
status = kepmsg.err(logfile,message,verbose)
# construct input pixel image
if status == 0:
flux = fluxpixels[rownum-1,:]
# image scale and intensity limits of pixel data
if status == 0:
flux_pl, zminfl, zmaxfl = kepplot.intScale1D(flux,imscale)
n = 0
imgflux_pl = empty((ydim+2,xdim+2))
for i in range(ydim+2):
for j in range(xdim+2):
imgflux_pl[i,j] = numpy.nan
for i in range(ydim):
for j in range(xdim):
imgflux_pl[i+1,j+1] = flux_pl[n]
n += 1
# cone search around target coordinates using the MAST target search form
if status == 0:
dr = max([ydim+2,xdim+2]) * 4.0
kepid,ra,dec,kepmag = MASTRADec(float(ra),float(dec),dr)
# convert celestial coordinates to detector coordinates
if status == 0:
sx = numpy.array([])
sy = numpy.array([])
inf, status = kepio.openfits(infile,'readonly',logfile,verbose)
crpix1, crpix2, crval1, crval2, cdelt1, cdelt2, pc, status = \
kepkey.getWCSs(infile,inf['APERTURE'],logfile,verbose)
crpix1p, crpix2p, crval1p, crval2p, cdelt1p, cdelt2p, status = \
kepkey.getWCSp(infile,inf['APERTURE'],logfile,verbose)
for i in range(len(kepid)):
dra = (ra[i] - crval1) * math.sin(math.radians(dec[i])) / cdelt1
ddec = (dec[i] - crval2) / cdelt2
if coa:
sx = numpy.append(sx,-(pc[0,0] * dra + pc[0,1] * ddec) + crpix1 + crval1p - 1.0)
else:
sx = numpy.append(sx,pc[0,0] * dra + pc[0,1] * ddec + crpix1 + crval1p - 1.0)
sy = numpy.append(sy,pc[1,0] * dra + pc[1,1] * ddec + crpix2 + crval2p - 1.0)
# plot style
if status == 0:
try:
params = {'backend': 'png',
'axes.linewidth': 2.0,
'axes.labelsize': 24,
'axes.font': 'sans-serif',
'axes.fontweight' : 'bold',
'text.fontsize': 12,
'legend.fontsize': 12,
'xtick.labelsize': 18,
'ytick.labelsize': 18}
pylab.rcParams.update(params)
except:
pass
pylab.figure(figsize=[10,10])
pylab.clf()
# pixel limits of the subimage
if status == 0:
ymin = copy(float(row))
ymax = ymin + ydim
xmin = copy(float(column))
xmax = xmin + xdim
# plot limits for flux image
if status == 0:
ymin = float(ymin) - 1.5
ymax = float(ymax) + 0.5
xmin = float(xmin) - 1.5
xmax = float(xmax) + 0.5
# plot the image window
if status == 0:
ax = pylab.axes([0.1,0.11,0.88,0.88])
pylab.imshow(imgflux_pl,aspect='auto',interpolation='nearest',origin='lower',
vmin=zminfl,vmax=zmaxfl,extent=(xmin,xmax,ymin,ymax),cmap=colmap)
pylab.gca().set_autoscale_on(False)
labels = ax.get_yticklabels()
setp(labels, 'rotation', 90)
pylab.gca().xaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.gca().yaxis.set_major_formatter(pylab.ScalarFormatter(useOffset=False))
pylab.xlabel('Pixel Column Number', {'color' : 'k'})
pylab.ylabel('Pixel Row Number', {'color' : 'k'})
# plot mask borders
if status == 0:
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,1,lcolor,'-',1)
# plot aperture borders
if status == 0:
kepplot.borders(maskimg,xdim,ydim,pixcoord1,pixcoord2,2,lcolor,'-',4.0)
# list sources
if status == 0 and verbose:
print 'Column Row RA J2000 Dec J2000 Kp Kepler ID'
print '----------------------------------------------------'
for i in range(len(sx)-1,-1,-1):
if sx[i] >= xmin and sx[i] < xmax and sy[i] >= ymin and sy[i] < ymax:
if kepid[i] != 0 and kepmag[i] != 0.0:
print '%6.1f %6.1f %9.5f %8.5f %5.2f KIC %d' % \
(float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i]),float(kepmag[i]),int(kepid[i]))
elif kepid[i] != 0 and kepmag[i] == 0.0:
print '%6.1f %6.1f %9.5f %8.5f KIC %d' % \
(float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i]),int(kepid[i]))
else:
print '%6.1f %6.1f %9.5f %8.5f' % (float(sx[i]),float(sy[i]),float(ra[i]),float(dec[i]))
# plot sources
if status == 0:
for i in range(len(sx)-1,-1,-1):
if kepid[i] != 0 and kepmag[i] != 0.0:
size = max(array([80.0,80.0 + (2.5**(18.0 - max(12.0,float(kepmag[i])))) * 250.0]))
pylab.scatter(sx[i],sy[i],s=size,facecolors='g',edgecolors='k',alpha=0.4)
else:
pylab.scatter(sx[i],sy[i],s=80,facecolors='r',edgecolors='k',alpha=0.4)
# render plot
if status == 0 and len(plotfile) > 0 and plotfile.lower() != 'none':
pylab.savefig(plotfile)
if status == 0:
if cmdLine:
pylab.show(block=True)
else:
pylab.ion()
pylab.plot([])
pylab.ioff()
pylab.clf()
# stop time
kepmsg.clock('\nKEPFIELD ended at',logfile,verbose)
# pdb.set_trace()
if kic > 0:
ind = np.where(kepid == kic)
colret = sx[ind]
rowret = sy[ind]
raret = ra[ind]
decret = dec[ind]
kepmagret = kepmag[ind]
kepidret = kepid[ind]
else:
inds = np.where(kepmag != 0.0)
colret = sx[inds]
rowret = sy[inds]
raret = ra[inds]
decret = dec[inds]
kepmagret = kepmag[inds]
kepidret = kepid[inds]
return colret,rowret,raret,decret,kepmagret,kepidret
