def calculate_V_minus_K(s, i, dartmouth=False):
"""
Using the isochrones package, calculate the V-K color of a star using data
from the KIC. Takes a pandas dataframe and the index of the star in the
dataframe. Returns V-K for that star.
"""
if dartmouth:
grid = g_dar
else:
grid = mist
mod = StarModel(grid,
Teff=(s.teff.values[i], s.teff.values[i]),
logg=(s.logg.values[i], s.logg_err1.values[i]),
feh=(s.feh.values[i], s.feh_err1.values[i]),
J=s.jmag.values[i],
K=s.kmag.values[i],
H=s.hmag.values[i],
Kp=s.kepmag.values[i],
parallax=(s.parallax.values[i],
s.parallax_error.values[i]),
use_emcee=True)
mod.fit()
if dartmouth:
return np.median(mod.samples.V_mag) - np.median(mod.samples.Ks_mag)
else:
return np.median(mod.samples.V_mag) - np.median(mod.samples.K_mag)
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 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 age(name):
outfn = os.path.join(OUTPUTDIR, '{}_isochrones.hdf'.format(name))
model = StarModel.load_hdf(outfn)
age = model.samples['age']
age = 10**age / 1e9
p15, p50, p85 = age.quantile([0.15, 0.5, 0.85])
return "${%.1f}^{%+.1f}_{%+.1f}$" % (p50, p85 - p50, p15 - p50)
def obs_to_starmodel(obs, iso=None):
""" Given an Observation, return a StarModel object """
if iso is None:
iso = Dartmouth_Isochrone()
mags = obs_to_mags(obs)
parallax = (obs.tgas_source.parallax, obs.tgas_source.parallax_error)
model = StarModel(iso, use_emcee=True, parallax=parallax, **mags)
model.set_bounds(mass=(0.01, 20),
feh=(-1, 1),
distance=(0, 300),
AV=(0, 1))
return model
def _ini1(ic):
""" Single star
"""
mod = StarModel.from_ini(ic, folder=os.path.join(FOLDER, 'star1'))
assert mod.n_params == 5
assert mod.obs.systems == [0]
assert mod.obs.Nstars == {0: 1}
p = [1.0, 9.4, 0.0, 100, 0.2]
assert np.isfinite(mod.lnlike(p))
def _ini2(ic):
""" A wide, well-resolved binary
"""
mod = StarModel.from_ini(ic, folder=os.path.join(FOLDER, 'star2'))
assert mod.n_params == 6
assert mod.obs.systems == [0]
assert mod.obs.Nstars == {0: 2}
p = [1.0, 0.5, 9.4, 0.0, 100, 0.2]
assert np.isfinite(mod.lnlike(p))
def _check_saving(mod):
filename = os.path.join(chainsdir,
'{}.h5'.format(np.random.randint(1000000)))
mod.save_hdf(filename)
newmod = StarModel.load_hdf(filename)
assert np.allclose(mod.samples, newmod.samples)
assert mod.ic.bands == newmod.ic.bands
os.remove(filename)
def _ini3(ic):
""" A close resolved triple (unresolved in KIC, TwoMASS)
modeled as a physically associated triple
"""
mod = StarModel.from_ini(ic, folder=os.path.join(FOLDER, 'star3'))
assert mod.n_params == 7
assert mod.obs.systems == [0]
assert mod.obs.Nstars == {0: 3}
p = [1.0, 0.8, 0.5, 9.4, 0.0, 100, 0.2]
assert np.isfinite(mod.lnlike(p))
def augment_chain(chain, isochrones_file, lpar_list):
model = StarModel.load_hdf(isochrones_file)
chain_star = model.samples
chain_star['agegyr'] = 10**chain_star['age'] / 1e9
chain_star = chain_star['Teff mass radius agegyr distance'.split()]
chain_star['rhostar'] = 1.410 * chain_star.mass * chain_star.radius**-3
nchain = len(chain)
chain_star = chain_star.sample(n=nchain, replace=True)
chain_star.index = chain.index
chain = pd.concat([chain_star, chain], axis=1)
if list(chain.columns).count('dvdt') > 0:
chain['dvdt'] *= 365 # Fitting is done in m/s/day, we want m/s/yr
i_planet = 1
for lpar in lpar_list:
e = chain['e%i' % i_planet]
k = chain['k%i' % i_planet]
RpRstar = np.random.normal(
loc=lpar.RpRstar, scale=lpar.RpRstar_err, size=nchain) * 1e-2
P = np.random.normal(loc=lpar.P, scale=lpar.P_err, size=nchain)
T0 = np.random.normal(loc=lpar.T0, scale=lpar.T0_err, size=nchain)
Rp = chain.radius * 109.045 * RpRstar
Mpsini = radvel.orbit.Msini(k,
P,
chain['mass'],
e,
Msini_units='earth')
rhop = radvel.orbit.density(Mpsini, Rp)
Lstar = radvel.orbit.Lstar(chain['radius'], chain['Teff'])
a = ((c.G * chain['mass'] * u.Msun * (P * u.d)**2 / 4 /
np.pi**2)**(1 / 3.)).to(u.AU)
a = a.to(u.AU).value
Sinc = radvel.orbit.Sinc(Lstar, a)
Teq = radvel.orbit.Teq(Sinc)
chain['P%i' % i_planet] = P
chain['T0%i' % i_planet] = T0
chain['RpRstar%i' % i_planet] = RpRstar
chain['Rp%i' % i_planet] = Rp
chain['Mpsini%i' % i_planet] = Mpsini
chain['rhop%i' % i_planet] = rhop
chain['Teq%i' % i_planet] = Teq
chain['Lstar%i' % i_planet] = Lstar
chain['a%i' % i_planet] = a
chain['Sinc%i' % i_planet] = Sinc
i_planet += 1
print_fmt_chain(fmt_chain(chain))
return chain
def _check_saving(mod):
filename = os.path.join(chainsdir, "{}.h5".format(np.random.randint(1000000)))
mod.save_hdf(filename)
assert len(tb.file._open_files.get_handlers_by_name(filename)) == 0
newmod = StarModel.load_hdf(filename)
assert len(tb.file._open_files.get_handlers_by_name(filename)) == 0
assert_frame_equal(mod.samples, newmod.samples)
assert mod.ic.bands == newmod.ic.bands
os.remove(filename)
def _check_saving(mod):
filename = os.path.join(chainsdir, '{}.h5'.format(np.random.randint(1000000)))
mod.save_hdf(filename)
assert len(tb.file._open_files.get_handlers_by_name(filename)) == 0
newmod = StarModel.load_hdf(filename)
assert len(tb.file._open_files.get_handlers_by_name(filename)) == 0
assert_frame_equal(mod.samples, newmod.samples)
assert mod.ic.bands == newmod.ic.bands
os.remove(filename)
def _ini3_2(ic):
""" A close resolved triple (unresolved in KIC, TwoMASS)
modeled as a physically associated binary plus non-associated single
"""
mod = StarModel.from_ini(ic,
folder=os.path.join(FOLDER, 'star3'),
index=[0, 0, 1])
assert mod.n_params == 11
assert mod.obs.systems == [0, 1]
assert mod.obs.Nstars == {0: 2, 1: 1}
p = [1.0, 0.8, 9.4, 0.0, 100, 0.2, 1.0, 9.7, 0.0, 200, 0.5]
assert np.isfinite(mod.lnlike(p))
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_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 = {
"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 isochrones(name):
dar = Dartmouth_Isochrone()
Teff, logg, feh, vsini, vmag = parameters(name)
model = StarModel(
dar,
Teff=Teff,
feh=feh,
logg=logg,
V=vmag,
)
outfn = os.path.join(OUTPUTDIR, '{}_isochrones.hdf'.format(name))
print "performing isochrones analysis on {}".format(name)
model.fit(overwrite=True)
columns = 'Teff logg feh mass radius age distance'.split()
print "performing isochrones analysis on {}".format(name)
print model.samples[columns].quantile([0.15, 0.5, 0.85]).T.to_string()
model.save_hdf(outfn)
def colour2physical(kid, plot=False):
# fetch photometry
client = kplr.API()
star = client.star(kid)
mags = {'H': (star.kic_hmag, 0.08),
'J': (star.kic_jmag, 0.08),
'K': (star.kic_kmag, 0.08),
'g':(star.kic_gmag, 0.08),
'r':(star.kic_rmag, 0.08)}
# find the mass and radius using isochrones
dar = Dartmouth_Isochrone()
smod_phot = StarModel(dar, **mags)
result = smod_phot.fit_mcmc()
# save samples and triangle plot
if plot:
smod_phot.triangle_plots("test", format="pdf")
smod_phot.save_hdf("samples_%s.h5" % str(int(kid)))
max_like = smod_phot.maxlike()
print max_like
np.savetxt("maxlike.txt", max_like)
def fit(self,
inits=[355, 9.659, 0., 1000., .01],
nwalkers=24,
max_n=100000,
thin_by=100,
burnin=0,
iso_only=False,
gyro_only=False):
"""Run MCMC on a star.
Explore the posterior probability density function of the stellar
parameters using MCMC (via emcee).
Args:
inits (Optional[array-like]): A list of initial values to use for
EEP, age (in log10[yrs]), feh, distance (in pc) and Av. The
defaults are Solar values at 1000 pc with .01 extinction.
nwalkers (Optional[int]): The number of walkers to use with emcee.
The default is 24.
max_n (Optional[int]): The maximum number of samples to obtain
(although not necessarily to save -- see thin_by). The default
is 100000.
thin_by (Optional[int]): Only one in every thin_by samples will be
saved. The default is 100. Set = 1 to save every sample (note
this substantially slows down the MCMC process because of the
additional I/O time.
burnin (Optional[int]): The number of SAVED samples to throw away
when accessing the results. This number cannot exceed the
number of saved samples (which is max_n/thin_by). Default = 0.
iso_only (Optional[bool]): If true only the isochronal likelihood
function will be used.
gyro_only (Optional[bool]): If true only the gyrochronal
likelihood function will be used. Cannot be true if iso_only
is true.
"""
self.max_n = max_n
self.nwalkers = nwalkers
self.thin_by = thin_by
if iso_only:
assert gyro_only == False, "You cannot set both iso_only and "\
"gyro_only to be True."
if gyro_only:
assert mass, "If gyro_only is set to True, you must " \
"provide a B-V colour and a mass."
if burnin > max_n / thin_by:
burnin = int(max_n / thin_by / 3)
print("Automatically setting burn in to {}".format(burnin))
p_init = [inits[0], inits[1], inits[2], np.log(inits[3]), inits[4]]
self.p_init = p_init
np.random.seed(42)
# Create the directory if it doesn't already exist.
if not os.path.exists(self.savedir):
os.makedirs(self.savedir)
# Set up the backend
# Don't forget to clear it in case the file already exists
fn = "{0}/{1}.h5".format(self.savedir, self.filename)
backend = emcee.backends.HDFBackend(fn)
nwalkers, ndim = 24, 5
backend.reset(nwalkers, ndim)
self.backend = backend
# Set up the StarModel object needed to calculate the likelihood.
mod = StarModel(mist, **self.iso_params) # StarModel isochrones obj
# lnprob arguments
args = [
mod, self.prot, self.prot_err, self.bv, self.mass, iso_only,
gyro_only
]
self.args = args
# Run the MCMC
# sampler = run_mcmc(args, p_init, backend, nwalkers=nwalkers,
# max_n=max_n, thin_by=thin_by)
sampler = self.run_mcmc()
self.sampler = sampler
def main():
# TODO: bad, hard-coded...
# base_path = '/Volumes/ProjectData/gaia-comoving-followup/'
base_path = '../../data/'
db_path = path.join(base_path, 'db.sqlite')
engine = db_connect(db_path)
session = Session()
chain_path = path.abspath('./isochrone_chains')
os.makedirs(chain_path, exist_ok=True)
# Check out the bottom of "Color-magnitude diagram.ipynb":
interesting_group_ids = [1500, 1229, 1515]
all_photometry = OrderedDict([
('1500-8455',
OrderedDict([('J', (6.8379998, 0.021)),
('H', (6.4640002, 0.017000001)),
('K', (6.3369999, 0.017999999)),
('W1', (6.2950001, 0.093000002)),
('W2', (6.2490001, 0.026000001)),
('W3', (6.3330002, 0.015)), ('B', (9.5950003, 0.022)),
('V', (8.5120001, 0.014))])),
('1500-1804',
OrderedDict([('J', (6.9039998, 0.041000001)),
('H', (6.8559999, 0.027000001)),
('K', (6.7989998, 0.017000001)),
('W1', (6.803, 0.064999998)),
('W2', (6.7600002, 0.018999999)),
('W3', (6.8270001, 0.016000001)),
('B', (7.4980001, 0.015)), ('V', (7.289, 0.011))])),
('1229-1366',
OrderedDict([('J', (6.7290001, 0.024)), ('H', (6.2449999, 0.02)),
('K', (6.1529999, 0.023)),
('W1', (6.1799998, 0.096000001)), ('W2', (6.04, 0.035)),
('W3', (6.132, 0.016000001)), ('B', (9.5539999, 0.021)),
('V', (8.4619999, 0.014))])),
('1229-7470',
OrderedDict([
('J', (9.1709995, 0.024)), ('H', (8.7959995, 0.026000001)),
('K', (8.7299995, 0.022)), ('W1', (8.6669998, 0.023)),
('W2', (8.7189999, 0.02)), ('W3', (8.6680002, 0.025)),
('B', (11.428, 0.054000001)), ('V', (10.614, 0.039999999))
])),
('1515-3584',
OrderedDict([('J', (5.363999843597412, 0.024000000208616257)),
('H', (4.965000152587891, 0.035999998450279236)),
('K', (4.815999984741211, 0.032999999821186066)),
('W1', (4.758, 0.215)), ('W2', (4.565, 0.115)),
('W3', (4.771, 0.015)),
('B', (8.347999572753906, 0.01600000075995922)),
('V', (7.182000160217285, 0.009999999776482582))])),
('1515-1834',
OrderedDict([('J', (8.855999946594238, 0.024000000208616257)),
('H', (8.29699993133545, 0.020999999716877937)),
('K', (8.178999900817871, 0.017999999225139618)),
('W1', (8.117, 0.022)), ('W2', (8.15, 0.019)),
('W3', (8.065, 0.02)),
('B', (12.309000015258789, 0.11999999731779099)),
('V', (11.069999694824219, 0.054999999701976776))]))
])
for k in all_photometry:
samples_file = path.join(chain_path, '{0}.hdf5'.format(k))
if path.exists(samples_file):
logger.info("skipping {0} - samples exist at {1}".format(
k, samples_file))
continue
phot = all_photometry[k]
obs = session.query(Observation).filter(Observation.object == k).one()
plx = (obs.tgas_source.parallax, obs.tgas_source.parallax_error)
# fit an isochrone
model = StarModel(iso, use_emcee=True, parallax=plx, **phot)
model.set_bounds(mass=(0.01, 20),
feh=(-1, 1),
distance=(0, 300),
AV=(0, 1))
# initial conditions for emcee walkers
nwalkers = 128
p0 = []
m0, age0, feh0 = model.ic.random_points(nwalkers,
minmass=0.01,
maxmass=10.,
minfeh=-1,
maxfeh=1)
_, max_distance = model.bounds('distance')
_, max_AV = model.bounds('AV')
d0 = 10**(np.random.uniform(0, np.log10(max_distance), size=nwalkers))
AV0 = np.random.uniform(0, max_AV, size=nwalkers)
p0 += [m0]
p0 += [age0, feh0, d0, AV0]
p0 = np.array(p0).T
npars = p0.shape[1]
# run emcee
ninit = 256
nburn = 1024
niter = 4096
logger.debug('Running emcee - initial sampling...')
sampler = emcee.EnsembleSampler(nwalkers, npars, model.lnpost)
# pos, prob, state = sampler.run_mcmc(p0, ninit)
for pos, prob, state in tqdm(sampler.sample(p0, iterations=ninit),
total=ninit):
pass
# cull the weak walkers
best_ix = sampler.flatlnprobability.argmax()
best_p0 = (sampler.flatchain[best_ix][None] +
np.random.normal(0, 1E-5, size=(nwalkers, npars)))
sampler.reset()
logger.debug('burn-in...')
for pos, prob, state in tqdm(sampler.sample(best_p0, iterations=nburn),
total=nburn):
pass
# pos,_,_ = sampler.run_mcmc(best_p0, nburn)
sampler.reset()
logger.debug('sampling...')
# _ = sampler.run_mcmc(pos, niter)
for pos, prob, state in tqdm(sampler.sample(pos, iterations=niter),
total=niter):
pass
model._sampler = sampler
model._make_samples(0.08)
model.samples.to_hdf(samples_file, key='samples')
# np.save('isochrone_chains/chain.npy', sampler.chain)
logger.debug('...done and saved!')
def from_ini(cls, folder='.',
ini_file='fpp.ini', recalc=False, refit_trap=False,
star_ini_file='star.ini', ichrone=DARTMOUTH,
**kwargs):
"""
To enable simple usage, initializes a FPPCalculation from a .ini file
By default, a file called ``fpp.ini`` will be looked for in the
current folder. Also present must be a ``star.ini`` file that
contains the observed properties of the target star.
``fpp.ini`` must be of the following form::
name = k2oi
ra = 11:30:14.510
dec = +07:35:18.21
period = 32.988 #days
rprs = 0.0534 #Rp/Rstar
photfile = lc_k2oi.csv
[constraints]
maxrad = 10 #exclusion radius [arcsec]
secthresh = 0.001 #maximum allowed secondary signal depth
#This variable defines contrast curves
#ccfiles = Keck_J.cc, Lick_J.cc
Photfile must be a text file with columns ``(days_from_midtransit,
flux, flux_err)``. Both whitespace- and comma-delimited
will be tried, using ``np.loadtxt``. Photfile need not be there
if there is a pickled :class:`TransitSignal` saved in the same
directory as ``ini_file``, named ``trsig.pkl`` (or another name
as defined by ``trsig`` keyword in ``.ini`` file).
``star.ini`` should look something like the following::
B = 15.005, 0.06
V = 13.496, 0.05
g = 14.223, 0.05
r = 12.858, 0.04
i = 11.661, 0.08
J = 9.763, 0.03
H = 9.135, 0.03
K = 8.899, 0.02
W1 = 8.769, 0.023
W2 = 8.668, 0.02
W3 = 8.552, 0.025
Kepler = 12.473
#Teff = 3503, 80
#feh = 0.09, 0.09
#logg = 4.89, 0.1
Any star properties can be defined; if errors are included
then they will be used in the :class:`isochrones.StarModel`
MCMC fit.
Spectroscopic parameters (``Teff, feh, logg``) are optional.
If included, then they will also be included in
:class:`isochrones.StarModel` fit. A magnitude for the
band in which the transit signal is observed (e.g., ``Kepler``)
is required, though need not have associated uncertainty.
:param folder:
Folder to find configuration files.
:param ini_file:
Input configuration file.
:param star_ini_file:
Input config file for :class:`isochrones.StarModel` fits.
:param recalc:
Whether to re-calculate :class:`PopulationSet`, if a
``popset.h5`` file is already present
:param **kwargs:
Keyword arguments passed to :class:`PopulationSet`.
Creates:
* ``trsig.pkl``: the pickled :class:`vespa.TransitSignal` object.
* ``starfield.h5``: the TRILEGAL field star simulation
* ``starmodel.h5``: the :class:`isochrones.StarModel` fit
* ``popset.h5``: the :class:`vespa.PopulationSet` object
representing the model population simulations.
"""
if not os.path.isabs(ini_file):
config = ConfigObj(os.path.join(folder,ini_file))
else:
config = ConfigObj(ini_file)
folder = os.path.abspath(folder)
#required items
name = config['name']
ra, dec = config['ra'], config['dec']
period = float(config['period'])
rprs = float(config['rprs'])
#load starmodels if there;
# if not, create them.
if 'starmodel_basename' not in config:
starmodel_basename = 'dartmouth_starmodel'
else:
starmodel_basename = config['starmodel_basename']
single_starmodel_file = os.path.join(folder,'{}_single.h5'.format(starmodel_basename))
binary_starmodel_file = os.path.join(folder,'{}_binary.h5'.format(starmodel_basename))
triple_starmodel_file = os.path.join(folder,'{}_triple.h5'.format(starmodel_basename))
#Single
try:
single_starmodel = StarModel.load_hdf(single_starmodel_file)
logging.info('Single StarModel loaded from {}'.format(single_starmodel_file))
except:
single_starmodel = StarModel.from_ini(ichrone, folder,
ini_file=star_ini_file)
logging.info('Fitting single StarModel to {}...'.format(single_starmodel.properties))
single_starmodel.fit()
single_starmodel.save_hdf(single_starmodel_file)
triangle_base = os.path.join(folder, '{}_triangle_single'.format(starmodel_basename))
single_starmodel.triangle_plots(triangle_base)
logging.info('StarModel fit done.')
#Binary
try:
binary_starmodel = BinaryStarModel.load_hdf(binary_starmodel_file)
logging.info('BinaryStarModel loaded from {}'.format(binary_starmodel_file))
except:
binary_starmodel = BinaryStarModel.from_ini(ichrone, folder,
ini_file=star_ini_file)
logging.info('Fitting BinaryStarModel to {}...'.format(binary_starmodel.properties))
binary_starmodel.fit()
binary_starmodel.save_hdf(binary_starmodel_file)
triangle_base = os.path.join(folder, '{}_triangle_binary'.format(starmodel_basename))
binary_starmodel.triangle_plots(triangle_base)
logging.info('BinaryStarModel fit done.')
#Triple
try:
triple_starmodel = TripleStarModel.load_hdf(triple_starmodel_file)
logging.info('TripleStarModel loaded from {}'.format(triple_starmodel_file))
except:
triple_starmodel = TripleStarModel.from_ini(ichrone, folder,
ini_file=star_ini_file)
logging.info('Fitting TripleStarModel to {}...'.format(triple_starmodel.properties))
triple_starmodel.fit()
triple_starmodel.save_hdf(triple_starmodel_file)
triangle_base = os.path.join(folder, '{}_triangle_triple'.format(starmodel_basename))
triple_starmodel.triangle_plots(triangle_base)
logging.info('TripleStarModel fit done.')
if 'popset' in config:
popset_file = config['popset']
if not os.path.isabs(popset_file):
popset_file = os.path.join(folder, popset_file)
else:
popset_file = os.path.join(folder,'popset.h5')
if 'starfield' in config:
trilegal_file = config['starfield']
if not os.path.isabs(trilegal_file):
trilegal_file = os.path.join(folder, trilegal_file)
else:
trilegal_file = os.path.join(folder,'starfield.h5')
if 'trsig' in config:
trsig_file = config['trsig']
if not os.path.isabs(trsig_file):
trsig_file = os.path.join(folder, trsig_file)
else:
trsig_file = os.path.join(folder,'trsig.pkl')
#create TransitSignal
if os.path.exists(trsig_file):
logging.info('Loading transit signal from {}...'.format(trsig_file))
trsig = pickle.load(open(trsig_file,'rb'))
else:
if 'photfile' not in config:
raise AttributeError('If transit pickle file (trsig.pkl) '+
'not present, "photfile" must be'+
'defined.')
if not os.path.isabs(config['photfile']):
photfile = os.path.join(folder,config['photfile'])
else:
photfile = config['photfile']
logging.info('Reading transit signal photometry ' +
'from {}...'.format(photfile))
try:
ts, fs, dfs = np.loadtxt(photfile, unpack=True)
except:
ts, fs, dfs = np.loadtxt(photfile, delimiter=',', unpack=True)
trsig = TransitSignal(ts, fs, dfs, P=period, name=name)
logging.info('Fitting transitsignal with MCMC...')
trsig.MCMC()
trsig.save(trsig_file)
#create PopulationSet
try:
if recalc:
if os.path.exists(popset_file):
os.remove(popset_file)
raise RuntimeError #just to get to except block
try:
popset = PopulationSet.load_hdf(popset_file)
except HDF5ExtError:
os.remove(popset_file)
logging.warning('{} file corrupted; removing.'.format(popset_file))
raise RuntimeError #to get to except block
for m in DEFAULT_MODELS:
popset[m] #should there be a better way to check this? (yes)
if refit_trap:
os.remove(popset_file)
for pop in popset.poplist:
logging.info('Re-fitting trapezoids for {}...'.format(pop.model))
pop.fit_trapezoids()
pop.save_hdf(popset_file, pop.modelshort,
append=True)
popset = PopulationSet.load_hdf(popset_file)
logging.info('PopulationSet loaded from {}'.format(popset_file))
except:
if recalc:
do_only = DEFAULT_MODELS
else:
try:
popset = PopulationSet.load_hdf(popset_file)
do_only = []
for m in DEFAULT_MODELS:
try:
popset[m]
except:
do_only.append(m)
except:
do_only = DEFAULT_MODELS
if os.path.exists(popset_file):
logging.warning('{} exists, but regenerating Population Set ({})...'.format(popset_file, do_only),
exc_info=True)
popset = PopulationSet(period=period, mags=single_starmodel.mags,
ra=ra, dec=dec,
trilegal_filename=trilegal_file,
starmodel=single_starmodel,
binary_starmodel=binary_starmodel,
triple_starmodel=triple_starmodel,
rprs=rprs, do_only=do_only,
savefile=popset_file, **kwargs)
fpp = cls(trsig, popset, folder=folder)
#############
# Apply constraints
# Exclusion radius
maxrad = float(config['constraints']['maxrad'])
fpp.set_maxrad(maxrad)
if 'secthresh' in config['constraints']:
secthresh = float(config['constraints']['secthresh'])
if not np.isnan(secthresh):
fpp.apply_secthresh(secthresh)
# Odd-even constraint
diff = 3 * np.max(trsig.depthfit[1])
fpp.constrain_oddeven(diff)
#apply contrast curve constraints if present
if 'ccfiles' in config['constraints']:
ccfiles = config['constraints']['ccfiles']
if isinstance(ccfiles, basestring):
ccfiles = [ccfiles]
for ccfile in ccfiles:
if not os.path.isabs(ccfile):
ccfile = os.path.join(folder, ccfile)
m = re.search('(\w+)_(\w+)\.cc',os.path.basename(ccfile))
if not m:
logging.warning('Invalid CC filename ({}); '.format(ccfile) +
'skipping.')
continue
else:
band = m.group(2)
inst = m.group(1)
name = '{} {}-band'.format(inst, band)
cc = ContrastCurveFromFile(ccfile, band, name=name)
fpp.apply_cc(cc)
#apply "velocity contrast curve" if present
if 'vcc' in config['constraints']:
dv = float(config['constraints']['vcc'][0])
dmag = float(config['constraints']['vcc'][1])
vcc = VelocityContrastCurve(dv, dmag)
fpp.apply_vcc(vcc)
return fpp
def _check_spec(ic):
mod = StarModel(ic, Teff=(5700,100), logg=(4.5, 0.1), feh=(0.0, 0.2))
assert np.isfinite(mod.lnlike([1.0, 9.6, 0.1, 200, 0.2]))
def from_ini(cls,
folder='.',
ini_file='fpp.ini',
recalc=False,
refit_trap=False,
star_ini_file='star.ini',
ichrone=DARTMOUTH,
**kwargs):
"""
To enable simple usage, initializes a FPPCalculation from a .ini file
By default, a file called ``fpp.ini`` will be looked for in the
current folder. Also present must be a ``star.ini`` file that
contains the observed properties of the target star.
``fpp.ini`` must be of the following form::
name = k2oi
ra = 11:30:14.510
dec = +07:35:18.21
period = 32.988 #days
rprs = 0.0534 #Rp/Rstar
photfile = lc_k2oi.csv
[constraints]
maxrad = 10 #exclusion radius [arcsec]
secthresh = 0.001 #maximum allowed secondary signal depth
#This variable defines contrast curves
#ccfiles = Keck_J.cc, Lick_J.cc
Photfile must be a text file with columns ``(days_from_midtransit,
flux, flux_err)``. Both whitespace- and comma-delimited
will be tried, using ``np.loadtxt``. Photfile need not be there
if there is a pickled :class:`TransitSignal` saved in the same
directory as ``ini_file``, named ``trsig.pkl`` (or another name
as defined by ``trsig`` keyword in ``.ini`` file).
``star.ini`` should look something like the following::
B = 15.005, 0.06
V = 13.496, 0.05
g = 14.223, 0.05
r = 12.858, 0.04
i = 11.661, 0.08
J = 9.763, 0.03
H = 9.135, 0.03
K = 8.899, 0.02
W1 = 8.769, 0.023
W2 = 8.668, 0.02
W3 = 8.552, 0.025
Kepler = 12.473
#Teff = 3503, 80
#feh = 0.09, 0.09
#logg = 4.89, 0.1
Any star properties can be defined; if errors are included
then they will be used in the :class:`isochrones.StarModel`
MCMC fit.
Spectroscopic parameters (``Teff, feh, logg``) are optional.
If included, then they will also be included in
:class:`isochrones.StarModel` fit. A magnitude for the
band in which the transit signal is observed (e.g., ``Kepler``)
is required, though need not have associated uncertainty.
:param folder:
Folder to find configuration files.
:param ini_file:
Input configuration file.
:param star_ini_file:
Input config file for :class:`isochrones.StarModel` fits.
:param recalc:
Whether to re-calculate :class:`PopulationSet`, if a
``popset.h5`` file is already present
:param **kwargs:
Keyword arguments passed to :class:`PopulationSet`.
Creates:
* ``trsig.pkl``: the pickled :class:`vespa.TransitSignal` object.
* ``starfield.h5``: the TRILEGAL field star simulation
* ``starmodel.h5``: the :class:`isochrones.StarModel` fit
* ``popset.h5``: the :class:`vespa.PopulationSet` object
representing the model population simulations.
"""
if not os.path.isabs(ini_file):
config = ConfigObj(os.path.join(folder, ini_file))
else:
config = ConfigObj(ini_file)
folder = os.path.abspath(folder)
#required items
name = config['name']
ra, dec = config['ra'], config['dec']
period = float(config['period'])
rprs = float(config['rprs'])
#load starmodels if there;
# if not, create them.
if 'starmodel_basename' not in config:
starmodel_basename = 'dartmouth_starmodel'
else:
starmodel_basename = config['starmodel_basename']
single_starmodel_file = os.path.join(
folder, '{}_single.h5'.format(starmodel_basename))
binary_starmodel_file = os.path.join(
folder, '{}_binary.h5'.format(starmodel_basename))
triple_starmodel_file = os.path.join(
folder, '{}_triple.h5'.format(starmodel_basename))
#Single
try:
single_starmodel = StarModel.load_hdf(single_starmodel_file)
logging.info('Single StarModel loaded from {}'.format(
single_starmodel_file))
except:
single_starmodel = StarModel.from_ini(ichrone,
folder,
ini_file=star_ini_file)
logging.info('Fitting single StarModel to {}...'.format(
single_starmodel.properties))
single_starmodel.fit()
single_starmodel.save_hdf(single_starmodel_file)
triangle_base = os.path.join(
folder, '{}_triangle_single'.format(starmodel_basename))
single_starmodel.triangle_plots(triangle_base)
logging.info('StarModel fit done.')
#Binary
try:
binary_starmodel = BinaryStarModel.load_hdf(binary_starmodel_file)
logging.info(
'BinaryStarModel loaded from {}'.format(binary_starmodel_file))
except:
binary_starmodel = BinaryStarModel.from_ini(ichrone,
folder,
ini_file=star_ini_file)
logging.info('Fitting BinaryStarModel to {}...'.format(
binary_starmodel.properties))
binary_starmodel.fit()
binary_starmodel.save_hdf(binary_starmodel_file)
triangle_base = os.path.join(
folder, '{}_triangle_binary'.format(starmodel_basename))
binary_starmodel.triangle_plots(triangle_base)
logging.info('BinaryStarModel fit done.')
#Triple
try:
triple_starmodel = TripleStarModel.load_hdf(triple_starmodel_file)
logging.info(
'TripleStarModel loaded from {}'.format(triple_starmodel_file))
except:
triple_starmodel = TripleStarModel.from_ini(ichrone,
folder,
ini_file=star_ini_file)
logging.info('Fitting TripleStarModel to {}...'.format(
triple_starmodel.properties))
triple_starmodel.fit()
triple_starmodel.save_hdf(triple_starmodel_file)
triangle_base = os.path.join(
folder, '{}_triangle_triple'.format(starmodel_basename))
triple_starmodel.triangle_plots(triangle_base)
logging.info('TripleStarModel fit done.')
if 'popset' in config:
popset_file = config['popset']
if not os.path.isabs(popset_file):
popset_file = os.path.join(folder, popset_file)
else:
popset_file = os.path.join(folder, 'popset.h5')
if 'starfield' in config:
trilegal_file = config['starfield']
if not os.path.isabs(trilegal_file):
trilegal_file = os.path.join(folder, trilegal_file)
else:
trilegal_file = os.path.join(folder, 'starfield.h5')
if 'trsig' in config:
trsig_file = config['trsig']
if not os.path.isabs(trsig_file):
trsig_file = os.path.join(folder, trsig_file)
else:
trsig_file = os.path.join(folder, 'trsig.pkl')
#create TransitSignal
if os.path.exists(trsig_file):
logging.info(
'Loading transit signal from {}...'.format(trsig_file))
trsig = pickle.load(open(trsig_file, 'rb'))
else:
if 'photfile' not in config:
raise AttributeError('If transit pickle file (trsig.pkl) ' +
'not present, "photfile" must be' +
'defined.')
if not os.path.isabs(config['photfile']):
photfile = os.path.join(folder, config['photfile'])
else:
photfile = config['photfile']
logging.info('Reading transit signal photometry ' +
'from {}...'.format(photfile))
try:
ts, fs, dfs = np.loadtxt(photfile, unpack=True)
except:
ts, fs, dfs = np.loadtxt(photfile, delimiter=',', unpack=True)
trsig = TransitSignal(ts, fs, dfs, P=period, name=name)
logging.info('Fitting transitsignal with MCMC...')
trsig.MCMC()
trsig.save(trsig_file)
#create PopulationSet
try:
if recalc:
if os.path.exists(popset_file):
os.remove(popset_file)
raise RuntimeError #just to get to except block
try:
popset = PopulationSet.load_hdf(popset_file)
except HDF5ExtError:
os.remove(popset_file)
logging.warning(
'{} file corrupted; removing.'.format(popset_file))
raise RuntimeError #to get to except block
for m in DEFAULT_MODELS:
popset[m] #should there be a better way to check this? (yes)
if refit_trap:
os.remove(popset_file)
for pop in popset.poplist:
logging.info('Re-fitting trapezoids for {}...'.format(
pop.model))
pop.fit_trapezoids()
pop.save_hdf(popset_file, pop.modelshort, append=True)
popset = PopulationSet.load_hdf(popset_file)
logging.info('PopulationSet loaded from {}'.format(popset_file))
except:
if recalc:
do_only = DEFAULT_MODELS
else:
try:
popset = PopulationSet.load_hdf(popset_file)
do_only = []
for m in DEFAULT_MODELS:
try:
popset[m]
except:
do_only.append(m)
except:
do_only = DEFAULT_MODELS
if os.path.exists(popset_file):
logging.warning(
'{} exists, but regenerating Population Set ({})...'.
format(popset_file, do_only),
exc_info=True)
popset = PopulationSet(period=period,
mags=single_starmodel.mags,
ra=ra,
dec=dec,
trilegal_filename=trilegal_file,
starmodel=single_starmodel,
binary_starmodel=binary_starmodel,
triple_starmodel=triple_starmodel,
rprs=rprs,
do_only=do_only,
savefile=popset_file,
**kwargs)
fpp = cls(trsig, popset, folder=folder)
#############
# Apply constraints
# Exclusion radius
maxrad = float(config['constraints']['maxrad'])
fpp.set_maxrad(maxrad)
if 'secthresh' in config['constraints']:
secthresh = float(config['constraints']['secthresh'])
if not np.isnan(secthresh):
fpp.apply_secthresh(secthresh)
# Odd-even constraint
diff = 3 * np.max(trsig.depthfit[1])
fpp.constrain_oddeven(diff)
#apply contrast curve constraints if present
if 'ccfiles' in config['constraints']:
ccfiles = list(config['constraints']['ccfiles'])
for ccfile in ccfiles:
if not os.path.isabs(ccfile):
ccfile = os.path.join(folder, ccfile)
m = re.search('(\w+)_(\w+)\.cc', os.path.basename(ccfile))
if not m:
logging.warning('Invalid CC filename ({}); ' +
'skipping.'.format(ccfile))
continue
else:
band = m.group(2)
inst = m.group(1)
name = '{} {}-band'.format(inst, band)
cc = ContrastCurveFromFile(ccfile, band, name=name)
fpp.apply_cc(cc)
#apply "velocity contrast curve" if present
if 'vcc' in config['constraints']:
dv = float(config['constraints']['vcc'][0])
dmag = float(config['constraints']['vcc'][1])
vcc = VelocityContrastCurve(dv, dmag)
fpp.apply_vcc(vcc)
return fpp
def _check_spec(ic):
mod = StarModel(ic, Teff=(5700, 100), logg=(4.5, 0.1), feh=(0.0, 0.2))
eep = ic.get_eep(1., 9.6, 0.1, accurate=True)
assert np.isfinite(mod.lnlike([eep, 9.6, 0.1, 200, 0.2]))
def test_fitting():
mod_mist = _check_fitting(StarModel(MIST_Isochrone, **props))
_check_saving(mod_mist)
def fit_star(star, verbose=False):
output_filename = "{0}.h5".format(star.kepid)
logging.info("Output filename: {0}".format(output_filename))
if os.path.exists(output_filename):
return
time.sleep(30)
return
strt = time.time()
# The KIC parameters
mean_log_mass = np.log(star.mass)
sigma_log_mass = (np.log(star.mass + star.mass_err1) -
np.log(star.mass + star.mass_err2)
) # double the kic value
mean_feh = star.feh
sigma_feh = star.feh_err1 - star.feh_err2 # double the kic value
min_distance, max_distance = 0.0, 3000.0
# Other bands
other_bands = dict()
if np.isfinite(star.tgas_w1gmag):
other_bands = dict(
W1=(star.tgas_w1gmag, star.tgas_w1gmag_error),
W2=(star.tgas_w2gmag, star.tgas_w2gmag_error),
W3=(star.tgas_w3gmag, star.tgas_w3gmag_error),
)
if np.isfinite(star.tgas_Vmag):
other_bands["V"] = (star.tgas_Vmag, star.tgas_e_Vmag)
if np.isfinite(star.tgas_Bmag):
other_bands["B"] = (star.tgas_Bmag, star.tgas_e_Bmag)
if np.isfinite(star.tgas_gpmag):
other_bands["g"] = (star.tgas_gpmag, star.tgas_e_gpmag)
if np.isfinite(star.tgas_rpmag):
other_bands["r"] = (star.tgas_rpmag, star.tgas_e_rpmag)
if np.isfinite(star.tgas_ipmag):
other_bands["i"] = (star.tgas_ipmag, star.tgas_e_ipmag)
# Build the model
mist = MIST_Isochrone()
mod = StarModel(mist,
J=(star.jmag, star.jmag_err),
H=(star.hmag, star.hmag_err),
K=(star.kmag, star.kmag_err),
parallax=(star.tgas_parallax, star.tgas_parallax_error),
**other_bands)
# Initialize
nwalkers = 500
ndim = 5
lnpost_init = -np.inf + np.zeros(nwalkers)
coords_init = np.empty((nwalkers, ndim))
m = ~np.isfinite(lnpost_init)
while np.any(m):
K = m.sum()
# Mass
coords_init[m, 0] = np.exp(mean_log_mass +
sigma_log_mass * np.random.randn(K))
# Age
u = np.random.rand(K)
coords_init[m,
1] = np.log((np.exp(mist.maxage) - np.exp(mist.minage)) *
u + np.exp(mist.minage))
# Fe/H
coords_init[m, 2] = mean_feh + sigma_feh * np.random.randn(K)
# Distance
u = np.random.rand(K)
coords_init[m, 3] = (u * (max_distance**3 - min_distance**3) +
min_distance**3)**(1. / 3)
# Av
coords_init[m, 4] = np.random.rand(K)
lnpost_init[m] = np.array(list(map(mod.lnpost, coords_init[m])))
m = ~np.isfinite(lnpost_init)
class ICModel(emcee3.Model):
def compute_log_prior(self, state):
state.log_prior = mod.lnprior(state.coords)
return state
def compute_log_likelihood(self, state):
state.log_likelihood = mod.lnlike(state.coords)
return state
sampler = emcee3.Sampler(emcee3.moves.KDEMove())
ensemble = emcee3.Ensemble(ICModel(), coords_init)
chunksize = 200
targetn = 3
for iteration in range(100):
if verbose:
print("Iteration {0}...".format(iteration + 1))
sampler.run(ensemble, chunksize, progress=verbose)
mu = np.mean(sampler.get_coords(), axis=1)
try:
tau = emcee3.autocorr.integrated_time(mu, c=1)
except emcee3.autocorr.AutocorrError:
continue
tau_max = tau.max()
neff = ((iteration + 1) * chunksize / tau_max - 2.0)
if verbose:
print("Maximum autocorrelation time: {0}".format(tau_max))
print("N_eff: {0}\n".format(neff * nwalkers))
if neff > targetn:
break
burnin = int(2 * tau_max)
ntot = 5000
if verbose:
print("Discarding {0} samples for burn-in".format(burnin))
print("Randomly choosing {0} samples".format(ntot))
samples = sampler.get_coords(flat=True, discard=burnin)
total_samples = len(total_samples)
inds = np.random.choice(np.arange(len(samples)), size=ntot, replace=False)
samples = samples[inds]
fit_parameters = np.empty(len(samples),
dtype=[
("mass", float),
("log10_age", float),
("feh", float),
("distance", float),
("av", float),
])
computed_parameters = np.empty(len(samples),
dtype=[
("radius", float),
("teff", float),
("logg", float),
])
if verbose:
prog = tqdm.tqdm
else:
prog = lambda f, *args, **kwargs: f
for i, p in prog(enumerate(samples), total=len(samples)):
ic = mod.ic(*p)
fit_parameters[i] = p
computed_parameters[i] = (ic["radius"], ic["Teff"], ic["logg"])
total_time = time.time() - strt
logging.info("emcee3 took {0} sec".format(total_time))
with h5py.File(output_filename, "w") as f:
f.attrs["kepid"] = int(star.kepid)
f.attrs["neff"] = neff * nwalkers
f.attrs["runtime"] = total_time
f.create_dataset("fit_parameters", data=fit_parameters)
f.create_dataset("computed_parameters", data=computed_parameters)
# Plot
fig = corner.corner(samples)
fig.savefig("corner-{0}.png".format(star.kepid))
plt.close(fig)
def get_mod(self, ic, folder):
return StarModel.from_ini(ic, folder=folder, index=self.index)
import corner from isochrones import StarModel from isochrones.mist import MIST_Isochrone # params from Gaia archive, accessed Dec 2018 Teff = (4444.2, 160) logg = (3.0, 0.5) feh = (0.0, 0.25) parallax = (31.92,0.05) # age from BJ's Specmatch-Gaia results age = [9.9,0.1] # log10(age in yr) mist = MIST_Isochrone() model = StarModel(mist, Teff=Teff, logg=logg, feh=feh, parallax=parallax, age=age, use_emcee=True) model.fit(niter=1000) # add in prior on age age_post = model.samples.age_0 age_prior_probs = nm(age[0],age[1]).pdf(age_post) compare = np.random.uniform(size=len(age_post)) new_samples = model.samples.loc[age_prior_probs > compare] new_samples = new_samples[['mass_0_0','radius_0_0','feh_0','age_0','distance_0']] # make figure corner.corner( new_samples, labels=['Mass [Msol]','Radius [Rsol]','Fe/H','log10(age [Gyr])','distance [pc]'],
def get_isochrone_params(stars, modeldir, overwrite=False):
"""Fill out parameter table with values obtained from isochrone package
Args:
stars (pd.DataFrame): parameter table
modeldir (str): directory to save fitted models
overwrite (bool, optional): whether to use existing models or overwrite
Returns:
stars (pd.DataFrame): updated parameter table
"""
dar = Dartmouth_Isochrone()
num_stars = len(stars)
current_star = 1
for idx, row in stars.iterrows():
print("Getting isochrone parameters for star {0} of {1}"
.format(current_star, num_stars))
current_star += 1
# get known stellar properties
lib_props = {}
for p in library.Library.STAR_PROPS:
if not np.isnan(row[p]):
# (value, uncertainty)
lib_props[p] = (row[p], row['u_'+p])
# if all properties are known, we don't need to use the model
if len(lib_props) == 6:
continue
if modeldir is None:
model = StarModel(dar, **lib_props)
model.fit(overwrite=True, verbose=False)
else:
# check if fitting has already been done
modelfile = os.path.join(modeldir,
"{0}_model.h5".format(row['cps_name']))
if os.path.exists(modelfile) and not overwrite:
model = StarModel.load_hdf(modelfile)
# otherwise perform the fit
else:
model = StarModel(dar, **lib_props)
model.fit(overwrite=True, verbose=False)
model.save_hdf(modelfile)
N_SIGMA = 2
MAX_PERCENTILE = 0.95
MIN_PERCENTILE = 0.05
# fill out unknown parameters
for p in library.Library.STAR_PROPS:
value = model.samples[p].quantile(0.5)
upper_bound = model.samples[p].quantile(MAX_PERCENTILE)
lower_bound = model.samples[p].quantile(MIN_PERCENTILE)
# If a property is already known, check for model consistency
if p in lib_props:
# check if 2-sigma bounds fail to overlap
if (row[p] + N_SIGMA * row['u_'+p]) < lower_bound \
or (row[p] - N_SIGMA * row['u_'+p]) > upper_bound:
warningstr = "Warning: Inconisistent {0} for star {1}\n"\
.format(p, row['cps_name'])
warningstr += "\tLibrary values: {0:.2f} +/- {1:.2f}\n"\
.format(row[p], row['u_'+p])
warningstr += "\tModel values: {0:.2f}, ".format(value)
warningstr += "{0:d}-sigma = ({1:.2f}, {2:.2f})\n".format(
N_SIGMA, lower_bound, upper_bound)
print(warningstr)
# Save error messages to file
errpath = os.path.join(modeldir, 'errors.txt')
with open(errpath, 'a') as f:
f.write(warningstr)
# Insert the unknown values if we don't already know them
else:
stars.loc[idx, p] = np.around(value, 2)
stars.loc[idx, 'u_'+p] = \
np.around((upper_bound - lower_bound) / 2, 2)
return stars
def get_isochrone_params(stars, modeldir, overwrite=False):
"""Fill out parameter table with values obtained from isochrone package
Args:
stars (pd.DataFrame): parameter table
modeldir (str): directory to save fitted models
overwrite (bool, optional): whether to use existing models or overwrite
Returns:
stars (pd.DataFrame): updated parameter table
"""
dar = Dartmouth_Isochrone()
num_stars = len(stars)
current_star = 1
for idx, row in stars.iterrows():
print("Getting isochrone parameters for star {0} of {1}".format(
current_star, num_stars))
current_star += 1
# get known stellar properties
lib_props = {}
for p in library.Library.STAR_PROPS:
if not np.isnan(row[p]):
# (value, uncertainty)
lib_props[p] = (row[p], row['u_' + p])
# if all properties are known, we don't need to use the model
if len(lib_props) == 6:
continue
if modeldir is None:
model = StarModel(dar, **lib_props)
model.fit(overwrite=True, verbose=False)
else:
# check if fitting has already been done
modelfile = os.path.join(modeldir,
"{0}_model.h5".format(row['cps_name']))
if os.path.exists(modelfile) and not overwrite:
model = StarModel.load_hdf(modelfile)
# otherwise perform the fit
else:
model = StarModel(dar, **lib_props)
model.fit(overwrite=True, verbose=False)
model.save_hdf(modelfile)
N_SIGMA = 2
MAX_PERCENTILE = 0.95
MIN_PERCENTILE = 0.05
# fill out unknown parameters
for p in library.Library.STAR_PROPS:
value = model.samples[p].quantile(0.5)
upper_bound = model.samples[p].quantile(MAX_PERCENTILE)
lower_bound = model.samples[p].quantile(MIN_PERCENTILE)
# If a property is already known, check for model consistency
if p in lib_props:
# check if 2-sigma bounds fail to overlap
if (row[p] + N_SIGMA * row['u_'+p]) < lower_bound \
or (row[p] - N_SIGMA * row['u_'+p]) > upper_bound:
warningstr = "Warning: Inconisistent {0} for star {1}\n"\
.format(p, row['cps_name'])
warningstr += "\tLibrary values: {0:.2f} +/- {1:.2f}\n"\
.format(row[p], row['u_'+p])
warningstr += "\tModel values: {0:.2f}, ".format(value)
warningstr += "{0:d}-sigma = ({1:.2f}, {2:.2f})\n".format(
N_SIGMA, lower_bound, upper_bound)
print(warningstr)
# Save error messages to file
errpath = os.path.join(modeldir, 'errors.txt')
with open(errpath, 'a') as f:
f.write(warningstr)
# Insert the unknown values if we don't already know them
else:
stars.loc[idx, p] = np.around(value, 2)
stars.loc[idx, 'u_'+p] = \
np.around((upper_bound - lower_bound) / 2, 2)
return stars
def get_mod(self, ic, folder):
return StarModel.from_ini(ic, folder=folder, index=self.index)
def main(index, overwrite=False):
# First make sure paths exist:
# os.makedirs('../cache', exist_ok=True)
# os.makedirs('../plots/isochrones', exist_ok=True)
# Load the DECam photometry
decam = load_data('../data/decam_apw.fits')
iso = MIST_Isochrone(['PanSTARRS_g', 'PanSTARRS_i', 'SkyMapper_u'])
row = decam[index]
name = 'lmcla-{0}-'.format(row['index'])
model_file = '../cache/starmodels-{0}.hdf5'.format(str(row['index']))
if path.exists(model_file) and not overwrite:
print('skipping {0} - already exists'.format(name))
sys.exit(0)
# This is our "anchor star": it was identified as being near the turnoff,
# bright, and positionally consistent with being in the LA cluster:
j1, = np.where(decam['index'] == 24365)[0]
j2 = index
if j1 == j2:
print('skipping anchor-anchor pair')
sys.exit(0)
# To fit pairs as resolved binaries, we have to construct the observation
# tree manually:
tree = ObservationTree()
for b in ['PanSTARRS_g', 'PanSTARRS_i', 'SkyMapper_u']:
survey, band = b.split('_')
if band == 'u' and decam[band.capitalize() + 'MAG'][j2] > 21:
extra_s = 0.2
else:
extra_s = 0.005
o = Observation(survey, b, 1.)
s0 = Source(
decam[band.capitalize() + 'MAG'][j1],
np.sqrt(0.005**2 + decam[band.capitalize() + 'ERR'][j1]**2))
s1 = Source(decam[band.capitalize() + 'MAG'][j2],
np.sqrt(extra_s**2 +
decam[band.capitalize() + 'ERR'][j2]**2),
separation=100.)
o.add_source(s0)
o.add_source(s1)
tree.add_observation(o)
model = StarModel(ic=iso, obs=tree, N=[1, 2])
# model = StarModel(ic=iso, obs=tree)
print('setting priors')
dist_bounds = [1 * 1e3, 100 * 1e3] # pc
# model._priors['distance'] = FlatPrior(dist_bounds)
model._priors['distance'] = GaussianPrior(30 * 1e3,
10 * 1e3,
bounds=dist_bounds)
model.set_bounds(distance=dist_bounds) # 1 to 100 kpc
feh_bounds = (-2., 0.5)
model.set_bounds(feh=feh_bounds)
# model._priors['feh'] = FlatPrior(feh_bounds)
model._priors['feh'] = GaussianPrior(-1.1, 0.5, bounds=feh_bounds)
AV_bounds = (0, 1)
model.set_bounds(AV=AV_bounds)
model._priors['AV'] = PowerLawPrior(-1.1, (1e-3, 1))
# model._priors['AV'] = GaussianPrior(0.2, 0.1, bounds=AV_bounds)
age_bounds = (7, 9.5)
model.set_bounds(age=age_bounds)
# model._priors['age'] = GaussianPrior(8, 0.5, bounds=age_bounds)
model._priors['age'] = FlatPrior(age_bounds)
print('sampling star {0}'.format(row['index']))
model.fit_multinest(basename=name,
refit=overwrite,
overwrite=overwrite,
n_live_points=2048)
# model.fit_mcmc(nwalkers=nwalkers,
# p0=np.array([350., 8., -0.5, 30000., 0.1]),
# nburn=1024, niter=2048)
model.save_hdf(model_file)
fig = model.corner_physical()
fig.savefig('../plots/isochrones/{0}-physical.png'.format(row['index']),
dpi=200)
plt.close(fig)
fig = model.corner_observed()
fig.savefig('../plots/isochrones/{0}-observed.png'.format(row['index']),
dpi=200)
plt.close(fig)
# model._samples = model.samples[::1024]
# model.save_hdf(sm_model_file)
sys.exit(0)
def _check_spec(ic):
mod = StarModel(ic, Teff=(5700, 100), logg=(4.5, 0.1), feh=(0.0, 0.2))
eep = ic.get_eep(1., 9.6, 0.1, accurate=True)
assert np.isfinite(mod.lnlike([eep, 9.6, 0.1, 200, 0.2]))
def from_ini(cls,
folder,
ini_file='fpp.ini',
ichrone='mist',
recalc=False,
refit_trap=False,
**kwargs):
"""
To enable simple usage, initializes a FPPCalculation from a .ini file
By default, a file called ``fpp.ini`` will be looked for in the
current folder. Also present must be a ``star.ini`` file that
contains the observed properties of the target star.
``fpp.ini`` must be of the following form::
name = k2oi
ra = 11:30:14.510
dec = +07:35:18.21
period = 32.988 #days
rprs = 0.0534 #Rp/Rstar
photfile = lc_k2oi.csv
[constraints]
maxrad = 10 #exclusion radius [arcsec]
secthresh = 0.001 #maximum allowed secondary signal depth
#This variable defines contrast curves
#ccfiles = Keck_J.cc, Lick_J.cc
Photfile must be a text file with columns ``(days_from_midtransit,
flux, flux_err)``. Both whitespace- and comma-delimited
will be tried, using ``np.loadtxt``. Photfile need not be there
if there is a pickled :class:`TransitSignal` saved in the same
directory as ``ini_file``, named ``trsig.pkl`` (or another name
as defined by ``trsig`` keyword in ``.ini`` file).
``star.ini`` should look something like the following::
B = 15.005, 0.06
V = 13.496, 0.05
g = 14.223, 0.05
r = 12.858, 0.04
i = 11.661, 0.08
J = 9.763, 0.03
H = 9.135, 0.03
K = 8.899, 0.02
W1 = 8.769, 0.023
W2 = 8.668, 0.02
W3 = 8.552, 0.025
Kepler = 12.473
#Teff = 3503, 80
#feh = 0.09, 0.09
#logg = 4.89, 0.1
Any star properties can be defined; if errors are included
then they will be used in the :class:`isochrones.StarModel`
MCMC fit.
Spectroscopic parameters (``Teff, feh, logg``) are optional.
If included, then they will also be included in
:class:`isochrones.StarModel` fit. A magnitude for the
band in which the transit signal is observed (e.g., ``Kepler``)
is required, though need not have associated uncertainty.
:param folder:
Folder to find configuration files.
:param ini_file:
Input configuration file.
:param star_ini_file:
Input config file for :class:`isochrones.StarModel` fits.
:param recalc:
Whether to re-calculate :class:`PopulationSet`, if a
``popset.h5`` file is already present
:param **kwargs:
Keyword arguments passed to :class:`PopulationSet`.
Creates:
* ``trsig.pkl``: the pickled :class:`vespa.TransitSignal` object.
* ``starfield.h5``: the TRILEGAL field star simulation
* ``starmodel.h5``: the :class:`isochrones.StarModel` fit
* ``popset.h5``: the :class:`vespa.PopulationSet` object
representing the model population simulations.
Raises
------
RuntimeError :
If single, double, and triple starmodels are
not computed, then raises with admonition to run
`starfit --all`.
AttributeError :
If `trsig.pkl` not present in folder, and
`photfile` is not defined in config file.
"""
# Check if all starmodel fits are done.
# If not, tell user to run 'starfit --all'
config = ConfigObj(os.path.join(folder, ini_file))
# Load required entries from ini_file
try:
name = config['name']
ra, dec = config['ra'], config['dec']
period = float(config['period'])
rprs = float(config['rprs'])
except KeyError as err:
raise KeyError(
'Missing required element of ini file: {}'.format(err))
try:
cadence = float(config['cadence'])
except KeyError:
logging.warning(
'Cadence not provided in fpp.ini; defaulting to Kepler cadence.'
)
logging.warning(
'If this is not a Kepler target, please set cadence (in days).'
)
cadence = 1626.0 / 86400 # Default to Kepler cadence
def fullpath(filename):
if os.path.isabs(filename):
return filename
else:
return os.path.join(folder, filename)
# Non-required entries with default values
popset_file = fullpath(config.get('popset', 'popset.h5'))
starfield_file = fullpath(config.get('starfield', 'starfield.h5'))
trsig_file = fullpath(config.get('trsig', 'trsig.pkl'))
# Check for StarModel fits
starmodel_basename = config.get('starmodel_basename',
'{}_starmodel'.format(ichrone))
single_starmodel_file = os.path.join(
folder, '{}_single.h5'.format(starmodel_basename))
binary_starmodel_file = os.path.join(
folder, '{}_binary.h5'.format(starmodel_basename))
triple_starmodel_file = os.path.join(
folder, '{}_triple.h5'.format(starmodel_basename))
try:
single_starmodel = StarModel.load_hdf(single_starmodel_file)
binary_starmodel = StarModel.load_hdf(binary_starmodel_file)
triple_starmodel = StarModel.load_hdf(triple_starmodel_file)
except Exception as e:
print(e)
raise RuntimeError('Cannot load StarModels. ' +
'Please run `starfit --all {}`.'.format(folder))
# Create (or load) TransitSignal
if os.path.exists(trsig_file):
logging.info(
'Loading transit signal from {}...'.format(trsig_file))
with open(trsig_file, 'rb') as f:
trsig = pickle.load(f)
else:
try:
photfile = fullpath(config['photfile'])
except KeyError:
raise AttributeError('If transit pickle file (trsig.pkl) ' +
'not present, "photfile" must be' +
'defined.')
trsig = TransitSignal.from_ascii(photfile, P=period, name=name)
if not trsig.hasMCMC or refit_trap:
logging.info('Fitting transitsignal with MCMC...')
trsig.MCMC()
trsig.save(trsig_file)
# Create (or load) PopulationSet
do_only = DEFAULT_MODELS
if os.path.exists(popset_file):
if recalc:
os.remove(popset_file)
else:
with pd.HDFStore(popset_file) as store:
do_only = [m for m in DEFAULT_MODELS if m not in store]
# Check that properties of saved population match requested
try:
popset = PopulationSet.load_hdf(popset_file)
for pop in popset.poplist:
if pop.cadence != cadence:
raise ValueError(
'Requested cadence ({}) '.format(cadence) +
'does not match stored {})! Set recalc=True.'.format(
pop.cadence))
except:
raise
if do_only:
logging.info(
'Generating {} models for PopulationSet...'.format(do_only))
else:
logging.info(
'Populations ({}) already generated.'.format(DEFAULT_MODELS))
popset = PopulationSet(
period=period,
cadence=cadence,
mags=single_starmodel.mags,
ra=ra,
dec=dec,
trilegal_filename=starfield_file, # Maybe change parameter name?
starmodel=single_starmodel,
binary_starmodel=binary_starmodel,
triple_starmodel=triple_starmodel,
rprs=rprs,
do_only=do_only,
savefile=popset_file,
**kwargs)
fpp = cls(trsig, popset, folder=folder)
#############
# Apply constraints
# Exclusion radius
maxrad = float(config['constraints']['maxrad'])
fpp.set_maxrad(maxrad)
if 'secthresh' in config['constraints']:
secthresh = float(config['constraints']['secthresh'])
if not np.isnan(secthresh):
fpp.apply_secthresh(secthresh)
# Odd-even constraint
diff = 3 * np.max(trsig.depthfit[1])
fpp.constrain_oddeven(diff)
#apply contrast curve constraints if present
if 'ccfiles' in config['constraints']:
ccfiles = config['constraints']['ccfiles']
if isinstance(ccfiles, string_types):
ccfiles = [ccfiles]
for ccfile in ccfiles:
if not os.path.isabs(ccfile):
ccfile = os.path.join(folder, ccfile)
m = re.search('(\w+)_(\w+)\.cc', os.path.basename(ccfile))
if not m:
logging.warning(
'Invalid CC filename ({}); '.format(ccfile) +
'skipping.')
continue
else:
band = m.group(2)
inst = m.group(1)
name = '{} {}-band'.format(inst, band)
cc = ContrastCurveFromFile(ccfile, band, name=name)
fpp.apply_cc(cc)
#apply "velocity contrast curve" if present
if 'vcc' in config['constraints']:
dv = float(config['constraints']['vcc'][0])
dmag = float(config['constraints']['vcc'][1])
vcc = VelocityContrastCurve(dv, dmag)
fpp.apply_vcc(vcc)
return fpp
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"