def test_for_nans():
"""
Something is causing the lhf to return NaN. Get to the bottom of it!
"""
df = pd.read_csv("../paper/code/data/simulated_data.csv")
for i in range(len(df)):
print(i, "of", len(df))
iso_params = pd.DataFrame(
dict({
"teff": (df.teff[i], 10),
"logg": (df.logg[i], .05),
"feh": (df.feh[i], .001),
"parallax": (df.parallax[i], .01)
})) # mas
mod = StarModel(mist, **iso_params)
N = 10000
eeps = np.random.uniform(-100, 2000, N)
lnages = np.random.uniform(0, 11, N)
fehs = np.random.uniform(-5, 5, N)
Ds = np.log(np.random.uniform(0, 10000, N))
Avs = np.random.uniform(-.2, 1.2, N)
# periods = 10**np.random.uniform(-1, 3, N)
probs, priors = [np.empty(N) for i in range(2)]
for j in trange(N):
lnparams = [eeps[j], lnages[j], fehs[j], Ds[j], Avs[j]]
args = [mod, df.prot[i], 1., None, None, False, False]
probs[j] = lnprob(lnparams, *args)[0]
priors[j] = lnprob(lnparams, *args)[1]
print(len(probs), len(probs[np.isnan(probs)]))
assert sum(np.isnan(probs)) == 0
def test_on_hot_star():
df = pd.read_csv("paper/code/data/simulated_data_noisy.csv")
i = 21
iso_params = dict({
"teff": (df.teff.values[i], df.teff_err.values[i]),
"logg": (df.logg.values[i], df.logg_err.values[i]),
"feh": (df.feh.values[i], df.feh_err.values[i]),
"J": (df.jmag.values[i], df.J_err.values[i]),
"H": (df.hmag.values[i], df.H_err.values[i]),
"K": (df.kmag.values[i], df.K_err.values[i]),
"B": (df.B.values[i], df.B_err.values[i]),
"V": (df.V.values[i], df.V_err.values[i]),
"G": (df.G.values[i], df.G_err.values[i]),
"BP": (df.BP.values[i], df.BP_err.values[i]),
"RP": (df.RP.values[i], df.RP_err.values[i]),
"parallax": (df.parallax.values[i], df.parallax_err.values[i]),
"maxAV":
.1
})
lnparams = [329.58, np.log10(650 * 1e6), 0., np.log(177), .035]
mod = StarModel(mist, **iso_params)
args = [
mod, df.prot.values[i], df.prot_err.values[i], False, False, True,
"angus15"
]
prob, prior = lnprob(lnparams, *args)
print(prob, prior)
assert np.isfinite(prob)
assert np.isfinite(prior)
def test_lnprob_higher_likelihood_real():
"""
The same test as above but for simulated data.
"""
df = pd.read_csv("../paper/code/data/simulated_data.csv")
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
i = 0
iso_params = pd.DataFrame(dict({"teff": (df.teff[i], 25),
"logg": (df.logg[i], .05),
"feh": (df.feh[i], .05),
"jmag": (df.jmag[i], .01),
"hmag": (df.hmag[i], .01),
"kmag": (df.kmag[i], .01),
"parallax": (df.parallax[i], .05)}))
# Set up the StarModel isochrones object.
mod = StarModel(mist, **iso_params)
args = [mod, df.prot[i], 1, None, None, False, False] # lnprob arguments
good_lnparams = [df.eep.values[i], df.age.values[i], df.feh.values[i],
np.log(df.d_kpc.values[i]*1e3), df.Av.values[i]]
good_lnprob = lnprob(good_lnparams, *args)
good_vs_bad(good_lnprob, good_lnparams, args, 10)
def good_vs_bad(good_lnprob, good_lnparams, args, nsamps):
"""
Compare the likelihood of nsamps random parameter values against the
likelihood of the true values.
The true values should be higher.
"""
bad_lnparams = good_lnparams * 1
bad_lnparams[0] = 10 + good_lnparams[0] # eep
bad_lnparams[1] = .5 + good_lnparams[1] # age
bad_lnparams[2] = .05 + good_lnparams[2] # feh
bad_lnparams[3] = .1 + good_lnparams[3] # dist
bad_lnprob = lnprob(bad_lnparams, *args)
assert bad_lnprob[0] < good_lnprob[0], \
"True parameters values must give a higher likelihood than" \
" wrong values"
def test_praesepe_angus_model():
df = pd.read_csv("paper/code/data/praesepe.csv")
df = df.iloc[0]
iso_params = {
"G": (df["G"], df["G_err"]),
"BP": (df["bp"], df["BP_err"]),
"RP": (df["rp"], df["RP_err"]),
"parallax": (df["parallax"], df["parallax_err"]),
"maxAV": .1
}
inits = [330, np.log10(650 * 1e6), 0., np.log(177), 0.035]
mod = StarModel(mist, **iso_params)
args = [mod, df["prot"], df["prot"] * .01, False, False, True, "angus15"]
prob, prior = lnprob(inits, *args)
assert np.isfinite(prob)
assert np.isfinite(prior)
def test_lnprob_higher_likelihood_sun():
"""
Make sure the likelihood goes down when the parameters are a worse fit.
Test on Solar values.
"""
iso_params = pd.DataFrame(dict({"teff": (5777, 10),
"logg": (4.44, .05),
"feh": (0., .001),
"parallax": (1., .01), # mas
"B": (15, 0.02)}))
# Set up the StarModel isochrones object.
mod = StarModel(mist, **iso_params)
args = [mod, 26., 1., None, None, False, False] # the lnprob arguments]
good_lnparams = [346, np.log10(4.56*1e9), 0., np.log(1000), 0.]
good_lnprob = lnprob(good_lnparams, *args)
good_vs_bad(good_lnprob, good_lnparams, args, 10)
def test_lnprob_higher_likelihood_sun():
"""
Make sure the likelihood goes down when the parameters are a worse fit.
Test on Solar values.
"""
iso_params = {
"teff": (5777, 10),
"logg": (4.44, .05),
"feh": (0., .001),
"parallax": (1., .01), # milliarcseconds
"B": (15.48, 0.02)
}
# Set up the StarModel isochrones object.
mod = StarModel(mist, **iso_params)
# the lnprob arguments]
args = [mod, 26., 1., False, False, True, "angus15"]
good_lnparams = [346, np.log10(4.56 * 1e9), 0., np.log(1000), 0.]
good_lnprob = lnprob(good_lnparams, *args)
good_vs_bad(good_lnprob, good_lnparams, args, 10)
def test_likelihood_rotation_giant():
"""
Make sure that the lhf can cope with zeros, NaNs and None values for the
rotation period.
Also, check that there is a drop in likelihood at the eep = 454 boundary.
"""
iso_params = pd.DataFrame(
dict({
"teff": (5777, 10),
"logg": (4.44, .05),
"feh": (0., .001),
"parallax": (1., .01)
})) # mas
# Set up the StarModel isochrones object.
mod = StarModel(mist, **iso_params)
lnparams = [355, np.log10(4.56 * 1e9), 0., np.log(1000), 0.]
args = [mod, None, None, .65, 1., False, False] # the lnprob arguments]
none_lnprob = lnprob(lnparams, *args)
args = [mod, np.nan, np.nan, .65, 1., False,
False] # the lnprob arguments]
nan_lnprob = lnprob(lnparams, *args)
args = [mod, 0., 0., .65, 1., False, False] # the lnprob arguments]
zero_lnprob = lnprob(lnparams, *args)
args = [mod, 26., 1., .65, 1., True, False] # the lnprob arguments]
iso_lnprob = lnprob(lnparams, *args)
args = [mod, 26., 1., .65, 1., False, True] # the lnprob arguments]
gyro_lnprob = lnprob(lnparams, *args)
# check that gyro is switched off for all of these.
none_lnprob == nan_lnprob
nan_lnprob == zero_lnprob
# check that gyro on gives different lnprob
assert gyro_lnprob != iso_lnprob
# Likelihood should be greater for dwarfs because gyro lnlike is a broad
# Gaussian for giants.
giant_params = [455, np.log10(4.56 * 1e9), 0., np.log(1000), 0.]
dwarf_params = [453, np.log10(4.56 * 1e9), 0., np.log(1000), 0.]
args = [mod, 26., 1., None, None, False, False]
giant_lnprob = lnprob(giant_params, *args)
dwarf_lnprob = lnprob(dwarf_params, *args)
assert giant_lnprob[0] < dwarf_lnprob[0]
# Likelihood should be greater for cool stars because gyro lnlike is a
# broad Gaussian for giants.
heep, hage, hfeh = 405, np.log10(2.295 * 1e9), 0.
ceep, cage, cfeh = 355, np.log10(4.56 * 1e9), 0.
hot_params = [heep, hage, hfeh, np.log(1000), 0.]
cool_params = [ceep, cage, cfeh, np.log(1000), 0.]
cool_prot = gyro_model_rossby(
cage, calc_bv(cool_params),
mist.interp_value([ceep, cage, cfeh], ["mass"]))
hot_prot = gyro_model_rossby(
hage, calc_bv(hot_params),
mist.interp_value([heep, hage, hfeh], ["mass"]))
cool_args = [mod, cool_prot, 1., None, None, False, False]
hot_args = [mod, hot_prot, 1., None, None, False, False]
hot_lnprob = lnprob(hot_params, *args)
cool_lnprob = lnprob(cool_params, *args)
assert hot_lnprob[0] < cool_lnprob[0], "cool star likelihood should be" \
" higher than hot star likelihood"
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
