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