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 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 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 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 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 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 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 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 kepsmooth(infile,outfile,datacol,function,fscale,plot,plotlab,
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 = 'KEPSMOOTH -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'function='+str(function)+' '
call += 'fscale='+str(fscale)+' '
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('KEPSMOOTH 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 -- KEPSMOOTH: ' + 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 = kepfunc.smooth(indata,fscale/(cadence/86400),function)
## 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, re.sub('_','-',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 -- KEPSMOOTH: install latex for scientific plotting'
status = 1
if status == 0 and plot:
pylab.figure(1,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.06,0.1,0.93,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)
pylab.plot(ptime[1:-1],pout[1:-1],color='#ff9900',linestyle='-',linewidth=lwidth)
fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
pylab.plot(ptime,pout2,color=lcolor,linestyle='-',linewidth=lwidth*4.0)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.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 = 'KEPSMOOTH completed at'
else:
message = '\nKEPSMOOTH aborted at'
kepmsg.clock(message,logfile,verbose)
def keprange(infile,rinfile,outfile,column,clobber,verbose,logfile,status,cLine=False):
# startup parameters
status = 0
global instr, cadence, barytime0, nrm, barytime, flux
global xmin, xmax, ymin, ymax, xr, yr, xlab, ylab
global clobb, outf, verb, logf, rinf, col, bjdref, cade, cmdLine
# log the call
if rinfile.lower() == 'none':
rinfile = ''
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPRANGE -- '
call += 'infile='+infile+' '
call += 'rinfile='+rinfile+' '
call += 'outfile='+outfile+' '
call += 'column='+column+' '
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)
clobb = clobber
outf = outfile
verb = verbose
logf = logfile
rinf = rinfile
cmdLine = cLine
# start time
kepmsg.clock('KEPRANGE 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 -- KEPRANGE: ' + 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
cade = cadenom
# 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
# filter out NaNs
work1 = []; work2 = []
col = column
if status == 0:
barytime, status = kepio.readtimecol(infile,table,logfile,verbose)
if status == 0:
try:
flux = instr[1].data.field(col)
except:
message = 'ERROR -- KEPRANGE: no column named ' + col + ' in table ' + infile + '[1]'
status = kepmsg.err(file,message,verbose)
if status == 0:
for i in range(len(barytime)):
if (numpy.isfinite(barytime[i]) and numpy.isfinite(flux[i]) and flux[i] != 0.0):
work1.append(barytime[i] + bjdref)
work2.append(flux[i])
barytime = array(work1,dtype='float64')
flux = array(work2,dtype='float32') / cadenom
# clean up x-axis unit
if status == 0:
barytime0 = float(int(tstart / 100) * 100.0)
barytime = barytime - barytime0
xlab = 'BJD $-$ %d' % barytime0
# clean up y-axis units
if status == 0:
nrm = len(str(int(flux.max())))-1
flux = flux / 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
flux[0] = 0.0
flux[-1] = 0.0
# plot new light curve
if status == 0:
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 -- KEPRANGE: install latex for scientific plotting'
status = 1
if status == 0:
pylab.figure(figsize=[xsize,ysize])
pylab.clf()
plotlc(cmdLine)
# close input file
if status == 0:
status = kepio.closefits(instr,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 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 kepflatten(infile,outfile,datacol,errcol,nsig,stepsize,winsize,npoly,niter,ranges,
plot,clobber,verbose,logfile,status,cmdLine=False):
# startup parameters
status = 0
labelsize = 32
ticksize = 18
xsize = 16
ysize = 10
lcolor = '#0000ff'
lwidth = 1.0
fcolor = '#ffff00'
falpha = 0.2
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPFLATTEN -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'errcol='+str(errcol)+' '
call += 'nsig='+str(nsig)+' '
call += 'stepsize='+str(stepsize)+' '
call += 'winsize='+str(winsize)+' '
call += 'npoly='+str(npoly)+' '
call += 'niter='+str(niter)+' '
call += 'ranges='+str(ranges)+' '
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('KEPFLATTEN started at',logfile,verbose)
# test log file
logfile = kepmsg.test(logfile)
# test winsize > stepsize
if winsize < stepsize:
message = 'ERROR -- KEPFLATTEN: winsize must be greater than stepsize'
status = kepmsg.err(logfile,message,verbose)
# clobber output file
if clobber: status = kepio.clobber(outfile,logfile,verbose)
if kepio.fileexists(outfile):
message = 'ERROR -- KEPFLATTEN: ' + 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:
datac = table.field(datacol)
except:
message = 'ERROR -- KEPFLATTEN: cannot find or read data column ' + datacol
status = kepmsg.err(logfile,message,verbose)
if status == 0:
try:
err = table.field(errcol)
except:
message = 'WARNING -- KEPFLATTEN: cannot find or read error column ' + errcol
errcol = 'None'
if status == 0:
if errcol.lower() == 'none' or errcol == 'PSF_FLUX_ERR':
err = datac * cadence
err = numpy.sqrt(numpy.abs(err)) / cadence
work1 = numpy.array([table.field('time'), datac, err])
else:
work1 = numpy.array([table.field('time'), datac, err])
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]
if len(intime) == 0:
message = 'ERROR -- KEPFLATTEN: one of the input arrays is all NaN'
status = kepmsg.err(logfile,message,verbose)
# 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+winsize,intime[-1]],dtype='float64').min())
work += stepsize
# find cadence limits of each time step
if status == 0:
cstep1 = []; cstep2 = []
for n in range(len(tstep1)):
for i in range(len(intime)-1):
if intime[i] <= tstep1[n] and intime[i+1] > tstep1[n]:
for j in range(i,len(intime)-1):
if intime[j] < tstep2[n] and intime[j+1] >= tstep2[n]:
cstep1.append(i)
cstep2.append(j+1)
# 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 = copy(indata)
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.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=[])
pylab.plot(ptime[1:-1],pout[1:-1],color=lcolor,linestyle='-',linewidth=lwidth)
pylab.fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
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:
fitarray = numpy.zeros((len(indata),len(cstep1)),dtype='float32')
sigarray = numpy.zeros((len(indata),len(cstep1)),dtype='float32')
fitarray[:,:] = numpy.nan
sigarray[:,:] = numpy.nan
masterfit = indata * 0.0
mastersigma = numpy.zeros(len(masterfit))
functype = 'poly' + str(npoly)
for i in range(len(cstep1)):
timeSeries = intime[cstep1[i]:cstep2[i]+1]-intime[cstep1[i]]
dataSeries = indata[cstep1[i]:cstep2[i]+1]
fitTimeSeries = numpy.array([],dtype='float32')
fitDataSeries = numpy.array([],dtype='float32')
pinit = [dataSeries.mean()]
if npoly > 0:
for j in range(npoly):
pinit.append(0.0)
pinit = array(pinit,dtype='float32')
try:
if len(fitarray[cstep1[i]:cstep2[i]+1,i]) > len(pinit):
coeffs, errors, covar, iiter, sigma, chi2, dof, fit, plotx, ploty, status = \
kepfit.lsqclip(functype,pinit,timeSeries,dataSeries,None,nsig,nsig,niter,
logfile,verbose)
fitarray[cstep1[i]:cstep2[i]+1,i] = 0.0
sigarray[cstep1[i]:cstep2[i]+1,i] = sigma
for j in range(len(coeffs)):
fitarray[cstep1[i]:cstep2[i]+1,i] += coeffs[j] * timeSeries**j
except:
for j in range(cstep1[i],cstep2[i]+1):
fitarray[cstep1[i]:cstep2[i]+1,i] = 0.0
sigarray[cstep1[i]:cstep2[i]+1,i] = 1.0e-10
message = 'WARNING -- KEPFLATTEN: could not fit range '
message += str(intime[cstep1[i]]) + '-' + str(intime[cstep2[i]])
kepmsg.warn(None,message)
# find mean fit for each timestamp
if status == 0:
for i in range(len(indata)):
masterfit[i] = scipy.stats.nanmean(fitarray[i,:])
mastersigma[i] = scipy.stats.nanmean(sigarray[i,:])
masterfit[-1] = masterfit[-4] #fudge
masterfit[-2] = masterfit[-4] #fudge
masterfit[-3] = masterfit[-4] #fudge
pylab.plot(intime-intime0, masterfit / 10**nrm,'g',lw='3')
# 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])
rejtime = array(rejtime,dtype='float64')
rejdata = array(rejdata,dtype='float32')
if plot:
pylab.plot(rejtime-intime0,rejdata / 10**nrm,'ro')
# new data for output file
if status == 0:
outdata = indata / masterfit
outerr = inerr / masterfit
# 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)
# plot residual data
if status == 0 and plot:
ax = pylab.axes([0.06,0.09,0.93,0.43])
# force tick labels to be absolute rather than relative
if status == 0 and plot:
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(outdata)
ylab = 'Normalized Flux'
# data limits
if status == 0 and plot:
ymin = pout.min()
ymax = pout.max()
yr = ymax - ymin
pout = insert(pout,[0],[0.0])
pout = append(pout,0.0)
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:
pylab.savefig(re.sub('.fits','.png',outfile))
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')
work2 = array([],dtype='float32')
instr, status = kepio.openfits(infile,'readonly',logfile,verbose)
table, status = kepio.readfitstab(infile,instr[1],logfile,verbose)
tn = table.field('time')
dn = table.field(datacol)
for i in range(len(table.field(0))):
if numpy.isfinite(tn[i]) and numpy.isfinite(dn[i]) and numpy.isfinite(err[i]):
try:
work1 = numpy.append(work1,outdata[n])
work2 = numpy.append(work2,outerr[n])
n += 1
except:
pass
else:
work1 = numpy.append(work1,numpy.nan)
work2 = numpy.append(work2,numpy.nan)
# history keyword in output file
if status == 0:
status = kepkey.history(call,instr[0],outfile,logfile,verbose)
# write output file
try:
col1 = pyfits.Column(name='DETSAP_FLUX',format='E13.7',array=work1)
col2 = pyfits.Column(name='DETSAP_FLUX_ERR',format='E13.7',array=work2)
cols = instr[1].data.columns + col1 + col2
instr[1] = pyfits.new_table(cols,header=instr[1].header)
instr.writeto(outfile)
except ValueError:
try:
instr[1].data.field('DETSAP_FLUX')[:] = work1
instr[1].data.field('DETSAP_FLUX_ERR')[:] = work2
instr.writeto(outfile)
except:
message = 'ERROR -- KEPFLATTEN: cannot add DETSAP_FLUX data to FITS file'
status = kepmsg.err(logfile,message,verbose)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
## end time
if (status == 0):
message = 'KEPFLATTEN completed at'
else:
message = '\nKEPFLATTEN aborted at'
kepmsg.clock(message,logfile,verbose)
def kepsmooth(
infile, outfile, datacol, function, fscale, plot, plotlab, 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 = "KEPSMOOTH -- "
call += "infile=" + infile + " "
call += "outfile=" + outfile + " "
call += "datacol=" + str(datacol) + " "
call += "function=" + str(function) + " "
call += "fscale=" + str(fscale) + " "
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("KEPSMOOTH 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 -- KEPSMOOTH: " + 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 = kepfunc.smooth(indata, fscale / (cadence / 86400), function)
## 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, re.sub("_", "-", 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 -- KEPSMOOTH: install latex for scientific plotting"
status = 1
if status == 0 and plot:
pylab.figure(1, 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.06, 0.1, 0.93, 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)
pylab.plot(ptime[1:-1], pout[1:-1], color="#ff9900", linestyle="-", linewidth=lwidth)
fill(ptime, pout, color=fcolor, linewidth=0.0, alpha=falpha)
pylab.plot(ptime, pout2, color=lcolor, linestyle="-", linewidth=lwidth * 4.0)
pylab.xlabel(xlab, {"color": "k"})
pylab.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 = "KEPSMOOTH completed at"
else:
message = "\nKEPSMOOTH aborted at"
kepmsg.clock(message, logfile, verbose)
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 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 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 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 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 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 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 kepsmooth(infile,outfile,datacol,function,fscale,plot,plotlab,
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 = 'KEPSMOOTH -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'datacol='+str(datacol)+' '
call += 'function='+str(function)+' '
call += 'fscale='+str(fscale)+' '
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('KEPSMOOTH 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 -- KEPSMOOTH: ' + 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 = kepfunc.smooth(indata,fscale/(cadence/86400),function)
## 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, re.sub('_','-',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 -- KEPSMOOTH: install latex for scientific plotting')
status = 1
if status == 0 and plot:
pylab.figure(1,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.06,0.1,0.93,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)
pylab.plot(ptime[1:-1],pout[1:-1],color='#ff9900',linestyle='-',linewidth=lwidth)
fill(ptime,pout,color=fcolor,linewidth=0.0,alpha=falpha)
pylab.plot(ptime,pout2,color=lcolor,linestyle='-',linewidth=lwidth*4.0)
pylab.xlabel(xlab, {'color' : 'k'})
pylab.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 = 'KEPSMOOTH completed at'
else:
message = '\nKEPSMOOTH 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 keptransitmodel(inputfile,
datacol,
errorcol,
period_d,
rprs,
T0,
Ecc,
ars,
inc,
omega,
LDparams,
sec,
norm=False,
verbose=0,
logfile='logfile.dat',
status=0,
cmdLine=False):
#write to a logfile
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile, hashline, verbose)
call = 'KEPTRANSIT -- '
call += 'inputfile=' + inputfile + ' '
call += 'datacol=' + str(datacol) + ' '
call += 'errorcol=' + str(errorcol) + ' '
call += 'period_d=' + str(period_d) + ' '
call += 'rprs=' + str(rprs) + ' '
call += 'T0=' + str(T0) + ' '
call += 'Ecc=' + str(Ecc) + ' '
call += 'ars=' + str(ars) + ' '
call += 'inc=' + str(inc) + ' '
call += 'omega=' + str(omega) + ' '
call += 'LDparams=' + str(LDparams) + ' '
call += 'sec=' + str(sec) + ' '
#to finish
# 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)
# 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 np.isfinite(table.field('barytime')[i]) and \
np.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 np.isfinite(table.field('time')[i]) and \
np.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(inputfile, instr[1].data,
'time', logfile, verbose)
indata, status = kepio.readfitscol(inputfile, instr[1].data, datacol,
logfile, verbose)
inerr, status = kepio.readfitscol(inputfile, instr[1].data, errorcol,
logfile, verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
inerr = inerr / cadenom
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()]
inc = inc * np.pi / 180.
if status == 0:
modelfit = tmod.lightcurve(intime, period_d, rprs, T0, Ecc, ars, inc,
omega, LDparams, sec)
if status == 0:
phi, fluxfold, modelfold, errorfold, phiNotFold = fold_data(
intime, modelfit, indata, inerr, period_d, T0)
if status == 0:
do_plot(intime, modelfit, indata, inerr, period_d, T0, cmdLine)
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 kepbin(infile,outfile,fluxcol,do_nbin,nbins,do_binwidth,binwidth,
do_ownbins,binfile,method,interpm,plot,clobber,verbose,logfile,status):
"""
Setup the kepbin environment
"""
# log the call
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPBIN -- '
call += 'infile='+infile+' '
call += 'outfile='+outfile+' '
call += 'fluxcol='+fluxcol+ ' '
donbin = 'n'
if (do_nbin): donbin = 'y'
call += 'donbin='+donbin+ ' '
dobinwidth = 'n'
if (do_binwidth): dobinwidth = 'y'
call += 'dbinwidth='+dobinwidth+ ' '
doownbin = 'n'
if (do_ownbins): doownbin = 'y'
call += 'doownbin='+doownbin+ ' '
call += 'method='+method+' '
call += 'interpm='+interpm+' '
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('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)
# 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)
# input data
if status == 0:
table = instr[1].data
# read time and flux columns
date = table.field('barytime')
flux = table.field(fluxcol)
#cut out infinites and zero flux columns
date,flux = cutBadData(date,flux)
if do_nbin:
bdate,bflux = bin_funct(date,flux,nbins=nbins
,method=method,interpm=interpm)
elif do_binwidth:
bdate,bflux = bin_funct(date,flux,binwidth=binwidth
,method=method,interpm=interpm)
elif do_ownbins:
filepointer = open(binfile,'r')
ownbins = []
for line in filepointer:
splitted = line.split()
ownbins.append(float(splitted[0]))
ownbins = n.array(ownbins)
bdate,bflux = bin_funct(date,flux,ownbins=ownbins
,method=method,interpm=interpm)
if plot:
do_plot(bdate,bflux)
if status == 0:
col1 = pyfits.Column(name='bdate',format='E',unit='day',array=bdate)
col2 = pyfits.Column(name='bflux',format='E',unit='e-/cadence',array=bflux)
cols = pyfits.ColDefs([col1,col2])
instr.append(pyfits.new_table(cols))
instr[-1].header.update('EXTNAME','BINNED DATA','extension name')
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr,logfile,verbose)
# end time
if (status == 0):
message = 'KEPBIN completed at'
else:
message = '\nKEPBIN 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 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 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 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 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 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 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 kepbin(
infile,
outfile,
fluxcol,
do_nbin,
nbins,
do_binwidth,
binwidth,
do_ownbins,
binfile,
method,
interpm,
plot,
clobber,
verbose,
logfile,
status,
):
"""
Setup the kepbin environment
"""
# log the call
hashline = "----------------------------------------------------------------------------"
kepmsg.log(logfile, hashline, verbose)
call = "KEPBIN -- "
call += "infile=" + infile + " "
call += "outfile=" + outfile + " "
call += "fluxcol=" + fluxcol + " "
donbin = "n"
if do_nbin:
donbin = "y"
call += "donbin=" + donbin + " "
dobinwidth = "n"
if do_binwidth:
dobinwidth = "y"
call += "dbinwidth=" + dobinwidth + " "
doownbin = "n"
if do_ownbins:
doownbin = "y"
call += "doownbin=" + doownbin + " "
call += "method=" + method + " "
call += "interpm=" + interpm + " "
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("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)
# 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)
# input data
if status == 0:
table = instr[1].data
# read time and flux columns
date = table.field("barytime")
flux = table.field(fluxcol)
# cut out infinites and zero flux columns
date, flux = cutBadData(date, flux)
if do_nbin:
bdate, bflux = bin_funct(date, flux, nbins=nbins, method=method, interpm=interpm)
elif do_binwidth:
bdate, bflux = bin_funct(date, flux, binwidth=binwidth, method=method, interpm=interpm)
elif do_ownbins:
filepointer = open(binfile, "r")
ownbins = []
for line in filepointer:
splitted = line.split()
ownbins.append(float(splitted[0]))
ownbins = n.array(ownbins)
bdate, bflux = bin_funct(date, flux, ownbins=ownbins, method=method, interpm=interpm)
if plot:
do_plot(bdate, bflux)
if status == 0:
col1 = pyfits.Column(name="bdate", format="E", unit="day", array=bdate)
col2 = pyfits.Column(name="bflux", format="E", unit="e-/cadence", array=bflux)
cols = pyfits.ColDefs([col1, col2])
instr.append(pyfits.new_table(cols))
instr[-1].header.update("EXTNAME", "BINNED DATA", "extension name")
instr.writeto(outfile)
# close input file
if status == 0:
status = kepio.closefits(instr, logfile, verbose)
# end time
if status == 0:
message = "KEPBIN completed at"
else:
message = "\nKEPBIN aborted at"
kepmsg.clock(message, logfile, verbose)
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 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 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 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 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 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 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 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 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 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 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 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 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 keptransitmodel(inputfile,datacol,errorcol,period_d,rprs,T0,
Ecc,ars,inc,omega,LDparams,sec,norm=False,
verbose=0,logfile='logfile.dat',status=0,cmdLine=False):
#write to a logfile
hashline = '----------------------------------------------------------------------------'
kepmsg.log(logfile,hashline,verbose)
call = 'KEPTRANSIT -- '
call += 'inputfile='+inputfile+' '
call += 'datacol='+str(datacol)+' '
call += 'errorcol='+str(errorcol)+' '
call += 'period_d='+str(period_d)+' '
call += 'rprs='+str(rprs)+' '
call += 'T0='+str(T0)+' '
call += 'Ecc='+str(Ecc)+' '
call += 'ars='+str(ars)+' '
call += 'inc='+str(inc)+' '
call += 'omega='+str(omega)+' '
call += 'LDparams='+str(LDparams)+' '
call += 'sec='+str(sec)+' '
#to finish
# 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)
# 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 np.isfinite(table.field('barytime')[i]) and \
np.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 np.isfinite(table.field('time')[i]) and \
np.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(inputfile,instr[1].data,'time',logfile,verbose)
indata, status = kepio.readfitscol(inputfile,instr[1].data,datacol,logfile,verbose)
inerr, status = kepio.readfitscol(inputfile,instr[1].data,errorcol,logfile,verbose)
if status == 0:
intime = intime + bjdref
indata = indata / cadenom
inerr = inerr / cadenom
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()]
inc = inc * np.pi / 180.
if status == 0:
modelfit = tmod.lightcurve(intime,period_d,rprs,T0,Ecc,
ars,inc,omega,LDparams,sec)
if status == 0:
phi, fluxfold, modelfold, errorfold, phiNotFold = fold_data(intime,
modelfit,indata,inerr,period_d,T0)
if status == 0:
do_plot(intime,modelfit,indata,inerr,period_d,T0,cmdLine)
