コード例 #1
0
ファイル: fergalmain.py プロジェクト: CheerfulUser/SynDiff
def newDetrendDataTask(clip):
    flux = clip['cotrend.flux_frac']
    flags = clip['cotrend.flags']

    nPoints = clip['config.nPointsForMedianSmooth']

    #When you detrend, you must do something about the gaps and bad values.
    #This is the simplest possible thing. Replace all bad/missing data with
    #zeros. This is a placehold. Bad data inside a transit is replaced with
    #a zero, which is not what you want.
    flux[flags] = 0

    #Do a simple detrend.
    detrend = kplrfits.medianSubtract1d(flux, nPoints)
    clip['detrend'] = dict()
    clip['detrend.flux_frac'] = detrend
    clip['detrend.flags'] = flags
    clip['detrend.source'] = "Simple Median detrend"

    rollTweakAmp = noise.computeRollTweakAmplitude(detrend[~flags])
    clip['detrend.rollTweakAmp'] = rollTweakAmp

    cdpp6 = noise.computeSgCdpp_ppm(detrend[~flags])
    clip['detrend.cdpp6_ppm'] = cdpp6

    perPointScatter = noise.estimateScatterWithMarshallMethod(detrend[~flags])
    clip['detrend.perPointScatter_ppm'] = 1e6 * perPointScatter

    assert (detrend is not None)
    return clip
コード例 #2
0
ファイル: milesmain.py プロジェクト: barentsen/dave
def newDetrendDataTask(clip):
    flux = clip['cotrend.flux_frac']
    flags = clip['cotrend.flags']

    nPoints = clip['config.nPointsForMedianSmooth']

    #When you detrend, you must do something about the gaps and bad values.
    #This is the simplest possible thing. Replace all bad/missing data with
    #zeros. This is a placehold. Bad data inside a transit is replaced with
    #a zero, which is not what you want.
    flux[flags] = 0

    #Do a simple detrend.
    detrend = kplrfits.medianSubtract1d(flux, nPoints)
    clip['detrend'] = dict()
    clip['detrend.flux_frac'] = detrend
    clip['detrend.flags'] = flags
    clip['detrend.source'] = "Simple Median detrend"

    rollTweakAmp = noise.computeRollTweakAmplitude(detrend[~flags])
    clip['detrend.rollTweakAmp'] = rollTweakAmp

    cdpp6 = noise.computeSgCdpp_ppm(detrend[~flags])
    clip['detrend.cdpp6_ppm'] = cdpp6

    perPointScatter = noise.estimateScatterWithMarshallMethod(detrend[~flags])
    clip['detrend.perPointScatter_ppm'] = 1e6*perPointScatter


    assert(detrend is not None)
    return clip
コード例 #3
0
ファイル: comparebls.py プロジェクト: CheerfulUser/SynDiff
def loadClipAndCompFits(data, row):
    epic = data[row, 0]

    clip = dpc.loadClipboard("clips/c%09i-05.clip" % (epic))
    clip = pl.serveTask(clip)

    mp.figure(2)
    mp.clf()
    dpp.plotData(clip)
    mp.title('Epic %.0f' % (epic))

    mp.figure(3)
    mp.clf()
    compareFits(clip)
    mp.title('Epic %.0f' % (epic))

    mp.figure(1)

    print "**************"
    print row, epic
    print clip.bls
    flux = clip.detrend.flux_frac
    flags = clip.detrend.flags
    noi = noise.computeSgCdpp_ppm(flux[~flags]) * 1e-6
    print "BLS SNR= %.2f" % (clip.bls.depth / noi)
コード例 #4
0
ファイル: comparebls.py プロジェクト: barentsen/dave
def loadClipAndCompFits(data, row):
    epic = data[row, 0]

    clip = dpc.loadClipboard("clips/c%09i-05.clip" %(epic))
    clip = pl.serveTask(clip)


    mp.figure(2)
    mp.clf()
    dpp.plotData(clip)
    mp.title('Epic %.0f' %(epic))

    mp.figure(3)
    mp.clf()
    compareFits(clip)
    mp.title('Epic %.0f' %(epic))

    mp.figure(1)

    print "**************"
    print row, epic
    print clip.bls
    flux = clip.detrend.flux_frac
    flags = clip.detrend.flags
    noi = noise.computeSgCdpp_ppm(flux[~flags]) * 1e-6
    print "BLS SNR= %.2f" %(clip.bls.depth/noi)
コード例 #5
0
def estimateSnr(time, flux, flags, period_days, epoch_bkjd, \
    duration_hrs, depth_frac, nDurForClip=2):
    """Estimate the SNR of a transit.

    SNR is defined as (transit depth) / (rms scatter). Transit depth
    is an input parameter, snr is calculated with the Marshall method

    Inputs:
    -------------
    time, flux, flags
        (np 1d arrays) arrays of time flux and flag values. All flag
        values > 0 are treated as though they indicate bad data.

    period_days, epoch_bkjd, duration_hrs, depth_frac
        (floats) Parameters of transit

    Optional Inputs:
    ----------------
    nDurForClip
        Points within nDurForClip*duration_hrs around each transit are
        excluded from the estimate of noise.

    """

    dur_days = duration_hrs / 24.
    idx = kplrfits.markTransitCadences(time, period_days, epoch_bkjd, \
        dur_days, nDurForClip, flags=flags)

    if np.all(idx):
        msg = "All cadences seem to be in or near transit: "
        msg += "Period %.1f Duration %.2f hrs" % (period_days, duration_hrs)
        raise ValueError(msg)

    #import pdb; pdb.set_trace()
    idx |= flags > 0  #Remove data flagged as bad
    idx |= ~np.isfinite(time)  #Or otherwise NaN
    idx |= ~np.isfinite(flux)  #Or otherwise NaN
    idx |= outliers.indexOfOutliers(flux)  #Remove outliers

    #No good cadences for some reason.
    if np.all(idx):
        raise ValueError(
            "No good cadences found for noise estimate. Check transit duration"
        )

    assert (np.all(np.isfinite(flux[~idx])))

    expTime_days = np.median(np.diff(time[~idx]))
    duration_cadences = dur_days / expTime_days

    #Duration must be at least 4 cadences of sgCdpp will crash
    duration_cadences = max(duration_cadences, 4)
    rms = noise.computeSgCdpp_ppm(flux[~idx], duration_cadences) * 1e-6

    idx = kplrfits.markTransitCadences(time, period_days, epoch_bkjd, \
        dur_days, 1, flags=flags)
    nCadenceInTransit = np.sum(idx)

    return depth_frac / rms * np.sqrt(nCadenceInTransit)
コード例 #6
0
ファイル: estimateSnr.py プロジェクト: barentsen/dave
def estimateSnr(time, flux, flags, period_days, epoch_bkjd, \
    duration_hrs, depth_frac, nDurForClip=2):
    """Estimate the SNR of a transit.

    SNR is defined as (transit depth) / (rms scatter). Transit depth
    is an input parameter, snr is calculated with the Marshall method

    Inputs:
    -------------
    time, flux, flags
        (np 1d arrays) arrays of time flux and flag values. All flag
        values > 0 are treated as though they indicate bad data.

    period_days, epoch_bkjd, duration_hrs, depth_frac
        (floats) Parameters of transit

    Optional Inputs:
    ----------------
    nDurForClip
        Points within nDurForClip*duration_hrs around each transit are
        excluded from the estimate of noise.

    """

    dur_days = duration_hrs / 24.
    idx = kplrfits.markTransitCadences(time, period_days, epoch_bkjd, \
        dur_days, nDurForClip, flags=flags)


    if np.all(idx):
        msg = "All cadences seem to be in or near transit: "
        msg += "Period %.1f Duration %.2f hrs" %(period_days, duration_hrs)
        raise ValueError(msg)

    idx |= flags > 0  #Remove data flagged as bad
    idx |= ~np.isfinite(time)  #Or otherwise NaN
    idx |= ~np.isfinite(flux)  #Or otherwise NaN
    idx |= outliers.indexOfOutliers(flux)    #Remove outliers

    #No good cadences for some reason.
    if np.all(idx):
        raise ValueError("No good cadences found for noise estimate. Check transit duration")

    assert( np.all(np.isfinite(flux[~idx])))

    expTime_days = np.median(np.diff(time[~idx]))
    duration_cadences = dur_days/expTime_days

    #Duration must be at least 4 cadences of sgCdpp will crash
    duration_cadences = max(duration_cadences, 4)
    rms = noise.computeSgCdpp_ppm(flux[~idx], duration_cadences)*1e-6

    idx = kplrfits.markTransitCadences(time, period_days, epoch_bkjd, \
        dur_days, 1, flags=flags)
    nCadenceInTransit = np.sum(idx)

    return depth_frac/rms * np.sqrt(nCadenceInTransit)
コード例 #7
0
ファイル: fitData.py プロジェクト: barentsen/dave
def getNoiseParams(lcv):
    # sigma clip it
    sigmaClip_tf = noise.sigmaClip(lcv, 5.0)
    lcv = lcv[~sigmaClip_tf]

    # get params
    rta = noise.computeRollTweakAmplitude(lcv)
    sgcdpp = noise.computeSgCdpp_ppm(lcv)
    scatter = noise.estimateScatterWithMarshallMethod(lcv)

    return rta, sgcdpp, scatter
コード例 #8
0
ファイル: fitData.py プロジェクト: CheerfulUser/SynDiff
def getNoiseParams(lcv):
    # sigma clip it
    sigmaClip_tf = noise.sigmaClip(lcv, 5.)
    lcv = lcv[~sigmaClip_tf]

    # get params
    rta = noise.computeRollTweakAmplitude(lcv)
    sgcdpp = noise.computeSgCdpp_ppm(lcv)
    scatter = noise.estimateScatterWithMarshallMethod(lcv)

    return rta, sgcdpp, scatter
コード例 #9
0
ファイル: fitData.py プロジェクト: barentsen/dave
def paramSubplot(cadenceSum, numPrinCompList, results_list):
    y = cadenceSum / np.mean(cadenceSum) - 1
    raw_rta = noise.computeRollTweakAmplitude(y)
    raw_sgcdpp = noise.computeSgCdpp_ppm(noise.sigmaClip(y, 5.0))
    raw_scatter = noise.estimateScatterWithMarshallMethod(y)
    f, axarr = plt.subplots(3, sharex=True)
    axarr[0].axhline(raw_rta, label="RTA for raw light curve")
    axarr[1].axhline(raw_sgcdpp, label="sgcdpp for raw light curve")
    axarr[2].axhline(raw_scatter, label="scatter for raw light curve")
    axarr[0].plot(numPrinCompList, results_list.T[1], ".", color="green")
    axarr[1].plot(numPrinCompList, results_list.T[2], ".", color="green")
    axarr[2].plot(numPrinCompList, results_list.T[3], ".", color="green")
    plt.xlabel("Number of Principal Components")
    axarr[0].set_ylabel("Roll Tweak Amplitude")
    axarr[1].set_ylabel("sgcdpp")
    axarr[2].set_ylabel("scatter")
    plt.show()
コード例 #10
0
ファイル: fitData.py プロジェクト: CheerfulUser/SynDiff
def paramSubplot(cadenceSum, numPrinCompList, results_list):
    y = cadenceSum / np.mean(cadenceSum) - 1
    raw_rta = noise.computeRollTweakAmplitude(y)
    raw_sgcdpp = noise.computeSgCdpp_ppm(noise.sigmaClip(y, 5.))
    raw_scatter = noise.estimateScatterWithMarshallMethod(y)
    f, axarr = plt.subplots(3, sharex=True)
    axarr[0].axhline(raw_rta, label="RTA for raw light curve")
    axarr[1].axhline(raw_sgcdpp, label="sgcdpp for raw light curve")
    axarr[2].axhline(raw_scatter, label="scatter for raw light curve")
    axarr[0].plot(numPrinCompList, results_list.T[1], ".", color="green")
    axarr[1].plot(numPrinCompList, results_list.T[2], ".", color="green")
    axarr[2].plot(numPrinCompList, results_list.T[3], ".", color="green")
    plt.xlabel("Number of Principal Components")
    axarr[0].set_ylabel("Roll Tweak Amplitude")
    axarr[1].set_ylabel("sgcdpp")
    axarr[2].set_ylabel("scatter")
    plt.show()
コード例 #11
0
ファイル: pipeline.py プロジェクト: barentsen/dave
def fblsTask(clip):
    time_days = clip['extract.time']
    flux_norm = clip['detrend.flux_frac']
    flags = clip['detrend.flags']
    minPeriod = clip['config.blsMinPeriod']
    maxPeriod = clip['config.blsMaxPeriod']

#    durations = np.array([ 2,4,6,8, 10, 12])/24.
    durations = np.array([ 4,6,8, 10, 12])/24.
    idx = flags == 0
    blsObj = fbls.BlsSearch(time_days[idx], flux_norm[idx], \
        [minPeriod, maxPeriod], durations)

    period, epoch, depth, duration = blsObj.getEvent()
    spectrum = blsObj.compute1dBls()

    duration_cadences = int(np.round(duration*48)) #Correct for K2
    rms = noise.computeSgCdpp_ppm(flux_norm[idx], duration_cadences)*1e-6
    idx = kplrfits.markTransitCadences(time_days, period, epoch, \
        duration, flags=flags)
    snr = (depth/rms)*np.sqrt(np.sum(idx))

    out = dict()
    out['period'] = period
    out['epoch'] = epoch
    out['duration_hrs'] = duration * 24
    out['depth'] = depth
    out['snr'] = snr
    out['bls_search_periods'] = spectrum[:,0]
    out['convolved_bls'] = spectrum[:,1]
    #out['obj'] = blsObj
#    out['bls'] = bls  #bls array is extremely big
    clip['bls'] = out

    #Enforce contract
    clip['bls.period']
    clip['bls.epoch']
    clip['bls.duration_hrs']
    return clip
コード例 #12
0
ファイル: pipeline.py プロジェクト: CheerfulUser/SynDiff
def fblsTask(clip):
    time_days = clip['extract.time']
    flux_norm = clip['detrend.flux_frac']
    flags = clip['detrend.flags']
    minPeriod = clip['config.blsMinPeriod']
    maxPeriod = clip['config.blsMaxPeriod']

    #    durations = np.array([ 2,4,6,8, 10, 12])/24.
    durations = np.array([4, 6, 8, 10, 12]) / 24.
    idx = flags == 0
    blsObj = fbls.BlsSearch(time_days[idx], flux_norm[idx], \
        [minPeriod, maxPeriod], durations)

    period, epoch, depth, duration = blsObj.getEvent()
    spectrum = blsObj.compute1dBls()

    duration_cadences = int(np.round(duration * 48))  #Correct for K2
    rms = noise.computeSgCdpp_ppm(flux_norm[idx], duration_cadences) * 1e-6
    idx = kplrfits.markTransitCadences(time_days, period, epoch, \
        duration, flags=flags)
    snr = (depth / rms) * np.sqrt(np.sum(idx))

    out = dict()
    out['period'] = period
    out['epoch'] = epoch
    out['duration_hrs'] = duration * 24
    out['depth'] = depth
    out['snr'] = snr
    out['bls_search_periods'] = spectrum[:, 0]
    out['convolved_bls'] = spectrum[:, 1]
    #out['obj'] = blsObj
    #    out['bls'] = bls  #bls array is extremely big
    clip['bls'] = out

    #Enforce contract
    clip['bls.period']
    clip['bls.epoch']
    clip['bls.duration_hrs']
    return clip
コード例 #13
0
ファイル: fitData.py プロジェクト: CheerfulUser/SynDiff
def varyPrinComp(epic, campaign, plotMask):
    # get the data
    getData_return = getData(epic, campaign)
    data = getData_return[0]
    inds_to_eliminate = getData_return[1].astype(bool)

    # plot the image
    #plotCadence(data[0], axis='relative')

    # create a mask for the light curve
    mask = createMask(data[0],
                      thresh=0,
                      title="Light Curve Mask",
                      plotMask=plotMask)
    lcvMatrix = reduceAperture(mask, data)

    # create a mask for PCA
    pca_mask = createMask(data[0],
                          thresh=0,
                          title="PCA Mask",
                          plotMask=plotMask)
    pcaMatrix = reduceAperture(pca_mask, data)

    # take out data points with thruster firings
    lcvMatrix = lcvMatrix[:, ~inds_to_eliminate]
    pcaMatrix = pcaMatrix[:, ~inds_to_eliminate]

    #get rid of nans in matrices
    lcvMatrix = noMoreNaN(lcvMatrix)
    assert checkNaN(lcvMatrix)
    pcaMatrix = noMoreNaN(pcaMatrix)
    assert checkNaN(pcaMatrix)

    # make the raw light curve
    cadenceSum = np.sum(lcvMatrix, axis=0)

    t = np.arange(len(cadenceSum))

    # plot the raw light curve
    make_plot(t,
              cadenceSum,
              title="Raw Light Curve, e: %s, c: %s" % (epic, campaign))

    # make a list of number of principal comps to try
    numPrinCompList = np.arange(2, np.sum(mask), 2)

    rta_list = []
    sgcdpp_list = []
    scatter_list = []
    results_list = []
    n = 0
    offset = 0.1

    #plt.figure()
    for numPrinComps in numPrinCompList:
        curveFit_return = curveFit(pcaMatrix, cadenceSum, numPrinComps)
        fittedCurve = curveFit_return[0]

        # make the mean zero
        corrected = correctedCurve(cadenceSum, fittedCurve)
        corrected /= np.mean(corrected)
        corrected -= 1

        sigmaClip_tf = noise.sigmaClip(corrected, 5.)
        corrected = corrected[~sigmaClip_tf]
        rta = noise.computeRollTweakAmplitude(corrected)
        sgcdpp = noise.computeSgCdpp_ppm(corrected)
        scatter = noise.estimateScatterWithMarshallMethod(corrected)

        rta_list.append(rta)
        sgcdpp_list.append(sgcdpp)
        scatter_list.append(scatter)

        results_list.append([numPrinComps, rta, sgcdpp, scatter])
        #plt.plot(range(len(corrected)), corrected+ n*offset, ".", markersize=4, label = "%f,%i"%(sgcdpp, int(numPrinComps)))
        n += 1

    #plt.legend()
    #plt.show()

    # plot the three params wrt the raw values
    if plotMask == True:
        y = cadenceSum / np.mean(cadenceSum) - 1
        raw_rta = noise.computeRollTweakAmplitude(y)
        raw_sgcdpp = noise.computeSgCdpp_ppm(noise.sigmaClip(y, 5.))
        raw_scatter = noise.estimateScatterWithMarshallMethod(y)
        f, axarr = plt.subplots(3, sharex=True)
        axarr[0].axhline(raw_rta, label="RTA for raw light curve")
        axarr[1].axhline(raw_sgcdpp, label="sgcdpp for raw light curve")
        axarr[2].axhline(raw_scatter, label="scatter for raw light curve")
        axarr[0].plot(numPrinCompList, rta_list, ".", color="green")
        axarr[1].plot(numPrinCompList, sgcdpp_list, ".", color="green")
        axarr[2].plot(numPrinCompList, scatter_list, ".", color="green")
        plt.xlabel("Number of Principal Components")
        axarr[0].set_ylabel("Roll Tweak Amplitude")
        axarr[1].set_ylabel("sgcdpp")
        axarr[2].set_ylabel("scatter")
        plt.show()

    # plot the corrected light curve with the lowest sgcdpp


#==============================================================================
#     optimalPC = numPrinCompList[np.argmin(sgcdpp_list)]
#     fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
#     optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
#     make_plot(t, optimal_lcv, title="e: %s, c: %s,sgcdpp=%s PC=%s"%(epic, campaign,
#                                                             str(np.min(sgcdpp_list)),
#                                                             numPrinCompList[np.argmin(sgcdpp_list)]))
#==============================================================================

# plot the corrected light curve with the smallest slope between sgcdpp values
    smallest_slope = np.argmin(np.abs(np.diff(sgcdpp_list)))
    optimalPC = numPrinCompList[smallest_slope]
    fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
    optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
    sigmaClip_tf = noise.sigmaClip(optimal_lcv, 5.)
    make_plot(t, optimal_lcv, show=False)
    make_plot(t[sigmaClip_tf],
              optimal_lcv[sigmaClip_tf],
              new=False,
              title="e:%s, c:%s, smallest slope, PC=%s" %
              (epic, campaign, numPrinCompList[smallest_slope]),
              marker='ro')

    folded = np.fmod(t, 4.16)
    make_plot(t, folded)

    #==============================================================================
    #     # plot the corrected light curve with the lowest rta
    #     plt.figure()
    #     plt.title("epic %s campaign %s lowest rta=%s PC=%s"%(epic, campaign,
    #                                                             str(np.min(rta_list)),
    #                                                             numPrinCompList[np.argmin(rta_list)]))
    #     optimalPC = numPrinCompList[np.argmin(rta_list)]
    #     fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
    #     optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
    #     plt.plot(range(len(optimal_lcv)), optimal_lcv, ".")
    #==============================================================================
    #plt.show()

    return np.array(results_list).T
コード例 #14
0
ファイル: productionPCA.py プロジェクト: barentsen/dave
def chooseNumPrinComps(prinComps, totLightcurve, numPixels):
    """Chooses the optimal # of principal components to use in the final fit
    
    Generates a list of sgcdpp values by doing an sgcdpp calculation (see
    noise.computeSgCdpp_ppm)
    
    Iterates through the list of sgcdpp values and determines where the slope 
    between two values starts to "flatten out" based on a certain threshold
    
    Inputs:
    ----------
    prinComps
        (2d numpy array) Size: (number of components, time steps)
        Numpy array of the principal components, ranked from most influential 
        to least (i.e. prinComps[0] is the most dominant component in the light
        curve)
    totLightcurve
        (1d numpy array) Array of summed raw light curve generated by summing
        each cadence, the length of which should be equal to the number of time
        steps for this particular data set.

    numPixels
        (int) the number of pixels per cadence
        
    Returns:
    ----------
    optimalNumPC
        (int) the optimal number of principal components to use in the best fit
        and correction to the raw light curve
    
    """
    # in my experience, the optimal number of principal components is always 
    # less than half of the total number of pixels. To save computation time, 
    # I only generate sgcdpp values for the first half of principal components    
    numPrinComps_sgcdppCalc = numPixels/2
    
    
    # threshold for sigma clip
    sigmaClipThresh = 5.    
    
    # get a list of sgcdpp values for fitting different numbers of prin comps
    n = 1
    sgcdppList = []
    while n < numPrinComps_sgcdppCalc:
        
        prinCompsToFit = prinComps[:n]
        
        # fit the light curve to the amount of prin comps selected
        fittedCurve = curveFit(prinCompsToFit, totLightcurve)

        # correct the light curve by subtracting the prin comp fit
        correctedCurve = totLightcurve - fittedCurve
        
        # make the mean of the corrected curve = 0, 
        # necessary for sgcdpp calculation
        correctedCurveMeanZero = correctedCurve / np.mean(correctedCurve) - 1
        
        # get sigma clip true/false values on the corrected curve with mean 0
        sigClip_tf = noise.sigmaClip(correctedCurveMeanZero, sigmaClipThresh)
        
        # perform sigma clip
        correctedMeanZeroSigClip = correctedCurveMeanZero[~sigClip_tf]
        
        # get the sgcdpp value
        sgcdppValue = noise.computeSgCdpp_ppm(correctedMeanZeroSigClip)
        
        sgcdppList.append([n,sgcdppValue])
        
        n += 1
    
    sgcdppList = np.array(sgcdppList).T
  
    # choose the number of principal components to use
    optimalNumPC = chooseBestSGcdppValue(sgcdppList)
    
    return optimalNumPC
コード例 #15
0
def chooseNumPrinComps(prinComps, totLightcurve, numPixels):
    """Chooses the optimal # of principal components to use in the final fit
    
    Generates a list of sgcdpp values by doing an sgcdpp calculation (see
    noise.computeSgCdpp_ppm)
    
    Iterates through the list of sgcdpp values and determines where the slope 
    between two values starts to "flatten out" based on a certain threshold
    
    Inputs:
    ----------
    prinComps
        (2d numpy array) Size: (number of components, time steps)
        Numpy array of the principal components, ranked from most influential 
        to least (i.e. prinComps[0] is the most dominant component in the light
        curve)
    totLightcurve
        (1d numpy array) Array of summed raw light curve generated by summing
        each cadence, the length of which should be equal to the number of time
        steps for this particular data set.

    numPixels
        (int) the number of pixels per cadence
        
    Returns:
    ----------
    optimalNumPC
        (int) the optimal number of principal components to use in the best fit
        and correction to the raw light curve
    
    """
    # in my experience, the optimal number of principal components is always
    # less than half of the total number of pixels. To save computation time,
    # I only generate sgcdpp values for the first half of principal components
    numPrinComps_sgcdppCalc = numPixels / 2

    # threshold for sigma clip
    sigmaClipThresh = 5.

    # get a list of sgcdpp values for fitting different numbers of prin comps
    n = 1
    sgcdppList = []
    while n < numPrinComps_sgcdppCalc:

        prinCompsToFit = prinComps[:n]

        # fit the light curve to the amount of prin comps selected
        fittedCurve = curveFit(prinCompsToFit, totLightcurve)

        # correct the light curve by subtracting the prin comp fit
        correctedCurve = totLightcurve - fittedCurve

        # make the mean of the corrected curve = 0,
        # necessary for sgcdpp calculation
        correctedCurveMeanZero = correctedCurve / np.mean(correctedCurve) - 1

        # get sigma clip true/false values on the corrected curve with mean 0
        sigClip_tf = noise.sigmaClip(correctedCurveMeanZero, sigmaClipThresh)

        # perform sigma clip
        correctedMeanZeroSigClip = correctedCurveMeanZero[~sigClip_tf]

        # get the sgcdpp value
        sgcdppValue = noise.computeSgCdpp_ppm(correctedMeanZeroSigClip)

        sgcdppList.append([n, sgcdppValue])

        n += 1

    sgcdppList = np.array(sgcdppList).T

    # choose the number of principal components to use
    optimalNumPC = chooseBestSGcdppValue(sgcdppList)

    return optimalNumPC
コード例 #16
0
ファイル: comparebls.py プロジェクト: CheerfulUser/SynDiff
def estSnrForK2(flux_norm, depth_frac, duration_days):
    duration_cadences = int(np.round(duration_days * 48))  #Correct for K2
    noi_frac = noise.computeSgCdpp_ppm(flux_norm, duration_cadences) * 1e-6
    return depth_frac / noi_frac * np.sqrt(duration_cadences)
コード例 #17
0
ファイル: fitData.py プロジェクト: barentsen/dave
def varyPrinComp(epic, campaign, plotMask):
    # get the data
    getData_return = getData(epic, campaign)
    data = getData_return[0]
    inds_to_eliminate = getData_return[1].astype(bool)

    # plot the image
    # plotCadence(data[0], axis='relative')

    # create a mask for the light curve
    mask = createMask(data[0], thresh=0, title="Light Curve Mask", plotMask=plotMask)
    lcvMatrix = reduceAperture(mask, data)

    # create a mask for PCA
    pca_mask = createMask(data[0], thresh=0, title="PCA Mask", plotMask=plotMask)
    pcaMatrix = reduceAperture(pca_mask, data)

    # take out data points with thruster firings
    lcvMatrix = lcvMatrix[:, ~inds_to_eliminate]
    pcaMatrix = pcaMatrix[:, ~inds_to_eliminate]

    # get rid of nans in matrices
    lcvMatrix = noMoreNaN(lcvMatrix)
    assert checkNaN(lcvMatrix)
    pcaMatrix = noMoreNaN(pcaMatrix)
    assert checkNaN(pcaMatrix)

    # make the raw light curve
    cadenceSum = np.sum(lcvMatrix, axis=0)

    t = np.arange(len(cadenceSum))

    # plot the raw light curve
    make_plot(t, cadenceSum, title="Raw Light Curve, e: %s, c: %s" % (epic, campaign))

    # make a list of number of principal comps to try
    numPrinCompList = np.arange(2, np.sum(mask), 2)

    rta_list = []
    sgcdpp_list = []
    scatter_list = []
    results_list = []
    n = 0
    offset = 0.1

    # plt.figure()
    for numPrinComps in numPrinCompList:
        curveFit_return = curveFit(pcaMatrix, cadenceSum, numPrinComps)
        fittedCurve = curveFit_return[0]

        # make the mean zero
        corrected = correctedCurve(cadenceSum, fittedCurve)
        corrected /= np.mean(corrected)
        corrected -= 1

        sigmaClip_tf = noise.sigmaClip(corrected, 5.0)
        corrected = corrected[~sigmaClip_tf]
        rta = noise.computeRollTweakAmplitude(corrected)
        sgcdpp = noise.computeSgCdpp_ppm(corrected)
        scatter = noise.estimateScatterWithMarshallMethod(corrected)

        rta_list.append(rta)
        sgcdpp_list.append(sgcdpp)
        scatter_list.append(scatter)

        results_list.append([numPrinComps, rta, sgcdpp, scatter])
        # plt.plot(range(len(corrected)), corrected+ n*offset, ".", markersize=4, label = "%f,%i"%(sgcdpp, int(numPrinComps)))
        n += 1

    # plt.legend()
    # plt.show()

    # plot the three params wrt the raw values
    if plotMask == True:
        y = cadenceSum / np.mean(cadenceSum) - 1
        raw_rta = noise.computeRollTweakAmplitude(y)
        raw_sgcdpp = noise.computeSgCdpp_ppm(noise.sigmaClip(y, 5.0))
        raw_scatter = noise.estimateScatterWithMarshallMethod(y)
        f, axarr = plt.subplots(3, sharex=True)
        axarr[0].axhline(raw_rta, label="RTA for raw light curve")
        axarr[1].axhline(raw_sgcdpp, label="sgcdpp for raw light curve")
        axarr[2].axhline(raw_scatter, label="scatter for raw light curve")
        axarr[0].plot(numPrinCompList, rta_list, ".", color="green")
        axarr[1].plot(numPrinCompList, sgcdpp_list, ".", color="green")
        axarr[2].plot(numPrinCompList, scatter_list, ".", color="green")
        plt.xlabel("Number of Principal Components")
        axarr[0].set_ylabel("Roll Tweak Amplitude")
        axarr[1].set_ylabel("sgcdpp")
        axarr[2].set_ylabel("scatter")
        plt.show()

    # plot the corrected light curve with the lowest sgcdpp
    # ==============================================================================
    #     optimalPC = numPrinCompList[np.argmin(sgcdpp_list)]
    #     fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
    #     optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
    #     make_plot(t, optimal_lcv, title="e: %s, c: %s,sgcdpp=%s PC=%s"%(epic, campaign,
    #                                                             str(np.min(sgcdpp_list)),
    #                                                             numPrinCompList[np.argmin(sgcdpp_list)]))
    # ==============================================================================

    # plot the corrected light curve with the smallest slope between sgcdpp values
    smallest_slope = np.argmin(np.abs(np.diff(sgcdpp_list)))
    optimalPC = numPrinCompList[smallest_slope]
    fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
    optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
    sigmaClip_tf = noise.sigmaClip(optimal_lcv, 5.0)
    make_plot(t, optimal_lcv, show=False)
    make_plot(
        t[sigmaClip_tf],
        optimal_lcv[sigmaClip_tf],
        new=False,
        title="e:%s, c:%s, smallest slope, PC=%s" % (epic, campaign, numPrinCompList[smallest_slope]),
        marker="ro",
    )

    folded = np.fmod(t, 4.16)
    make_plot(t, folded)

    # ==============================================================================
    #     # plot the corrected light curve with the lowest rta
    #     plt.figure()
    #     plt.title("epic %s campaign %s lowest rta=%s PC=%s"%(epic, campaign,
    #                                                             str(np.min(rta_list)),
    #                                                             numPrinCompList[np.argmin(rta_list)]))
    #     optimalPC = numPrinCompList[np.argmin(rta_list)]
    #     fittedCurve = curveFit(pcaMatrix, cadenceSum, optimalPC)[0]
    #     optimal_lcv = correctedCurve(cadenceSum, fittedCurve)
    #     plt.plot(range(len(optimal_lcv)), optimal_lcv, ".")
    # ==============================================================================
    # plt.show()

    return np.array(results_list).T
コード例 #18
0
ファイル: comparebls.py プロジェクト: barentsen/dave
def estSnrForK2(flux_norm, depth_frac, duration_days):
    duration_cadences = int(np.round(duration_days*48)) #Correct for K2
    noi_frac = noise.computeSgCdpp_ppm(flux_norm, duration_cadences)*1e-6
    return depth_frac/noi_frac * np.sqrt(duration_cadences)