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