示例#1
0
文件: test_pipeline.py 项目: adrn/PTF
def test_iscandidate(plot=False):
    ''' Use test light curves to test selection:
        - Periodic
        - Bad data
        - Various simulated events
        - Flat light curve
        - Transients (SN, Nova, etc.)
    '''

    np.random.seed(10)

    logger.setLevel(logging.DEBUG)
    from ptf.lightcurve import SimulatedLightCurve
    import ptf.db.mongodb as mongo

    db = mongo.PTFConnection()

    logger.info("---------------------------------------------------")
    logger.info(greenText("Periodic light curves"))
    logger.info("---------------------------------------------------")

    # Periodic light curves
    periodics = [(4588, 7, 13227), (4588, 2, 15432), (4588, 9, 17195), (2562, 10, 28317), (4721, 8, 11979), (4162, 2, 14360)]

    for field_id, ccd_id, source_id in periodics:
        periodic_light_curve = pdb.get_light_curve(field_id, ccd_id, source_id, clean=True)
        periodic_light_curve.indices = pa.compute_variability_indices(periodic_light_curve, indices=["eta", "delta_chi_squared", "j", "k", "sigma_mu"])
        assert pa.iscandidate(periodic_light_curve, lower_eta_cut=10**db.fields.find_one({"_id" : field_id}, {"selection_criteria" : 1})["selection_criteria"]["eta"]) in ["subcandidate" , False]
        if plot: plot_lc(periodic_light_curve)

    logger.info("---------------------------------------------------")
    logger.info(greenText("Bad light curves"))
    logger.info("---------------------------------------------------")

    # Bad data
    bads = [(3756, 0, 14281), (1983, 10, 1580)]

    for field_id, ccd_id, source_id in bads:
        bad_light_curve = pdb.get_light_curve(field_id, ccd_id, source_id, clean=True)
        bad_light_curve.indices = pa.compute_variability_indices(bad_light_curve, indices=["eta", "delta_chi_squared", "j", "k", "sigma_mu"])
        assert not pa.iscandidate(bad_light_curve, lower_eta_cut=10**db.fields.find_one({"_id" : field_id}, {"selection_criteria" : 1})["selection_criteria"]["eta"])
        if plot: plot_lc(bad_light_curve)

    logger.info("---------------------------------------------------")
    logger.info(greenText("Simulated light curves"))
    logger.info("---------------------------------------------------")

    # Simulated light curves
    for field_id,mjd in [(4721,periodic_light_curve.mjd)]:
        for err in [0.01, 0.05, 0.1]:
            logger.debug("field: {0}, err: {1}".format(field_id,err))
            light_curve = SimulatedLightCurve(mjd=mjd, mag=15, error=[err])
            light_curve.indices = pa.compute_variability_indices(light_curve, indices=["eta", "delta_chi_squared", "j", "k", "sigma_mu"])
            assert not pa.iscandidate(light_curve, lower_eta_cut=10**db.fields.find_one({"_id" : field_id}, {"selection_criteria" : 1})["selection_criteria"]["eta"])

            light_curve.add_microlensing_event(u0=np.random.uniform(0.2, 0.8), t0=light_curve.mjd[int(len(light_curve)/2)], tE=light_curve.baseline/8.)
            light_curve.indices = pa.compute_variability_indices(light_curve, indices=["eta", "delta_chi_squared", "j", "k", "sigma_mu"])
            if plot:
                plt.clf()
                light_curve.plot()
                plt.savefig("plots/tests/{0}_{1}.png".format(field_id,err))
            assert pa.iscandidate(light_curve, lower_eta_cut=10**db.fields.find_one({"_id" : field_id}, {"selection_criteria" : 1})["selection_criteria"]["eta"])

    logger.info("---------------------------------------------------")
    logger.info(greenText("Transient light curves"))
    logger.info("---------------------------------------------------")

    # Transients (SN, Novae)
    transients = [(4564, 0, 4703), (4914, 6, 9673), (100041, 1, 4855), (100082, 5, 7447), (4721, 8, 3208), (4445, 7, 11458),\
                  (100003, 6, 10741), (100001, 10, 5466), (4789, 6, 11457), (2263, 0, 3214), (4077, 8, 15293), (4330, 10, 6648), \
                  (4913, 7, 13436), (100090, 7, 2070), (4338, 2, 10330), (5171, 0, 885)]

    for field_id, ccd_id, source_id in transients:
        transient_light_curve = pdb.get_light_curve(field_id, ccd_id, source_id, clean=True)
        logger.debug(transient_light_curve)
        transient_light_curve.indices = pa.compute_variability_indices(transient_light_curve, indices=["eta", "delta_chi_squared", "j", "k", "sigma_mu"])
        assert pa.iscandidate(transient_light_curve, lower_eta_cut=10**db.fields.find_one({"_id" : field_id}, {"selection_criteria" : 1})["selection_criteria"]["eta"])
        if plot: plot_lc(transient_light_curve)
示例#2
0
def select_candidates(field, selection_criteria, num_fit_attempts=10):
    """ Select candidates from a field given the log10(selection criteria) from mongodb.

        The current selection scheme is to first select on eta, then to
        sanity check with delta chi-squared by making sure it's positive 
        and >10.

    """

    eta_cut = 10**selection_criteria

    light_curves = []
    for ccd in field.ccds.values():
        logger.info("Starting with CCD {}".format(ccd.id))
        chip = ccd.read()
        ####### APW @ MDM
        #print("Total:", len(chip.sources.read(field="matchedSourceID")))
        #cdtn = "(ngoodobs > 10) " #& ((ngoodobs/nobs) > 0.5)"
        #print("Condition:", len(chip.sources.readWhere(cdtn, field="matchedSourceID")))
        #continue
        ########################
        cdtn = ("(ngoodobs > {}) & (vonNeumannRatio > 0.0) & "
                "(vonNeumannRatio < {}) & ((ngoodobs/nobs) > 0.5)")
        cdtn = cdtn.format(min_number_of_good_observations, eta_cut)
        source_ids = chip.sources.readWhere(cdtn, field="matchedSourceID")

        logger.info("\tSelected {} pre-candidates from PDB"\
                    .format(len(source_ids)))
        for source_id in source_ids:
            # APW: TODO -- this is still the biggest time hog!!! It turns 
            #   out it's still faster than reading the whole thing into 
            #   memory, though!
            light_curve = ccd.light_curve(source_id, barebones=True, 
                                          clean=True)

            # If light curve doesn't have enough clean observations, skip it
            if light_curve != None and \
                len(light_curve) < min_number_of_good_observations: 
                continue

            # Compute the variability indices for the cleaned light curve
            try:
                ind_names = ["eta", "delta_chi_squared", "j", "k", "sigma_mu"]
                indices = pa.compute_variability_indices(light_curve, 
                                                         indices=ind_names)
            except ValueError:
                logger.warning("Failed to compute variability indices for "
                               "light curve! {0}".format(light_curve))
                return False

            light_curve.indices = indices
            light_curve.tags = []
            light_curve.features = {}

            if light_curve.sdss_type() == "galaxy":
                light_curve.tags.append("galaxy")
                continue

            # If the object is not a Galaxy or has no SDSS data, try to get 
            #    the SDSS colors to see if it passes the Richards et al. 
            #    QSO color cut.
            sdss_colors = light_curve.sdss_colors("psf")
            qso_status = richards_qso(sdss_colors)
            if sdss_colors != None and qso_status:
                light_curve.tags.append("qso")
            
            candidate_status = pa.iscandidate(light_curve, 
                                              lower_eta_cut=eta_cut)

            if candidate_status == "candidate" and \
                "qso" not in light_curve.tags:
                light_curve.tags.append("candidate")
                light_curves.append(light_curve)
                continue

            if candidate_status == "subcandidate" and \
                light_curve.indices["eta"] < eta_cut and not qso_status:
                # Try to do period analysis with AOV
                try:
                    peak_period = light_curve.features["aov_period"]
                    peak_power = light_curve.features["aov_power"]
                except KeyError:
                    try:
                        fp = pa.findPeaks_aov(light_curve.mjd.copy(),
                                              light_curve.mag.copy(), 
                                              light_curve.error.copy(), 
                                              3, 1., 2.*light_curve.baseline, 
                                              1., 0.1, 20)
                    except ZeroDivisionError:
                        continue

                    peak_period = fp["peak_period"][0]
                    peak_power = max(fp["peak_period"])

                    light_curve.features["aov_period"] = peak_period
                    light_curve.features["aov_power"] = peak_power

                if (peak_period < 2.*light_curve.baseline):
                    if peak_power > 25.:
                        light_curve.tags.append("variable star")

                        if "subcandidate" in light_curve.tags:
                            light_curve.tags.pop(light_curve.tags\
                                .index("subcandidate"))

                        if light_curve not in light_curves:
                            light_curves.append(light_curve)

        ccd.close()

    return light_curves