def infer_stellar_age(df): # Small observational uncertainties are needed (even though the stars # weren't simulated with any) in order to get a good fit. teff_err = 25 # Kelvin logg_err = .05 # dex feh_err = .05 # dex jmag_err = .01 # mags hmag_err = .01 # mags kmag_err = .01 # mags parallax_err = .05 # milliarcseconds prot_err = 1 # Days BV_err = .01 # mags # Infer ages of the simulated stars. # Set up the parameter dictionary. iso_params = { "teff": (df["teff"], teff_err), "logg": (df["logg"], logg_err), "feh": (df["feh"], feh_err), "jmag": (df["jmag"], jmag_err), "hmag": (df["hmag"], hmag_err), "kmag": (df["kmag"], kmag_err), "parallax": (df["parallax"], parallax_err) } # Infer an age with isochrones and gyrochronology. try: sd_fn = "{}_stardate".format(str(int(df["ID"])).zfill(4)) iso_fn = "{}_isochrones".format(str(int(df["ID"])).zfill(4)) if not os.path.exists(sd_fn): # Set up the star object star = sd.Star(iso_params, df["prot"], .01, filename=sd_fn) # Run the MCMC sampler = star.fit(max_n=200000) else: print("failed to save file for star. File exists: ", sd_fn) # Now infer an age with isochrones only. if not os.path.exists(iso_fn): # Set up the star object star_iso = sd.Star(iso_params, df["prot"], .01, filename=iso_fn) # Run the MCMC sampler = star_iso.fit(max_n=200000, iso_only=True) else: print("failed to save file for star. File exists: ", iso_fn) except: print("failed to save file for star ", str(int(df["ID"])).zfill(4))
def infer_stellar_age(df): # Set up the parameter dictionary. iso_params = { "G": (df["phot_g_mean_mag"], df["G_err"]), "BP": (df["phot_bp_mean_mag"], df["bp_err"]), "RP": (df["phot_rp_mean_mag"], df["rp_err"]), "teff": (df["cks_steff"], df["cks_steff_err1"]), "feh": (df["cks_smet"], df["cks_smet_err1"]), "logg": (df["cks_slogg"], df["cks_slogg_err1"]), "parallax": (df["parallax"], df["parallax_error"]) } # Infer an age with isochrones and gyrochronology. gyro_fn = "samples/{}_gyro".format(str(int(df["kepid"])).zfill(9)) iso_fn = "samples/{}_iso".format(str(int(df["kepid"])).zfill(9)) # Get initialization bprp = df["phot_bp_mean_mag"] - df["phot_rp_mean_mag"] log10_period = np.log10(df["Prot"]) log10_age_yrs = age_model(log10_period, bprp) gyro_age = (10**log10_age_yrs) * 1e-9 eep = mist.get_eep(df["koi_smass"], np.log10(gyro_age * 1e9), df["cks_smet"], accurate=True) inits = [ eep, np.log10(gyro_age * 1e9), df["cks_smet"], (1. / df["parallax"]) * 1e3, df["Av"] ] # Set up the star object iso_star = sd.Star(iso_params, Av=df["Av"], Av_err=df["Av_std"], filename=iso_fn) gyro_star = sd.Star(iso_params, prot=df["Prot"], prot_err=df["e_Prot"], Av=df["Av"], Av_err=df["Av_std"], filename=gyro_fn) # Run the MCMC iso_sampler = iso_star.fit(inits=inits, max_n=300000, save_samples=True) gyro_sampler = gyro_star.fit(inits=inits, max_n=300000, save_samples=True)
def measure_koi_ages(row): df = row[1] iso_params = { "G": (df.phot_g_mean_mag, df.phot_g_mean_mag * .05), "bp": (df.phot_bp_mean_mag, df.phot_bp_mean_mag * .05), "rp": (df.phot_rp_mean_mag, df.phot_rp_mean_mag * .05), "J": (df.kic_jmag, df.kic_jmag * .05), "H": (df.kic_hmag, df.kic_hmag * .05), "K": (df.kic_kmag, df.kic_kmag * .05), "teff": (df.iso_steff, df.iso_steff_err2), "logg": (df.iso_slogg, df.iso_slogg_err2), "feh": (df.iso_smet, df.iso_smet_err2), "parallax": (df.parallax, df.parallax_error) } starname = str(int(df.id_kic)).zfill(9) filename = "planet_results/{}".format(starname) star = sd.Star(iso_params, df.period, .5 * (df.period_errp + df.period_errm), filename=filename) sampler = star.fit(max_n=200000)
def infer_stellar_age(df): if df["n_[Fe/H]i"] == "SPE": iso_params = { "g": (df["g_final"], df["g_final_err"]), "r": (df["r_final"], df["r_final_err"]), "J": (df["Jmag"], df["e_Jmag"]), "H": (df["Hmag"], df["e_Hmag"]), "K": (df["Kmag"], df["e_Kmag"]), "feh": (df["[Fe/H]"], .05), "parallax": (df["plx"] * 1e3, df["plxe"] * 1e3) } else: iso_params = { "g": (df["g_final"], df["g_final_err"]), "r": (df["r_final"], df["r_final_err"]), "J": (df["Jmag"], df["e_Jmag"]), "H": (df["Hmag"], df["e_Hmag"]), "K": (df["Kmag"], df["e_Kmag"]), "parallax": (df["plx"] * 1e3, df["plxe"] * 1e3) } prot, prot_err = df["Prot"], df["Prot"] * .05 star = sd.Star(iso_params, prot=prot, prot_err=prot_err, Av=df["Av"], Av_err=df["Av_std"], savedir="mcquillan", filename="{}".format(df["KID"])) star.fit(max_n=10000, thin_by=100)
def test_on_sun(): iso_params = { "teff": (5778, 50), "logg": (4.44, .1), "feh": (0., .1), "parallax": (1, .1), "maxAV": .1 } fn = "star_test" star = sd.Star(iso_params, prot=26., prot_err=26 * .01, Av=0., Av_err=.001, savedir=".", filename=fn) star.fit(max_n=1000, seed=42) samples = star.samples flatsamples, _, _, _ = load_samples("{0}.h5".format(fn)) assert np.shape(flatsamples[:, :-1]) == np.shape(samples) results = read_samples(flatsamples) labels = ["EEP", "Age", "Fe/H", "Distance", "Av", "lnprob"] truths = [355, np.log10(4.56 * 1e9), 0., 1000, 0., None] # corner.corner(flatsamples, labels=labels, truths=truths); # plt.savefig("sun_test_corner") # Assert the results are within 1 sigma of the Sun. assert (float(results.age_med_gyr) - float(results.age_errm) < 4.56), \ "Solar age too high" assert (4.56 < float(results.age_med_gyr) + float(results.age_errp)), \ "Solar age too low" assert (float(results.EEP_med) - float(results.EEP_errm) < 355), \ "Solar EEP too high" assert (255 < float(results.EEP_med) + float(results.EEP_errp)), \ "Solar EEP too low"
def test_Av(): iso_params = {"teff": (5770, 50), "feh": (0, .01)} star = sd.Star(iso_params, prot=26, prot_err=1, Av=.2, Av_err=.01)
def test_iso_lnlike(): iso_params = { "teff": (5770, 10), "feh": (0, .01), "logg": (4.44, .1), "parallax": (1, 1) } mod = SingleStarModel(mist, **iso_params) # StarModel isochrones obj params = [354, np.log10(4.56 * 1e9), 0., 1000, 0.] lnparams = [354, np.log10(4.56 * 1e9), 0., np.log(1000), 0.] lnpr = mod.lnprior(params) # lnparams = [350, 9, 0., 6, 0.] args1 = [mod, iso_params] # Calculate the lnprob above iso_lp = iso_lnprob(lnparams, *args1) start = time.time() for i in range(100): iso_lp = iso_lnprob(lnparams, *args1) end = time.time() # Calculate the stardate lnprob args2 = [mod, None, None, True, False, True, "praesepe"] start = time.time() for i in range(100): lp = lnprob(lnparams, *args2)[0] end = time.time() # print("time = ", end - start) ll = lnlike(lnparams, *args2) lnprior = lp - ll assert iso_lp == lp assert np.isclose(iso_lp - lnpr, ll) assert lnpr == lnprior # THIS TEST np.random.seed(42) nwalkers, ndim, nsteps = 50, 5, 100 p0 = [np.random.randn(ndim) * 1e-4 + lnparams for j in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, iso_lnprob, args=args1) start = time.time() sampler.run_mcmc(p0, nsteps) end = time.time() samples = np.reshape(sampler.chain, (nwalkers * nsteps, ndim)) test_median = np.median(samples[:, 1]) # STARDATE star = sd.Star(iso_params, filename="sun_test") start = time.time() star.fit(max_n=100, inits=params, thin_by=1, seed=42, save_samples=False) end = time.time() iso_median = np.median(star.samples[:, 1]) assert iso_median == test_median