Пример #1
0
def interpolate(time, flux, approx_duration):

    min_gap = approx_duration / gap_days

    # p.close(5)
    # p.figure(5)
    # p.subplot(2,1,1)
    # p.plot(time, flux, 'k.')

    """ Calculate noise properties """
    flux_filt = filter.filt1d(flux, 10, 5)
    med_noise, sig_noise = filter.medsig(flux - flux_filt)

    """
    Find gaps greater than 1 (1.1) data points and linear interp with
    noise
    """
    diff1 = time[1:] - time[:-1]
    diff1 = scipy.append(diff1, gap_days)
    gap_find = diff1 > min_gap * gap_days * 0.9  # 1.1*gap_days
    gap_times = time[gap_find]
    time_index = scipy.r_[0 : len(time) : 1]

    fill_arr_t = scipy.zeros(1)
    fill_arr_f = scipy.zeros(1)
    # fill_arr_nan = scipy.zeros(1)

    print("Filling gaps...")
    for m in scipy.arange(len(gap_times)):
        time_start = time[time_index[gap_find][m]]
        flux_start = flux[time_index[gap_find][m]]
        time_end = time[time_index[gap_find][m] + 1]
        flux_end = flux[time_index[gap_find][m] + 1]
        span = time_end - time_start
        if span < 2.0 * gap_days:
            fill = scipy.array([time_start, time_start + gap_days, time_end])
        else:
            fill = scipy.r_[time_start:time_end:gap_days]
        fill = fill[1:-1]
        if time_end - fill.max() > 1.1 * gap_days:  # 1.1*gap_days*min_gap:
            fill = scipy.append(fill, fill.max() + gap_days)

        f = scipy.interpolate.interp1d([time_start, time_end], [flux_start, flux_end])
        gap_new = f(fill)

        if sig_noise > 0:
            gap_new += normal(0, sig_noise, len(fill))

        fill_arr_t = scipy.append(fill_arr_t, fill)
        fill_arr_f = scipy.append(fill_arr_f, gap_new)
        # fill_arr_nan = scipy.append(fill_arr_nan, scipy.ones(len(fill))*scipy.nan)

    # combine time and flux arrays with their filled sections
    fill_arr_t = fill_arr_t[1:]
    fill_arr_f = fill_arr_f[1:]
    # fill_arr_nan = fill_arr_nan[1:]
    fill_arr_t = scipy.append(fill_arr_t, time)
    fill_arr_f = scipy.append(fill_arr_f, flux)
    # fill_arr_nan = scipy.append(fill_arr_nan, flux_base)

    if len(fill_arr_t) == 0:
        print("*************** empty time array ***************")
        return False, atpy.Table(), 0, 0

    # put in table and sort
    tf = atpy.Table()
    tf.add_column("time", fill_arr_t)
    tf.add_column("flux", fill_arr_f)
    # tf.add_column('flux_pdc', fill_arr_nan)
    tf.sort("time")

    # for i in range(0, len(gap_times)):
    #     p.axvline(gap_times[i], color = 'y')
    # p.subplot(2,1,2)
    # p.plot(fill_arr_t, fill_arr_f, 'k.')

    return tf.time, tf.flux
Пример #2
0
def load_lc(quarter_load, kid_x = None, index = None, tr_out = False, tr_type = False):
    # read in tableset of LCs for all Qs, normalise and quarter join
    dir_lc = '/Users/angusr/angusr/data2/Q%s_public' %quarter_load + '/Light_Curves'
    print 'Reading in LCs...'
    tset, found = kt.GetLc(id = kid_x, dir = dir_lc, tr_out = tr_out, \
                           filename = index.filename[(index.keplerid == kid_x) * (index.quarter <= qmax) * (index.quarter >= qmin)])
    if found == 0:
        print '****not found****'
        return False, atpy.Table(), 0, 0
    
    # find number of Quarters and max(time) per quarter
    if tr_out == False: lc = tset[0]
    else: lc = tset[1]
    quarters = scipy.array(list(set(lc.Q)))
    tablen = len(quarters)
    qt_max = scipy.zeros(tablen)
    for z in scipy.arange(len(quarters)):
        qt_max[z] = max(lc.TIME[lc.Q == quarters[z]])
    qt_max = scipy.append(0,qt_max)
    finite = scipy.where((scipy.isfinite(lc.TIME) == True) * (scipy.isfinite(lc.SAP_FLUX) == True) * \
                         (scipy.isfinite(lc.PDCSAP_FLUX) == True))

    # keep unchanged set for table
    flux_base = lc.SAP_FLUX[finite]
    q_arr_base = lc.Q[finite]
    for qt in quarters:
        flux_base[q_arr_base == qt] = (flux_base[q_arr_base == qt] / scipy.median(flux_base[q_arr_base == qt])) - 1.0

    time = lc.TIME
    flux_raw = lc.SAP_FLUX
    flux = lc.PDCSAP_FLUX
    
    if tr_out == True:
        print 'Removing eclipses...'    
        # remove in-eclipse regions
        phase, inTr = kt.TransitPhase(tset)
        npl, nobs = inTr.shape
        for ipl in scipy.arange(npl):
            trlist = inTr[ipl,:].astype(bool)
            time[trlist] = scipy.nan
            flux_raw[trlist] = scipy.nan
            flux[trlist] = scipy.nan

    if tr_type == 'EB':
        print 'Removing EB transits...'
        phase, inTr = EBTransitPhase(tset, kid_x)
        npl, nobs = inTr.shape
        for ipl in scipy.arange(npl):
            trlist = inTr[ipl,:].astype(bool)
            time[trlist] = scipy.nan
            flux_raw[trlist] = scipy.nan
            flux[trlist] = scipy.nan
        pylab.plot(time, flux, 'r.')

    finite_tr = scipy.where((scipy.isfinite(time) == True) * \
                            (scipy.isfinite(flux) == True) * (scipy.isfinite(flux_raw) == True) * (scipy.isfinite(lc.Q) == True))
    time = time[finite_tr]
    flux = flux[finite_tr]
    flux_raw = flux_raw[finite_tr]
    quarter_arr = lc.Q[finite_tr]

    # median normalise each quarter
    for qt in quarters:
        flux[quarter_arr == qt] = (flux[quarter_arr == qt] / scipy.median(flux[quarter_arr == qt])) - 1.0
        flux_raw[quarter_arr == qt] = (flux_raw[quarter_arr == qt] / scipy.median(flux_raw[quarter_arr == qt])) - 1.0
    
    # fit 1d polynomial and remove >5sig outliers 
    coeff = scipy.polyfit(time,flux, 1) 
    p = scipy.poly1d(coeff) 
    med, sig = filter.medsig(flux - p(time))
    sigclip = abs(flux - p(time)) <= 5*sig
    time = time[sigclip]
    flux = flux[sigclip]
    flux_base = flux_base[sigclip]

    # to get noise properties
    flux_filt = filter.filt1d(flux, 10, 5)
    med_noise, sig_noise = filter.medsig(flux-flux_filt)

    # find gaps greater than 1 (1.1) data points and linear interp with noise
    diff1 = time[1:] - time[:-1]
    diff1 = scipy.append(diff1, gap_days)
    gap_find = diff1 > 1.1*gap_days
    gap_times = time[gap_find]
    time_index = scipy.r_[0:len(time):1]

    fill_arr_t = scipy.zeros(1)
    fill_arr_f = scipy.zeros(1)
    fill_arr_nan = scipy.zeros(1)

    print 'Filling gaps...'
    for m in scipy.arange(len(gap_times)):
        time_start = time[time_index[gap_find][m]]
        flux_start = flux[time_index[gap_find][m]]
        time_end = time[time_index[gap_find][m] + 1]
        flux_end = flux[time_index[gap_find][m] + 1]
        span =  time_end - time_start
        if span < 2.0*gap_days:
            fill = scipy.array([time_start, time_start+gap_days, time_end])
        else: fill = scipy.r_[time_start: time_end: gap_days]
        fill = fill[1:-1]
        if time_end - fill.max() > 1.1*gap_days: fill = scipy.append(fill, fill.max()+gap_days)

        f = scipy.interpolate.interp1d([time_start, time_end], [flux_start, flux_end])
        gap_new = f(fill)
        if sig_noise > 0: gap_new += normal(0,sig_noise,len(fill))

        fill_arr_t = scipy.append(fill_arr_t, fill)
        fill_arr_f = scipy.append(fill_arr_f, gap_new)
        fill_arr_nan = scipy.append(fill_arr_nan, scipy.ones(len(fill))*scipy.nan)

    # combine time and flux arrays with their filled sections
    fill_arr_t = fill_arr_t[1:]
    fill_arr_f = fill_arr_f[1:]
    fill_arr_nan = fill_arr_nan[1:]
    fill_arr_t = scipy.append(fill_arr_t, time)
    fill_arr_f = scipy.append(fill_arr_f, flux)
    fill_arr_nan = scipy.append(fill_arr_nan, flux_base)

    if len(fill_arr_t) == 0:
        print '*************** empty time array ***************'
        return False, atpy.Table(), 0, 0
    
    # put in table and sort
    tf = atpy.Table()
    tf.add_column('time', fill_arr_t)
    tf.add_column('flux', fill_arr_f)
    tf.add_column('flux_pdc', fill_arr_nan)
    tf.sort('time')

    return True, tf, qt_max, tablen
Пример #3
0
def interpolate(time, flux, approx_duration):

    min_gap = approx_duration/gap_days

    # p.close(5)
    # p.figure(5)
    # p.subplot(2,1,1)
    # p.plot(time, flux, 'k.')
    
    ''' Calculate noise properties '''
    flux_filt = filter.filt1d(flux, 10, 5)
    med_noise, sig_noise = filter.medsig(flux-flux_filt)


    ''' find gaps greater than 1 (1.1) data points and linear interp with noise'''
    diff1 = time[1:] - time[:-1]
    diff1 = scipy.append(diff1, gap_days)
    gap_find = diff1 > min_gap*gap_days*0.9 #1.1*gap_days
    gap_times = time[gap_find]
    time_index = scipy.r_[0:len(time):1]

    fill_arr_t = scipy.zeros(1)
    fill_arr_f = scipy.zeros(1)
    #fill_arr_nan = scipy.zeros(1)

    print 'Filling gaps...'
    for m in scipy.arange(len(gap_times)):
        time_start = time[time_index[gap_find][m]]
        flux_start = flux[time_index[gap_find][m]]
        time_end = time[time_index[gap_find][m] + 1]
        flux_end = flux[time_index[gap_find][m] + 1]
        span =  time_end - time_start
        if span < 2.0*gap_days:
            fill = scipy.array([time_start, time_start+gap_days, time_end])
        else: fill = scipy.r_[time_start: time_end: gap_days]
        fill = fill[1:-1]
        if time_end - fill.max() > 1.1*gap_days:  #1.1*gap_days*min_gap: 
            fill = scipy.append(fill, fill.max()+gap_days)

        f = scipy.interpolate.interp1d([time_start, time_end], [flux_start, flux_end])
        gap_new = f(fill)

       
        if sig_noise > 0: gap_new += normal(0,sig_noise,len(fill))

        fill_arr_t = scipy.append(fill_arr_t, fill)
        fill_arr_f = scipy.append(fill_arr_f, gap_new)
        #fill_arr_nan = scipy.append(fill_arr_nan, scipy.ones(len(fill))*scipy.nan)

    # combine time and flux arrays with their filled sections
    fill_arr_t = fill_arr_t[1:]
    fill_arr_f = fill_arr_f[1:]
    #fill_arr_nan = fill_arr_nan[1:]
    fill_arr_t = scipy.append(fill_arr_t, time)
    fill_arr_f = scipy.append(fill_arr_f, flux)
    #fill_arr_nan = scipy.append(fill_arr_nan, flux_base)

    if len(fill_arr_t) == 0:
        print '*************** empty time array ***************'
        return False, atpy.Table(), 0, 0
    
    # put in table and sort
    tf = atpy.Table()
    tf.add_column('time', fill_arr_t)
    tf.add_column('flux', fill_arr_f)
    # tf.add_column('flux_pdc', fill_arr_nan)
    tf.sort('time')

    # for i in range(0, len(gap_times)):
    #     p.axvline(gap_times[i], color = 'y')
    # p.subplot(2,1,2)
    # p.plot(fill_arr_t, fill_arr_f, 'k.')
        

    return tf.time, tf.flux