Exemplo n.º 1
0
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
Exemplo n.º 2
0
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
Exemplo n.º 3
0
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
Exemplo n.º 4
0
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
Exemplo n.º 5
0
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()
Exemplo n.º 6
0
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()
Exemplo n.º 7
0
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
Exemplo n.º 8
0
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